API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 26th, 2019
150
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
OpenGL Shading 18.71 KB | None | 0 0
raw download clone embed print report
  1. /* clang-format off */
  2. [vertex]
  3. /* clang-format on */
  4.  
  5. #version 450
  6.  
  7. /* clang-format off */
  8. VERSION_DEFINES
  9. /* clang-format on */
  10.  
  11. #ifdef USE_ATTRIBUTES
  12. layout(location = 0) in vec2 vertex_attrib;
  13. layout(location = 3) in vec4 color_attrib;
  14. layout(location = 4) in vec2 uv_attrib;
  15.  
  16. layout(location = 6) in uvec4 bone_indices_attrib;
  17. layout(location = 7) in vec4 bone_weights_attrib;
  18.  
  19. #endif
  20.  
  21. #include "canvas_uniforms_inc.glsl"
  22.  
  23.  
  24. layout(location=0) out vec2 uv_interp;
  25. layout(location=1) out vec4 color_interp;
  26. layout(location=2) out vec2 vertex_interp;
  27.  
  28. #ifdef USE_NINEPATCH
  29.  
  30. layout(location=3) out vec2 pixel_size_interp;
  31.  
  32. #endif
  33.  
  34. #ifdef USE_MATERIAL_UNIFORMS
  35. layout(set = 1, binding = 1, std140) uniform MaterialUniforms {
  36. /* clang-format off */
  37. MATERIAL_UNIFORMS
  38. /* clang-format on */
  39. } material;
  40. #endif
  41.  
  42. /* clang-format off */
  43. VERTEX_SHADER_GLOBALS
  44. /* clang-format on */
  45.  
  46.  
  47. void main() {
  48.  
  49.     vec4 instance_custom = vec4(0.0);
  50. #ifdef USE_PRIMITIVE
  51.  
  52. //weird bug,
  53. //this works
  54.     vec2 vertex;
  55.     vec2 uv;
  56.     vec4 color;
  57.  
  58.     if (gl_VertexIndex==0) {
  59.         vertex = draw_data.points[0];
  60.         uv = draw_data.uvs[0];
  61.         color = vec4(unpackHalf2x16(draw_data.colors[0]),unpackHalf2x16(draw_data.colors[1]));
  62.     } else if (gl_VertexIndex==1) {
  63.         vertex = draw_data.points[1];
  64.         uv = draw_data.uvs[1];
  65.         color = vec4(unpackHalf2x16(draw_data.colors[2]),unpackHalf2x16(draw_data.colors[3]));
  66.     } else {
  67.         vertex = draw_data.points[2];
  68.         uv = draw_data.uvs[2];
  69.         color = vec4(unpackHalf2x16(draw_data.colors[4]),unpackHalf2x16(draw_data.colors[5]));
  70.     }
  71.     uvec4 bone_indices = uvec4(0,0,0,0);
  72.     vec4 bone_weights = vec4(0,0,0,0);
  73.  
  74. #elif defined(USE_ATTRIBUTES)
  75.  
  76.     vec2 vertex = vertex_attrib;
  77.     vec4 color = color_attrib;
  78.     vec2 uv = uv_attrib;
  79.  
  80.     uvec4 bone_indices = bone_indices_attrib;
  81.     vec4 bone_weights = bone_weights_attrib;
  82. #else
  83.  
  84.     vec2 vertex_base_arr[4] = vec2[](vec2(0.0,0.0),vec2(0.0,1.0),vec2(1.0,1.0),vec2(1.0,0.0));
  85.     vec2 vertex_base = vertex_base_arr[gl_VertexIndex];
  86.  
  87.     vec2 uv = draw_data.src_rect.xy + abs(draw_data.src_rect.zw) * ((draw_data.flags&FLAGS_TRANSPOSE_RECT)!=0 ? vertex_base.yx : vertex_base.xy);
  88.     vec4 color = draw_data.modulation;
  89.     vec2 vertex = draw_data.dst_rect.xy + abs(draw_data.dst_rect.zw) * mix(vertex_base, vec2(1.0, 1.0) - vertex_base, lessThan(draw_data.src_rect.zw, vec2(0.0, 0.0)));
  90.     uvec4 bone_indices = uvec4(0,0,0,0);
  91.     vec4 bone_weights = vec4(0,0,0,0);
  92.  
  93. #endif
  94.  
  95.     mat4 world_matrix  = mat4(vec4(draw_data.world_x,0.0,0.0),vec4(draw_data.world_y,0.0,0.0),vec4(0.0,0.0,1.0,0.0),vec4(draw_data.world_ofs,0.0,1.0));
  96. #if 0
  97.  
  98.     if (draw_data.flags&FLAGS_INSTANCING_ENABLED) {
  99.  
  100.         uint offset = draw_data.flags&FLAGS_INSTANCING_STRIDE_MASK;
  101.         offset *= gl_InstanceIndex;
  102.         mat4 instance_xform  = mat4(
  103.                     vec4( texelFetch(instancing_buffer,offset+0),texelFetch(instancing_buffer,offset+1),0.0,texelFetch(instancing_buffer,offset+3) ),
  104.                     vec4( texelFetch(instancing_buffer,offset+4),texelFetch(instancing_buffer,offset+5),0.0,texelFetch(instancing_buffer,offset+7) ),
  105.                     vec4( 0.0,0.0,1.0,0.0),
  106.                     vec4( 0.0,0.0,0.0,1.0 ) );
  107.         offset+=8;
  108.         if ( draw_data.flags&FLAGS_INSTANCING_HAS_COLORS ) {
  109.             vec4 instance_color;
  110.             if (draw_data.flags&FLAGS_INSTANCING_COLOR_8_BIT ) {
  111.                 uint bits = floatBitsToUint(texelFetch(instancing_buffer,offset));
  112.                 instance_color = unpackUnorm4x8(bits);
  113.                 offset+=1;
  114.             } else {
  115.                 instance_color = vec4(texelFetch(instancing_buffer,offset+0),texelFetch(instancing_buffer,offset+1),texelFetch(instancing_buffer,offset+2),texelFetch(instancing_buffer,offset+3));
  116.                 offser+=4;
  117.             }
  118.  
  119.             color*=instance_color;
  120.         }
  121.         if ( draw_data.flags&FLAGS_INSTANCING_HAS_CUSTOM_DATA ) {
  122.             if (draw_data.flags&FLAGS_INSTANCING_CUSTOM_DATA_8_BIT ) {
  123.                 uint bits = floatBitsToUint(texelFetch(instancing_buffer,offset));
  124.                 instance_custom = unpackUnorm4x8(bits);
  125.             } else {
  126.                 instance_custom = vec4(texelFetch(instancing_buffer,offset+0),texelFetch(instancing_buffer,offset+1),texelFetch(instancing_buffer,offset+2),texelFetch(instancing_buffer,offset+3));
  127.             }
  128.         }
  129.  
  130.     }
  131.  
  132. #endif
  133.  
  134. #if !defined(USE_ATTRIBUTES) && !defined(USE_PRIMITIVE)
  135.     if (bool(draw_data.flags&FLAGS_USING_PARTICLES)) {
  136.         //scale by texture size
  137.         vertex /= draw_data.color_texture_pixel_size;
  138.     }
  139. #endif
  140.  
  141. #ifdef USE_POINT_SIZE
  142.     float point_size = 1.0;
  143. #endif
  144.     {
  145.         /* clang-format off */
  146. VERTEX_SHADER_CODE
  147.         /* clang-format on */
  148.     }
  149.  
  150.  
  151.  
  152. #ifdef USE_NINEPATCH
  153.     pixel_size_interp = abs(draw_data.dst_rect.zw) * vertex_base;
  154. #endif
  155.  
  156. #if !defined(SKIP_TRANSFORM_USED)
  157.     vertex = (world_matrix * vec4(vertex,0.0,1.0)).xy;
  158. #endif
  159.  
  160.     color_interp = color;
  161.  
  162.     if (bool(draw_data.flags&FLAGS_USE_PIXEL_SNAP)) {
  163.  
  164.         vertex = floor(vertex + 0.5);
  165.         // precision issue on some hardware creates artifacts within texture
  166.         // offset uv by a small amount to avoid
  167.         uv += 1e-5;
  168.     }
  169.  
  170. #ifdef USE_ATTRIBUTES
  171. #if 0
  172.     if (bool(draw_data.flags&FLAGS_USE_SKELETON) && bone_weights != vec4(0.0)) { //must be a valid bone
  173.         //skeleton transform
  174.  
  175.         ivec4 bone_indicesi = ivec4(bone_indices);
  176.  
  177.         uvec2 tex_ofs = bone_indicesi.x *2;
  178.  
  179.         mat2x4 m;
  180.         m = mat2x4(
  181.                     texelFetch(skeleton_buffer, tex_ofs+0),
  182.                     texelFetch(skeleton_buffer, tex_ofs+1) ) *
  183.             bone_weights.x;
  184.  
  185.         tex_ofs = bone_indicesi.y * 2;
  186.  
  187.         m += mat2x4(
  188.                     texelFetch(skeleton_buffer, tex_ofs+0),
  189.                     texelFetch(skeleton_buffer, tex_ofs+1) ) *
  190.              bone_weights.y;
  191.  
  192.         tex_ofs = bone_indicesi.z * 2;
  193.  
  194.         m += mat2x4(
  195.                     texelFetch(skeleton_buffer, tex_ofs+0),
  196.                     texelFetch(skeleton_buffer, tex_ofs+1) ) *
  197.              bone_weights.z;
  198.  
  199.         tex_ofs = bone_indicesi.w * 2;
  200.  
  201.         m += mat2x4(
  202.                     texelFetch(skeleton_buffer, tex_ofs+0),
  203.                     texelFetch(skeleton_buffer, tex_ofs+1) ) *
  204.              bone_weights.w;
  205.  
  206.         mat4 bone_matrix = skeleton_data.skeleton_transform * transpose(mat4(m[0], m[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))) * skeleton_data.skeleton_transform_inverse;
  207.  
  208.         //outvec = bone_matrix * outvec;
  209.     }
  210. #endif
  211. #endif
  212.  
  213.  
  214.     vertex = (canvas_data.canvas_transform * vec4(vertex,0.0,1.0)).xy;
  215.  
  216.     vertex_interp = vertex;
  217.     uv_interp = uv;
  218.  
  219.     gl_Position = canvas_data.screen_transform * vec4(vertex,0.0,1.0);
  220.  
  221. #ifdef USE_POINT_SIZE
  222.     gl_PointSize=point_size;
  223. #endif
  224.  
  225. }
  226.  
  227. /* clang-format off */
  228. [fragment]
  229.  
  230. #version 450
  231.  
  232. /* clang-format off */
  233. VERSION_DEFINES
  234. /* clang-format on */
  235.  
  236. #include "canvas_uniforms_inc.glsl"
  237.  
  238. layout(location=0) in vec2 uv_interp;
  239. layout(location=1) in vec4 color_interp;
  240. layout(location=2) in vec2 vertex_interp;
  241.  
  242. #ifdef USE_NINEPATCH
  243.  
  244. layout(location=3) in vec2 pixel_size_interp;
  245.  
  246. #endif
  247.  
  248. layout(location = 0) out vec4 frag_color;
  249.  
  250. #ifdef USE_MATERIAL_UNIFORMS
  251. layout(set = 1, binding = 1, std140) uniform MaterialUniforms {
  252. /* clang-format off */
  253. MATERIAL_UNIFORMS
  254. /* clang-format on */
  255. } material;
  256. #endif
  257.  
  258.  
  259. /* clang-format off */
  260. FRAGMENT_SHADER_GLOBALS
  261. /* clang-format on */
  262.  
  263. #ifdef LIGHT_SHADER_CODE_USED
  264.  
  265. vec4 light_compute(
  266.         vec3 light_vertex,
  267.         vec3 light_position,
  268.         vec3 normal,
  269.         vec4 light_color,
  270.         float light_energy,
  271.         vec4 specular_shininess,
  272.         inout vec4 shadow_modulate,
  273.         vec2 screen_uv,
  274.         vec2 uv,
  275.         vec4 color) {
  276.  
  277.     vec4 light = vec4(0.0);
  278.     /* clang-format off */
  279. LIGHT_SHADER_CODE
  280.     /* clang-format on */
  281.     return light;
  282. }
  283.  
  284. #endif
  285.  
  286. #ifdef USE_NINEPATCH
  287.  
  288. float map_ninepatch_axis(float pixel, float draw_size, float tex_pixel_size, float margin_begin, float margin_end, int np_repeat, inout int draw_center) {
  289.  
  290.     float tex_size = 1.0 / tex_pixel_size;
  291.  
  292.     if (pixel < margin_begin) {
  293.         return pixel * tex_pixel_size;
  294.     } else if (pixel >= draw_size - margin_end) {
  295.         return (tex_size - (draw_size - pixel)) * tex_pixel_size;
  296.     } else {
  297.         if (!bool(draw_data.flags&FLAGS_NINEPACH_DRAW_CENTER)) {
  298.             draw_center--;
  299.         }
  300.  
  301.         if (np_repeat == 0) { //stretch
  302.             //convert to ratio
  303.             float ratio = (pixel - margin_begin) / (draw_size - margin_begin - margin_end);
  304.             //scale to source texture
  305.             return (margin_begin + ratio * (tex_size - margin_begin - margin_end)) * tex_pixel_size;
  306.         } else if (np_repeat == 1) { //tile
  307.             //convert to ratio
  308.             float ofs = mod((pixel - margin_begin), tex_size - margin_begin - margin_end);
  309.             //scale to source texture
  310.             return (margin_begin + ofs) * tex_pixel_size;
  311.         } else if (np_repeat == 2) { //tile fit
  312.             //convert to ratio
  313.             float src_area = draw_size - margin_begin - margin_end;
  314.             float dst_area = tex_size - margin_begin - margin_end;
  315.             float scale = max(1.0, floor(src_area / max(dst_area, 0.0000001) + 0.5));
  316.  
  317.             //convert to ratio
  318.             float ratio = (pixel - margin_begin) / src_area;
  319.             ratio = mod(ratio * scale, 1.0);
  320.             return (margin_begin + ratio * dst_area) * tex_pixel_size;
  321.         }
  322.     }
  323. }
  324.  
  325.  
  326. #endif
  327.  
  328. void main() {
  329.  
  330.     vec4 color = color_interp;
  331.     vec2 uv = uv_interp;
  332.     vec2 vertex = vertex_interp;
  333.  
  334. #if !defined(USE_ATTRIBUTES) && !defined(USE_PRIMITIVE)
  335.  
  336. #ifdef USE_NINEPATCH
  337.  
  338.     int draw_center = 2;
  339.     uv = vec2(
  340.             map_ninepatch_axis(pixel_size_interp.x, abs(draw_data.dst_rect.z), draw_data.color_texture_pixel_size.x, draw_data.ninepatch_margins.x, draw_data.ninepatch_margins.z, int(draw_data.flags>>FLAGS_NINEPATCH_H_MODE_SHIFT)&0x3, draw_center),
  341.             map_ninepatch_axis(pixel_size_interp.y, abs(draw_data.dst_rect.w), draw_data.color_texture_pixel_size.y, draw_data.ninepatch_margins.y, draw_data.ninepatch_margins.w, int(draw_data.flags>>FLAGS_NINEPATCH_V_MODE_SHIFT)&0x3, draw_center));
  342.  
  343.     if (draw_center == 0) {
  344.         color.a = 0.0;
  345.     }
  346.  
  347.     uv = uv * draw_data.src_rect.zw + draw_data.src_rect.xy; //apply region if needed
  348.  
  349. #endif 
  350.     if (bool(draw_data.flags&FLAGS_CLIP_RECT_UV)) {
  351.  
  352.         uv = clamp(uv, draw_data.src_rect.xy, draw_data.src_rect.xy + abs(draw_data.src_rect.zw));
  353.     }
  354.  
  355. #endif
  356.  
  357.     color *= texture(sampler2D(color_texture,texture_sampler), uv);
  358.  
  359.     uint light_count = (draw_data.flags>>FLAGS_LIGHT_COUNT_SHIFT)&0xF; //max 16 lights
  360.  
  361.  
  362.     vec3 normal;
  363.  
  364. #if defined(NORMAL_USED)
  365.  
  366.     bool normal_used = true;
  367. #else
  368.     bool normal_used = false;
  369. #endif
  370.  
  371.  
  372.     if (normal_used || (light_count > 0 && bool(draw_data.flags&FLAGS_DEFAULT_NORMAL_MAP_USED))) {
  373.         normal.xy = texture(sampler2D(normal_texture,texture_sampler), uv).xy * vec2(2.0,-2.0) - vec2(1.0,-1.0);
  374.         normal.z = sqrt(1.0 - dot(normal.xy, normal.xy));
  375.         normal_used = true;
  376.     } else {
  377.         normal = vec3(0.0, 0.0, 1.0);
  378.     }
  379.  
  380.     vec4 specular_shininess;
  381.  
  382. #if defined(SPECULAR_SHININESS_USED)
  383.  
  384.     bool specular_shininess_used = true;
  385. #else
  386.     bool specular_shininess_used = false;
  387. #endif
  388.  
  389.     if (specular_shininess_used || (light_count > 0 && normal_used && bool(draw_data.flags&FLAGS_DEFAULT_SPECULAR_MAP_USED))) {
  390.         specular_shininess = texture(sampler2D(specular_texture,texture_sampler ), uv);
  391.         specular_shininess *= unpackUnorm4x8(draw_data.specular_shininess);
  392.         specular_shininess_used=true;
  393.     } else {
  394.         specular_shininess = vec4(1.0);
  395.     }
  396.  
  397.  
  398. #if defined(SCREEN_UV_USED)
  399.     vec2 screen_uv = gl_FragCoord.xy * canvas_data.screen_pixel_size;
  400. #else
  401.     vec2 screen_uv = vec2(0.0);
  402. #endif
  403.  
  404.     vec3 light_vertex = vec3(vertex,0.0);
  405.     vec2 shadow_vertex = vertex;
  406.  
  407.     {
  408.         float normal_depth = 1.0;
  409.  
  410. #if defined(NORMALMAP_USED)
  411.         vec3 normal_map = vec3(0.0, 0.0, 1.0);
  412.         normal_used = true;
  413. #endif
  414.  
  415.         /* clang-format off */
  416.  
  417. FRAGMENT_SHADER_CODE
  418.  
  419.         /* clang-format on */
  420.  
  421. #if defined(NORMALMAP_USED)
  422.         normal = mix(vec3(0.0, 0.0, 1.0), normal_map * vec3(2.0, -2.0, 1.0) - vec3(1.0, -1.0, 0.0), normal_depth);
  423. #endif
  424.     }
  425.  
  426.     if (normal_used) {
  427.         //convert by item transform
  428.         normal.xy = mat2(normalize(draw_data.world_x), normalize(draw_data.world_y)) * normal.xy;
  429.         //convert by canvas transform
  430.         normal = normalize((canvas_data.canvas_normal_transform *  vec4(normal,0.0)).xyz);
  431.     }
  432.  
  433.  
  434.     vec4 base_color=color;
  435.     if (bool(draw_data.flags&FLAGS_USING_LIGHT_MASK)) {
  436.         color=vec4(0.0); //inivisible by default due to using light mask
  437.     }
  438.  
  439.     color*=canvas_data.canvas_modulation;
  440. #ifdef USE_LIGHTING
  441.     for(uint i=0;i<MAX_LIGHT_TEXTURES;i++) {
  442.         if (i>=light_count) {
  443.             break;
  444.         }
  445.         uint light_base;
  446.         if (i<8) {
  447.             if (i<4) {
  448.                 light_base=draw_data.lights[0];
  449.             } else {
  450.                 light_base=draw_data.lights[1];
  451.             }
  452.         } else {
  453.             if (i<12) {
  454.                 light_base=draw_data.lights[2];
  455.             } else {
  456.                 light_base=draw_data.lights[3];
  457.             }
  458.         }
  459.         light_base>>=(i&3)*8;
  460.         light_base&=0xFF;
  461.  
  462.         vec2 tex_uv = (vec4(vertex,0.0,1.0) * mat4(light_array.data[light_base].matrix[0],light_array.data[light_base].matrix[1],vec4(0.0,0.0,1.0,0.0),vec4(0.0,0.0,0.0,1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
  463.         vec4 light_color = texture(sampler2D(light_textures[i],texture_sampler),tex_uv);               
  464.         vec4 light_base_color = light_array.data[light_base].color;
  465.  
  466. #ifdef LIGHT_SHADER_CODE_USED
  467.  
  468.         vec4 shadow_modulate = vec4(1.0);
  469.         vec3 light_position = vec3(light_array.data[light_base].position,light_array.data[light_base].height);
  470.  
  471.         light_color.rgb*=light_base_color.rgb;
  472.         light_color = light_compute(light_vertex,light_position,normal,light_color,light_base_color.a,specular_shininess,shadow_modulate,screen_uv,color,uv);
  473. #else
  474.  
  475.  
  476.         light_color.rgb*=light_base_color.rgb*light_base_color.a;
  477.  
  478.         if (normal_used) {
  479.  
  480.             vec3 light_pos = vec3(light_array.data[light_base].position,light_array.data[light_base].height);
  481.             vec3 pos = light_vertex;
  482.             vec3 light_vec = normalize(light_pos-pos);
  483.             float cNdotL = max(0.0,dot(normal,light_vec));
  484.  
  485.             if (specular_shininess_used) {
  486.                 //blinn
  487.                 vec3 view = vec3(0.0,0.0,1.0);// not great but good enough
  488.                 vec3 half_vec = normalize(view+light_vec);
  489.  
  490.                 float cNdotV = max(dot(normal, view), 0.0);
  491.                 float cNdotH = max(dot(normal, half_vec), 0.0);
  492.                 float cVdotH = max(dot(view, half_vec), 0.0);
  493.                 float cLdotH = max(dot(light_vec, half_vec), 0.0);
  494.                 float shininess = exp2(15.0 * specular_shininess.a + 1.0) * 0.25;
  495.                 float blinn = pow(cNdotH, shininess);
  496.                 blinn *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
  497.                 float s = (blinn) / max(4.0 * cNdotV * cNdotL, 0.75);
  498.  
  499.                 light_color.rgb = specular_shininess.rgb * light_base_color.rgb * s + light_color.rgb * cNdotL;
  500.             } else {
  501.                 light_color.rgb *= cNdotL;
  502.             }
  503.  
  504.         }
  505. #endif
  506.         if (any(lessThan(tex_uv, vec2(0.0, 0.0))) || any(greaterThanEqual(tex_uv, vec2(1.0, 1.0)))) {
  507.             //if outside the light texture, light color is zero
  508.             light_color.a = 0.0;
  509.         }
  510.  
  511.         if (bool(light_array.data[light_base].flags&LIGHT_FLAGS_HAS_SHADOW)) {
  512.  
  513.             vec2 shadow_pos = (vec4(shadow_vertex,0.0,1.0) * mat4(light_array.data[light_base].shadow_matrix[0],light_array.data[light_base].shadow_matrix[1],vec4(0.0,0.0,1.0,0.0),vec4(0.0,0.0,0.0,1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
  514.  
  515.             vec2 pos_norm = normalize(shadow_pos);
  516.             vec2 pos_abs = abs(pos_norm);
  517.             vec2 pos_box = pos_norm / max(pos_abs.x,pos_abs.y);
  518.             vec2 pos_rot = pos_norm * mat2(vec2(0.7071067811865476,-0.7071067811865476),vec2(0.7071067811865476,0.7071067811865476)); //is there a faster way to 45 degrees rot?
  519.             float tex_ofs;
  520.             float distance;
  521.             if (pos_rot.y>0) {
  522.                 if (pos_rot.x>0) {
  523.                     tex_ofs=pos_box.y*0.125+0.125;
  524.                     distance=shadow_pos.x;
  525.                 } else {
  526.                     tex_ofs=pos_box.x*-0.125+(0.25+0.125);
  527.                     distance=shadow_pos.y;
  528.                 }
  529.             } else {
  530.                 if (pos_rot.x<0) {
  531.                     tex_ofs=pos_box.y*-0.125+(0.5+0.125);
  532.                     distance=-shadow_pos.x;
  533.                 } else {
  534.                     tex_ofs=pos_box.x*0.125+(0.75+0.125);
  535.                     distance=-shadow_pos.y;
  536.                 }
  537.             }
  538.  
  539.             //float distance = length(shadow_pos);
  540.             float shadow;
  541.             uint shadow_mode = light_array.data[light_base].flags&LIGHT_FLAGS_FILTER_MASK;
  542.  
  543.             vec4 shadow_uv = vec4(tex_ofs,0.0,distance,1.0);
  544.  
  545.             if (shadow_mode==LIGHT_FLAGS_SHADOW_NEAREST) {
  546.                 shadow = textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv).x;
  547.             } else if (shadow_mode==LIGHT_FLAGS_SHADOW_PCF5) {
  548.                 vec4 shadow_pixel_size = vec4(light_array.data[light_base].shadow_pixel_size,0.0,0.0,0.0);
  549.                 shadow = 0.0;
  550.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*2.0).x;
  551.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size).x;
  552.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv).x;
  553.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size).x;
  554.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*2.0).x;
  555.                 shadow/=5.0;
  556.             } else { //PCF13
  557.                 vec4 shadow_pixel_size = vec4(light_array.data[light_base].shadow_pixel_size,0.0,0.0,0.0);
  558.                 shadow = 0.0;
  559.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*6.0).x;
  560.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*5.0).x;
  561.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*4.0).x;
  562.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*3.0).x;
  563.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size*2.0).x;
  564.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv-shadow_pixel_size).x;
  565.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv).x;
  566.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size).x;
  567.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*2.0).x;
  568.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*3.0).x;
  569.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*4.0).x;
  570.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*5.0).x;
  571.                 shadow += textureProj(sampler2DShadow(shadow_textures[i],shadow_sampler),shadow_uv+shadow_pixel_size*6.0).x;
  572.                 shadow/=13.0;
  573.             }
  574.  
  575.             vec4 shadow_color = light_array.data[light_base].shadow_color;
  576. #ifdef LIGHT_SHADER_CODE_USED
  577.             shadow_color*=shadow_modulate;
  578. #endif
  579.             light_color = mix(light_color,shadow_color,shadow);
  580.  
  581.         }
  582.  
  583.         uint blend_mode = light_array.data[light_base].flags&LIGHT_FLAGS_BLEND_MASK;
  584.  
  585.         switch(blend_mode) {
  586.             case LIGHT_FLAGS_BLEND_MODE_ADD: {
  587.                 color.rgb+=light_color.rgb*light_color.a;
  588.             } break;
  589.             case LIGHT_FLAGS_BLEND_MODE_SUB: {
  590.                 color.rgb-=light_color.rgb*light_color.a;
  591.             } break;
  592.             case LIGHT_FLAGS_BLEND_MODE_MIX: {
  593.                 color.rgb=mix(color.rgb,light_color.rgb,light_color.a);
  594.             } break;
  595.             case LIGHT_FLAGS_BLEND_MODE_MASK: {
  596.                 light_color.a*=base_color.a;
  597.                 color.rgb=mix(color.rgb,light_color.rgb,light_color.a);
  598.             } break;
  599.         }
  600.     }
  601. #endif
  602.  
  603.     frag_color = color;
  604.  
  605. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!