Scolring - Forum

// This is a comment

// Our material had two techniques, one is a shader bump effect, and one "backup" technique with no shader for PC that does not support the shaders used.
material cube_material.018
{
    technique cube_technique_bump   // Technique "name" is optionnal
    {
        pass cube_ambient_pass          // Pass "name" is optionnal
        { 
            vertex_program_ref ambient_vs
            {
            }
           
            fragment_program_ref ambient_ps
            {
            }
           
            texture_unit                        // Texture_unit "name" is optionnal too, automatically generated here
            {
                texture Cube/floor04_diff.png
                filtering liner liner liner
            }
           
            texture_unit
            {
                texture Cube/floor04_spec.png
                filtering liner liner liner
            }
        }

        pass cube_diffuse_pass
        {
            iteration once_per_light
	    scene_blend add
	    illumination_stage per_light

            vertex_program_ref diffuse_vs
	    {
	    }

	    fragment_program_ref diffuse_ps
	    {
	    }

	    texture_unit
	    {
	        texture Cube/floor04_diff.png
                filtering linear linear linear
            }

            texture_unit
            {
                texture Cube/floor04_spec.png
                filtering linear linear linear
            }

            texture_unit
            {
                texture Cube/floor04_normal.png
                filtering liner liner liner
            }
        }
    }

    technique cube_technique_no_shaders
    {
        pass cube_diffuse_pass
        {
            ambient 0.356863 0.356863 0.356863 1
            diffuse 0.603922 0.603922 0.603922 1
            specular 0.898039 0.898039 0.898039 1 80

            texture_unit
            {
                texture Cube/floor04_diff.png
                filtering linear linear linear
            }
        }
    }
}

material fond_piscine
{
	lod_distances 0 10
	technique Map#36
	{
	  lod_index 1
		pass Map#37
		{
			ambient 0.356863 0.356863 0.356863 1
			diffuse 0.603922 0.603922 0.603922 1
			specular 0.898039 0.898039 0.898039 1 80

			vertex_program_ref ambient_vs
			{
			}

			fragment_program_ref ambient_ps
			{
			}

			texture_unit Map#38
			{
				texture_alias Map#38
				texture examples/media/bitmap/fond_piscine_diff.jpg
				filtering linear linear linear
			}

			texture_unit Map#304
			{
				texture_alias Map#304
				texture examples/media/bitmap/fond_piscine_spec.jpg
				filtering linear linear linear
			}
		}

		pass Map#305
		{
			iteration once_per_light
			ambient 0.356863 0.356863 0.356863 1
			diffuse 0.603922 0.603922 0.603922 1
			specular 0.898039 0.898039 0.898039 1 80
			scene_blend add
			illumination_stage per_light

			vertex_program_ref diffuse_vs
			{
			}

			fragment_program_ref diffuse_ps
			{
			}

			texture_unit Map#38
			{
				texture_alias Map#38
				texture examples/media/bitmap/fond_piscine_diff.jpg
				filtering linear linear linear
			}

			texture_unit Map#304
			{
				texture_alias Map#304
				texture examples/media/bitmap/fond_piscine_spec.jpg
				filtering linear linear linear
			}

			texture_unit Map#306
			{
				texture_alias Map#306
				texture examples/media/bitmap/fond_piscine_normal.jpg
				filtering linear linear linear
			}
		}

	}

	technique Texture#332
	{
	  lod_index 2
		pass Map#37
		{
			ambient 0.356863 0.356863 0.356863 1
			diffuse 0.603922 0.603922 0.603922 1
			specular 0.898039 0.898039 0.898039 1 80

			texture_unit Map#38
			{
				texture_alias Map#38
				texture examples/media/bitmap/fond_piscine_diff.jpg
				filtering linear linear linear
			}
		}
	}

}

material OpenSpace3D/Growing_Fur
{
    technique
    {
        pass base_coat
        {
            ambient 0.698039 0.698039 0.698039 1
            diffuse 0.698039 0.698039 0.698039 1
            specular 0.898039 0.898039 0.898039 1 20

            vertex_program_ref ambient_vs
            {
            }

            fragment_program_ref ambient_ps
            {
            }

            texture_unit
            {
                texture Fur/skin.jpg
                filtering linear linear linear
            }

            texture_unit
            {
                texture white.jpg
                filtering linear linear linear
            }
        }

        pass grow_fur
        {
            iteration 32 per_light
            ambient 0.65098 0.65098 0.65098 1
            diffuse 0.698039 0.698039 0.698039 1
            specular 0.898039 0.898039 0.898039 1 20
            scene_blend alpha_blend
            depth_write off

            vertex_program_ref OpenSpace3D/fur_vs
            {
                param_named UVScale float4 0.8 0.8 0 0
                param_named furHeight float4 0.12 0 0 0
                param_named gravity float4 0 0.06 0 0
                param_named totalPass float4 32 0 0 0
            }

            fragment_program_ref OpenSpace3D/fur_ps
            {
            }

            texture_unit
            {
                texture Fur/Fur.tga
                filtering linear linear linear
            }

            texture_unit
            {
                texture Fur/skin.jpg
                filtering linear linear linear
            }
        }
    }
}

struct typInput {
  float4 Position : POSITION;
  float3 Normal   : NORMAL;
  float2 uv0      : TEXCOORD0;
  float4 c        : COLOR0;
};

