// ------------- draw void EyeLinker::draw(){ drawFireworks(); if(isGlow) drawGlow(); for(auto eye: eyes){ eye.draw(); } // drawParticles(); }
// -------------- draw void StencilWaves::draw(){ // drawBg(); for(auto &p: contours){ p.setFillColor(peopleColor); p.draw(); } // mask.draw(); // waves[0].polyline.draw(); refract.draw(0, 0); strokeMesh.draw(); drawGlow(); gui.draw(); }
void STKMeshSceneNode::render() { irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); if (!Mesh || !driver) return; ++PassCount; updateNoGL(); updateGL(); bool isTransparent; for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); isTransparent = rnd->isTransparent(); break; } if ((irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS) && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame) updatevbo(); glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(std::vector < GLuint > { getTextureGLuint(mesh.textures[0]) }); MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == SOLID_LIT_PASS && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame && !UserConfigParams::m_dynamic_lights) updatevbo(); glUseProgram(MeshShader::ObjectPass2Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; if (UserConfigParams::m_azdo) { GLuint64 DiffuseHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_DIFFUSE), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(DiffuseHandle)) glMakeTextureHandleResidentARB(DiffuseHandle); GLuint64 SpecularHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_SPECULAR), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[1]); if (!glIsTextureHandleResidentARB(SpecularHandle)) glMakeTextureHandleResidentARB(SpecularHandle); GLuint64 SSAOHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_HALF1_R), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[2]); if (!glIsTextureHandleResidentARB(SSAOHandle)) glMakeTextureHandleResidentARB(SSAOHandle); if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0])); } else MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(createVector<GLuint>( irr_driver->getRenderTargetTexture(RTT_DIFFUSE), irr_driver->getRenderTargetTexture(RTT_SPECULAR), irr_driver->getRenderTargetTexture(RTT_HALF1_R), getTextureGLuint(mesh.textures[0]))); MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == GLOW_PASS) { glUseProgram(MeshShader::ColorizeShader::getInstance()->Program); for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; if (irr_driver->hasARB_base_instance()) glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD)); else glBindVertexArray(GLmeshes[i].vao); drawGlow(GLmeshes[i]); } } if (irr_driver->getPhase() == TRANSPARENT_PASS && isTransparent) { ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation); if (immediate_draw) { if (update_each_frame) updatevbo(); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); if (World::getWorld() && World::getWorld()->isFogEnabled()) { glUseProgram(MeshShader::TransparentFogShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { GLMesh &mesh = GLmeshes[i]; irr_driver->IncreaseObjectCount(); GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; const Track * const track = World::getWorld()->getTrack(); // This function is only called once per frame - thus no need for setters. const float fogmax = track->getFogMax(); const float startH = track->getFogStartHeight(); const float endH = track->getFogEndHeight(); const float start = track->getFogStart(); const float end = track->getFogEnd(); const video::SColor tmpcol = track->getFogColor(); video::SColorf col(tmpcol.getRed() / 255.0f, tmpcol.getGreen() / 255.0f, tmpcol.getBlue() / 255.0f); compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } else { glUseProgram(MeshShader::TransparentShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } return; } } }
void STKMeshSceneNode::render() { irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); if (!Mesh || !driver) return; if (reload_each_frame) updatevbo(); bool isTransparentPass = SceneManager->getSceneNodeRenderPass() == scene::ESNRP_TRANSPARENT; ++PassCount; driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); Box = Mesh->getBoundingBox(); setFirstTimeMaterial(); for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; GLmeshes[i].TextureMatrix = getMaterial(i).getTextureMatrix(0); } if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS) { if (reload_each_frame) glDisable(GL_CULL_FACE); computeMVP(ModelViewProjectionMatrix); computeTIMV(TransposeInverseModelView); if (!GeometricMesh[FPSM_DEFAULT].empty()) glUseProgram(MeshShader::ObjectPass1Shader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++) drawSolidPass1(*GeometricMesh[FPSM_DEFAULT][i], FPSM_DEFAULT); if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty()) glUseProgram(MeshShader::ObjectRefPass1Shader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++) drawSolidPass1(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], FPSM_ALPHA_REF_TEXTURE); if (!GeometricMesh[FPSM_NORMAL_MAP].empty()) glUseProgram(MeshShader::NormalMapShader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_NORMAL_MAP].size(); i++) drawSolidPass1(*GeometricMesh[FPSM_NORMAL_MAP][i], FPSM_NORMAL_MAP); if (!GeometricMesh[FPSM_GRASS].empty()) glUseProgram(MeshShader::GrassPass1Shader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++) drawSolidPass1(*GeometricMesh[FPSM_GRASS][i], FPSM_GRASS); if (reload_each_frame) glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == SOLID_LIT_PASS) { if (reload_each_frame) glDisable(GL_CULL_FACE); if (!ShadedMesh[SM_DEFAULT].empty()) glUseProgram(MeshShader::ObjectPass2Shader::Program); for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT].size(); i++) drawSolidPass2(*ShadedMesh[SM_DEFAULT][i], SM_DEFAULT); if (!ShadedMesh[SM_ALPHA_REF_TEXTURE].empty()) glUseProgram(MeshShader::ObjectRefPass2Shader::Program); for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++) drawSolidPass2(*ShadedMesh[SM_ALPHA_REF_TEXTURE][i], SM_ALPHA_REF_TEXTURE); if (!ShadedMesh[SM_RIMLIT].empty()) glUseProgram(MeshShader::ObjectRimLimitShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_RIMLIT].size(); i++) drawSolidPass2(*ShadedMesh[SM_RIMLIT][i], SM_RIMLIT); if (!ShadedMesh[SM_SPHEREMAP].empty()) glUseProgram(MeshShader::SphereMapShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_SPHEREMAP].size(); i++) drawSolidPass2(*ShadedMesh[SM_SPHEREMAP][i], SM_SPHEREMAP); if (!ShadedMesh[SM_SPLATTING].empty()) glUseProgram(MeshShader::SplattingShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_SPLATTING].size(); i++) drawSolidPass2(*ShadedMesh[SM_SPLATTING][i], SM_SPLATTING); if (!ShadedMesh[SM_GRASS].empty()) glUseProgram(MeshShader::GrassPass2Shader::Program); for (unsigned i = 0; i < ShadedMesh[SM_GRASS].size(); i++) drawSolidPass2(*ShadedMesh[SM_GRASS][i], SM_GRASS); if (!ShadedMesh[SM_UNLIT].empty()) glUseProgram(MeshShader::ObjectUnlitShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_UNLIT].size(); i++) drawSolidPass2(*ShadedMesh[SM_UNLIT][i], SM_UNLIT); if (!ShadedMesh[SM_CAUSTICS].empty()) glUseProgram(MeshShader::CausticsShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_CAUSTICS].size(); i++) drawSolidPass2(*ShadedMesh[SM_CAUSTICS][i], SM_CAUSTICS); if (!ShadedMesh[SM_DETAILS].empty()) glUseProgram(MeshShader::DetailledObjectPass2Shader::Program); for (unsigned i = 0; i < ShadedMesh[SM_DETAILS].size(); i++) drawSolidPass2(*ShadedMesh[SM_DETAILS][i], SM_DETAILS); if (!ShadedMesh[SM_UNTEXTURED].empty()) glUseProgram(MeshShader::UntexturedObjectShader::Program); for (unsigned i = 0; i < ShadedMesh[SM_UNTEXTURED].size(); i++) drawSolidPass2(*ShadedMesh[SM_UNTEXTURED][i], SM_UNTEXTURED); if (reload_each_frame) glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == SHADOW_PASS) { if (reload_each_frame) glDisable(GL_CULL_FACE); if (!GeometricMesh[FPSM_DEFAULT].empty()) glUseProgram(MeshShader::ShadowShader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++) drawShadow(*GeometricMesh[FPSM_DEFAULT][i]); if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty()) glUseProgram(MeshShader::RefShadowShader::Program); for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++) drawShadowRef(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i]); if (reload_each_frame) glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == GLOW_PASS) { glUseProgram(MeshShader::ColorizeShader::Program); for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; drawGlow(GLmeshes[i]); } } if (irr_driver->getPhase() == TRANSPARENT_PASS) { computeMVP(ModelViewProjectionMatrix); if (!TransparentMesh[TM_BUBBLE].empty()) glUseProgram(MeshShader::BubbleShader::Program); for (unsigned i = 0; i < TransparentMesh[TM_BUBBLE].size(); i++) drawBubble(*TransparentMesh[TM_BUBBLE][i], ModelViewProjectionMatrix); if (World::getWorld()->getTrack()->isFogEnabled()) { if (!TransparentMesh[TM_DEFAULT].empty()) glUseProgram(MeshShader::TransparentFogShader::Program); for (unsigned i = 0; i < TransparentMesh[TM_DEFAULT].size(); i++) drawTransparentFogObject(*TransparentMesh[TM_DEFAULT][i], ModelViewProjectionMatrix, (*TransparentMesh[TM_DEFAULT][i]).TextureMatrix); } else { if (!TransparentMesh[TM_DEFAULT].empty()) glUseProgram(MeshShader::TransparentShader::Program); for (unsigned i = 0; i < TransparentMesh[TM_DEFAULT].size(); i++) drawTransparentObject(*TransparentMesh[TM_DEFAULT][i], ModelViewProjectionMatrix, (*TransparentMesh[TM_DEFAULT][i]).TextureMatrix); } return; } if (irr_driver->getPhase() == DISPLACEMENT_PASS) { for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; drawDisplace(GLmeshes[i]); } } }
void drawCam(int player) { int i; float up[3] = { 0, 0, 1 }; Visual *d = & gPlayerVisuals[player].display; float reflectivity = getReflectivity(); // compute shadow color based on glocal constant & reflectivity for(i = 0; i < 4; i++) gCurrentShadowColor[i] = gShadowColor[i] * (1 - reflectivity); glColor3f(0.0, 1.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); doPerspective(gSettingsCache.fov, (float) d->vp_w / (float) d->vp_h, gSettingsCache.znear, box2_Diameter(& game2->level->boundingBox) * 6.5f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); { vec3 vLookAt; vec3 vTarget; matrix matRotate; vec3_Sub(&vLookAt, (vec3*)gPlayerVisuals[player].camera.target, (vec3*)gPlayerVisuals[player].camera.cam); vec3_Normalize(&vLookAt, &vLookAt); matrixRotationAxis(&matRotate, 90.0f * (float) gPlayerVisuals[player].camera.bIsGlancing, (vec3*)up); vec3_Transform(&vLookAt, &vLookAt, &matRotate); vec3_Add(&vTarget, (vec3*)gPlayerVisuals[player].camera.cam, &vLookAt); doLookAt(gPlayerVisuals[player].camera.cam, (float*)&vTarget, up); } glDisable(GL_LIGHTING); // initial config at frame start glDisable(GL_BLEND); // initial config at frame start // disable writes to alpha glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); /* skybox */ glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); /* skybox done */ /* floor */ if(reflectivity == 0) { // draw floor to fb and stencil (set to 1), // using alpha-blending // TODO: draw floor alpha to fb video_Shader_Setup(& gWorld->floor_shader); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, 255); glEnable(GL_STENCIL_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); nebu_Mesh_DrawGeometry( gWorld->floor ); glDisable(GL_BLEND); glDisable(GL_STENCIL_TEST); video_Shader_Cleanup(& gWorld->floor_shader); } else { /* reflections */ /* first draw reflector to stencil */ /* and reflector alpha to fb */ video_Shader_Setup(& gWorld->floor_shader); // store only reflector alpha in framebuffer glDepthMask(GL_FALSE); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, 255); glEnable(GL_STENCIL_TEST); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); // glEnable(GL_ALPHA_TEST); // glAlphaFunc(GL_GREATER, 0.1f); nebu_Mesh_DrawGeometry( gWorld->floor ); // glDisable(GL_ALPHA_TEST); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 1, 255); video_Shader_Cleanup(& gWorld->floor_shader); /* then draw world & skybox reflected, where stencil is set */ /* protect the alpha buffer */ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); isRenderingReflection = 1; // hack: reverse lighting glPushMatrix(); glScalef(1,1,-1); glCullFace(GL_FRONT); // reverse culling // clip skybox & world to floor plane glEnable(GL_CLIP_PLANE0); { double plane[] = { 0, 0, 1, 0 }; glClipPlane(GL_CLIP_PLANE0, plane); } drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); drawWorld(player); glDisable(GL_CLIP_PLANE0); glCullFace(GL_BACK); glPopMatrix(); isRenderingReflection = 0; // hack: normal lighting /* then blend the skybox into the scene, where stencil is set */ /* modulate with the destination alpha */ glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA); drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); /* then blend reflector into the scene */ glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1, 1, 1, 1 - reflectivity); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_ALWAYS, 1, 255); video_Shader_Setup(& gWorld->floor_shader); nebu_Mesh_DrawGeometry( gWorld->floor ); video_Shader_Cleanup(& gWorld->floor_shader); glDisable(GL_STENCIL_TEST); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); } /* floor done */ /* planar shadows */ glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); if(reflectivity != 1) // there are no shadows on perfect mirrors drawPlanarShadows(player); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); /* planar shadows done */ drawWorld(player); /* transparent stuff */ /* draw the glow around the other players: */ if (gSettingsCache.show_glow == 1) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); for (i = 0; i < game->players; i++) { if (i != player && PLAYER_IS_ACTIVE(game->player + i)) { drawGlow(&gPlayerVisuals[player].camera, game->player + i, gPlayerVisuals + i, d, TRAIL_HEIGHT * 4); } } glDisable(GL_BLEND); } }
void STKMeshSceneNode::render() { irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); if (!Mesh || !driver) return; bool isTransparentPass = SceneManager->getSceneNodeRenderPass() == scene::ESNRP_TRANSPARENT; ++PassCount; driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); Box = Mesh->getBoundingBox(); for (u32 i = 0; i<Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (mb) { TextureMatrix = getMaterial(i).getTextureMatrix(0); const video::SMaterial& material = ReadOnlyMaterials ? mb->getMaterial() : Materials[i]; video::IMaterialRenderer* rnd = driver->getMaterialRenderer(material.MaterialType); bool transparent = (rnd && rnd->isTransparent()); if (isTransparentPass != transparent) continue; if (irr_driver->getPhase() == DISPLACEMENT_PASS) { initvaostate(GLmeshes[i], material.MaterialType); drawDisplace(GLmeshes[i]); continue; } if (!isObject(material.MaterialType)) { #ifdef DEBUG Log::warn("material", "Unhandled (static) material type : %d", material.MaterialType); #endif continue; } // only render transparent buffer if this is the transparent render pass // and solid only in solid pass if (irr_driver->getPhase() == GLOW_PASS) { initvaostate(GLmeshes[i], material.MaterialType); drawGlow(GLmeshes[i]); } else if (irr_driver->getPhase() == SHADOW_PASS) { initvaostate(GLmeshes[i], material.MaterialType); drawShadow(GLmeshes[i], material.MaterialType); } else { irr_driver->IncreaseObjectCount(); initvaostate(GLmeshes[i], material.MaterialType); if (transparent) drawTransparent(GLmeshes[i], material.MaterialType); else drawSolid(GLmeshes[i], material.MaterialType); } } } }