Shader für 3d - Licht, Lichtreflexion und Bumpmapping (Letzteres geht noch nicht)

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Shader für 3d - Licht, Lichtreflexion und Bumpmapping (Letzteres geht noch nicht)

    Hallöle,

    Anschließend an meinen letzten Thread präsentiere ich euch meine Arbeit der letzten Tage. Einen Shader mit dem es möglich ist mehr als nur 8 Lichtquellen zu verwenden.
    Außerdem wird das standart Vertexlighting im 3d Modus immer ignoriert wenn man einen Shader auf seine Modelle anwenden will, darum ist dieser Shader auch sinnvoll.

    Außerdem wollte ich unbedingt Bumpmapping können darum Hab ich die letzten Tage viel im Netz recharchiert und habe folgendes Tutorial gefunden:
    fabiensanglard.net/bumpMapping/index.php
    Zusammen mit dem Wissen das ich von Xor's Tutorials habe (kann ich jedem nur empfehlen) habe ich in viel Arbeit und mit leider zu wenigem mathematischem Verständnis diesen Shader "zusammen gebastelt". Teile davon hab ich nur ausm Netz kopert ohne sie ganz zu verstehen und da liegt glaub ich auch der Fehler.

    Wie gesagt, das Bumpmapping geht nicht. Das Problem ist glaube ich das ich den Tangentvektor von den Positionsvektor und den Normal Vektor brauche und den nicht korrekt berechne.
    Denn wenn ich das ric htig versteh (und davon geh ich nicht aus^^) dann muss man mehere Richtungsverktoren berechnen aber nicht für jedes Vertex sondern für jedes Pixel.

    Wer kann mir weiterhelfen?

    Der Shader darf frei verwendet werden und es ist auch kein Creditseintrag nötig. Ihr müsst nur ein paar Arrays erstellen und an den Shader übergeben. Wichtig ist, dass ihr die Richtungen für direktionales Licht mit degtorad ind Radians umwandelt. Wenn ihr keine Liochtreflexion braucht, dann lasst einfach das zweite gl_FragColor im Fragmentshader weg.

    Vertex Shader:

    GML-Quellcode

    1. attribute vec3 in_Position; // (x,y,z)
    2. attribute vec3 in_Normal; // (x,y,z)
    3. attribute vec4 in_Colour; // (r,g,b,a)
    4. attribute vec2 in_TextureCoord; // (u,v)
    6. varying vec2 v_vTexcoord;
    7. varying vec3 v_vNormal;
    8. varying vec3 v_vPosition;
    9. varying vec4 v_vColour;
    10. varying vec3 v_vLightVec;
    11. varying vec3 ldir;
    12. varying vec3 halfVec;
    13. varying vec3 eyeVec;
    15. uniform vec3 CamPos;
    16. uniform float LIGHTS;
    17. uniform float Lights_Kind[16];
    18. uniform float Lights_Direction[16];
    19. uniform float Lights_DirectionZ[16];
    20. uniform float Lights_Color_R[16];
    21. uniform float Lights_Color_G[16];
    22. uniform float Lights_Color_B[16];
    23. uniform float Lights_X[16];
    24. uniform float Lights_Y[16];
    25. uniform float Lights_Z[16];
    26. uniform float Lights_Range[16];
    27. uniform vec2 resolution;
    29. //diese Funktion is für direktionales Licht
    30. vec3 DoDirLightB(vec3 ws_normal, float dir, float dirz, float R, float G, float B)
    31. {
    32. //die Richtung wird mit zwei Radien angegeben
    33. //und da unten in einen Richtungsvektor umgerechnet
    34. float vx = cos(dir) * cos(dirz);
    35. float vy = sin(dir) * cos(dirz);
    36. float vz = sin(dirz);
    38. ldir = vec3(vx, vy, vz);
    40. float dotresult = dot(ws_normal, normalize(ldir)) * 0.5 + 0.5;
    42. vec3 diffusecolor = vec3(R, G, B);
    44. //hier wird die Farbe des Vertex an void main übergeben
    45. return dotresult * diffusecolor;
    46. }
    48. //diese Funktion ist für Pointlights (nicht getestet)
    49. vec3 DoPointLightB(vec3 pos, float posx,float posy,float posz, float range, float R, float G, float B)
    50. {
    51. ldir = vec3(posx, posy, posz) - pos;
    53. float attenuation = max( 1.0 - length(normalize(ldir))/range, 0.0);
    54. float lighting = (dot( normalize(v_vNormal), normalize(ldir)) * 0.5 + 0.5) * attenuation;
    56. vec3 diffusecol = vec3(R, G, B);
    58. return lighting * diffusecol;
    59. }
    61. //das ist die hauptfunktion für das Licht
    62. vec4 DoLightingB(vec4 vertexcolor, vec3 objectspacepos, vec3 objectspacenormal)
    63. {
    64. vec4 objectspacenormal4 = vec4(objectspacenormal, 1.0);
    65. vec3 ws_normal = normalize(objectspacenormal);
    67. vec3 accumcol = vec3(0.3, 0.3, 0.3);
    69. //hier werden alle Lichtinformation aus den Arrays gelesen
    70. //und an die Funktionen oben übergeben
    71. for(int i = 1; i <= int(LIGHTS); i++) {
    72. accumcol += abs(min(Lights_Kind[i], 0.0)) * DoDirLightB(ws_normal, Lights_Direction[i], Lights_DirectionZ[i], Lights_Color_R[i], Lights_Color_G[i], Lights_Color_B[i]);
    73. accumcol += max(Lights_Kind[i], 0.0) * DoPointLightB(objectspacepos, Lights_X[i], Lights_Y[i], Lights_Z[i], Lights_Range[i], Lights_Color_R[i], Lights_Color_G[i], Lights_Color_B[i]);
    74. }
    76. // das sccumcolor mit 0,5 multipliziert wird sorgt nur
    77. //dafür das das Endergebnis nicht zu hell ist. Dass ist
    78. //eigentlich schon ein Beweis dafür, dass meine Arbeit noch nicht ganz stimmt
    79. vec4 resultcolor = vec4(accumcol * 0.5, 1.0);
    81. return resultcolor;
    82. }
    84. void main()
    85. {
    86. //alles Ubliche
    87. vec4 object_space_pos = vec4( in_Position, 1.0);
    88. gl_Position = gm_Matrices[MATRIX_WORLD_VIEW_PROJECTION] * object_space_pos;
    90. v_vTexcoord = in_TextureCoord;
    91. v_vNormal = in_Normal;
    92. v_vPosition = in_Position;
    93. v_vColour = in_Colour;
    95. //hier wird die Hauptfunktion für das Licht ausgeführt
    96. v_vColour = DoLightingB(v_vColour, v_vPosition, v_vNormal);
    99. // folgender Codeblock hab ich aus dem Internet und errechnet NormalMatrix
    100. // in GLSL gibt es die 3x3 Matrix gl_modelmatrix
    101. // das ist die modelviewmatrix nur umgestellt und invertiert
    102. // allerdings erkennt GMS diese nicht an obwohl sie rot geschrieben ist
    104. // Get upper left 3x3 matrix of ModelView:
    105. // | a b c |
    106. // | d e f |
    107. // | g h i |
    108. mat3 M = mat3(gm_Matrices[MATRIX_WORLD_VIEW]);
    110. // Get determinant of M = a*e*i - a*f*h - b*d*i + b*f*g + c*d*h - c*e*g
    111. float dtm;
    112. dtm = M[0][0]*M[1][1]*M[2][2]; // a*e*i
    113. dtm -= M[0][0]*M[2][1]*M[1][2]; // a*f*h
    114. dtm -= M[1][0]*M[0][1]*M[2][2]; // b*d*i
    115. dtm += M[1][0]*M[2][1]*M[0][2]; // b*f*g
    116. dtm += M[2][0]*M[0][1]*M[1][2]; // c*d*h
    117. dtm -= M[2][0]*M[1][1]*M[0][2]; // c*e*g
    119. // Transpose I:
    120. mat3 NormalMatrix;
    121. NormalMatrix[0][0] = (M[1][1] * M[2][2] - M[1][2] * M[2][1]);
    122. NormalMatrix[1][0] = (M[0][2] * M[2][1] - M[0][1] * M[2][2]);
    123. NormalMatrix[2][0] = (M[0][1] * M[1][2] - M[0][2] * M[1][1]);
    124. NormalMatrix[0][1] = (M[1][2] * M[2][0] - M[1][0] * M[2][2]);
    125. NormalMatrix[1][1] = (M[0][0] * M[2][2] - M[0][2] * M[2][0]);
    126. NormalMatrix[2][1] = (M[0][2] * M[1][0] - M[0][0] * M[1][2]);
    127. NormalMatrix[0][2] = (M[1][0] * M[2][1] - M[1][1] * M[2][0]);
    128. NormalMatrix[1][2] = (M[0][1] * M[2][0] - M[0][0] * M[2][1]);
    129. NormalMatrix[2][2] = (M[0][0] * M[1][1] - M[0][1] * M[1][0]);
    130. NormalMatrix /= dtm;
    132. //nun haben wir unsere normale Matrix
    133. //jetzt berechnen wir den Tangentvektor
    134. vec3 normal = vec3(1.0,1.0,0.0);
    135. vec3 tangent;
    136. vec3 t1 = cross( normal, in_Position);
    137. vec3 t2 = cross( normal, in_Normal);
    138. if (length(t1) > length(t2)) {
    139. tangent = t1;
    140. }
    141. else {
    142. tangent = t2;
    143. }
    145. // nun normalisieren wir unsere Vektoren im Verhältnis
    146. // zur NormalMatrix und errechnen den Kreuzpunkt
    147. // und nun geht meine Unwissenheit los :)
    148. // ich denke ab hier unten hab ich die meisten Fehler drin
    149. vec3 N = normalize(NormalMatrix * in_Normal);
    150. vec3 T = normalize(NormalMatrix * tangent);
    151. vec3 B = normalize(cross(N, T));
    153. vec3 v;
    154. v.x = dot(normalize(ldir), T);
    155. v.y = dot(normalize(ldir), B);
    156. v.z = dot(normalize(ldir), N);
    158. v_vLightVec = normalize(v); //Lichtvektor
    160. vec3 vertexPosition = normalize(NormalMatrix * in_Position);
    162. v.x = dot(vertexPosition, T);
    163. v.y = dot(vertexPosition, B);
    164. v.z = dot(vertexPosition, N);
    165. eyeVec = normalize(v);
    167. vertexPosition = normalize(vertexPosition);
    169. halfVec = normalize(vertexPosition + normalize(ldir));
    170. v.x = dot(halfVec, T);
    171. v.y = dot(halfVec, B);
    172. v.z = dot(halfVec, N);
    174. halfVec = v;
    175. }
    Alles anzeigen



    Fragment Shader:

    GML-Quellcode

    1. varying vec2 v_vTexcoord;
    2. varying vec3 v_vNormal;
    3. varying vec3 v_vPosition;
    4. varying vec4 v_vColour;
    5. varying vec3 v_vLightVec;
    6. varying vec3 ldir;
    7. varying vec3 halfVec;
    8. varying vec3 eyeVec;
    10. uniform vec3 CamPos;
    11. uniform float specStrength;
    12. uniform sampler2D bumpmap;
    14. void main()
    15. {
    16. vec3 normal = texture2D(bumpmap, v_vTexcoord).rgb; //die Bumpmap
    17. normal = normalize(normal);
    18. float lamberFactor = max(dot(v_vLightVec, normal), 0.1) * 4.0; //der Lamberfaktor
    19. vec4 finalFactor = vec4(vec3(lamberFactor), 1.0);
    21. // hier wird die Lichtreflexion berechnet
    22. vec3 EyeDirection_cameraspace = CamPos - v_vPosition;// Richtungsvektor der Kamera
    23. vec3 E = normalize(EyeDirection_cameraspace);
    24. vec3 R = reflect(-normalize(ldir), normalize(v_vPosition)); // die Lichtreflexion
    25. float cosAlpha = clamp( dot( E, R ), 0.0, 1.0 );
    26. vec3 specCol = vec3(0.5, 0.5, 1.0);
    27. vec4 Specular = cosAlpha * vec4( specCol, 1.0);
    28. float shininess = pow(max(dot(halfVec, normal), 0.0), 2.0);
    30. gl_FragColor = v_vColour * texture2D( gm_BaseTexture, v_vTexcoord) * finalFactor;
    31. gl_FragColor += Specular * shininess;
    32. }
    Alles anzeigen

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Morpheus ()