struct typOutput {
  float4 Position : POSITION;
  float4 light    : COLOR1;
  float2 T0       : TEXCOORD0;
  float2 T1       : TEXCOORD1;
  float2 T2       : TEXCOORD2;
};

typOutput main(typInput inData, 
      uniform float3 gravity,
      uniform float furHeight,
      uniform float totalPass,
      uniform float2 UVScale,
      uniform float4x4 wvpMat,
      uniform float4x4 iwpMat,
      uniform float4x4 wpMat,
      uniform float4 eyePosition,
      uniform float3 ambientColor,
      uniform float4 lightPosition,
      uniform float4 lightAttenuation,
      uniform float3 lightDiffuseColor,
      uniform float3 Ke,
      uniform float3 Ka,
      uniform float3 Kd,
      uniform float3 Ks,
      uniform float shininess,
      uniform float multiPassIter){
  typOutput outData;

  float4 normal = mul(wpMat, float4(inData.Normal, 1.0));
  // light
  float4 tmpcolor = inData.c;
  
  furHeight = furHeight * ((1.0 / (totalPass + 1)) * (multiPassIter + 1));
  float3 vGravity = mul(wpMat, float4(gravity, 0.0)).xyz;
  
  //float pp = 3.14 * 0.5 * Layer; // depth paramete
    //float A = dot(normal, vGravity);  //A is the angle between surface normal and gravity vector
  float k = pow(((1.0 / (totalPass + 1)) * (multiPassIter + 1)), 3); // We use the pow function, so that only the tips of the hairs bend
                             // As layer goes from 0 to 1, so by using pow(..) function is still 
                             // goes form 0 to 1, but it increases faster! exponentially
  
  float3 P = inData.Position.xyz + (inData.Normal * furHeight);
  P = P + vGravity*k;
  
  float4 znormal = 1 - dot(normal, float4(0,0,1,0));
  outData.T0 = inData.uv0 * UVScale;
    outData.T1 = inData.uv0 * UVScale + znormal.xy * 0.0007;
    outData.T2 = inData.uv0;  
  
  lightPosition = mul(iwpMat, lightPosition);
  eyePosition = mul(iwpMat, eyePosition);
  
  float3 N = normalize(inData.Normal);
  float3 emissive = Ke;
  float3 ambient = Ka * ambientColor;
  float3 L = normalize(lightPosition).xyz;
  float diffuseLight = max(dot(L, N), 0);
  float3 diffuse = Kd * lightDiffuseColor * diffuseLight;
  float3 V = normalize(eyePosition).xyz;
  float3 H = normalize(L + V);
  float specularLight = pow(max(dot(H, N), 0), shininess);
  if (diffuseLight <= 0) specularLight = 0;
  float3 specular = Ks * lightDiffuseColor * specularLight;
  tmpcolor.xyz = emissive + ambient + specular + diffuse;  
  
  outData.Position     = mul(wvpMat, float4(P, 1.0));
  outData.light        = tmpcolor;
  return outData;
}

struct typOut {
  float4 fragColor : COLOR;
};

struct typIn {
  float4 Position : POSITION;
  float4 light    : COLOR1;
  float2 T0       : TEXCOORD0;
  float2 T1       : TEXCOORD1;
  float2 T2       : TEXCOORD2;
  float2 ambient  : TEXCOORD3;
};


typOut main(typIn             inData,
            uniform float3    vecLightDir,
            uniform sampler2D noiseTexture : register(s0),
            uniform sampler2D colorTexture : register(s1),
            uniform float     spacing,
            uniform float     transparency) {

   typOut outData;

  float4 furcolr        = tex2D(noiseTexture, inData.T0);
    float4 furcolr_offset = tex2D(noiseTexture, inData.T1);
  float4 texcolr        = tex2D(colorTexture, inData.T2);

  float4 color = furcolr_offset - furcolr;
    
    float4 fcolor = color;
  fcolor.a = color.a;
  
  // Y is the luma, and contains most of the information of the image
  
    fcolor = (texcolr * inData.light) + (fcolor * inData.light);
  fcolor.a = color.a;
  
  //float furValue = tex2D(noiseTexture, inData.uv0 * float2(spacing, spacing) ).x * transparency;
  //outData.fragColor = float4(float3(inData.light) * tex2D(colorTexture, inData.uv0).rgb, furValue);
  
  outData.fragColor = fcolor;
  return outData;
}

// CG simple Fur
vertex_program OpenSpace3D/fur_vs cg
{
source Fur/FurV.cg
profiles vs_1_1 arbvp1
entry_point main

default_params
{
param_named furHeight float 0.15
param_named UVScale float2 1.0 1.0
param_named totalPass float 8
param_named_auto multiPassIter pass_iteration_number
param_named_auto wvpMat worldviewproj_matrix
param_named_auto wpMat world_matrix
param_named_auto iwpMat inverse_world_matrix
param_named_auto eyePosition camera_position
param_named_auto ambientColor ambient_light_colour
    param_named_auto lightPosition light_position 0
    param_named_auto lightDiffuseColor light_diffuse_colour 0
    param_named_auto shininess surface_shininess
    param_named_auto Ka surface_ambient_colour
    param_named_auto Kd surface_diffuse_colour
    param_named_auto Ke surface_emissive_colour
    param_named_auto Ks surface_specular_colour
}
}

fragment_program OpenSpace3D/fur_ps cg
{
source Fur/FurF.cg
profiles ps_2_x arbfp1
entry_point main

default_params
{
param_named spacing float 0.0
param_named transparency float 0.3
}
}