void CBaseShader::SetFixedFunctionTextureScale( MaterialMatrixMode_t textureTransform, int scaleVar )
{
Assert( !IsSnapshotting() );
// handle scrolling of base texture
Vector2D vScale;
s_ppParams[scaleVar]->GetVecValue( vScale.Base(), 2 );
if( vScale[0] != 0.0f || vScale[1] != 0.0f )
{
s_pShaderAPI->MatrixMode( textureTransform );
// only do the upper 3x3 since this is a 2D matrix
float mat[16];
mat[0] = vScale[0]; mat[1] = 0.0f; mat[2] = 0.0f;
mat[4] = 0.0f; mat[5] = vScale[1]; mat[6] = 0.0f;
mat[8] = 0.0f; mat[9] = 0.0f; mat[10] = 1.0f;
// Better set the stuff we don't set with some sort of value!
mat[3] = mat[7] = mat[11] = 0;
mat[12] = mat[13] = mat[14] = 0;
mat[15] = 1;
s_pShaderAPI->LoadMatrix( mat );
}
else
{
LoadIdentity( textureTransform );
}
}
//-----------------------------------------------------------------------------
// Attribute types related to vector math
//-----------------------------------------------------------------------------
bool Serialize( CUtlBuffer &buf, const Vector2D &src )
{
if ( buf.IsText() )
{
SerializeFloats( buf, 2, src.Base() );
}
else
{
buf.PutFloat( src.x );
buf.PutFloat( src.y );
}
return buf.IsValid();
}
void CTextureTransformProxy::OnBind( void *pC_BaseEntity )
{
Vector2D center( 0.5, 0.5 );
Vector2D translation( 0, 0 );
VMatrix mat, temp;
if (m_pCenterVar)
{
m_pCenterVar->GetVecValue( center.Base(), 2 );
}
MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
if (m_pScaleVar)
{
Vector2D scale;
m_pScaleVar->GetVecValue( scale.Base(), 2 );
MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
MatrixMultiply( temp, mat, mat );
}
if (m_pRotateVar)
{
float angle = m_pRotateVar->GetFloatValue( );
MatrixBuildRotateZ( temp, angle );
MatrixMultiply( temp, mat, mat );
}
MatrixBuildTranslation( temp, center.x, center.y, 0.0f );
MatrixMultiply( temp, mat, mat );
if (m_pTranslateVar)
{
m_pTranslateVar->GetVecValue( translation.Base(), 2 );
MatrixBuildTranslation( temp, translation.x, translation.y, 0.0f );
MatrixMultiply( temp, mat, mat );
}
m_pResult->SetMatrixValue( mat );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
// ----------------------------------------------------------------------------- //
// Adds shadow rendering data to a particular mesh builder
// ----------------------------------------------------------------------------- //
int DispInfo_AddShadowsToMeshBuilder( CMeshBuilder& meshBuilder,
DispShadowHandle_t h, int baseIndex )
{
#ifndef SWDS
if ( !r_DrawDisp.GetBool() )
{
return baseIndex;
}
CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h];
int shadow = pShadowDecal->m_Shadow;
ShadowInfo_t const& info = g_pShadowMgr->GetInfo( shadow );
// It had better be computed by now...
Assert( pShadowDecal->m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED );
#ifdef _DEBUG
int triCount = 0;
int vertCount = 0;
#endif
DispShadowFragmentHandle_t f = pShadowDecal->m_FirstFragment;
while ( f != DISP_SHADOW_FRAGMENT_HANDLE_INVALID )
{
CDispShadowFragment& fragment = s_DispShadowFragments[f];
// Add in the vertices + indices, use two loops to minimize tests...
int i;
for ( i = 0; i < fragment.m_nVerts - 2; ++i )
{
meshBuilder.Position3fv( fragment.m_Verts[i].Base() );
// Transform + offset the texture coords
Vector2D texCoord;
Vector2DMultiply( fragment.m_TCoords[i].AsVector2D(), info.m_TexSize, texCoord );
texCoord += info.m_TexOrigin;
meshBuilder.TexCoord2fv( 0, texCoord.Base() );
unsigned char c = g_pShadowMgr->ComputeDarkness( fragment.m_TCoords[i].z, info );
meshBuilder.Color4ub( c, c, c, c );
meshBuilder.AdvanceVertex();
meshBuilder.Index( baseIndex );
meshBuilder.AdvanceIndex();
meshBuilder.Index( i + baseIndex + 1 );
meshBuilder.AdvanceIndex();
meshBuilder.Index( i + baseIndex + 2 );
meshBuilder.AdvanceIndex();
#ifdef _DEBUG
++triCount;
++vertCount;
#endif
}
for ( ; i < fragment.m_nVerts; ++i )
{
meshBuilder.Position3fv( fragment.m_Verts[i].Base() );
// Transform + offset the texture coords
Vector2D texCoord;
Vector2DMultiply( fragment.m_TCoords[i].AsVector2D(), info.m_TexSize, texCoord );
texCoord += info.m_TexOrigin;
meshBuilder.TexCoord2fv( 0, texCoord.Base() );
unsigned char c = g_pShadowMgr->ComputeDarkness( fragment.m_TCoords[i].z, info );
meshBuilder.Color4ub( c, c, c, c );
meshBuilder.AdvanceVertex();
#ifdef _DEBUG
++vertCount;
#endif
}
baseIndex += fragment.m_nVerts;
f = s_DispShadowFragments.Next(f);
}
#ifdef _DEBUG
Assert( triCount == pShadowDecal->m_nTris );
Assert( vertCount == pShadowDecal->m_nVerts );
#endif
return baseIndex;
#else
return 0;
#endif
}
void CHLSL_Mesh::CreateCylinder( float size, int subdiv )
{
subdiv /= 2;
delete [] m_Vertices;
delete [] m_Triangles;
int num_verts_u = subdiv + 1;
int num_verts_v = subdiv + 1;
int num_verts_side = num_verts_u * num_verts_v;
int num_verts_top = 1 + num_verts_u - 1;
m_iNumVertices = num_verts_side + num_verts_top * 2;
int num_tris_u = (num_verts_u-1);
int num_tris_v = (num_verts_v-1);
int num_tris_side = num_tris_u * num_tris_v * 2;
int num_tris_top = num_tris_u;
m_iNumTriangles = num_tris_side + num_tris_top * 2;
m_Vertices = new CHLSL_Vertex[ m_iNumVertices ];
m_Triangles = new CHLSL_Triangle[ m_iNumTriangles ];
QAngle rotate( 0, 0, 0 );
float yaw_step = 360.0f / (num_verts_u-1);
float up_step = size * 2.0f / (num_verts_v-1);
float size_radius = size * 0.5f;
Vector fwd, right, up, pos;
/// verts for side
for ( int vert_u = 0; vert_u < num_verts_u; vert_u++ )
{
AngleVectors( rotate, &fwd, &right, &up );
pos = up * size + fwd * size_radius;
for ( int vert_v = 0; vert_v < num_verts_v; vert_v++ )
{
int vindex = vert_u * num_verts_v +
vert_v;
Assert( vindex < m_iNumVertices );
CHLSL_Vertex &vert = m_Vertices[ vindex ];
Q_memcpy( vert.normal, fwd.Base(), sizeof( float ) * 3 );
Q_memcpy( vert.pos, pos.Base(), sizeof( float ) * 3 );
vert.uv[0][0] = vert_u / (float)( num_verts_u - 1 );
vert.uv[0][1] = vert_v / (float)( num_verts_v - 1 );
pos -= up * up_step;
}
rotate.y += yaw_step;
}
/// verts for top/bottom
for ( int v_side = 0; v_side < 2; v_side++ )
{
rotate.y = 0;
float sign = (v_side==1) ? -1.0f : 1.0f;
up.Init( 0, 0, sign );
Vector height = up * size;
for ( int v_u = 0; v_u < num_verts_top; v_u++ )
{
int vindex = num_verts_side +
v_side * num_verts_top +
v_u;
Assert( vindex < m_iNumVertices );
CHLSL_Vertex &vert = m_Vertices[ vindex ];
Vector2D uv;
Vector pos = height;
if ( v_u > 0 )
{
AngleVectors( rotate, &fwd, NULL, NULL );
pos += fwd * size_radius;
uv.x = -sign * fwd.x * 0.5f + 0.5f;
uv.y = fwd.y * 0.5f + 0.5f;
rotate.y += yaw_step * sign;
}
else
uv.Init( 0.5f, 0.5f );
Q_memcpy( vert.pos, pos.Base(), sizeof( float ) * 3 );
Q_memcpy( vert.normal, up.Base(), sizeof( float ) * 3 );
Q_memcpy( vert.uv, uv.Base(), sizeof( float ) * 2 );
}
}
/// tris for side
for ( int tri_u = 0; tri_u < num_tris_u; tri_u++ )
{
for ( int tri_v = 0; tri_v < num_tris_v; tri_v++ )
{
int tri_0 = tri_u * num_tris_v +
tri_v;
int tri_1 = tri_0 + num_tris_side / 2;
Assert( tri_0 < m_iNumTriangles );
Assert( tri_1 < m_iNumTriangles );
CHLSL_Triangle &t0 = m_Triangles[ tri_0 ];
CHLSL_Triangle &t1 = m_Triangles[ tri_1 ];
int v00 = tri_u * num_verts_v +
tri_v;
int v01 = v00 + 1;
int v10 = (tri_u+1) * num_verts_v +
tri_v;
int v11 = v10 + 1;
Assert( v00 < m_iNumVertices );
Assert( v01 < m_iNumVertices );
Assert( v10 < m_iNumVertices );
Assert( v11 < m_iNumVertices );
t0.vertices[ 0 ] = &m_Vertices[ v00 ];
t0.vertices[ 1 ] = &m_Vertices[ v10 ];
t0.vertices[ 2 ] = &m_Vertices[ v01 ];
t1.vertices[ 0 ] = &m_Vertices[ v10 ];
t1.vertices[ 1 ] = &m_Vertices[ v11 ];
t1.vertices[ 2 ] = &m_Vertices[ v01 ];
}
}
/// tris for top
for ( int dir = 0; dir < 2; dir++ )
{
int v_mid = num_verts_side +
dir * num_verts_top;
Assert( v_mid < m_iNumVertices );
for ( int tri_n = 0; tri_n < num_tris_top; tri_n++ )
{
int tIndex = num_tris_side +
dir * num_tris_top +
tri_n;
Assert( tIndex < m_iNumTriangles );
CHLSL_Triangle &t = m_Triangles[ tIndex ];
int v00 = v_mid + tri_n + 1;
int v10 = (tri_n < (num_tris_top-1)) ? v00 + 1 : v_mid + 1;
Assert( v00 < m_iNumVertices );
Assert( v10 < m_iNumVertices );
t.vertices[ 0 ] = &m_Vertices[ v00 ];
t.vertices[ 1 ] = &m_Vertices[ v_mid ];
t.vertices[ 2 ] = &m_Vertices[ v10 ];
}
}
GenerateTangentSpace();
}
