Under GPU Shader Analyzer (ATI's tool), that is; not under nvshaderperf... well, haven't tried yet.
Code: Select all
//NEW SHADER (high end)
uniform int light_enabled[gl_MaxLights];
uniform int max_light_enabled;
//samplers
uniform samplerCube cubeMap;
uniform sampler2D diffMap; //1-bit alpha in alpha, for alpha-testing only
uniform sampler2D specMap; //log256(shininess) in alpha
uniform sampler2D glowMap; //ambient occlusion in alpha
uniform sampler2D normMap; //U in .rgb; V in alpha (special encoding; see norm_decode())
uniform sampler2D damgMap; //"dielectricness" in blue, specular blend in alpha
uniform sampler2D detailMap; //.rgb adds to diffuse, subtracts from spec; alpha mods shininess
//other uniforms
uniform vec4 cloakdmg; //.rg=cloak, .ba=damage
#define cloak_alpha() ((cloakdmg.rrrg))
#define damage() ((cloakdmg.b))
#define inv_damage() ((1.0-cloakdmg.b))
//envColor won't be needed, since we're fetching it from the envmap
//NOTE: Since the term "binormal" has been rightly deprecated, I use "cotangent" instead :)
//general subroutines:
float lerp( in float f, in float a, in float b)
{
return (1.0-f)*a + f*b;
}
vec3 lerp( in float f, in vec3 a, in vec3 b)
{
return (1.0-f)*a + f*b;
}
vec3 fastnormalize( in vec3 v ) //less accurate than normalize() but should use less instructions
{
float tmp = dot( v, v );
tmp = 1.5 - (0.5*tmp);
return tmp * v;
}
float make_signed( in float zero_to_one_signed )
{
return zero_to_one_signed - 127.0/256.0;
}
vec3 imatmul( in vec3 tan, in vec3 cotan, in vec3 norm, in vec3 texnorm )
{
return normalize( texnorm.xxx*tan + texnorm.yyy*cotan + texnorm.zzz*norm );
}
//decoding subroutines:
void detail_blend_decode( in float dmgblend, out float bump, out float tex )
{
float temp = (dmgblend-127.0/256.0)*2.0;
bump = clamp( temp, 0.0, 1.0 );
tex = clamp( -temp, 0.0, 1.0 );
}
float DBSRF( in float dielectric_blend_input, in float shininess_input )
{
float temp1 = dielectric_blend_input * (1.0-dielectric_blend_input);
float temp2 = shininess_input * (1.0-shininess_input);
return temp1 / (temp1+temp2+0.0001);
}
/* The LaGrande normalmap noodle does away with the z-term for the normal by encoding U & V
as 0.5*tan( angle ), where angle is arcsin( U ) or arcsin( V ), respectively. To fit that
into a 0-1 range, we multiply by 0.5 once again, and add 0.5.
To reverse the encoding, we first subtract 0.5, then multiply by four, fill the z term with
1.0, and normalize. But multiplying by four is not needed if instead we fill the z term with
0.25, instead; *then* normalize :D
Here we've broken up the normalization, since there's no need to fully denormalize before
adding the normalmap, damage and detail normals. Just subtractin 0.5 is enough. And there's
also no point in normalizing before imatmul(); so normalization is done inside imatmul().
*/
vec2 dUdV_first_decode( vec2 raw_dudv )
{
return raw_dudv - vec2( 127.0/256.0 );
}
vec3 dUdV_final_decode( vec2 blend_of_first_decode )
{
vec3 temp;
temp.rg = blend_of_first_decode;
temp.b = 0.25;
return temp; //might as well normalize after imatmul
}
float dielectricblend_decode( in float linear_input )
{
float temp1 = linear_input - 0.5;
float temp2 = temp1 * temp1;
return temp1/(1.8*temp2+0.55) + 0.5;
}
float dielectric_decode( in float linear_input )
{
return (1.0625+linear_input) / (1.0625-linear_input);
}
float ambient_LOD( in float dielectric_k )
{
float temp = 1.0 / dielectric_k;
return 4.0 * (temp*temp - temp) + 9.0;
}
float is_metal_decode( in float specdiffbalance )
{
float tmp1 = 19.6444*(specdiffbalance-0.583333);
float tmp2 = sqrt(1+tmp1*tmp1);
return 0.5*tmp1/tmp2+0.5024772;
}
float nonzerok_decode( in float linear_k_input )
{
float temp = linear_k_input * linear_k_input;
temp *= ( temp * 20000.0 );
return temp / (temp+1);
}
void distribute_gloss
(
in float is_metal, in float is_dielectric, in float gloss_in,
out vec2 linear_glosses
)
{
// Shininess CTRL goes to metallic spec for metals; dielectric gloss for non-metals;
// and the defaults are min for both; except when dielectric k is 0/trivial we want
// to max-out shininess for fgloss, as it will be used for dual specularity metals
// rather than for dielectric, Fresnel shininess.
// This whole routine works with linear, 0-1 values (input representation) in & out,
// rather than with actual shininess values. Outputs to a vec2 with both glosses
linear_glosses.x = is_metal * gloss_in;
linear_glosses.y = lerp( is_metal, gloss_in, 1.0-is_dielectric );
}
vec2 lin_gloss_2_LOD( in vec2 lin_gloss )
{
//The following is an approximation of the true formula. It avoids
//using a logarithm, plus it makes better use of env-map mipmaps.
//The true formula would be 8+log2( tan( spotlight radial angle ) )
//The approximation is 15.2*(x^3+1.07)*(0.92-x) + 8.5*x - 6.0; but
//we do it for 2 shininesses simultaneously, using vec2 in and out.
vec2 temp1 = lin_gloss * lin_gloss * lin_gloss + vec2( 1.07 );
vec2 temp2 = vec2( 0.92 ) - lin_gloss;
return temp1 * temp2 * 15.2 + lin_gloss * 8.5 - vec2( 6.0 );
}
vec2 lin_gloss_2_exp( in vec2 lin_gloss )
{
/* The formula used to compute shininess from alpha is just an ad-hoc formula
that produces *useful* linearites across the alpha range; --with gradual change
at the bottom of the curve, but rising fast at the top. Almost linear with the
radius of specular light-spots, but not quite. Input and output are vec2, so
that two shininesses (one for metallic, one for dielectric specularities) are
computed in one shot. Using the formula (1.0625+x)/(1.0625-x) cubed. */
vec2 temp1 = vec2( 1.0625 );
vec2 temp2 = (temp1+lin_gloss) / (temp1-lin_gloss);
temp1 = temp2 * temp2 * temp2;
/* tests:
Alpha Shininess Angular radius of specular highlights
0/256 1.000 67.08
1/256 1.022 66.35 1.10% angular decrement
32/256 2.032 47.06
33/256 2.078 46.53 1.14%
64/256 4.215 32.67
65/256 4.315 32.29 1.18%
96/256 9.141 22.19
97/256 9.375 21.91 1.28%
128/256 21.433 14.49
129/256 22.051 14.29 1.40%
160/256 57.385 8.86
161/256 59.360 8.71 1.72%
192/256 195.112 4.80
193/256 203.928 4.70 2.13%
224/256 1103.370 2.02
225/256 1182.430 1.95 3.59%
254/256 24953.974 0.42
255/256 29791.000 0.39 7.69% */
/* limit to 1 degree radius (shininess of 4500) by product over sum; so
that point source lights don't become single pixels on reflections */
vec2 temp3 = vec2( 4500.0 );
return temp1 * temp3 / (temp1+temp3);
}
vec3 envMappingLOD( in vec3 direction, in float LoD )
{
vec4 result = textureCubeLod( cubeMap, direction, LoD );
return result.rgb * result.a;
}
//Per-light called subroutines and macros:
float selfshadow_step( in float cosa )
{
float temp1 = 77.7 * cosa;
float temp2 = temp1 * temp1;
return 0.5 * temp1 / sqrt( 1.0 + temp2 ) + 0.5;
}
void soft_penumbra_NdotL
(
in vec3 normal, in vec3 vnormal, in vec3 light,
out float selfshadow, out float NdotL, out float vNdotL
)
{
vec2 result;
float cosa = dot( vnormal, light );
result.x = dot( normal, light );
result.y = cosa;
float ss = selfshadow_step( cosa );
result += vec2( 0.02 );
result *= ( 0.97 * ss );
vNdotL = clamp( result.y, 0.0, 1.0 );
selfshadow = ss;
NdotL = clamp( result.x, 0.0, sqrt(vNdotL) );
}
float fresnel( in float cosa, in float k )
{
float tmp1 = sqrt(1.0-(1.0-cosa*cosa)/(k*k));
float tmp2 = k*cosa;
float tmp3 = k*tmp1;
float tmp4 = (tmp1-tmp2)/(tmp1+tmp2+0.0001);
tmp1 = (cosa-tmp3)/(cosa+tmp3+0.0001);
return 0.5*(tmp1*tmp1+tmp4*tmp4);
}
void perlite
(
in vec3 light, in vec3 normal, in vec3 vnormal, in vec3 reflection,
in vec3 lightDiffuse, in float lightAtt,
in float fresnel_blend, in float k, in vec2 ltd_glosses,
inout vec3 DLacc, inout vec3 MSacc, inout vec3 FSacc
)
{
float selfshadow, NdotL, vNdotL;
soft_penumbra_NdotL( normal, vnormal, light, selfshadow, NdotL, vNdotL );
//cos of reflection to light angle
float RdotL = clamp( dot( reflection, light), 0.0, 4.0*vNdotL );
// precalculate some factors used more than once
vec3 incident_light = lightDiffuse.rgb * lightAtt * selfshadow;
float fresnel_refl = fresnel_blend * fresnel( NdotL, k );
vec3 reflected_light = incident_light * fresnel_refl;
vec3 refracted_light = incident_light * (1.0-fresnel_refl);
float ltd_Mgloss = ltd_glosses.x;
float ltd_Fgloss = ltd_glosses.y;
// * DL - diffuse light: Needs to be multiplied by
// (1-fresnel_blend*fresnel reflection), from light vector
DLacc += ( NdotL * refracted_light );
// * MS - metallic specularity: Modulated by
// (1-fresnel_blend*fresnel reflection), also, and
// metallic shininess phong. And we also multiply by the
// shininess, as smaller spots get more light concentration
MSacc += ( pow( NdotL, ltd_Mgloss ) * ltd_Mgloss * refracted_light );
// * FS - fresnel specularity: Doesn't need fresnel, really,
// as the only fresnel applicable is view-vector-dependent,
// which can be applied afterwards, to the accumulated value;
// so, we'll multiply the accumulator by view fresnel after...
FSacc += ( pow( NdotL, ltd_Fgloss ) * ltd_Fgloss ); //*reflected_light);
}
#define lighting(name, lightno_gl, lightno_tex) \
void name( \
in vec3 normal, in vec3 vnormal, in vec3 reflection, \
in float k_blend, in float k_const, in vec2 limited_glosses, \
inout vec3 DL_acc, inout vec3 MS_acc, inout vec3 FS_acc) \
{ \
perlite( normalize(gl_TexCoord[lightno_tex].xyz), \
normal, vnormal, reflection, \
gl_FrontLightProduct[lightno_gl].diffuse.rgb, \
gl_TexCoord[lightno_tex].w, \
k_blend, k_const, limited_glosses, \
DL_acc, MS_acc, FS_acc); \
}
lighting(lite0, 0, 5)
lighting(lite1, 1, 6)
//final blend subroutines:
vec3 multibounce_color( in vec3 color, in float refl_factor, in float blend )
{
/* After light's penetrated the outer dielectric & is about to hit the inner, opaque
layer below, instead of *= color, use this to account for multiple inner bouncings
The formula is: *= (c-refL*c)/(1-refL*c), where refL is the fresnel reflectivity and
c is the color of the material under the dielectric coating. But blended materials,
such as plastics, are only partially covered by a specular dielectric layer, so we do
have to allow some pure color reflectivity; thus the "blend" thing... */
vec3 temp = color * refl_factor;
return blend*(color-temp)/(vec3(1.0)-temp) + (1.0-blend)*color;
}
vec3 final_blend
(
in vec3 DLacc, in vec3 MSacc, in vec3 FSacc, //DL=DiffuseLight; MS=MetallicSpec; FS=FresnelSpec
in vec3 AMBenv, in vec3 MSenv, in vec3 FSenv, //Environment mapped counterparts
in vec3 view_vec, in vec3 norm_vec, in vec3 glow,
in vec3 diff_color, in vec3 spec_color,
in float dielectric_blend, in float dielectric_k, in float AO
)
{
float NdotV = clamp( dot( norm_vec, view_vec ), 0.0, 1.0 );
float AO_fresnel_reflection = (1.0-dielectric_k)/(1.0+dielectric_k );
AO_fresnel_reflection *= AO_fresnel_reflection;
float reflection = fresnel( NdotV, dielectric_k );
float diffAOfactor = sqrt(AO);
float MspecAOfactor = AO * AO;
float FspecAOfactor = AO * diffAOfactor;
//Begin with the accumulated direct light (diffuse lighting)
vec3 final_acc = (DLacc*diffAOfactor);
//Add ambient light minus fresnel-reflected (note that amb reflection IS the envmapping)
final_acc += ( AMBenv * AO * (1.0-AO_fresnel_reflection) );
//multiply by the diffuse color
final_acc *= multibounce_color( diff_color, reflection, dielectric_blend );
//MSenv is multiplied by 1-fresnel to account for partial reflection on entering dielectric
final_acc += ( ( MSacc + (MSenv*(1.0-reflection)) ) *
multibounce_color( spec_color, reflection, dielectric_blend ) * MspecAOfactor );
//Both diffuse and metallic spec have to exit the dielectric. So, we'd multiply by the
//refraction, here. However, multibounce_color() already took care of it, so, nought to do.
//We just add fresnel specularity and... By the way, NOW we will multiply by fresnel
//reflectivity from view angle --remember we didn't in perlite():
final_acc += ( (FSacc+FSenv) * dielectric_blend * reflection * FspecAOfactor );
return final_acc + glow;
}
//main:
void main()
{
//READ INTPUT DATA:
//get interpolated, per-vertex data
vec2 texcoords2 = gl_TexCoord[0].xy;
vec3 vnormal_v3 = fastnormalize( gl_TexCoord[1].xyz );
vec3 tangent_v3 = gl_TexCoord[2].xyz;
vec3 cotangent_v3 = gl_TexCoord[3].xyz;
vec3 eye_v3 = gl_TexCoord[4].xyz;
//get texture data needed for detail and normal computations first
vec4 DMG_in4 = texture2D( damgMap,texcoords2 );
vec4 DET_in4 = texture2D( detailMap,16.0*texcoords2 );
vec4 NOR_in4 = texture2D( normMap,texcoords2 );
//then the rest
vec4 SPC_in4 = texture2D( specMap,texcoords2 );
vec4 COL_in4 = texture2D( diffMap,texcoords2 );
vec4 GLO_in4 = texture2D( glowMap,texcoords2 );
// computed vectors
vec3 reflection_v3 = -reflect(eye_v3,vnormal_v3);
//UNPACK:
//we use a macro table to ease possible future changes to the texture packing:
#define _matcolor_in_ ((COL_in4.rgb))
#define _matalpha_in_ ((COL_in4.a))
#define _damage_dUdV_ ((DMG_in4.rb))
#define _detailblend_ ((DMG_in4.g))
#define _damageAOdrk_ ((DMG_in4.a))
#define _specdiffbal_ ((SPC_in4.r))
#define _dielblendin_ ((SPC_in4.g))
#define _dielectrkin_ ((SPC_in4.b))
#define _shininessin_ ((SPC_in4.a))
#define _glowcolorin_ ((GLO_in4.rgb))
#define _ambientoccl_ ((GLO_in4.a))
#define _normalmapin_ ((vec2(0.3333*(NOR_in4.r+NOR_in4.g+NOR_in4.b),NOR_in4.a)))
#define _detail_dUdV_ ((DET_in4.rb))
#define _detail_wild_ ((DET_in4.g))
#define _detailgloss_ ((DET_in4.a))
/* The most urgent item to unpack is the detail texture data because at its minimum
level, detail provides dithering to hide DXT quantization; but such dithering needs
to be applied before non-linear transformations. Keep in mind that all four rgba
channels of the detail texture will be scaled to use the full 0-1 range. Minimum
detail application to a channel will be where full range matches 1 channel step. */
///////////////////////////////////////////////////////////////////////////
//CORE SHADER A.I. --MATERIAL FAMILY DETECTION:
//characterize the material to determine how to interpret shininess, detail, etc.:
float ismetal_ch1 = is_metal_decode( _specdiffbal_ );
//"nonzerok" is short for "has dielectric k greater than 1.2 or so"
float nonzerok_ch1 = nonzerok_decode( _dielectrkin_ );
//dielectric blend to shininess relevance factor:
float relevance_factor = DBSRF( _dielblendin_, _shininessin_ );
///////////////////////////////////////////////////////////////////////////
//Manage distribution of detail texture application:
float bump_det_fac1, nonbump_det_fac1;
// decide: bumpy detail or textury detail?
detail_blend_decode( _detailblend_, bump_det_fac1, nonbump_det_fac1 );
// metallic vs non-metallic textury detail deciding fate of detail.green:
float dielectricblend_detail = ismetal_ch1 * nonbump_det_fac1;
float diffuse_detail = nonbump_det_fac1 - dielectricblend_detail;
// metallic shininess detail mostly deciding fate of detail.alpha:
float adjusted_gloss = nonbump_det_fac1 * make_signed(_detailgloss_);
float gloss_detail = ismetal_ch1 * adjusted_gloss;
// for non-metals, dilectric balance vs shininess relevance spells fate of detail.alpha:
dielectricblend_detail += ( (adjusted_gloss - gloss_detail) * relevance_factor );
//Apply details and damage:
float damage = cloakdmg.b;
float integrity = 1.0 - damage;
// to normal:
vec2 dUdV_in2 = dUdV_first_decode(_normalmapin_);
dUdV_in2 += ( dUdV_first_decode(_damage_dUdV_) * damage );
dUdV_in2 += ( dUdV_first_decode(_detail_dUdV_) * (bump_det_fac1+1.0/32.0) );
// to diff/spec balance and glow:
float diffuse_jitter = (diffuse_detail+1.0/32.0) * make_signed(_detail_wild_);
float specdiffbal_in1 = _specdiffbal_ + diffuse_jitter;
vec3 glow_in3 = _glowcolorin_ + vec3( diffuse_jitter );
// to shininess:
float s_gloss_det = make_signed(_detailgloss_);
float shininess_in = _shininessin_ + (gloss_detail+1.0/256.0)*s_gloss_det;
// to dielectric blend:
float dielectricblend_in1 = _dielblendin_ + (dielectricblend_detail+1.0/64.0)*s_gloss_det;
// to ambient occlusion:
float AO_darkener1 = lerp( damage(), 1.0, _damageAOdrk_ );
float ao_mat1 = _ambientoccl_ * AO_darkener1;
//Non-linear transformations, rangings, and any unpacking left:
// diffuse, alpha and specular:
vec3 spec_mat3 = _matcolor_in_ * _specdiffbal_;
vec3 diff_mat3 = _matcolor_in_ - spec_mat3;
vec3 glow_mat3 = glow_in3 * glow_in3 * inv_damage(); //de-gamma & damage fade
// shininess CTRL goes to metallic spec for metals; dielectric gloss for non-metals;
// and the defaults are min for both; except when dielectric k is 0/trivial we want to
// max out shininess for fgloss, as it will be used for dual specularity metals
vec2 lin_gloss2, gloss_lod2, glosses2;
distribute_gloss( ismetal_ch1, nonzerok_ch1, shininess_in, lin_gloss2 );
gloss_lod2 = lin_gloss_2_LOD( lin_gloss2 );
glosses2 = lin_gloss_2_exp( lin_gloss2 );
// compute final normal
vec3 tmp3 = dUdV_final_decode( dUdV_in2 );
vec3 normal_v3 = imatmul( tangent_v3, cotangent_v3, vnormal_v3, tmp3 );
// dielectric stuff:
float dielec_blend_mat1 = dielectricblend_decode( dielectricblend_in1 );
float dielectric_k_mat1 = dielectric_decode( _dielectrkin_ );
// LOD for ambient lighting:
float ambient_lod1 = ambient_LOD( dielectric_k_mat1 );
//texture fetches (dependent on normal)
vec3 ambenv_il3 = envMappingLOD( normal_v3, ambient_lod1 ); //ambient env mapping
vec3 MSenv_il3 = envMappingLOD( reflection_v3, gloss_lod2.x ); //metallic spec env mapping
vec3 FSenv_il3 = envMappingLOD( reflection_v3, gloss_lod2.y ); //fresnel spec env mapping
//END OF UNPACKING
///////////////////////////////////////////////////////////////////////////
//PER-LIGHT COMPUTATIONS
// initialize accumulators
vec3 DL_acc3, MS_acc3, FS_acc3;
DL_acc3 = MS_acc3 = FS_acc3 = vec3( 0.0 );
// then loop:
if( light_enabled[0] != 0 )
lite0
(
normal_v3,vnormal_v3,reflection_v3,
dielec_blend_mat1,dielectric_k_mat1,glosses2,
DL_acc3,MS_acc3,FS_acc3
);
if( light_enabled[1] != 0 )
lite1
(
normal_v3,vnormal_v3,reflection_v3,
dielec_blend_mat1,dielectric_k_mat1,glosses2,
DL_acc3,MS_acc3,FS_acc3
);
//FINAL BLEND
//////vec3 reflection_v3 = -reflect(eye_v3,vnormal_v3);
vec4 result4;
result4.rgb = final_blend
(
DL_acc3, MS_acc3, FS_acc3, ambenv_il3, MSenv_il3, FSenv_il3,
eye_v3, vnormal_v3, glow_mat3, diff_mat3, spec_mat3,
dielec_blend_mat1, dielectric_k_mat1, ao_mat1
);
result4.a = _matalpha_in_;
//ALPHA and CLOAK
result4.rgb *= _matalpha_in_; //mul by 1-bit alpha interpolated
result4 *= cloak_alpha();
//WRITE
gl_FragColor = result4;
}
Code: Select all
Name,GPR,Min,Max,Avg,Est Cycles(Bi),ALU:TEX(Bi),Est Cycles(Tri),ALU:TEX(Tri),Est Cycles(Aniso),ALU:TEX(Aniso),BottleNeck(Bi),BottleNeck(Tri),BottleNeck(Aniso),%s\Clock(Bi),%s\Clock(Tri),%s\Clock(Aniso),Scratch Reg
Radeon 9700,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A
Radeon x800,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A
Radeon x850,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A
Radeon x1800,26,93.00,154.00,126.11,126.11,9.13,126.11,7.61,126.11,6.52,ALU,ALU,ALU,0.13,0.13,0.13,0
Radeon x1300,26,93.00,154.00,123.44,123.44,12.03,123.44,10.03,123.44,8.59,ALU,ALU,ALU,0.03,0.03,0.03,0
Radeon x1600,26,31.67,52.00,42.42,42.42,3.35,42.42,2.79,42.42,2.39,ALU,ALU,ALU,0.09,0.09,0.09,0
Radeon x1900,26,31.67,52.00,44.71,44.71,2.05,44.71,1.70,44.71,1.46,ALU,ALU,ALU,0.36,0.36,0.36,0
Radeon HD 2900,19,18.75,33.25,26.00,26.00,2.89,26.00,2.41,26.00,2.06,ALU,ALU,ALU,0.62,0.62,0.62,0
Radeon HD 2400,19,75.00,133.00,104.00,104.00,11.56,104.00,9.63,104.00,8.25,ALU,ALU,ALU,0.04,0.04,0.04,0
Radeon HD 2600,19,25.00,44.33,34.67,34.67,3.85,34.67,3.21,34.67,2.75,ALU,ALU,ALU,0.12,0.12,0.12,0
Radeon HD 3870,19,18.75,33.25,26.00,26.00,2.89,26.00,2.41,26.00,2.06,ALU,ALU,ALU,0.62,0.62,0.62,0
Radeon HD 4870,19,9.00,13.30,10.40,10.40,2.89,10.40,2.41,10.40,2.06,ALU,ALU,ALU,1.54,1.54,1.54,0
Looks like the Radeon 1300 and 2400 are trashed, with 0.03 and 0.04 pixels per clock...
Ehm... I still haven't done the dual shininess metals special case.
Code: Select all
!!NVfp4.0
# cgc version 2.0.0012, build date Jan 30 2008
# command line args: -profile gp4fp -oglsl
# source file: new_cinemut_opaque.fp
#vendor NVIDIA Corporation
#version 2.0.0.12
#profile gp4fp
#program main
#semantic light_enabled
#semantic max_light_enabled
#semantic cubeMap
#semantic diffMap
#semantic specMap
#semantic glowMap
#semantic normMap
#semantic damgMap
#semantic detailMap
#semantic cloakdmg
#semantic gl_FrontLightProduct : state.lightprod.front
#var int light_enabled[0] : : c[0] : -1 : 1
#var int light_enabled[1] : : c[1] : -1 : 1
#var int light_enabled[2] : : : -1 : 0
#var int light_enabled[3] : : : -1 : 0
#var int light_enabled[4] : : : -1 : 0
#var int light_enabled[5] : : : -1 : 0
#var int light_enabled[6] : : : -1 : 0
#var int light_enabled[7] : : : -1 : 0
#var int max_light_enabled : : : -1 : 0
#var samplerCUBE cubeMap : : texunit 6 : -1 : 1
#var sampler2D diffMap : : texunit 4 : -1 : 1
#var sampler2D specMap : : texunit 3 : -1 : 1
#var sampler2D glowMap : : texunit 5 : -1 : 1
#var sampler2D normMap : : texunit 2 : -1 : 1
#var sampler2D damgMap : : texunit 0 : -1 : 1
#var sampler2D detailMap : : texunit 1 : -1 : 1
#var float4 cloakdmg : : c[2] : -1 : 1
#var float4 gl_TexCoord[0] : $vin.TEX0 : TEX0 : -1 : 1
#var float4 gl_TexCoord[1] : $vin.TEX1 : TEX1 : -1 : 1
#var float4 gl_TexCoord[2] : $vin.TEX2 : TEX2 : -1 : 1
#var float4 gl_TexCoord[3] : $vin.TEX3 : TEX3 : -1 : 1
#var float4 gl_TexCoord[4] : $vin.TEX4 : TEX4 : -1 : 1
#var float4 gl_TexCoord[5] : $vin.TEX5 : TEX5 : -1 : 1
#var float4 gl_TexCoord[6] : $vin.TEX6 : TEX6 : -1 : 1
#var float4 gl_TexCoord[7] : : : -1 : 0
#var float4 gl_FrontLightProduct[0].ambient : state.lightprod[0].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[0].diffuse : state.lightprod[0].front.diffuse : c[3] : -1 : 1
#var float4 gl_FrontLightProduct[0].specular : state.lightprod[0].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[1].ambient : state.lightprod[1].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[1].diffuse : state.lightprod[1].front.diffuse : c[4] : -1 : 1
#var float4 gl_FrontLightProduct[1].specular : state.lightprod[1].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[2].ambient : state.lightprod[2].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[2].diffuse : state.lightprod[2].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[2].specular : state.lightprod[2].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[3].ambient : state.lightprod[3].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[3].diffuse : state.lightprod[3].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[3].specular : state.lightprod[3].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[4].ambient : state.lightprod[4].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[4].diffuse : state.lightprod[4].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[4].specular : state.lightprod[4].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[5].ambient : state.lightprod[5].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[5].diffuse : state.lightprod[5].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[5].specular : state.lightprod[5].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[6].ambient : state.lightprod[6].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[6].diffuse : state.lightprod[6].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[6].specular : state.lightprod[6].front.specular : : -1 : 0
#var float4 gl_FrontLightProduct[7].ambient : state.lightprod[7].front.ambient : : -1 : 0
#var float4 gl_FrontLightProduct[7].diffuse : state.lightprod[7].front.diffuse : : -1 : 0
#var float4 gl_FrontLightProduct[7].specular : state.lightprod[7].front.specular : : -1 : 0
#var float4 gl_FragColor : $vout.COLOR : COL : -1 : 1
PARAM c[5] = { program.local[0..2],
state.lightprod[0].front.diffuse,
state.lightprod[1].front.diffuse };
ATTRIB fragment_texcoord[] = { fragment.texcoord[0..6] };
TEMP R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12;
TEMP RC, HC;
OUTPUT oCol = result.color;
TEX.F R3, fragment.texcoord[0], texture[3], 2D;
TEX.F R4, fragment.texcoord[0], texture[0], 2D;
ADD.F R0.w, R4.y, {-0.49609375}.x;
ADD.F R0.x, R3, {-0.58333302};
MUL.F R0.x, R0, {19.6444};
MAD.F R0.y, R0.x, R0.x, {1}.x;
RSQ.F R0.y, R0.y;
MUL.F R0.x, R0.y, R0;
MAD.F R1.z, R0.x, {0.5, 0.50247723}.x, {0.5, 0.50247723}.y;
MUL.F R0.xy, fragment.texcoord[0], {16}.x;
TEX.F R8, R0, texture[1], 2D;
MUL.F R1.w, R0, {2}.x;
MIN.F R0.x, -R1.w, {1};
MIN.F R1.w, R1, {1}.x;
MAX.F R1.w, R1, {0}.x;
MAX.F R5.w, R0.x, {0}.x;
ADD.F R6.x, R8.w, {-0.49609375};
MUL.F R6.y, R5.w, R6.x;
MUL.F R0.z, R3, R3;
MUL.F R0.x, R0.z, R0.z;
MUL.F R0.y, R0.x, {20000}.x;
MUL.F R7.x, R1.z, R6.y;
ADD.F R0.z, R0.y, {1}.x;
DIV.F R0.y, R0, R0.z;
ADD.F R0.x, R7, {0.00390625};
MAD.F R0.x, R0, R6, R3.w;
MUL.F R1.x, R1.z, R0;
MAD.F R0.y, R1.z, -R0, R1.z;
MAD.F R0.x, -R1.z, R0, R0;
ADD.F R1.y, R0.x, R0;
ADD.F R0.xy, -R1, {1.0625}.x;
MUL.F R5.xy, R1, R1;
ADD.F R0.zw, R1.xyxy, {1.0625}.x;
ADD.F R6.zw, -R1.xyxy, {0.92000002}.x;
MAD.F R5.xy, R1, R5, {1.0700001}.x;
MUL.F R5.xy, R5, R6.zwzw;
MUL.F R1.xy, R1, {8.5}.x;
MAD.F R1.xy, R5, {15.2}.x, R1;
ADD.F R6.zw, R1.xyxy, {-6}.x;
ADD.F R1.y, -R7.x, R6;
ADD.F R1.w, R1, {0.03125}.x;
MAD.F R1.x, -R3.w, R3.w, R3.w;
MAD.F R4.w, R4, c[2].z, -c[2].z;
RCP.F R0.y, R0.y;
RCP.F R0.x, R0.x;
MUL.F R0.xy, R0.zwzw, R0;
MUL.F R0.zw, R0.xyxy, R0.xyxy;
MUL.F R2.xy, R0.zwzw, R0;
TEX.F R0, fragment.texcoord[0], texture[2], 2D;
ADD.F R0.y, R0.x, R0;
ADD.F R2.zw, R2.xyxy, {4500}.x;
ADD.F R0.z, R0.y, R0;
RCP.F R0.x, R2.z;
RCP.F R0.y, R2.w;
ADD.F R2.zw, R4.xyxz, {-0.49609375}.x;
MUL.F R4.xy, R2, R0;
MUL.F R0.z, R0, {0.33329999}.x;
MAD.F R0.zw, R2, c[2].z, R0;
ADD.F R2.zw, R8.xyxz, {-0.49609375}.x;
MAD.F R0.zw, R2, R1.w, R0;
ADD.F R2.xy, R0.zwzw, {-0.49609375}.x;
MUL.F R0.xyz, R2.y, fragment.texcoord[3];
DP3.F R0.w, fragment.texcoord[1], fragment.texcoord[1];
MAD.F R2.xyz, R2.x, fragment.texcoord[2], R0;
MAD.F R0.w, -R0, {0.5, 1.5}.x, {0.5, 1.5}.y;
MUL.F R0.xyz, R0.w, fragment.texcoord[1];
MAD.F R2.xyz, R0, {0.25}.x, R2;
DP3.F R0.w, R2, R2;
ADD.F R2.w, R3.z, {1.0625}.x;
ADD.F R1.w, -R3.z, {1.0625}.x;
DIV.F R1.w, R2, R1.w;
RSQ.F R2.w, R0.w;
MUL.F R12.xy, R4, {4500}.x;
MUL.F R4.xyz, R2.w, R2;
RCP.F R0.w, R1.w;
MAD.F R0.w, R0, R0, -R0;
MAD.F R2.w, R0, {4, 9}.x, {4, 9}.y;
MAD.F R0.w, -R3.y, R3.y, R3.y;
ADD.F R1.x, R0.w, R1;
ADD.F R1.x, R1, {9.9999997e-005};
DIV.F R0.w, R0, R1.x;
MUL.F R3.z, R5.w, R1;
MAD.F R0.w, R1.y, R0, R3.z;
MOV.F R2.xyz, R4;
TXL.F R2, R2, texture[6], CUBE;
MUL.F R5.xyz, R2, R2.w;
DP3.F R1.x, R0, fragment.texcoord[4];
MUL.F R1.xyz, R0, R1.x;
MAD.F R1.xyz, -R1, {2}.x, fragment.texcoord[4];
ADD.F R0.w, R0, {0.015625}.x;
MAD.F R0.w, R6.x, R0, R3.y;
MOV.F R2.xyz, -R1;
MOV.F R2.w, R6.z;
TXL.F R2, R2, texture[6], CUBE;
MUL.F R6.xyz, R2, R2.w;
ADD.F R0.w, R0, {-0.5}.x;
MUL.F R2.x, R0.w, R0.w;
MAD.F R3.y, R2.x, {1.8, 0.55000001}.x, {1.8, 0.55000001};
MOV.F R2.xyz, -R1;
RCP.F R1.x, R3.y;
MOV.F R2.w, R6;
ADD.F R3.y, R5.w, -R3.z;
TXL.F R2, R2, texture[6], CUBE;
ADD.F R6.w, R8.y, {-0.49609375}.x;
MUL.F R7.xyz, R2, R2.w;
TEX.F R2, fragment.texcoord[0], texture[4], 2D;
MAD.F R0.w, R0, R1.x, {0.5}.x;
MUL.F R1.xyz, R2, R3.x;
ADD.F R5.w, R3.y, {0.03125}.x;
TEX.F R3, fragment.texcoord[0], texture[5], 2D;
MAD.F R3.xyz, R5.w, R6.w, R3;
MUL.F R3.xyz, R3, R3;
MAD.F R3.w, R4, R3, R3;
MOV.S R4.w, {0}.x;
SNE.S R4.w, c[0].x, R4;
MOV.U.CC HC.x, -R4.w;
ADD.F R2.xyz, R2, -R1;
MAD.F R3.xyz, R3, -c[2].z, R3;
MOV.F R8.xyz, {0}.x;
MOV.F R9.xyz, {0}.x;
MOV.F R10.xyz, {0}.x;
IF NE.x;
DP3.F R4.w, fragment.texcoord[5], fragment.texcoord[5];
RSQ.F R4.w, R4.w;
MUL.F R8.xyz, R4.w, fragment.texcoord[5];
DP3.F R5.w, R0, R8;
MUL.F R4.w, R5, {77.699997}.x;
DP3.F R8.x, R8, R4;
MAD.F R6.w, R4, R4, {1}.x;
RSQ.F R6.w, R6.w;
MUL.F R4.w, R6, R4;
MOV.F R8.y, R5.w;
MUL.F R6.w, R1, R1;
MAD.F R5.w, R4, {0.5}.x, {0.5}.x;
ADD.F R8.xy, R8, {0.02}.x;
MUL.F R8.xy, R5.w, R8;
MUL.F R8.xy, R8, {0.97000003}.x;
MIN.F R4.w, R8.y, {1}.x;
MAX.F R4.w, R4, {0}.x;
RSQ.F R4.w, R4.w;
RCP.F R4.w, R4.w;
MIN.F R4.w, R4, R8.x;
MAX.F R4.w, R4, {0}.x;
RCP.F R7.w, R6.w;
MUL.F R6.w, R4, R4;
MAD.F R6.w, -R6, R7, R7;
ADD.F R6.w, -R6, {1}.x;
RSQ.F R7.w, R6.w;
MUL.F R8.y, R4.w, R1.w;
RCP.F R8.x, R7.w;
ADD.F R8.z, R8.x, R8.y;
DIV.F R6.w, R1, R7.w;
ADD.F R7.w, R4, R6;
ADD.F R8.x, R8, -R8.y;
ADD.F R8.z, R8, {9.9999997e-005}.x;
DIV.F R8.x, R8, R8.z;
ADD.F R7.w, R7, {9.9999997e-005}.x;
ADD.F R6.w, R4, -R6;
DIV.F R6.w, R6, R7.w;
MUL.F R7.w, R8.x, R8.x;
MUL.F R8.xyz, fragment.texcoord[5].w, c[3];
MUL.F R8.xyz, R5.w, R8;
MAD.F R6.w, R6, R6, R7;
MUL.F R5.w, R6, R0;
MUL.F R9.xyz, -R5.w, R8;
MAD.F R8.xyz, R9, {0.5}.x, R8;
POW.F R5.w, R4.w, R12.x;
MUL.F R10.xyz, R4.w, R8;
MUL.F R5.w, R5, R12.x;
POW.F R4.w, R4.w, R12.y;
MUL.F R9.xyz, R8, R5.w;
MUL.F R8.xyz, R12.y, R4.w;
ENDIF;
MOV.S R4.w, {0}.x;
SNE.S R4.w, c[1].x, R4;
MOV.U.CC HC.x, -R4.w;
IF NE.x;
DP3.F R4.w, fragment.texcoord[6], fragment.texcoord[6];
RSQ.F R4.w, R4.w;
MUL.F R11.xyz, R4.w, fragment.texcoord[6];
DP3.F R5.w, R0, R11;
DP3.F R4.x, R11, R4;
MUL.F R4.w, R5, {77.699997}.x;
MAD.F R6.w, R4, R4, {1}.x;
RSQ.F R6.w, R6.w;
MOV.F R4.y, R5.w;
MUL.F R4.w, R6, R4;
MAD.F R5.w, R4, {0.5}.x, {0.5}.x;
ADD.F R4.xy, R4, {0.02}.x;
MUL.F R4.xy, R5.w, R4;
MUL.F R4.xy, R4, {0.97000003}.x;
MIN.F R4.y, R4, {1}.x;
MAX.F R4.y, R4, {0}.x;
RSQ.F R4.y, R4.y;
RCP.F R4.y, R4.y;
MIN.F R4.y, R4, R4.x;
MAX.F R4.w, R4.y, {0}.x;
MUL.F R4.x, R1.w, R1.w;
RCP.F R4.y, R4.x;
MUL.F R4.x, R4.w, R4.w;
MAD.F R4.x, -R4, R4.y, R4.y;
ADD.F R4.x, -R4, {1};
RSQ.F R4.y, R4.x;
MUL.F R6.w, R4, R1;
RCP.F R4.z, R4.y;
ADD.F R7.w, R4.z, R6;
DIV.F R4.x, R1.w, R4.y;
ADD.F R4.y, R4.w, R4.x;
ADD.F R4.z, R4, -R6.w;
ADD.F R7.w, R7, {9.9999997e-005}.x;
DIV.F R4.z, R4, R7.w;
ADD.F R4.x, R4.w, -R4;
ADD.F R4.y, R4, {9.9999997e-005}.x;
DIV.F R6.w, R4.x, R4.y;
MUL.F R7.w, R4.z, R4.z;
MUL.F R4.xyz, fragment.texcoord[6].w, c[4];
MUL.F R4.xyz, R5.w, R4;
MAD.F R6.w, R6, R6, R7;
MUL.F R5.w, R6, R0;
MUL.F R11.xyz, -R5.w, R4;
MAD.F R4.xyz, R11, {0.5}.x, R4;
POW.F R5.w, R4.w, R12.x;
MAD.F R10.xyz, R4.w, R4, R10;
MUL.F R5.w, R5, R12.x;
POW.F R4.w, R4.w, R12.y;
MAD.F R9.xyz, R4, R5.w, R9;
MAD.F R8.xyz, R12.y, R4.w, R8;
ENDIF;
DP3.F R0.x, R0, fragment.texcoord[4];
MUL.F R0.y, R1.w, R1.w;
MIN.F R0.x, R0, {1};
MAX.F R0.x, R0, {0};
RCP.F R0.z, R0.y;
MUL.F R0.y, R0.x, R0.x;
MAD.F R0.y, -R0, R0.z, R0.z;
ADD.F R0.y, -R0, {1}.x;
RSQ.F R0.y, R0.y;
RCP.F R0.z, R0.y;
MUL.F R4.x, R0, R1.w;
ADD.F R4.y, R0.z, R4.x;
ADD.F R0.z, R0, -R4.x;
ADD.F R4.x, R4.y, {9.9999997e-005};
DIV.F R4.x, R0.z, R4.x;
DIV.F R0.y, R1.w, R0.y;
ADD.F R0.z, R0.x, R0.y;
ADD.F R0.x, R0, -R0.y;
ADD.F R0.z, R0, {9.9999997e-005}.x;
DIV.F R0.x, R0, R0.z;
MUL.F R4.x, R4, R4;
MAD.F R0.x, R0, R0, R4;
MUL.F R4.w, R0.x, {0.5}.x;
MUL.F R4.xyz, R4.w, R2;
ADD.F R0.xyz, R2, -R4;
ADD.F R4.xyz, -R4, {1}.x;
MAD.F R2.xyz, -R0.w, R2, R2;
MUL.F R0.xyz, R0.w, R0;
RCP.F R4.x, R4.x;
RCP.F R4.y, R4.y;
RCP.F R4.z, R4.z;
MAD.F R0.xyz, R0, R4, R2;
MAD.F R4.xyz, -R4.w, R6, R6;
MUL.F R2.xyz, R4.w, R1;
ADD.F R6.xyz, R1, -R2;
ADD.F R2.xyz, -R2, {1}.x;
MUL.F R6.xyz, R0.w, R6;
RCP.F R2.x, R2.x;
RCP.F R2.y, R2.y;
MAD.F R1.xyz, -R0.w, R1, R1;
RCP.F R2.z, R2.z;
MAD.F R1.xyz, R6, R2, R1;
ADD.F R2.xyz, R9, R4;
MUL.F R1.xyz, R2, R1;
ADD.F R2.x, R1.w, {1};
RCP.F R4.x, R2.x;
MAD.F R1.w, -R1, R4.x, R4.x;
MUL.F R2.y, R3.w, R3.w;
MUL.F R1.xyz, R1, R2.y;
MUL.F R4.xyz, R3.w, R5;
MUL.F R5.x, R1.w, R1.w;
ADD.F R2.xyz, R8, R7;
RSQ.F R1.w, R3.w;
MAD.F R4.xyz, -R5.x, R4, R4;
MUL.F R2.xyz, R2, R0.w;
RCP.F R5.x, R1.w;
MAD.F R4.xyz, R10, R5.x, R4;
MAD.F R0.xyz, R4, R0, R1;
DIV.F R0.w, R3, R1.w;
MUL.F R1.xyz, R2, R4.w;
MAD.F R0.xyz, R1, R0.w, R0;
ADD.F R0.xyz, R0, R3;
MOV.F R0.w, R2;
MUL.F R0.xyz, R0, R2.w;
MUL.F oCol, R0, c[2].xxxy;
END
# 293 instructions, 13 R-regs
Its clock speed is 750MHz, so that's more than a billion pixels/s; 4 times faster than my NVidia 8800.
.
