A nice one with function call, no trigonometric function but also no test !
It's full of DOT product. There is very few texture access and fewer
access to the vector element than the previous filter.
One person speak about the use of cache in the GPU. I think it could be
usefull to have dedicated memory for texture for exemple.
i supposed that "half" is 16 bits integer ?
I begin to read ARB_vertext_program anf ARB_fragment_program 70 pages each :/
All of this show me that GPU are almost like normal CPU that manage more
complexe DATA (vect4 rather than int). The shader code will not go in 256
ASM instructions. And you need function call, a _lot_ of register, and
if-clause and loops.
So you need something simple that look a lot like simple CPU but with udge
unit.
> Oh, there can be much more than that. Here is a more complete vertex
> & fragment shader program.
>
>
>
>
> ///////////////////////////////////////////////////////////////////////////////
> // Vertex source
> ///////////////////////////////////////////////////////////////////////////////
>
>
> struct interpolants
> {
> float2 texcoords : TEXCOORD0;
> float2 texcoords1 : TEXCOORD1;
> float4 tangentToEyeMat0 : TEXCOORD4;
> float4 tangentToEyeMat1 : TEXCOORD5;
> float3 tangentToEyeMat2 : TEXCOORD6;
> float4 eyeSpacePosition : TEXCOORD7;
> };
>
> void vertexProgram(in float4 oPosition : POSITION,
> in float2 texcoord0 : TEXCOORD0,
> in float3 tangent : TANGENT,
> in float3 binormal : BINORMAL,
> in float3 normal : NORMAL,
>
> out float4 hPosition : POSITION,
> out float4 color : COLOR0,
> out interpolants OUT,
>
> uniform float bumpScale,
>
> uniform float diseaseMapScale,
> uniform float diseaseBumpScale,
>
> uniform float4x4 modelViewProj,
> uniform float4x4 modelView)
> {
> hPosition = mul(modelViewProj, oPosition);
> color = float4(1.0, 1.0, 1.0, 1.0);
>
> OUT.texcoords = texcoord0;
> OUT.texcoords1 = diseaseMapScale * texcoord0;
>
> OUT.eyeSpacePosition = mul(modelView, oPosition);
>
> OUT.tangentToEyeMat0.x = dot(modelView[0].xyz, tangent);
> OUT.tangentToEyeMat0.y = dot(modelView[0].xyz, binormal);
> OUT.tangentToEyeMat0.z = dot(modelView[0].xyz, normal);
> OUT.tangentToEyeMat0.w = bumpScale;
>
> OUT.tangentToEyeMat1.x = dot(modelView[1].xyz, tangent);
> OUT.tangentToEyeMat1.y = dot(modelView[1].xyz, binormal);
> OUT.tangentToEyeMat1.z = dot(modelView[1].xyz, normal);
> OUT.tangentToEyeMat1.w = diseaseBumpScale;
>
> OUT.tangentToEyeMat2.x = dot(modelView[2].xyz, tangent);
> OUT.tangentToEyeMat2.y = dot(modelView[2].xyz, binormal);
> OUT.tangentToEyeMat2.z = dot(modelView[2].xyz, normal);
> }
>
> ///////////////////////////////////////////////////////////////////////////////
> // Fragment source
> ///////////////////////////////////////////////////////////////////////////////
>
> struct fragin
> {
> half2 texcoords : TEXCOORD0;
> half2 diseasecoords : TEXCOORD1;
> half4 tangentToEyeMat0 : TEXCOORD4;
> half4 tangentToEyeMat1 : TEXCOORD5;
> half3 tangentToEyeMat2 : TEXCOORD6;
> half3 eyeSpacePosition : TEXCOORD7;
> };
>
> half4 blinnSkin(fragin In,
> uniform sampler2D normalTexture,
> uniform sampler2D diffuseTexture,
> uniform sampler2D glossyTexture,
> uniform half3 eyeSpaceLightPosition) : COLOR
> {
> half4 kd = tex2D(diffuseTexture, In.texcoords); // diffuse color
> half4 ks = tex2D(glossyTexture, In.texcoords); // specular color
>
> // Get eye-space eye vector.
> half3 v = normalize(-In.eyeSpacePosition);
>
> // Get eye-space light and halfangle vectors.
> half3 l = normalize(eyeSpaceLightPosition - In.eyeSpacePosition);
>
> half3 h = normalize(v + l);
>
> // Get tangent-space normal vector from normal map.
> half3 bumpScale = {In.tangentToEyeMat0.ww, 1};
> half3 tangentSpaceNormal bumpScale * tex2D(normalTexture,
> In.texcoords).xyz;
>
> // Transform it into eye-space.
> half3 n;
> n.x = dot(In.tangentToEyeMat0.xyz, tangentSpaceNormal);
> n.y = dot(In.tangentToEyeMat1.xyz, tangentSpaceNormal);
> n.z = dot(In.tangentToEyeMat2, tangentSpaceNormal);
>
> static const half m = 34; // specular exponent
> half4 coeffs;
>
> n = normalize(n);
> coeffs.y = dot(n,l);
> coeffs.z = dot(n,h);
>
> coeffs = lit(coeffs.y, coeffs.z, m);
>
> // Compute Blinn-Phong lighting.
> return coeffs.y * kd + coeffs.z * ks;
> }
>
>
> half4 crawlSkin(fragin In,
> uniform sampler2D normalTexture,
> uniform sampler2D diffuseTexture,
> uniform sampler2D glossyTexture,
> uniform sampler2D diseaseNormalTexture,
> uniform half3 eyeSpaceLightPosition) : COLOR
> {
> half4 kd = tex2D(diffuseTexture, In.texcoords); // diffuse color
> half4 ks = tex2D(glossyTexture, In.texcoords); // specular color
>
> // Get eye-space eye vector.
> half3 v = normalize(-In.eyeSpacePosition);
>
> // Get eye-space light and halfangle vectors.
> half3 l = normalize(eyeSpaceLightPosition - In.eyeSpacePosition);
>
> half3 h = normalize(v + l);
>
> // Get tangent-space normal vector from normal map.
> half3 bumpScale = { In.tangentToEyeMat0.ww, 1 };
> half3 diseaseBumpScale = { In.tangentToEyeMat1.ww, 1 };
>
> half3 tangentSpaceNormal = diseaseBumpScale *
> (2 * tex2D(diseaseNormalTexture, In.diseasecoords).xyz - 1);
> tangentSpaceNormal += bumpScale * tex2D(normalTexture,
> In.texcoords).xyz;
>
> // Transform it into eye-space.
> half3 n;
> n.x = dot(In.tangentToEyeMat0.xyz, tangentSpaceNormal);
> n.y = dot(In.tangentToEyeMat1.xyz, tangentSpaceNormal);
> n.z = dot(In.tangentToEyeMat2, tangentSpaceNormal);
>
> static const half m = 34; // specular exponent
> half4 coeffs;
>
> n = normalize(n);
> coeffs.y = dot(n,l);
> coeffs.z = dot(n,h);
>
> coeffs = lit(coeffs.y, coeffs.z, m);
>
> // Compute Blinn-Phong lighting.
> return coeffs.y * kd + coeffs.z * ks;
> }
>
> half4 diseaseSkin(fragin In,
> uniform sampler2D normalTexture,
> uniform sampler2D diffuseTexture,
> uniform sampler2D glossyTexture,
> uniform sampler2D diseaseNormalTexture,
> uniform sampler2D diseaseTexture,
> uniform half3 eyeSpaceLightPosition,
> uniform half3 diseaseColor) : COLOR
> {
> half4 kd = tex2D(diffuseTexture, In.texcoords); // diffuse color
> half4 ks = tex2D(glossyTexture, In.texcoords); // specular color
>
> // Get eye-space eye vector.
> half3 v = normalize(-In.eyeSpacePosition);
>
> // Get eye-space light and halfangle vectors.
> half3 l = normalize(eyeSpaceLightPosition - In.eyeSpacePosition);
>
> half3 h = normalize(v + l);
>
> // Get tangent-space normal vector from normal map.
> half3 bumpScale = {In.tangentToEyeMat0.ww, 1};
> half3 diseaseBumpScale = { In.tangentToEyeMat1.w,
> In.tangentToEyeMat1.w, 1 };
> // The dynamic normal map is unsigned, so we have to scale and
> bias to [-1, 1].
> half3 tangentSpaceNormal = diseaseBumpScale *
> (2 * h3tex2D(diseaseNormalTexture, In.diseasecoords).rgb - 1);
> tangentSpaceNormal += bumpScale * h3tex2D( normalTexture,
> In.texcoords ).rgb;
>
> // Transform it into eye-space.
> half3 n;
> n.x = dot(In.tangentToEyeMat0.xyz, tangentSpaceNormal);
> n.y = dot(In.tangentToEyeMat1.xyz, tangentSpaceNormal);
> n.z = dot(In.tangentToEyeMat2, tangentSpaceNormal);
>
> n = normalize(n);
> // Modify the skin color where the disease makes lesions.
> half t = 1 - tex2D(diseaseTexture, In.diseasecoords).x;
> kd.xyz = lerp(kd.xyz, diseaseColor, t);
>
> static const half m = 34; // specular exponent
> half4 coeffs;
>
> coeffs.y = dot(n,l);
> coeffs.z = dot(n,h);
>
> coeffs = lit(coeffs.y, coeffs.z, m);
>
> // Compute Blinn-Phong lighting.
> return coeffs.y * kd + coeffs.z * ks;
> }
>
> half4 chromeSkin(fragin In,
> uniform sampler2D normalTexture,
> uniform sampler2D diffuseTexture,
> uniform sampler2D glossyTexture,
> uniform sampler2D diseaseNormalTexture,
> uniform sampler2D diseaseTexture,
> uniform samplerCUBE envTexture,
> uniform half3 eyeSpaceLightPosition) : COLOR
> {
> half4 kd = tex2D(diffuseTexture, In.texcoords); // diffuse color
> half4 ks = tex2D(glossyTexture, In.texcoords); // specular color
>
> // Get eye-space eye vector.
> half3 v = normalize(-In.eyeSpacePosition);
>
> // Get eye-space light and halfangle vectors.
> half3 l = normalize(eyeSpaceLightPosition - In.eyeSpacePosition);
>
> half3 h = normalize(v + l);
>
> // Get tangent-space normal vector from normal map.
> half3 bumpScale = {In.tangentToEyeMat0.ww, 1};
> half3 diseaseBumpScale = { In.tangentToEyeMat1.w,
> In.tangentToEyeMat1.w, 1 };
> // The dynamic normal map is unsigned, so we have to scale and
> bias to [-1, 1].
> half3 tangentSpaceNormal = diseaseBumpScale *
> (2 * h3tex2D(diseaseNormalTexture, In.diseasecoords).rgb - 1);
> tangentSpaceNormal += bumpScale * h3tex2D( normalTexture,
> In.texcoords ).rgb;
>
> // Transform it into eye-space.
> half3 n;
> n.x = dot(In.tangentToEyeMat0.xyz, tangentSpaceNormal);
> n.y = dot(In.tangentToEyeMat1.xyz, tangentSpaceNormal);
> n.z = dot(In.tangentToEyeMat2, tangentSpaceNormal);
>
> n = normalize(n);
>
> // Modify the skin color where the disease makes lesions.
> half t = 1 - tex2D(diseaseTexture, In.diseasecoords).x;
> kd.xyz = lerp(kd.xyz, texCUBE(envTexture, n), smoothstep(0.5, 1.0,
> diseaseBumpScale * t));
>
> static const half m = 34; // specular exponent
> half4 coeffs;
>
> coeffs.y = dot(n,l);
> coeffs.z = dot(n,h);
>
> coeffs = lit(coeffs.y, coeffs.z, m);
>
> // Compute Blinn-Phong lighting.
> return coeffs.y * kd + coeffs.z * ks;
> }
>
>
>
> On 4/18/06, Timothy Miller <[EMAIL PROTECTED]> wrote:
>> On 4/18/06, Daniel Rozsnyó <[EMAIL PROTECTED]> wrote:
>> > The shader is not a program, better call it a filter, it takes some
>> > input (vertex, fragment) and modifies it. I suppose that these are the
>> > data inputs:
>> >
>> > varying vec3 Normal;
>> > varying vec3 EyeDir;
>> > varying vec4 EyePos;
>> > varying float LightIntensity;
>>
>> All of that information is available even for fragment shaders? Wow.
>> That's a heck of a lot of information. :)
>> _______________________________________________
>> Open-graphics mailing list
>> [email protected]
>> http://lists.duskglow.com/mailman/listinfo/open-graphics
>> List service provided by Duskglow Consulting, LLC (www.duskglow.com)
>>
>
>
> --
> I think computer viruses should count as life. I think it says
> something about human nature that the only form of life we have
> created so far is purely destructive. We've created life in our own
> image. (Stephen Hawking)
> _______________________________________________
> Open-graphics mailing list
> [email protected]
> http://lists.duskglow.com/mailman/listinfo/open-graphics
> List service provided by Duskglow Consulting, LLC (www.duskglow.com)
>
_______________________________________________
Open-graphics mailing list
[email protected]
http://lists.duskglow.com/mailman/listinfo/open-graphics
List service provided by Duskglow Consulting, LLC (www.duskglow.com)
