bool bExecute( const shaderreg *i_pInput, vector4 &io_vColor, float32 &io_fDepth )
{
if( fGetFloat( 0 ) )
{
// render flare
vector4 vFlareColor;
SampleTexture( vFlareColor, 0, i_pInput[0].x, i_pInput[0].y, 0.0f );
if( vFlareColor.a <= FLT_EPSILON ) // perform alpha test
return false;
io_vColor += vFlareColor * fGetFloat( 1 ); // scale and blend with backbuffer
}
else
io_vColor = vGetVector( 0 );
return true;
}
m3dshaderregtype GetOutputRegisters( uint32 i_iRegister )
{
switch( i_iRegister )
{
case 0: return m3dsrt_vector3;
case 1: if( fGetFloat( 0 ) ) return m3dsrt_vector2;
default: return m3dsrt_unused;
}
}
void Execute( const shaderreg *i_pInput, vector4 &o_vPosition, shaderreg *o_pOutput )
{
// transform position
o_vPosition = i_pInput[0] * matGetMatrix( m3dsc_wvpmatrix );
if( fGetFloat( 0 ) )
{
// pass texcoord to pixelshader for flare rendering
o_pOutput[0] = i_pInput[1];
}
}
void Execute( const shaderreg *i_pInput, vector4 &o_vPosition, shaderreg *o_pOutput )
{
// const vector4 vWaveOffset( 0.0f, 0.0f, 0.0f, 0.0f );
const vector4 vWaveSpeed( 0.6f, 0.7f, 1.2f, 1.4f );
const vector4 vWaveDirX( 0.0f, 2.0f, 0.0f, 4.0f );
const vector4 vWaveDirY( 2.0f, 0.0f, 4.0f, 0.0f );
const vector4 vWaveHeight( 0.25f, 0.25f, 0.125f, 0.125f );
const float32 fNormalWarpScale = 0.01f;
vector4 vWaves = vWaveDirX * i_pInput[1].x + vWaveDirY * i_pInput[1].y;
vWaves += vWaveSpeed * fGetFloat( 0 ); //+ vWaveOffset;
// calculate fractions of warp-vector components and scale to radians.
vWaves.x -= (int32)vWaves.x + 0.5f; vWaves.y -= (int32)vWaves.y + 0.5f;
vWaves.z -= (int32)vWaves.z + 0.5f; vWaves.w -= (int32)vWaves.w + 0.5f;
vWaves *= 2.0f * M3D_PI;
const vector4 vSinWaves( sinf( vWaves.x ), sinf( vWaves.y ), sinf( vWaves.z ), sinf( vWaves.w ) );
const vector4 vCosWaves( cosf( vWaves.x ), cosf( vWaves.y ), cosf( vWaves.z ), cosf( vWaves.w ) );
// apply deformation in direction of normal using sine-waves
vector3 vNormal = i_pInput[0]; vNormal.normalize();
const vector4 vPosition = i_pInput[0] + vNormal * fVector4Dot( vSinWaves, vWaveHeight );
o_vPosition = vPosition * matGetMatrix( m3dsc_wvpmatrix );
// pass texcoord to pixel shader
o_pOutput[0] = i_pInput[1];
const vector3 vTangent( -vNormal.z, 0, vNormal.x ); /* vTangent.x = vNormal % vector3( 0, 0, -1 ); vTangent.y = 0; vTangent.z = vNormal % vector3( 1, 0, 0 ); */
vector3 vBinormal; vVector3Cross( vBinormal, vNormal, vTangent );
const float32 fNormalWarpBinormal = fVector4Dot( -vCosWaves, vWaveDirX );
const float32 fNormalWarpTangent = fVector4Dot( -vCosWaves, vWaveDirY );
vector3 vWarpedNormal = vBinormal * fNormalWarpBinormal + vTangent * fNormalWarpTangent;
vWarpedNormal = vWarpedNormal * fNormalWarpScale + vNormal;
vWarpedNormal.normalize();
vVector3TransformNormal( vWarpedNormal, vWarpedNormal, matGetMatrix( m3dsc_worldmatrix ) );
const vector3 vWorldPos = vPosition * matGetMatrix( m3dsc_worldmatrix );
const vector3 vViewDir = ( (vector3)vGetVector( 0 ) - vWorldPos ).normalize();
const float32 fViewDotNormal = fVector3Dot( vWarpedNormal, vViewDir );
o_pOutput[1] = vWarpedNormal * ( 2.0f * fViewDotNormal ) - vViewDir;
o_pOutput[2].x = fViewDotNormal;
}
/****** cull/dump_scan/lUndumpElemFp() ******************************************
* NAME
* lUndumpElemFp() -- Read element from FILE stream
*
* SYNOPSIS
* lListElem* lUndumpElemFp(FILE *fp, const lDescr *dp)
*
* FUNCTION
* Read element from FILE stream
*
* INPUTS
* FILE *fp - file stream
* const lDescr *dp - descriptor
*
* RESULT
* lListElem* - Read element
******************************************************************************/
lListElem *lUndumpElemFp(FILE *fp, const lDescr *dp)
{
lListElem *ep;
int n, i;
int ret = 0;
char *str;
u_long32 dummy;
DENTER(CULL_LAYER, "lUndumpElemFp");
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return NULL;
}
if (!dp) {
LERROR(LEDESCRNULL);
DEXIT;
return NULL;
}
if (!(ep = lCreateElem(dp))) {
LERROR(LECREATEELEM);
DEXIT;
return NULL;
}
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
lFreeElem(&ep);
DEXIT;
return NULL;
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
lFreeElem(&ep);
DEXIT;
return NULL;
}
for (i = 0; i < n && ret == 0; i++) {
switch (mt_get_type(dp[i].mt)) {
case lIntT:
ret = fGetInt(fp, &(ep->cont[i].i));
break;
case lUlongT:
ret = fGetUlong(fp, &(ep->cont[i].ul));
break;
case lStringT:
ret = fGetString(fp, &str);
if (ret == 0) {
lSetPosString(ep, i, str);
free(str); /* fGetString strdup's */
}
break;
case lHostT:
ret = fGetHost(fp, &str);
if (ret == 0) {
lSetPosHost(ep, i, str);
free(str); /* fGetHost strdup's */
}
break;
case lFloatT:
ret = fGetFloat(fp, &(ep->cont[i].fl));
break;
case lDoubleT:
ret = fGetDouble(fp, &(ep->cont[i].db));
break;
case lLongT:
ret = fGetLong(fp, &(ep->cont[i].l));
break;
case lCharT:
ret = fGetChar(fp, &(ep->cont[i].c));
break;
case lBoolT:
ret = fGetBool(fp, &(ep->cont[i].b));
break;
case lRefT:
/* we will not undump references! But we have to skip the line! */
ret = fGetUlong(fp, &dummy);
ep->cont[i].ref = NULL;
break;
case lObjectT:
ret = fGetObject(fp, &(ep->cont[i].obj));
break;
case lListT:
ret = fGetList(fp, &(ep->cont[i].glp));
break;
default:
lFreeElem(&ep);
unknownType("lUndumpElemFp");
}
}
/* error handling for loop */
if (ret != 0) {
lFreeElem(&ep);
LERROR(LEFIELDREAD);
DEXIT;
return NULL;
}
/* read ket */
if (fGetKet(fp)) {
lFreeElem(&ep);
printf("ket is missing\n");
LERROR(LESYNTAX);
DEXIT;
return NULL;
}
DEXIT;
return ep;
}