Attachment 63910 Details for Bug 51802 – shader from overgrowth game

shader from overgrowth game

shader_24.frag (text/plain), 7.79 KB, created by Sven Arvidsson on 2012-07-06 14:27:22 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Sven Arvidsson

Created: 2012-07-06 14:27:22 UTC

Size: 7.79 KB

patch

obsolete

>/* Shader 24 source, checksum 0 */
>uniform samplerCube tex2;
>
>varying vec3 normal;
>varying float opac;
>
>
>#line 4
>float GetDirectContribSimple( float amount ) {
>    return amount * gl_LightSource[0].diffuse.a;
>}
>
>float GetDirectContrib( const vec3 light_pos,
>                        const vec3 normal, 
>                        const float unshadowed ) {
>    float direct_contrib;
>    direct_contrib = max(0.0,dot(light_pos, normal));
>    direct_contrib *= unshadowed;
>    return GetDirectContribSimple(direct_contrib);
>}
>
>float GetDirectContribSoft( const vec3 light_pos,
>                            const vec3 normal, 
>                            const float unshadowed ) {
>    float direct_contrib;
>    direct_contrib = max(0.0,dot(light_pos, normal)*0.5+0.5);
>    direct_contrib *= unshadowed;
>    return GetDirectContribSimple(direct_contrib);
>}
>
>void SetCascadeShadowCoords(vec4 vert, inout vec4 sc[4]) {
>    sc[0] = gl_TextureMatrix[0] * gl_ModelViewMatrix * vert;
>    sc[1] = gl_TextureMatrix[1] * gl_ModelViewMatrix * vert;
>    sc[2] = gl_TextureMatrix[2] * gl_ModelViewMatrix * vert;
>    sc[3] = gl_TextureMatrix[3] * gl_ModelViewMatrix * vert;
>}
>
>float rand(vec2 co){
>    return fract(sin(dot(vec2(floor(co.x),floor(co.y)) ,vec2(12.9898,78.233))) * 43758.5453);
>}
>
>float GetCascadeShadow(sampler2DShadow tex5, vec4 sc[4], float dist){
>    vec3 shadow_tex = vec3(1.0);
>    
>
>    int index = 0;
>    if(dist > 20.0/2.8284){
>        index = 1;
>    }
>    if(dist > 60.0/2.8284){
>        index = 2;
>    }
>    if(dist > 250.0/2.8284){
>        index = 3;
>    }
>    vec4 shadow_coord = sc[index];
>    shadow_coord.z -= 0.00003 * pow(2.0, float(index)*1.7);
>    shadow_coord.x *= 0.5;
>    shadow_coord.y *= 0.5;
>    if(index == 1){
>        shadow_coord.x += 0.5;
>    }
>    if(index == 2){
>        shadow_coord.y += 0.5;
>    }
>    if(index == 3){
>        shadow_coord.xy += vec2(0.5);
>    }
>    if(shadow_coord.x >= 1.0 ||
>       shadow_coord.y >= 1.0 ||
>       shadow_coord.x <= 0.0 ||
>       shadow_coord.y <= 0.0)
>    {
>        return 1.0;
>    }
>    float shadow_amount = 0.0;
>    float offset = 0.0002;
>    shadow_amount += shadow2DProj(tex5,shadow_coord).r * 0.2;
>    shadow_amount += shadow2DProj(tex5,shadow_coord+vec4(offset,-offset*0.2,0.0,0.0)).r * 0.2;
>    shadow_amount += shadow2DProj(tex5,shadow_coord+vec4(-offset,offset*0.2,0.0,0.0)).r * 0.2;
>    shadow_amount += shadow2DProj(tex5,shadow_coord+vec4(offset*0.2,offset,0.0,0.0)).r * 0.2;
>    shadow_amount += shadow2DProj(tex5,shadow_coord+vec4(-offset*0.2,-offset,0.0,0.0)).r * 0.2;
>    return shadow_amount;
>}
>
>vec3 CalcVertexOffset (const vec4 world_pos, float wind_amount, float time, float plant_shake) {
>    vec3 vertex_offset = vec3(0.0);
>
>    float wind_shake_amount = 0.02;
>    float wind_time_scale = 8.0;
>    float wind_shake_detail = 6.0;
>    float wind_shake_offset = (world_pos.x+world_pos.y)*wind_shake_detail;
>    wind_shake_amount *= max(0.0,sin((world_pos.x+world_pos.y)+time*0.3));
>    wind_shake_amount *= sin((world_pos.x*0.1+world_pos.z)*0.3+time*0.6)+1.0;
>    wind_shake_amount = max(0.002,wind_shake_amount);
>    wind_shake_amount += plant_shake;
>    wind_shake_amount *= wind_amount;
>
>    vertex_offset.x += sin(time*wind_time_scale+wind_shake_offset);
>    vertex_offset.z += cos(time*wind_time_scale*1.2+wind_shake_offset);
>    vertex_offset.y += cos(time*wind_time_scale*1.4+wind_shake_offset);
>
>    vertex_offset *= wind_shake_amount;
>
>    return vertex_offset;
>}
>
>vec3 UnpackObjNormal(const vec4 normalmap) {
>    return normalize(vec3(2.0,2.0,-2.0)*normalmap.xzy + vec3(-1.0,-1.0,1.0));
>    
>
>}
>
>vec3 UnpackObjNormalV3(const vec3 normalmap) {
>    return normalize(vec3(2.0,2.0,-2.0)*normalmap.xzy + vec3(-1.0,-1.0,1.0));
>}
>
>
>
>vec3 PackObjNormal(const vec3 normal) {
>    return vec3(0.5,-0.5,0.5)*normal.xzy + vec3(0.5,0.5,0.5);
>    
>}
>
>vec3 UnpackTanNormal(const vec4 normalmap) {
>    return normalize(vec3(vec2(2.0,-2.0)*normalmap.xy + vec2(-1.0,1.0),normalmap.z));
>}
>
>vec3 GetDirectColor(const float intensity) {
>    return gl_LightSource[0].diffuse.xyz * intensity;
>}
>
>vec3 LookupCubemap(const mat3 obj2world_mat3, 
>                   const vec3 vec, 
>                   const samplerCube cube_map) {
>    vec3 world_space_vec = obj2world_mat3 * vec;
>    world_space_vec.xy *= -1.0;
>    return textureCube(cube_map,world_space_vec).xyz;
>}
>
>vec3 LookupCubemapMat4(const mat4 obj2world, 
>                   const vec3 vec, 
>                   const samplerCube cube_map) {
>    vec3 world_space_vec = (obj2world * vec4(vec,0.0)).xyz;
>    world_space_vec.xy *= -1.0;
>    return textureCube(cube_map,world_space_vec).xyz;
>}
>
>vec3 LookupCubemapSimple(const vec3 vec, 
>                   const samplerCube cube_map) {
>    vec3 world_space_vec = vec;
>    world_space_vec.xy *= -1.0;
>    return textureCube(cube_map,world_space_vec).xyz;
>}
>
>float GetAmbientMultiplier() {
>    return (1.5-gl_LightSource[0].diffuse.a*0.5);
>}
>
>float GetAmbientMultiplierScaled() {
>    return GetAmbientMultiplier()/1.5;
>}
>
>float GetAmbientContrib (const float unshadowed) {
>    float contrib = min(1.0,max(unshadowed * 1.5, 0.5));
>    contrib *= GetAmbientMultiplier();
>    return contrib;
>}
>
>float GetSpecContrib ( const vec3 light_pos,
>                       const vec3 normal,
>                       const vec3 vertex_pos,
>                       const float unshadowed ) {
>    vec3 H = normalize(normalize(vertex_pos*-1.0) + normalize(light_pos));
>    return min(1.0, pow(max(0.0,dot(normal,H)),10.0)*1.0)*unshadowed*gl_LightSource[0].diffuse.a;
>}
>
>float GetSpecContrib ( const vec3 light_pos,
>                       const vec3 normal,
>                       const vec3 vertex_pos,
>                       const float unshadowed,
>                       const float pow_val) {
>    vec3 H = normalize(normalize(vertex_pos*-1.0) + normalize(light_pos));
>    return min(1.0, pow(max(0.0,dot(normal,H)),pow_val)*1.0)*unshadowed*gl_LightSource[0].diffuse.a;
>}
>
>float BalanceAmbient ( const float direct_contrib ) {
>    return 1.0-direct_contrib*0.2;
>}
>
>float GetHazeAmount( in vec3 relative_position ) { 
>    float near = 0.1;
>    float far = 1000.0;
>    float fog_opac = min(1.0,length(relative_position)/far);
>    return fog_opac;
>}
>
>void AddHaze( inout vec3 color, 
>              in vec3 relative_position,
>              in samplerCube fog_cube ) { 
>    vec3 fog_color = textureCube(fog_cube,relative_position).xyz;
>    color = mix(color, fog_color, GetHazeAmount(relative_position));
>}
>
>float Exposure() {
>    return gl_LightSource[0].ambient.a;
>}
>
>
>
>float GammaCorrectFloat(in float val) {
>    return val;
>}
>
>vec3 GammaCorrectVec3(in vec3 val) {
>    return val;
>}
>
>vec3 GammaAntiCorrectVec3(in vec3 val) {
>    return val;
>}
>
>void ReadBloodTex(in sampler2D tex, in vec2 tex_coords, out float blood_amount, out float wetblood){
>    vec4 blood_tex = texture2D(tex,tex_coords);
>    blood_amount = min(blood_tex.r*5.0, 1.0);
>    wetblood = max(0.0,blood_tex.g*1.4-0.4);
>}
>
>void ApplyBloodToColorMap(inout vec4 colormap, in float blood_amount, in float temp_wetblood){
>    float wetblood = mix(temp_wetblood, 0.4, colormap.a);
>    colormap = mix(colormap, 
>                   mix(vec4(0.2*wetblood+0.05,0.0,0.0,wetblood),
>                       colormap*vec4(0.8,0.0,0.0,0.0)+vec4(0.0,0.0,0.0,wetblood*0.5+0.5),
>                       (1.0-wetblood)*0.5), 
>                   blood_amount);
>}
>
>#line 8
>vec3 YCOCGtoRGB(in vec4 YCoCg) {
>    float Co = YCoCg.r - 0.5;
>    float Cg = YCoCg.g - 0.5;
>    float Y  = YCoCg.a;
>    
>    float t = Y - Cg * 0.5;
>    float g = Cg + t;
>    float b = t - Co * 0.5;
>    float r = b + Co;
>    
>    r = max(0.0,min(1.0,r));
>    g = max(0.0,min(1.0,g));
>    b = max(0.0,min(1.0,b));
>
>    return vec3(r,g,b);
>}
>
>void main()
>{    
>    vec3 color;
>    
>    color = YCOCGtoRGB(textureCube(tex2,normal));
>    
>
>    color *= Exposure();
>
>    gl_FragColor = vec4(color,opac);
>}
>/* Compile status: fail */
>/* Log Info: */
>0:8(1): error: syntax error, unexpected $undefined, expecting $end

Actions: View

Attachments on bug 51802: 63910

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.