void OGLRender::SetTextureUFlag(TextureUVFlag dwFlag, uint32 dwTile)
{
TileUFlags[dwTile] = dwFlag;
if( dwTile == gRSP.curTile ) // For basic OGL, only support the 1st texel
{
COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
if( pTexture )
{
EnableTexUnit(0,TRUE);
BindTexture(pTexture->m_dwTextureName, 0);
}
SetTexWrapS(0, OGLXUVFlagMaps[dwFlag].realFlag);
}
}
//-----------------------------------------------------------------------------
// Fixed function Self illumination pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionSelfIlluminationPass( TextureStage_t stage,
int baseTextureVar, int frameVar, int baseTextureTransformVar, int selfIllumTintVar )
{
// IMaterialVar** params = s_ppParams;
if (IsSnapshotting())
{
// A little setup for self illum here...
SetModulationShadowState( selfIllumTintVar );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
s_pShaderShadow->EnableAlphaTest( false );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, false );
s_pShaderShadow->EnableTexture( stage, true );
// No overbrighting
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f );
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f );
// Don't bother with z writes here...
s_pShaderShadow->EnableDepthWrites( false );
// We're always blending
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
int flags = SHADER_DRAW_POSITION;
if (stage == SHADER_TEXTURE_STAGE0)
flags |= SHADER_DRAW_TEXCOORD0;
else
flags |= SHADER_DRAW_TEXCOORD1;
s_pShaderShadow->DrawFlags( flags );
}
else
{
SetFixedFunctionTextureTransform(
(stage == SHADER_TEXTURE_STAGE0) ? MATERIAL_TEXTURE0 : MATERIAL_TEXTURE1,
baseTextureTransformVar );
BindTexture( stage, baseTextureVar, frameVar );
// NOTE: Texture + texture offset are set from BaseTimesLightmap
SetModulationDynamicState( selfIllumTintVar );
FogToFogColor();
}
Draw();
}
void ObjectDisplay::setOneTexture(const char * fileName, GLuint * textureId)
{
cout <<"Loading \"" << fileName << "\" !" << endl;
// 1. Load image via the OpenCV lib.
IplImage * image;
image = cvLoadImage(fileName, 1);
// 2. Convert the result of step 1 to OpenGL format.
unsigned char * pixels = new unsigned char [4 * image->width * image->height];
ConvertFromIplImageToRGBA(pixels, image, image->width, image->height);
// 3. Bind the texture to OpenGL
BindTexture(textureId, pixels, image->width, image->height);
// 4. Release the data array and IplImage.
delete pixels;
cvReleaseImage(&image);
}
tTextureID Cre8Render::CreateTexture2D(std::string uniqueName, si32 width, si32 height, si32 format, si32 type, const void *pixels)
{
tTextureID resultTexture = -1;
CRE8_BREAKIF_IGNORE(m_NamedTextures.find(uniqueName) != m_NamedTextures.end(),
"The texture name \"%s\" is already taken. If you meant to replace it, delete it first.", uniqueName.c_str());
glGenTextures(1, &resultTexture);
BindTexture(0, resultTexture);
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, pixels);
m_NamedTextures[uniqueName] = resultTexture;
return resultTexture;
}
void GLRenderTexture::RebindFramebuffer()
{
ASSERT(m_size.x >= 1 && m_size.y >= 1);
ASSERT(m_fbname && m_texname);
BindTexture(0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_fbname);
glReportFramebufferError();
glViewport(0,0,m_size.x,m_size.y);
glReportError();
}
void Display::Draw2D(uint32 textureId, float left, float top, float width, float height)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
BindTexture(textureId);
glBegin(GL_QUADS);
glColor3ub(255, 255, 255);
glTexCoord2f(1.0f, 0.0f); glVertex2d(left+width, top+0);
glTexCoord2f(1.0f, 1.0f); glVertex2d(left+width, top+height);
glTexCoord2f(0.0f, 1.0f); glVertex2d(left+0, top+height);
glTexCoord2f(0.0f, 0.0f); glVertex2d(left+0, top+0);
glEnd();
}
void RenderImage(int image_id,float posX,float posY,float sizeX,
float sizeY)
{
glEnable(GL_TEXTURE_2D);
BindTexture(image_id);
glBegin(GL_QUADS); // Draw A Quad
glTexCoord2f(0,0); glVertex2f(posX,posY);
glTexCoord2f(1,0); glVertex2f(posX+sizeX,posY);
glTexCoord2f(1,1); glVertex2f(sizeX+posX,sizeY+posY);
glTexCoord2f(0,1); glVertex2f(posX,sizeY+posY);
glEnd();
if(!isGlobalColor)
glColor4ub(255,255,255,255);
glDisable(GL_TEXTURE_2D);
}
void DrawDecal( IMaterialVar **params, IShaderDynamicAPI *pShaderAPI, IShaderShadow *pShaderShadow )
{
if( IsSnapshotting() )
{
// Be sure not to write to dest alpha
pShaderShadow->EnableAlphaWrites( false );
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
SetNormalBlendingShadowState( BASETEXTURE, true );
int pTexCoords[3] = { 2, 2, 1 };
pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION | VERTEX_COLOR, 3, pTexCoords, 0 );
sdk_lightmappedgeneric_decal_Static_Index vshIndex;
pShaderShadow->SetVertexShader( "SDK_LightmappedGeneric_Decal", vshIndex.GetIndex() );
pShaderShadow->SetPixelShader( "SDK_LightmappedGeneric_Decal" );
FogToFogColor();
}
else
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
// Load the z^2 components of the lightmap coordinate axes only
// This is (N dot basis)^2
Vector vecZValues( g_localBumpBasis[0].z, g_localBumpBasis[1].z, g_localBumpBasis[2].z );
vecZValues *= vecZValues;
Vector4D basis[3];
basis[0].Init( vecZValues.x, vecZValues.x, vecZValues.x, 0.0f );
basis[1].Init( vecZValues.y, vecZValues.y, vecZValues.y, 0.0f );
basis[2].Init( vecZValues.z, vecZValues.z, vecZValues.z, 0.0f );
pShaderAPI->SetPixelShaderConstant( 0, (float*)basis, 3 );
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
SetModulationPixelShaderDynamicState( 3 );
sdk_lightmappedgeneric_decal_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
void Shader::BindMaterial(const std::shared_ptr<Material> &material)
{
if (m_Dirty)
return;
for (auto it = material->m_Textures.begin(); it != material->m_Textures.end(); ++it)
{
BindTexture(it->first, it->second);
}
for (auto it = material->m_Uniforms.begin(); it != material->m_Uniforms.end(); ++it)
{
UniformBase::Ptr &ptr = it->second;
if (ptr != nullptr)
ptr->Bind(m_Program, it->first.c_str());
}
}
//Draw the mesh
void DrawMesh(Mesh *mesh)
{
//Bind the buffers
BindMesh(&mesh->Buffers);
BindTexture(&mesh->MeshTexture);
//Draw the mesh
glDrawElements(GL_TRIANGLES //Drawing type
, mesh->Data.IndicesCount //Number of indices
, GL_UNSIGNED_INT //Indices type
, 0); //The location of the indices (NULL means to look for them in the buffer)
//Unbind the buffers
UnbindMesh();
UnbindTexture();
}
void GLInstancedArraysBench::onPerCanvasPostDraw(SkCanvas* canvas) {
// This bench exclusively tests GL calls directly
const GrGLContext* ctx = get_gl_context(canvas);
if (!ctx) {
return;
}
const GrGLInterface* gl = ctx->interface();
// teardown
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
this->teardown(gl);
}
void COGLExtRender::SetTextureUFlag(TextureUVFlag dwFlag, uint32 dwTile)
{
TileUFlags[dwTile] = dwFlag;
if( !m_bEnableMultiTexture )
{
OGLRender::SetTextureUFlag(dwFlag, dwTile);
return;
}
int tex;
if( dwTile == gRSP.curTile )
tex=0;
else if( dwTile == ((gRSP.curTile+1)&7) )
tex=1;
else
{
if( dwTile == ((gRSP.curTile+2)&7) )
tex=2;
else if( dwTile == ((gRSP.curTile+3)&7) )
tex=3;
else
{
TRACE2("Incorrect tile number for OGL SetTextureUFlag: cur=%d, tile=%d", gRSP.curTile, dwTile);
return;
}
}
for( int textureNo=0; textureNo<8; textureNo++)
{
if( m_textureUnitMap[textureNo] == tex )
{
pglActiveTexture(GL_TEXTURE0_ARB+textureNo);
OPENGL_CHECK_ERRORS;
COGLTexture* pTexture = g_textures[(gRSP.curTile+tex)&7].m_pCOGLTexture;
if( pTexture )
{
EnableTexUnit(textureNo,TRUE);
BindTexture(pTexture->m_dwTextureName, textureNo);
}
SetTexWrapS(textureNo, OGLXUVFlagMaps[dwFlag].realFlag);
}
}
}
void FxRenderSprite(int image_id,float posX,float posY,float sizeX,float sizeY,
float rowNum,float columnNum,float frameNumX,float frameNumY)
{
glEnable(GL_TEXTURE_2D);
frameNumX=rowNum+1-frameNumX;
eglut_x1=((frameNumY-1)*((1/columnNum)));
eglut_y1=((frameNumX-1)*((1/rowNum)));
eglut_x2=((frameNumY)*((1/columnNum)));
eglut_y2=((frameNumX)*((1/rowNum)));
glPushMatrix();
glTranslatef(posX,posY,0);
glTranslatef(RotationAnchorX,RotationAnchorY,0);
glRotatef(eglut_Angle,0,0,1);
glTranslatef(-RotationAnchorX,-RotationAnchorY,0);
BindTexture(image_id);
glBegin(GL_QUADS); // Draw A Quad
glTexCoord2f(eglut_x1*(textureX/100)* (1 - flipX * 2),eglut_y1*(textureY/100)* (1 - flipY * 2)); glVertex2f(0,0);
glTexCoord2f(eglut_x2*(textureX/100) * (1 - flipX * 2),eglut_y1*(textureY/100)* (1 - flipY * 2)); glVertex2f(0+sizeX,0);
glTexCoord2f(eglut_x2*(textureX/100) * (1 - flipX * 2),eglut_y2*(textureY/100)* (1 - flipY * 2)); glVertex2f(sizeX,sizeY);
glTexCoord2f(eglut_x1*(textureX/100)* (1 - flipX * 2),eglut_y2*(textureY/100)* (1 - flipY * 2)); glVertex2f(0,sizeY);
glEnd();
glPopMatrix();
flipX=flipY=0;
textureX=textureY=100;
eglut_Angle=RotationAnchorX=RotationAnchorY=0;
if(!isGlobalColor)
glColor4ub(255,255,255,255);
glDisable(GL_TEXTURE_2D);
}
void Display::InitFont(uint8 font)
{
if (font >= MAX_FONTS)
return;
float cx;
float cy;
GLint charsize = 16;
if (font == SMALL_FONT)
charsize = 12;
// V tomto pripade charsperline = charspercolumn
uint32 charsperline = 16;
float charoffset = 1.0f/charsperline;
float spacing = 10.0f;
if (font == SMALL_FONT)
spacing = 7.5f;
m_fontBase[font] = glGenLists(256);
// Textura s fontem
BindTexture(fontTextures[font]);
for (uint16 loop = 0; loop < 256; loop++)
{
cx = float(loop%charsperline)/float(charsperline);
cy = float(loop/charsperline)/float(charsperline)+charoffset;
glNewList(m_fontBase[font]+loop,GL_COMPILE);
glBegin(GL_QUADS);
glTexCoord2f(cx, cy-charoffset); glVertex2i(0, 0);
glTexCoord2f(cx+charoffset,cy-charoffset); glVertex2i(charsize,0);
glTexCoord2f(cx+charoffset,cy); glVertex2i(charsize,charsize);
glTexCoord2f(cx, cy); glVertex2i(0, charsize);
glEnd();
glTranslated(spacing,0,0);
glEndList();
}
m_fontLoaded[font] = true;
}
//Vykresleni textu
void Display::PrintText(uint8 font, uint32 left, uint32 top, const char *fmt, ...)
{
if (font >= MAX_FONTS)
return;
if (!m_fontLoaded[font])
InitFont(font);
glEnable(GL_BLEND);
// Nabindujeme texturu s fontem
BindTexture(fontTextures[font]);
char text[512];
va_list ap;
if (fmt == NULL)
return;
va_start(ap, fmt);
vsprintf(text, fmt, ap);
va_end(ap);
// Pokud jsme ve 3D rezimu
bool in3D = !IsIn2DMode();
// Prepneme do 2D
if (in3D)
Setup2DMode();
glLoadIdentity();
glTranslated(left,top,0);
glListBase(m_fontBase[font]-32);
glCallLists(strlen(text),GL_UNSIGNED_BYTE,text);
glLoadIdentity();
// A po vykresleni se vratime zpet do puvodniho modu pokud je to nutne
if (in3D)
Setup3DMode();
}
void RenderTerrain()
{
glUseProgram(g_terrainShader);
UpdateTerrainShaderParameters();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, g_lightDir);
if (g_disableColorMaps)
{
BindTexture(g_nullTexture, 0);
BindTexture(g_nullTexture, 1);
BindTexture(g_nullTexture, 2);
BindTexture(g_nullTexture, 3);
}
else
{
BindTexture(g_regions[0].texture, 0);
BindTexture(g_regions[1].texture, 1);
BindTexture(g_regions[2].texture, 2);
BindTexture(g_regions[3].texture, 3);
}
g_terrain.draw();
for (int i = 3; i >= 0; --i)
{
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
glDisable(GL_LIGHT0);
glDisable(GL_LIGHTING);
glUseProgram(0);
}
void GrGLTexture::uploadTextureData(int x,
int y,
int width,
int height,
const void* srcData) {
GPUGL->setSpareTextureUnit();
// glCompressedTexSubImage2D doesn't support any formats
// (at least without extensions)
GrAssert(fUploadFormat != GR_GL_PALETTE8_RGBA8);
// If we need to update textures that are created upside down
// then we have to modify this code to flip the srcData
GrAssert(kTopDown_Orientation == fOrientation);
GR_GL(BindTexture(GR_GL_TEXTURE_2D, fTexIDObj->id()));
GR_GL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, fUploadByteCount));
GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, x, y, width, height,
fUploadFormat, fUploadType, srcData));
}
RenderContextType RenderSolidColored(CoreState* state)
{
if (state->render_state->m_enable_font_rendering)
{
if (BindTexture(state))
// text map retrieved as sampler2darray with layer
;
else
// text map retrieved as sampler2d
return RenderContextType::TextSolidColor;
}
else if (state->render_state->m_enable_diffuse_shading)
{
if (state->render_state->m_enable_vertex_color)
// use color from vertex attributes
return RenderContextType::NoLightVertexColor;
else
// use color from uniform parameters
return RenderContextType::NoLightSolidColor;
}
return RenderContextType::NoRender;
}
GrGLint SkGLContext::createTextureRectangle(int width, int height, GrGLenum internalFormat,
GrGLenum externalFormat, GrGLenum externalType,
GrGLvoid* data) {
if (!(kGL_GrGLStandard == fGL->fStandard && GrGLGetVersion(fGL) >= GR_GL_VER(3, 2)) &&
!fGL->fExtensions.has("GL_ARB_texture_rectangle")) {
return 0;
}
GrGLuint id;
GR_GL_CALL(fGL, GenTextures(1, &id));
GR_GL_CALL(fGL, BindTexture(GR_GL_TEXTURE_RECTANGLE, id));
GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_MAG_FILTER,
GR_GL_NEAREST));
GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_MIN_FILTER,
GR_GL_NEAREST));
GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_S,
GR_GL_CLAMP_TO_EDGE));
GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_T,
GR_GL_CLAMP_TO_EDGE));
GR_GL_CALL(fGL, TexImage2D(GR_GL_TEXTURE_RECTANGLE, 0, internalFormat, width, height, 0,
externalFormat, externalType, data));
return id;
}
void PrelightPipeline::DrawRenderable(const std::shared_ptr<Pass> &pass, const std::shared_ptr<SceneNode> &node)
{
auto render = node->GetComponent<MeshRender>();
if (render == nullptr || !render->GetRenderable())
return;
auto mesh = render->GetMesh();
auto material = render->GetMaterial();
auto shader = material->GetShaderForPass(pass->GetRenderIndex());
if (shader == nullptr)
shader = pass->GetShader(material->GetShaderType());
if (shader == nullptr)
{
LOGW << "Failed to draw " << node->GetName() << ", data incomplete!";
return;
}
shader->Bind();
shader->BindCamera(m_CurrentCamera);
shader->BindMatrix(Matrix4::WORLD_MATRIX, node->GetWorldMatrix());
shader->BindMesh(mesh);
shader->BindMaterial(material);
for (unsigned int i = 0; i < pass->GetTextureCount(true); i++)
{
auto ptr = pass->GetTextureAt(i, true);
shader->BindTexture(ptr->GetName(), ptr);
}
glDrawElements(GL_TRIANGLES, mesh->Indices.Data.size(), GL_UNSIGNED_INT, 0);
shader->UnBind();
m_DrawCall++;
}
bool GLTexture::writeFile(const char *fname) const
{
const int2 sz = ceil_int(m_texsize);
const size_t size = sz.x * sz.y * 4;
uint *pix = (uint*) malloc(size);
OutlawImage img = {};
img.width = sz.x;
img.height = sz.y;
img.format = GL_RGBA;
img.type = GL_UNSIGNED_BYTE;
img.data = (char*) pix;
BindTexture(0);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix);
glReportError();
invert_image(pix, sz.x, sz.y);
const int success = OL_SaveImage(&img, fname);
free(pix);
return success;
}
void Model::Draw(const Matrix4f& transform) const
{
if (_vbuffer == 0)
return;
auto video = _context->GetModule<Video>();
if (!video->BindBuffer(_vbuffer, Vertex3::DECLARE.size, Vertex3::DECLARE.types, Vertex3::DECLARE.count))
return;
glPushMatrix();
glMultMatrixf(transform.GetData());
video->BindTexture(_texture);
if (_ibuffer && video->BindBuffer(_ibuffer, 0, 0, 0))
{
video->DrawIndexedPrimitives(_topology, _icount, VALUE_USHORT);
video->UnbindBuffer(_ibuffer, 0, 0);
}
else video->DrawPrimitives(_topology, _vcount, 0);
glPopMatrix();
video->UnbindBuffer(_vbuffer, Vertex3::DECLARE.types, Vertex3::DECLARE.count);
}
void CBaseShader::BindTexture( Sampler_t sampler1, ITexture *pTexture, int nFrame /* = 0 */ )
{
BindTexture( sampler1, (Sampler_t) -1, pTexture, nFrame );
}
void CBaseShader::BindTexture( Sampler_t sampler1, int nTextureVar, int nFrameVar /* = -1 */ )
{
BindTexture( sampler1, (Sampler_t) -1, nTextureVar, nFrameVar );
}
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
bool hasEnvmap = params[ENVMAP]->IsTexture() && !bBumpedEnvMap;
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasEnvmapCameraSpace = IS_FLAG_SET( MATERIAL_VAR_ENVMAPCAMERASPACE );
bool hasEnvmapSphere = IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE );
if ( hasEnvmap || hasBaseTexture || hasVertexColor || !bBumpedEnvMap )
{
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() );
}
// Base texture on stage 0
if (params[BASETEXTURE]->IsTexture())
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
}
// Lightmap on stage 1
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
int fmt = VERTEX_POSITION;
if ( hasEnvmap )
{
fmt |= VERTEX_NORMAL;
// envmap on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// envmapmask on stage 3
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
}
if (params[BASETEXTURE]->IsTexture() || bBumpedEnvMap)
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
else
{
SetDefaultBlendingShadowState( ENVMAPMASK, false );
}
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
{
fmt |= VERTEX_COLOR;
}
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( false );
vshIndex.SetENVMAP( hasEnvmap );
vshIndex.SetENVMAPCAMERASPACE( hasEnvmap && hasEnvmapCameraSpace );
vshIndex.SetENVMAPSPHERE( hasEnvmap && hasEnvmapSphere );
vshIndex.SetVERTEXCOLOR( hasVertexColor );
pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
const char *pshName = GetPixelShaderName( params, bBumpedEnvMap );
pShaderShadow->SetPixelShader( pshName );
DefaultFog();
}
DYNAMIC_STATE
{
if (hasBaseTexture)
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( hasEnvmap )
{
BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME );
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
{
if (params[ENVMAPMASK]->IsTexture() )
BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME );
else
BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE );
}
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ||
IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
{
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
}
SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 );
}
if ( !hasEnvmap || hasBaseTexture || hasVertexColor )
{
SetModulationVertexShaderDynamicState();
}
EnablePixelShaderOverbright( 0, true, true );
SetPixelShaderConstant( 1, SELFILLUMTINT );
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
void Display::DrawMap()
{
const Map* pMap = sMapManager->GetMap();
if (!pMap || pMap->field.size() < 1 || pMap->field[0].size() < 1)
return;
// Pracovni promenne pro vykreslovani
GLfloat x,y,z;
Map::DynamicCellSet::const_iterator itr;
glLoadIdentity();
glRotatef(m_angleX,1.0f,0.0f,0.0f);
glRotatef(m_angleY,0.0f,1.0f,0.0f);
glRotatef(m_angleZ,0.0f,0.0f,1.0f);
glTranslatef(m_viewX, m_viewY, m_viewZ);
// Vykresleni skyboxu
/*
Skybox data struktura:
id
box_textures[6]
0 = dolni
1 = horni
2 = zadni
3 = predni
4 = vlevo
5 = vpravo
*/
uint32 m_skybox = pMap->m_skybox;
GLfloat skyboxSize = 50.0f;
// Predni cast
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[3]);
glBegin(GL_QUADS);
glTexCoord2f(1, 1); glVertex3f( skyboxSize, -skyboxSize, -skyboxSize );
glTexCoord2f(0, 1); glVertex3f( -skyboxSize, -skyboxSize, -skyboxSize );
glTexCoord2f(0, 0); glVertex3f( -skyboxSize, skyboxSize, -skyboxSize );
glTexCoord2f(1, 0); glVertex3f( skyboxSize, skyboxSize, -skyboxSize );
glEnd();
// Cast vlevo
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[4]);
glBegin(GL_QUADS);
glTexCoord2f(1, 1); glVertex3f( skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(0, 1); glVertex3f( skyboxSize, -skyboxSize, -skyboxSize );
glTexCoord2f(0, 0); glVertex3f( skyboxSize, skyboxSize, -skyboxSize );
glTexCoord2f(1, 0); glVertex3f( skyboxSize, skyboxSize, skyboxSize );
glEnd();
// Zadni cast
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[2]);
glBegin(GL_QUADS);
glTexCoord2f(1, 1); glVertex3f( -skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(0, 1); glVertex3f( skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(0, 0); glVertex3f( skyboxSize, skyboxSize, skyboxSize );
glTexCoord2f(1, 0); glVertex3f( -skyboxSize, skyboxSize, skyboxSize );
glEnd();
// Cast vpravo
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[5]);
glBegin(GL_QUADS);
glTexCoord2f(1, 1); glVertex3f( -skyboxSize, -skyboxSize, -skyboxSize );
glTexCoord2f(0, 1); glVertex3f( -skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(0, 0); glVertex3f( -skyboxSize, skyboxSize, skyboxSize );
glTexCoord2f(1, 0); glVertex3f( -skyboxSize, skyboxSize, -skyboxSize );
glEnd();
// Strop
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[1]);
glBegin(GL_QUADS);
glTexCoord2f(0, 1); glVertex3f( -skyboxSize, skyboxSize, -skyboxSize );
glTexCoord2f(0, 0); glVertex3f( -skyboxSize, skyboxSize, skyboxSize );
glTexCoord2f(1, 0); glVertex3f( skyboxSize, skyboxSize, skyboxSize );
glTexCoord2f(1, 1); glVertex3f( skyboxSize, skyboxSize, -skyboxSize );
glEnd();
// Spodni cast
sDisplay->BindTexture(sStorage->SkyboxData[m_skybox].box_textures[0]);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f( -skyboxSize, -skyboxSize, -skyboxSize );
glTexCoord2f(0, 1); glVertex3f( -skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(1, 1); glVertex3f( skyboxSize, -skyboxSize, skyboxSize );
glTexCoord2f(1, 0); glVertex3f( skyboxSize, -skyboxSize, -skyboxSize );
glEnd();
// Konec vykresleni skyboxu
for (uint32 w = 0; w < pMap->field.size(); w++)
{
for (uint32 h = 0; h < pMap->field[0].size(); h++)
{
x = w;
y = 0;
z = h;
BindTexture(pMap->field[w][h].texture);
// Nejdrive staticke prvky
if (pMap->field[w][h].type == TYPE_GROUND || pMap->field[w][h].type == TYPE_STARTLOC)
{
glBegin(GL_POLYGON);
glNormal3f(0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x-1, y, z-1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x , y, z-1);
glTexCoord2f(0.0f, 0.0f); glVertex3f(x , y, z );
glTexCoord2f(1.0f, 0.0f); glVertex3f(x-1, y, z );
glEnd();
}
else if (pMap->field[w][h].type == TYPE_SOLID_BOX)
{
glBegin(GL_QUADS);
glNormal3f(0.0f,-1.0f, 0.0f);
// horni
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z-1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z-1);
glTexCoord2f(0.0f, 0.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z );
glTexCoord2f(1.0f, 0.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z );
// levobok
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z-1);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x-1, y , z-1);
glTexCoord2f(0.0f, 0.0f); glVertex3f(x-1, y , z );
glTexCoord2f(0.0f, 1.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z );
// pravobok
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z );
glTexCoord2f(1.0f, 0.0f); glVertex3f(x , y , z );
glTexCoord2f(0.0f, 0.0f); glVertex3f(x , y , z-1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z-1);
// predni
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z );
glTexCoord2f(1.0f, 0.0f); glVertex3f(x-1, y , z );
glTexCoord2f(0.0f, 0.0f); glVertex3f(x , y , z );
glTexCoord2f(0.0f, 1.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z );
// zadni
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x-1, y+SOLID_BOX_HEIGHT, z-1);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x-1, y , z-1);
glTexCoord2f(0.0f, 0.0f); glVertex3f(x , y , z-1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x , y+SOLID_BOX_HEIGHT, z-1);
glEnd();
}
}
}
}
inline void DrawPass( IMaterialVar **params, IShaderShadow* pShaderShadow,
IShaderDynamicAPI* pShaderAPI, int nPass, VertexCompressionType_t vertexCompression )
{
bool bIsModel = IS_FLAG_SET( MATERIAL_VAR_MODEL );
bool bHasEnvmap = params[ENVMAP]->IsTexture();
bool bHasFlowmap = params[FLOWMAP]->IsTexture();
bool bHasCoreColorTexture = params[CORECOLORTEXTURE]->IsTexture();
SHADOW_STATE
{
SetInitialShadowState( );
if( nPass == 0 )
{
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
}
else
{
pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
}
// If envmap is not specified, the alpha channel is the translucency
// (If envmap *is* specified, alpha channel is the reflection amount)
if ( params[NORMALMAP]->IsTexture() && !bHasEnvmap )
{
SetDefaultBlendingShadowState( NORMALMAP, false );
}
// source render target that contains the image that we are warping.
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
// normal map
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if( bHasEnvmap )
{
// envmap
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
}
if( bHasFlowmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if( bHasCoreColorTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
}
if( g_pHardwareConfig->GetHDRType() != HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBWrite( true );
}
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
int userDataSize = 0;
int nTexCoordCount = 1;
if( bIsModel )
{
userDataSize = 4;
}
else
{
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
DECLARE_STATIC_VERTEX_SHADER( sdk_core_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bIsModel );
SET_STATIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20 );
}
DefaultFog();
}
DYNAMIC_STATE
{
pShaderAPI->SetDefaultState();
if ( params[BASETEXTURE]->IsTexture() )
{
BindTexture( SHADER_SAMPLER2, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_FRAME_BUFFER_FULL_TEXTURE_0 );
}
BindTexture( SHADER_SAMPLER3, NORMALMAP, BUMPFRAME );
if( bHasEnvmap )
{
BindTexture( SHADER_SAMPLER4, ENVMAP, ENVMAPFRAME );
}
if( bHasFlowmap )
{
BindTexture( SHADER_SAMPLER6, FLOWMAP, FLOWMAPFRAME );
}
if( bHasCoreColorTexture )
{
BindTexture( SHADER_SAMPLER7, CORECOLORTEXTURE, CORECOLORTEXTUREFRAME );
}
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
}
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, BUMPTRANSFORM );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
SetPixelShaderConstant( 0, ENVMAPTINT );
SetPixelShaderConstant( 1, REFRACTTINT );
}
else
{
SetPixelShaderConstantGammaToLinear( 0, ENVMAPTINT );
SetPixelShaderConstantGammaToLinear( 1, REFRACTTINT );
}
SetPixelShaderConstant( 2, ENVMAPCONTRAST );
SetPixelShaderConstant( 3, ENVMAPSATURATION );
float c5[4] = { params[REFRACTAMOUNT]->GetFloatValue(),
params[REFRACTAMOUNT]->GetFloatValue(), 0.0f, 0.0f };
pShaderAPI->SetPixelShaderConstant( 5, c5, 1 );
float eyePos[4];
s_pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
s_pShaderAPI->SetPixelShaderConstant( 8, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 11 );
if( bHasFlowmap )
{
float curTime = pShaderAPI->CurrentTime();
float timeVec[4] = { curTime, curTime, curTime, curTime };
pShaderAPI->SetPixelShaderConstant( 6, timeVec, 1 );
SetPixelShaderConstant( 7, FLOWMAPSCROLLRATE );
SetPixelShaderConstant( 9, FLOWMAPTEXCOORDOFFSET );
}
}
Draw();
}
void DrawUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, VertexCompressionType_t vertexCompression )
{
bool hasBump = params[BUMPMAP]->IsTexture();
BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true );
bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base map
int flags = VERTEX_POSITION | VERTEX_NORMAL;
int nTexCoordCount = 1;
int userDataSize = 0;
if ( hasBump )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Bump map
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Normalization sampler for per-pixel lighting
userDataSize = 4; // tangent S
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
if ( hasBump )
{
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 );
SET_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs20 );
// ps_2_b version which does phong
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20b );
SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20 );
SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20 );
}
}
#ifndef _X360
else
{
// The vertex shader uses the vertex id stream
SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID );
DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 );
SET_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs30 );
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps30 );
SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps30 );
}
#endif
}
else
{
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 );
SET_STATIC_VERTEX_SHADER( sdk_teeth_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps20b );
SET_STATIC_PIXEL_SHADER( sdk_teeth_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps20 );
SET_STATIC_PIXEL_SHADER( sdk_teeth_ps20 );
}
}
#ifndef _X360
else
{
// The vertex shader uses the vertex id stream
SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID );
DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 );
SET_STATIC_VERTEX_SHADER( sdk_teeth_vs30 );
DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps30 );
SET_STATIC_PIXEL_SHADER( sdk_teeth_ps30 );
}
#endif
}
// On DX9, do sRGB
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBWrite( true );
FogToFogColor();
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
}
DYNAMIC_STATE
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
if ( hasBump )
{
BindTexture( SHADER_SAMPLER1, BUMPMAP );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
pShaderAPI->SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE );
pShaderAPI->CommitPixelShaderLighting( PSREG_LIGHT_INFO_ARRAY );
Vector4D lighting;
params[FORWARD]->GetVecValue( lighting.Base(), 3 );
lighting[3] = params[ILLUMFACTOR]->GetFloatValue();
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, lighting.Base() );
LightState_t lightState;
pShaderAPI->GetDX9LightState( &lightState );
pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
float vEyePos_SpecExponent[4];
pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
vEyePos_SpecExponent[3] = 0.0f;
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
if ( hasBump )
{
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs20 );
// ps_2_b version which does Phong
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
Vector4D vSpecExponent;
vSpecExponent[3] = params[PHONGEXPONENT]->GetFloatValue();
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vSpecExponent.Base(), 1 );
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20 );
}
}
#ifndef _X360
else
{
SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 );
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs30 );
Vector4D vSpecExponent;
vSpecExponent[3] = params[PHONGEXPONENT]->GetFloatValue();
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vSpecExponent.Base(), 1 );
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps30 );
}
#endif
}
else
{
// For non-bumped case, ambient cube is computed in the vertex shader
SetAmbientCubeDynamicStateVertexShader();
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() );
SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20 );
}
}
#ifndef _X360
else
{
SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 );
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() );
SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs30 );
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps30 );
}
#endif
}
if( params[INTRO]->GetIntValue() )
{
float curTime = params[WARPPARAM]->GetFloatValue();
float timeVec[4] = { 0.0f, 0.0f, 0.0f, curTime };
Assert( params[ENTITYORIGIN]->IsDefined() );
params[ENTITYORIGIN]->GetVecValue( timeVec, 3 );
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, timeVec, 1 );
}
}
Draw();
}
void DrawPass( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, bool hasFlashlight, VertexCompressionType_t vertexCompression )
{
bool bSinglePassFlashlight = false;
bool hasBump = params[BUMPMAP]->IsTexture();
bool hasDiffuseBumpmap = hasBump && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0);
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasDetailTexture = /*!hasBump && */params[DETAIL]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) != 0;
bool bHasDetailAlpha = params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->GetIntValue() != 0;
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true );
bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use
bool bSeamlessMapping = params[SEAMLESS_SCALE]->GetFloatValue() != 0.0;
bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( SHADERSRGBREAD360 ) && params[SHADERSRGBREAD360]->GetIntValue() );
SHADOW_STATE
{
int nShadowFilterMode = 0;
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if( hasFlashlight )
{
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats
}
SetAdditiveBlendingShadowState( BASETEXTURE, true );
pShaderShadow->EnableDepthWrites( false );
// Be sure not to write to dest alpha
pShaderShadow->EnableAlphaWrites( false );
}
else
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
unsigned int flags = VERTEX_POSITION;
if( hasBaseTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead );
}
// if( hasLightmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
}
if( hasFlashlight )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL;
}
if( hasDetailTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
if( hasBump )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
}
if( hasVertexColor )
{
flags |= VERTEX_COLOR;
}
// Normalizing cube map
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
// texcoord0 : base texcoord
// texcoord1 : lightmap texcoord
// texcoord2 : lightmap texcoord offset
int numTexCoords = 2;
if( hasBump )
{
numTexCoords = 3;
}
pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
// Pre-cache pixel shaders
bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
pShaderShadow->EnableSRGBWrite( true );
int nLightingPreviewMode = IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 );
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
}
else
#endif
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 );
#ifdef _X360
SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
#endif
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
}
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
}
// HACK HACK HACK - enable alpha writes all the time so that we have them for
// underwater stuff.
// But only do it if we're not using the alpha already for translucency
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
if( hasFlashlight )
{
FogToBlack();
}
else
{
DefaultFog();
}
PI_BeginCommandBuffer();
PI_SetModulationVertexShaderDynamicState( );
PI_EndCommandBuffer();
}
DYNAMIC_STATE
{
if( hasBaseTexture )
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
}
// if( hasLightmap )
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
}
bool bFlashlightShadows = false;
bool bUberlight = false;
if( hasFlashlight )
{
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
bFlashlightShadows = state.m_bEnableShadows;
bUberlight = state.m_bUberlight;
SetFlashLightColorFromState( state, pShaderAPI, bSinglePassFlashlight );
BindTexture( SHADER_SAMPLER2, state.m_pSpotlightTexture, state.m_nSpotlightTextureFrame );
if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() )
{
BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture );
}
}
if( hasDetailTexture )
{
BindTexture( SHADER_SAMPLER3, DETAIL, DETAILFRAME );
}
if( hasBump )
{
if( !g_pConfig->m_bFastNoBump )
{
BindTexture( SHADER_SAMPLER4, BUMPMAP, BUMPFRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT );
}
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER6, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
// If we don't have a texture transform, we don't have
// to set vertex shader constants or run vertex shader instructions
// for the texture transform.
bool bHasTextureTransform =
!( params[BASETEXTURETRANSFORM]->MatrixIsIdentity() &&
params[BUMPTRANSFORM]->MatrixIsIdentity() );
bool bVertexShaderFastPath = !bHasTextureTransform;
if( params[DETAIL]->IsTexture() )
{
bVertexShaderFastPath = false;
}
if( pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING) != 0 )
{
bVertexShaderFastPath = false;
}
if( !bVertexShaderFastPath )
{
if ( !bSeamlessMapping )
{
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
if( hasBump && !bHasDetailAlpha )
{
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BUMPTRANSFORM );
Assert( !hasDetailTexture );
}
}
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
if ( IsPC() )
{
bool bWorldNormal = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ) == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH;
if ( bWorldNormal )
{
float vEyeDir[4];
pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir );
float flFarZ = pShaderAPI->GetFarZ();
vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm
vEyeDir[1] /= flFarZ;
vEyeDir[2] /= flFarZ;
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_12, vEyeDir );
}
}
#ifndef _X360
if (g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
}
else
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
}
bool bWriteDepthToAlpha;
bool bWriteWaterFogToAlpha;
if( bFullyOpaque )
{
bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha();
bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z);
AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." );
}
else
{
//can't write a special value to dest alpha if we're actually using as-intended alpha
bWriteDepthToAlpha = false;
bWriteWaterFogToAlpha = false;
}
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, bUberlight );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z) &&
(nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
}
// always set the transform for detail textures since I'm assuming that you'll
// always have a detailscale.
if( hasDetailTexture )
{
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, DETAILSCALE );
Assert( !( hasBump && !bHasDetailAlpha ) );
}
SetPixelShaderConstantGammaToLinear( 7, SELFILLUMTINT );
float eyePos[4];
pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
pShaderAPI->SetPixelShaderConstant( 10, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 11 );
if ( bSeamlessMapping )
{
float map_scale[4]={ params[SEAMLESS_SCALE]->GetFloatValue(),0,0,0};
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, map_scale );
}
if( hasFlashlight )
{
VMatrix worldToTexture;
const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture );
// Set the flashlight attenuation factors
float atten[4];
atten[0] = flashlightState.m_fConstantAtten;
atten[1] = flashlightState.m_fLinearAtten;
atten[2] = flashlightState.m_fQuadraticAtten;
atten[3] = flashlightState.m_FarZAtten;
pShaderAPI->SetPixelShaderConstant( 20, atten, 1 );
// Set the flashlight origin
float pos[4];
pos[0] = flashlightState.m_vecLightOrigin[0];
pos[1] = flashlightState.m_vecLightOrigin[1];
pos[2] = flashlightState.m_vecLightOrigin[2];
pos[3] = flashlightState.m_FarZ; // didn't have this in main. . probably need this?
pShaderAPI->SetPixelShaderConstant( 15, pos, 1 );
pShaderAPI->SetPixelShaderConstant( 16, worldToTexture.Base(), 4 );
if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() )
{
SetupUberlightFromState( pShaderAPI, flashlightState );
}
}
}
Draw();
}
void Display::DrawBillboards()
{
BillboardDisplayListRecord* temp = NULL;
glDepthMask(GL_FALSE);
bool lightingEnable = (glIsEnabled(GL_LIGHTING) == GL_TRUE);
glDisable(GL_LIGHTING);
if (!BillboardDisplayList.empty())
BillboardDisplayList.sort(BubbleSortDistance);
for (std::list<BillboardDisplayListRecord*>::iterator itr = BillboardDisplayList.begin(); itr != BillboardDisplayList.end();)
{
temp = (*itr);
if (!temp)
{
itr = BillboardDisplayList.erase(itr);
continue;
}
if (temp->remove)
{
if (temp->displayList)
glDeleteLists(temp->displayList, temp->displayListSize);
if (temp->AnimTicket)
sAnimator->DestroyAnimTicket(temp->AnimTicket);
if (temp)
delete temp;
itr = BillboardDisplayList.erase(itr);
continue;
}
// Zabezpeceni proti vykreslovani billboardu, ktere jsou od nas vzdalene vice jak 14 jednotek
// - Zvysuje vykon
if (pythagoras_c(fabs(temp->x-fabs(m_targetX)), fabs(temp->z-fabs(m_targetZ))) > 14.0f)
{
++itr;
continue;
}
glLoadIdentity();
glColor3ub(255, 255, 255);
AdjustViewToTarget();
if (temp->AnimTicket)
BindTexture(sAnimator->GetActualTexture(temp->AnimTicket));
else
BindTexture(temp->textureId);
// Pruhledne objekty potrebuji mit zapnuty mod pro blending a mod one minus src alpha pro
// spravne vykresleni pruhlednosti
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Nechat depth test pro ted zapnuty, zpusobuje nepruhlednost
// vykreslenych spritu vuci jinym spritum
//glDisable(GL_DEPTH_TEST);
// TODO: blending zvlast kanalu
// asi useless
//glColor4f(1,1,1,0.85);
glTranslatef(temp->x, temp->y, temp->z);
if (temp->billboard_y)
glRotatef(90.0f-m_angleY, 0.0f, 1.0f, 0.0f);
if (temp->billboard_x)
glRotatef(m_angleX, 0.0f, 0.0f, -1.0f);
if (temp->displayList > 0)
{
glCallList(temp->displayList);
}
else
{
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1.0f, 1.0f); glVertex3f(0, 0 , (-temp->scale_x/2));
glTexCoord2f(0.0f, 1.0f); glVertex3f(0, 0 , ( temp->scale_x/2));
glTexCoord2f(1.0f, 0.0f); glVertex3f(0, temp->scale_y , (-temp->scale_x/2));
glTexCoord2f(0.0f, 0.0f); glVertex3f(0, temp->scale_y , ( temp->scale_x/2));
glEnd();
}
// Nezapomeneme vypnout blending, jen jako slusnacci
glDisable(GL_BLEND);
// Netreba, viz. komentar vyse
//glEnable(GL_DEPTH_TEST);
++itr;
}
glDepthMask(GL_TRUE);
if (lightingEnable)
glEnable(GL_LIGHTING);
glLoadIdentity();
glRotatef(m_angleX, 1.0f, 0.0f, 0.0f);
glRotatef(m_angleY, 0.0f, -1.0f, 0.0f);
glTranslatef(m_viewX, m_viewY, m_viewZ);
}
