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); }