/* ================ CmdSystemEx::ExecuteSingleCmd ================ */ void CmdSystemEx::ExecuteSingleCmd( const char *cmd ) { CmdArgs args(cmd); if ( !args.Argc() ) return; const char *arg0 = args.Argv(0); int index = cmdList.Find( arg0 ); if ( index != -1 ) { ConsoleCmd &cCmd = cmdList[index]; if( cCmd.flags & CMD_DEVELOPER && !com_developer.GetBool() ) { User::Warning( "Developer mode is not active!" ); return; } if( cCmd.flags & CMD_CHEAT && !net_allowCheats.GetBool() ) { User::Warning( Format( "$* is cheat protected" ) << cmdList.GetKey(index) ); return; } if ( cCmd.usage->minArguments > (args.Argc()-1) ) cCmd.usage->ShowUsage(); else cCmd.func(args); return; } if ( !cvarSystemEx->OnCommand(args) ) User::Warning( Format( "Unknown command '$*'.\n" ) << arg0 ); }
void CCamera::Think() { bool bFreeMode = cam_free.GetBool(); if (bFreeMode != m_bFreeMode) { m_vecFreeCamera = GetCameraPosition(); m_angFreeCamera = VectorAngles((GetCameraTarget() - GetCameraPosition()).Normalized()); m_bFreeMode = bFreeMode; CApplication::Get()->SetMouseCursorEnabled(!m_bFreeMode); } if (m_bFreeMode) { Vector vecForward, vecRight; AngleVectors(m_angFreeCamera, &vecForward, &vecRight, NULL); m_vecFreeCamera += vecForward * m_vecFreeVelocity.x * GameServer()->GetFrameTime() * 20; m_vecFreeCamera -= vecRight * m_vecFreeVelocity.z * GameServer()->GetFrameTime() * 20; } else { if (shrink_frustum.GetBool()) GameServer()->GetRenderer()->FrustumOverride(GetCameraPosition(), GetCameraTarget(), GetCameraFOV()-1, GetCameraNear()+1, GetCameraFar()-1); } }
void CTreeNode::CExpandButton::Paint(float x, float y, float w, float h) { MakeQuad(); ::CRenderingContext r(nullptr, true); if ((w < 0) ^ (h < 0)) r.SetBackCulling(false); r.UseMaterial(m_hMaterial); r.SetBlend(BLEND_ALPHA); r.SetUniform("iBorder", 0); r.SetUniform("bHighlight", false); r.SetUniform("vecColor", Color(255, 255, 255)); r.SetUniform("bDiffuse", true); r.SetUniform("bTexCoords", false); r.SetUniform("vecDimensions", Vector4D(-w/2, -h/2, w, h)); r.Translate(Vector((float)x+w/2, (float)y+h/2, 0)); r.Rotate(m_flExpandedCurrent*90-90, Vector(0, 0, 1)); // Hehe. if (glgui_spinnyarrows.GetBool()) r.Rotate((float)RootPanel()->GetTime()*200, Vector(0, 0, 1)); r.BeginRenderVertexArray(s_iQuad); r.SetPositionBuffer((size_t)0u, 24); r.SetTexCoordBuffer(12, 24); r.SetCustomIntBuffer("iVertex", 1, 20, 24); r.EndRenderVertexArray(6); }
void CCamera::KeyDown(int c) { if (CVar::GetCVarBool("cheats") && c == 'Z') { cam_free.SetValue(m_bFreeMode?_T("off"):_T("on")); if (lock_freemode_frustum.GetBool()) { if (m_bFreeMode) GameServer()->GetRenderer()->FrustumOverride(GetCameraPosition(), GetCameraTarget(), GetCameraFOV(), GetCameraNear(), GetCameraFar()); else GameServer()->GetRenderer()->CancelFrustumOverride(); } } if (m_bFreeMode) { if (c == 'W') m_vecFreeVelocity.x = 10.0f; if (c == 'S') m_vecFreeVelocity.x = -10.0f; if (c == 'D') m_vecFreeVelocity.z = 10.0f; if (c == 'A') m_vecFreeVelocity.z = -10.0f; } }
bool CConsole::IsVisible() { if (developer.GetBool() && m_bBackground) return true; return BaseClass::IsVisible(); }
void CPlayer::Instructor_LessonLearned(const tstring& sLesson) { if (!GameWindow()->GetInstructor()->IsInitialized()) GameWindow()->GetInstructor()->Initialize(); auto it = m_apLessonProgress.find(sLesson); TAssert(it != m_apLessonProgress.end()); if (it == m_apLessonProgress.end()) return; CLessonProgress* pLessonProgress = &it->second; TAssert(pLessonProgress); if (!pLessonProgress) return; // Can only learn a lesson once in a while, to ensure that it is truly learned. // The idea is that the player spends a couple seconds toying around with the // new feature, but won't spend all of the lessons in that time. if (GameServer()->GetGameTime() < pLessonProgress->m_flLastTimeLearned + lesson_learntime.GetFloat()) return; pLessonProgress->m_flLastTimeLearned = GameServer()->GetGameTime(); pLessonProgress->m_iTimesLearned++; if (lesson_debug.GetBool()) { CLesson* pLesson = GameWindow()->GetInstructor()->GetLesson(sLesson); if (pLessonProgress->m_iTimesLearned < pLesson->m_iTimesToLearn) TMsg(tsprintf("Instructor: Trained lesson " + sLesson + " - %d/%d\n", pLessonProgress->m_iTimesLearned, pLesson->m_iTimesToLearn)); else if (pLessonProgress->m_iTimesLearned == pLesson->m_iTimesToLearn) TMsg("Instructor: Learned lesson " + sLesson + "\n"); } }
bool CConsole::IsCursorListener() { // Don't interfere with mouse events, we're just showing an overlay. if (developer.GetBool() && !BaseClass::IsVisible()) return false; return BaseClass::IsCursorListener(); }
bool CVar::GetCVarBool(tstring sName) { CVar* pVar = FindCVar(sName); if (!pVar) return false; return pVar->GetBool(); }
CConsole* CApplication::GetConsole() { if (m_pConsole == NULL) { m_pConsole = new CConsole(); if (developer.GetBool()) TMsg("Developer mode ON.\n"); } return m_pConsole; }
void CALLBACK GLDebugCallback(GLenum iSource, GLenum iType, GLuint id, GLenum iSeverity, GLsizei iLength, const GLchar* pszMessage, GLvoid* pUserParam) { if (iType != GL_DEBUG_TYPE_PERFORMANCE_ARB) { TAssert(iSeverity != GL_DEBUG_SEVERITY_HIGH_ARB); TAssert(iSeverity != GL_DEBUG_SEVERITY_MEDIUM_ARB); } if (gl_debug.GetBool()) { tstring sMessage = "OpenGL Debug Message ("; if (iSource == GL_DEBUG_SOURCE_API_ARB) sMessage += "Source: API "; else if (iSource == GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB) sMessage += "Source: Window System "; else if (iSource == GL_DEBUG_SOURCE_SHADER_COMPILER_ARB) sMessage += "Source: Shader Compiler "; else if (iSource == GL_DEBUG_SOURCE_THIRD_PARTY_ARB) sMessage += "Source: Third Party "; else if (iSource == GL_DEBUG_SOURCE_APPLICATION_ARB) sMessage += "Source: Application "; else if (iSource == GL_DEBUG_SOURCE_OTHER_ARB) sMessage += "Source: Other "; if (iType == GL_DEBUG_TYPE_ERROR_ARB) sMessage += "Type: Error "; else if (iType == GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB) sMessage += "Type: Deprecated Behavior "; else if (iType == GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB) sMessage += "Type: Undefined Behavior "; else if (iType == GL_DEBUG_TYPE_PORTABILITY_ARB) sMessage += "Type: Portability "; else if (iType == GL_DEBUG_TYPE_PERFORMANCE_ARB) sMessage += "Type: Performance "; else if (iType == GL_DEBUG_TYPE_OTHER_ARB) sMessage += "Type: Other "; if (iSeverity == GL_DEBUG_SEVERITY_HIGH_ARB) sMessage += "Severity: High) "; else if (iSeverity == GL_DEBUG_SEVERITY_MEDIUM_ARB) sMessage += "Severity: Medium) "; else if (iSeverity == GL_DEBUG_SEVERITY_LOW_ARB) sMessage += "Severity: Low) "; sMessage += convertstring<GLchar, tchar>(pszMessage) + "\n"; TMsg(convertstring<GLchar, tchar>(sMessage).c_str()); } }
void CParticleSystemLibrary::Render() { TPROF("CParticleSystemLibrary::Render"); if (!r_particles.GetBool()) return; MakeQuad(); CParticleSystemLibrary* pPSL = Get(); if (!pPSL->m_apInstances.size()) return; tmap<size_t, CSystemInstance*>::iterator it; if (true) { CGameRenderingContext c(GameServer()->GetRenderer(), true); c.UseProgram("particle"); c.SetUniform("bDiffuse", true); c.SetUniform("iDiffuse", 0); for (it = pPSL->m_apInstances.begin(); it != pPSL->m_apInstances.end(); it++) { CSystemInstance* pInstance = (*it).second; pInstance->Render(&c, false); } } if (true) { CGameRenderingContext c(GameServer()->GetRenderer(), true); c.UseProgram("particle"); c.SetUniform("bDiffuse", true); c.SetUniform("iDiffuse", 0); c.SetDepthMask(false); for (it = pPSL->m_apInstances.begin(); it != pPSL->m_apInstances.end(); it++) { CSystemInstance* pInstance = (*it).second; pInstance->Render(&c, true); } } CRenderingContext::DebugFinish(); }
void CConsole::Paint(float x, float y, float w, float h) { if (!CApplication::Get()->IsOpen()) return; if (!BaseClass::IsVisible() && developer.GetBool()) { int iAlpha = m_hOutput->GetAlpha(); m_hOutput->SetAlpha(100); m_hOutput->Paint(); m_hOutput->SetAlpha(iAlpha); return; } if (!BaseClass::IsVisible()) return; glgui::CRootPanel::PaintRect(x, y, w, h, Color(0, 0, 0, 200), 1, true); BaseClass::Paint(x, y, w, h); }
void CInstructor::DisplayLesson(tstring sLesson) { if (!lesson_enable.GetBool()) return; if (!m_bActive) return; if (sLesson.length() == 0 || m_apLessons.find(sLesson) == m_apLessons.end()) { if (m_apLessons[m_sCurrentLesson] && m_apLessons[m_sCurrentLesson]->m_bKillOnFinish) SetActive(false); if (m_pCurrentPanel) HideLesson(); return; } if (m_pCurrentPanel) HideLesson(); m_sCurrentLesson = sLesson; if (Game() && m_sLastLesson != m_sCurrentLesson) Game()->OnDisplayLesson(sLesson); m_sLastLesson = m_sCurrentLesson; CLesson* pLesson = m_apLessons[sLesson]; CPlayer *pLocalPlayer = Game()->GetLocalPlayer(); if (pLesson->m_iLearningMethod == CLesson::LEARN_DISPLAYING) pLocalPlayer->Instructor_LessonLearned(sLesson); m_pCurrentPanel = new CLessonPanel(pLesson); RootPanel()->AddControl(m_pCurrentPanel, true); CallOutput("OnDisplay"); }
void CRenderingContext::EndRenderVertexArrayIndexed(size_t iBuffer, size_t iVertices) { CRenderContext& oContext = GetContext(); if (!oContext.m_bProjectionUpdated) SetUniform("mProjection", oContext.m_mProjection); if (!oContext.m_bViewUpdated) SetUniform("mView", oContext.m_mView); if (!oContext.m_bTransformUpdated) SetUniform("mGlobal", oContext.m_mTransformations); oContext.m_bProjectionUpdated = oContext.m_bViewUpdated = oContext.m_bTransformUpdated = true; glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBuffer); glDrawElements(r_wireframe.GetBool()?GL_LINES:GL_TRIANGLES, iVertices, GL_UNSIGNED_INT, nullptr); glDisableVertexAttribArray(m_pShader->m_iPositionAttribute); for (size_t i = 0; i < MAX_TEXTURE_CHANNELS; i++) { if (m_pShader->m_aiTexCoordAttributes[i] != ~0) glDisableVertexAttribArray(m_pShader->m_aiTexCoordAttributes[i]); } if (m_pShader->m_iNormalAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iNormalAttribute); if (m_pShader->m_iTangentAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iTangentAttribute); if (m_pShader->m_iBitangentAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iBitangentAttribute); if (m_pShader->m_iColorAttribute != ~0) glDisableVertexAttribArray(m_pShader->m_iColorAttribute); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
void CGameServerNetwork::UpdateNetworkVariables(int iClient, bool bForceAll) { if (!GameNetwork()->IsConnected()) return; double flTime = GameServer()->GetGameTime(); size_t iMaxEnts = GameServer()->GetMaxEntities(); for (size_t i = 0; i < iMaxEnts; i++) { CBaseEntity* pEntity = CBaseEntity::GetEntity(i); if (!pEntity) continue; const tchar* pszClassName = pEntity->GetClassName(); CEntityRegistration* pRegistration = NULL; do { pRegistration = pEntity->GetRegisteredEntity(pszClassName); TAssert(pRegistration); if (!pRegistration) break; size_t iNetVarsSize = pRegistration->m_aNetworkVariables.size(); for (size_t j = 0; j < iNetVarsSize; j++) { CNetworkedVariableData* pVarData = &pRegistration->m_aNetworkVariables[j]; CNetworkedVariableBase* pVariable = pVarData->GetNetworkedVariableBase(pEntity); if (!bForceAll) { if (!pVariable->IsDirty()) continue; if (flTime - pVariable->m_flLastUpdate < pVarData->m_flUpdateInterval) continue; } // For one, m_flLastUpdate needs to be a double pVariable->m_flLastUpdate = (float)flTime; // For two, it's shit. TUnimplemented(); // Try some testing or something. CNetworkParameters p; p.ui1 = pEntity->GetHandle(); size_t iDataSize; void* pValue = pVariable->Serialize(iDataSize); if (net_replication_debug.GetBool()) { if (iDataSize >= 4) TMsg(tstring("Updating ") + pVarData->GetName() + sprintf(tstring(" (%x) (%f) (%d)\n"), *(unsigned int*)pValue, *(float*)pValue, *(int*)pValue)); else TMsg(tstring("Updating ") + pVarData->GetName() + "\n"); } p.CreateExtraData(iDataSize + strlen(pVarData->GetName())+1); strcpy((char*)p.m_pExtraData, pVarData->GetName()); memcpy((unsigned char*)(p.m_pExtraData) + strlen(pVarData->GetName())+1, pValue, iDataSize); // UV stands for UpdateValue GameNetwork()->CallFunctionParameters(iClient, "UV", &p); // Only reset the dirty flag if all clients got the message. if (iClient == NETWORK_TOCLIENTS) pVariable->SetDirty(false); } pszClassName = pRegistration->m_pszParentClass; } while (pszClassName); } }
void CAOGenerator::Generate() { double flTimeStarted = Application()->GetTime(); if (!m_eAOMethod) return; m_pWorkListener->BeginProgress(); m_pWorkListener->SetAction("Setting up", 0); m_bIsGenerating = true; m_bStopGenerating = false; m_bDoneGenerating = false; m_bIsBleeding = false; m_flLowestValue = -1; m_flHighestValue = 0; if (SMAKWindow()) SMAKWindow()->ClearDebugLines(); memset(&m_bPixelMask[0], 0, m_iWidth*m_iHeight*sizeof(bool)); if (m_eAOMethod == AOMETHOD_SHADOWMAP) { ShadowMapSetupScene(); GenerateShadowMaps(); } else { if (m_eAOMethod == AOMETHOD_RENDER) RenderSetupScene(); // In AO debug mode we need this to do the debug rendering, so do it anyways. else if (ao_debug.GetBool()) RenderSetupScene(); GenerateByTexel(); } size_t i; m_pWorkListener->SetAction("Averaging reads", m_iWidth*m_iHeight); // Average out all of the reads. for (i = 0; i < m_iWidth*m_iHeight; i++) { // Don't immediately return, just skip this loop. We have cleanup work to do. if (m_bStopGenerating) break; if (m_eAOMethod == AOMETHOD_SHADOWMAP) m_avecShadowValues[i] = Vector(m_avecShadowValues[i].x, m_avecShadowValues[i].x, m_avecShadowValues[i].x); if (m_aiShadowReads[i]) m_avecShadowValues[i] /= (float)m_aiShadowReads[i]; else m_avecShadowValues[i] = Vector(0,0,0); m_pWorkListener->WorkProgress(i); } if (m_eAOMethod == AOMETHOD_RENDER || m_eAOMethod == AOMETHOD_SHADOWMAP) { if (m_eAOMethod == AOMETHOD_SHADOWMAP) { m_oAOFB.Destroy(); CRenderer::UnloadVertexDataFromGL(m_iScene); CRenderer::UnloadVertexDataFromGL(m_iSceneDepth); } else { for (size_t i = 0; i < m_aiSceneMaterials.size(); i++) CRenderer::UnloadVertexDataFromGL(m_aiSceneMaterials[i]); m_oRenderFB.Destroy(); } } // Somebody get this ao some clotters and morphine, STAT! m_bIsBleeding = true; if (!m_bStopGenerating) Bleed(); m_bIsBleeding = false; if (!m_bStopGenerating) m_bDoneGenerating = true; m_bIsGenerating = false; // One last call to let them know we're done. m_pWorkListener->EndProgress(); double flTimeEnded = Application()->GetTime(); double flTimePassed = flTimeEnded - flTimeStarted; TMsg(sprintf("AO generation completed in %f seconds\n", flTimePassed)); }
void CAOGenerator::GenerateShadowMaps() { double flProcessSceneRead = 0; double flProgress = 0; size_t iShadowMapSize = 1024; // A frame buffer for holding the depth buffer shadow render CFrameBuffer oDepthFB = SMAKRenderer()->CreateFrameBuffer(iShadowMapSize, iShadowMapSize, (fb_options_e)(FB_DEPTH_TEXTURE|FB_RENDERBUFFER)); // RB unused // A frame buffer for holding the UV layout once it is rendered flat with the shadow CFrameBuffer oUVFB = SMAKRenderer()->CreateFrameBuffer(m_iWidth, m_iHeight, (fb_options_e)(FB_TEXTURE|FB_LINEAR|FB_DEPTH)); // Depth unused // A frame buffer for holding the completed AO map m_oAOFB = SMAKRenderer()->CreateFrameBuffer(m_iWidth, m_iHeight, (fb_options_e)(FB_TEXTURE|FB_TEXTURE_HALF_FLOAT|FB_LINEAR|FB_DEPTH)); // Depth unused CRenderingContext c(SMAKRenderer()); c.UseFrameBuffer(&m_oAOFB); c.ClearColor(Color(0, 0, 0, 0)); c.SetDepthFunction(DF_LEQUAL); c.SetDepthTest(true); c.SetBackCulling(false); Matrix4x4 mBias( 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f); // Bias from [-1, 1] to [0, 1] AABB oBox = m_pScene->m_oExtends; Vector vecCenter = oBox.Center(); float flSize = oBox.Size().Length(); // Length of the box's diagonal Matrix4x4 mLightProjection = Matrix4x4::ProjectOrthographic(-flSize/2, flSize/2, -flSize/2, flSize/2, 1, flSize*2); size_t iSamples = (size_t)sqrt((float)m_iSamples); m_pWorkListener->SetAction("Taking exposures", m_iSamples); for (size_t x = 0; x <= iSamples; x++) { float flPitch = -asin(RemapVal((float)x, 0, (float)iSamples, -1, 1)) * 90 / (M_PI/2); for (size_t y = 0; y < iSamples; y++) { if (x == 0 || x == iSamples) { // Don't do a bunch of samples from the same spot on the poles. if (y != 0) continue; } float flYaw = RemapVal((float)y, 0, (float)iSamples, -180, 180); // Randomize the direction a tad to help fight moire Vector vecDir = AngleVector(EAngle(flPitch+RandomFloat(-1, 1)/2, flYaw+RandomFloat(-1, 1)/2, 0)); Vector vecLightPosition = vecDir*flSize + vecCenter; // Puts us twice as far from the closest vertex if (ao_debug.GetInt() > 1) SMAKWindow()->AddDebugLine(vecLightPosition, vecLightPosition-vecDir); Matrix4x4 mLightView = Matrix4x4::ConstructCameraView(vecLightPosition, (vecCenter-vecLightPosition).Normalized(), Vector(0, 1, 0)); c.SetProjection(mLightProjection); c.SetView(mLightView); // If we're looking from below and ground occlusion is on, don't bother with this render. if (!(flPitch < -10 && m_bGroundOcclusion)) { c.UseProgram("model"); c.UseFrameBuffer(&oDepthFB); c.SetViewport(Rect(0, 0, iShadowMapSize, iShadowMapSize)); c.SetBackCulling(false); c.ClearDepth(); c.BeginRenderVertexArray(m_iSceneDepth); c.SetPositionBuffer((size_t)0, 8*sizeof(float)); c.SetNormalsBuffer((size_t)3*sizeof(float), 8*sizeof(float)); c.SetTexCoordBuffer((size_t)6*sizeof(float), 8*sizeof(float)); c.EndRenderVertexArray(m_iSceneDepthVerts); c.UseFrameBuffer(nullptr); if (ao_debug.GetBool()) { CRenderingContext c(SMAKRenderer()); c.SetViewport(Rect(0, 0, iShadowMapSize/2, iShadowMapSize/2)); DrawTexture(oDepthFB.m_iDepthTexture, 1, c); } } Matrix4x4 mTextureMatrix = mBias*mLightProjection*mLightView; { CRenderingContext c(SMAKRenderer(), true); c.UseFrameBuffer(&oUVFB); c.SetViewport(Rect(0, 0, m_iWidth, m_iHeight)); c.ClearColor(Color(0, 0, 0, 0)); c.ClearDepth(); c.UseProgram("flat_shadow"); c.SetUniform("mBiasedLightMatrix", mTextureMatrix); c.SetUniform("iShadowMap", 0); c.SetUniform("vecLightNormal", -vecDir); c.SetUniform("bOccludeAll", (flPitch < -10 && m_bGroundOcclusion)); c.SetUniform("flTime", (float)Application()->GetTime()); c.BindTexture(oDepthFB.m_iDepthTexture); c.BeginRenderVertexArray(m_iScene); c.SetPositionBuffer((size_t)0, 8*sizeof(float)); c.SetNormalsBuffer((size_t)3*sizeof(float), 8*sizeof(float)); c.SetTexCoordBuffer((size_t)6*sizeof(float), 8*sizeof(float)); c.EndRenderVertexArray(m_iSceneVerts); } if (ao_debug.GetBool()) { CRenderingContext c(SMAKRenderer()); c.SetViewport(Rect(iShadowMapSize/2, 0, m_iWidth, m_iHeight)); DrawTexture(oUVFB.m_iMap, 1, c); } double flTimeBefore = SMAKWindow()->GetTime(); c.SetViewport(Rect(0, 0, m_iWidth, m_iHeight)); c.UseFrameBuffer(&m_oAOFB); AccumulateTexture(oUVFB.m_iMap); c.UseFrameBuffer(nullptr); if (ao_debug.GetBool()) { CRenderingContext c(SMAKRenderer()); c.UseProgram("ao"); c.SetViewport(Rect(iShadowMapSize/2+m_iWidth, 0, m_iWidth, m_iHeight)); c.SetUniform("iAOMap", 0); c.SetBlend(BLEND_ALPHA); DrawTexture(m_oAOFB.m_iMap, 1, c); } flProcessSceneRead += (SMAKWindow()->GetTime() - flTimeBefore); flTimeBefore = SMAKWindow()->GetTime(); m_pWorkListener->WorkProgress(x*iSamples + y); flProgress += (SMAKWindow()->GetTime() - flTimeBefore); if (m_bStopGenerating) break; } if (m_bStopGenerating) break; } c.UseFrameBuffer(&m_oAOFB); c.ReadPixels(0, 0, m_iWidth, m_iHeight, m_pvecPixels); c.UseFrameBuffer(nullptr); if (!m_bStopGenerating) { size_t iBufferSize = m_iWidth*m_iHeight; m_pWorkListener->SetAction("Reading pixels", iBufferSize); for (size_t p = 0; p < iBufferSize; p++) { Vector4D& vecPixel = m_pvecPixels[p]; if (vecPixel.w == 0.0f) continue; m_avecShadowValues[p].x = vecPixel.x; m_aiShadowReads[p] = (size_t)vecPixel.w; m_bPixelMask[p] = true; m_pWorkListener->WorkProgress(p); } } oDepthFB.Destroy(); oUVFB.Destroy(); // Don't destroy m_oAOFB yet, we need it in a bit. It gets destroyed later. }
void Console::Draw(IRenderer* renderer) { if(!text) text = renderer->GetMaterial("console_text"); if(!bgShader) bgShader = renderer->GetMaterial("console_bg"); int maxLines = (int)(conPos / 12); int pos = bufPos; int posEnd = bufPos; int trailPos = (int)(height * 0.11f); // Draw console trail if(!active && (conPos == 0) && contrail.GetBool()) { renderer->SetOrthoProjection(); renderer->SetViewMatrix(0); renderer->SetColor(1,1,1); renderer->BindMaterial(text); // draw bottom up for(int i = 0; i < 3; i++) { while(pos > 0 && pos < 8192 && buffer[pos] != '\n') { pos--; } // draw line (pos to bufPos) renderer->DrawTextLen(5.0f, (height - (trailPos - ((i+1) * 14))+5.0f), 16.0f, &buffer[pos+1], (posEnd-pos-1)); posEnd = pos; pos--; if(pos < 0) { break; } } return; } // Draw Active Console renderer->SetOrthoProjection(); renderer->SetViewMatrix(0); renderer->BindMaterial(bgShader); renderer->SetColor(1,1,1); renderer->DrawRect(0.0, (height - conPos), (float)width, conPos, 0.0f,0.0f, 1.0f,(conPos / (height*0.5f))); renderer->BindMaterial(text); // draw bottom up for(int i = 0; i < maxLines; i++) { while(pos > 0 && pos < 8192 && buffer[pos] != '\n') { pos--; } // draw line (pos to bufPos) renderer->DrawTextLen(5.0f, (height - (conPos - ((i+1) * 14))+5.0f), 16.0f, &buffer[pos+1], (int)(posEnd-pos-1)); posEnd = pos; pos--; if(pos < 0) { break; } } renderer->DrawTextP(5.0f, (height - conPos+5.0f), 16.0f, cmd); }
void CSystemInstance::Render(CGameRenderingContext* c, bool bTransparent) { for (size_t i = 0; i < m_apChildren.size(); i++) m_apChildren[i]->Render(c, bTransparent); if (m_pSystem->GetBlend() == BLEND_NONE && bTransparent) return; if (m_pSystem->GetBlend() != BLEND_NONE && !bTransparent) return; CGameRenderer* pRenderer = GameWindow()->GetGameRenderer(); if (particles_debug.GetBool()) { CRenderingContext c(pRenderer, true); c.UseProgram("debug"); c.SetUniform("vecColor", Color(1.0, 1.0, 1.0, 1.0f)); c.ResetTransformations(); c.RenderWireBox(m_aabbBounds); } if (!pRenderer->IsSphereInFrustum(m_aabbBounds.Center(), m_aabbBounds.Size().Length() / 2)) return; Vector vecForward, vecLeft, vecUp; pRenderer->GetCameraVectors(&vecForward, &vecLeft, &vecUp); if (m_pSystem->GetMaterial()) c->UseMaterial(m_pSystem->GetMaterial()); c->SetBlend(m_pSystem->GetBlend()); Color clrParticle = m_pSystem->GetColor(); if (m_bColorOverride) clrParticle = m_clrOverride; if (m_pSystem->GetModel()) { int iRadius = c->GetUniform("flRadius"); for (size_t i = 0; i < m_aParticles.size(); i++) { CParticle* pParticle = &m_aParticles[i]; if (!pParticle->m_bActive) continue; c->SetUniform(iRadius, pParticle->m_flAlpha); c->SetColor(clrParticle); c->Translate(pParticle->m_vecOrigin); c->Rotate(-pParticle->m_angAngles.y, Vector(0, 0, 1)); c->Rotate(pParticle->m_angAngles.p, Vector(0, 1, 0)); c->Rotate(pParticle->m_angAngles.r, Vector(1, 0, 0)); c->Scale(pParticle->m_flRadius, pParticle->m_flRadius, pParticle->m_flRadius); c->RenderModel(m_pSystem->GetModel()); c->ResetTransformations(); } } else { c->SetUniform("vecCameraPosition", GameServer()->GetRenderer()->GetCameraPosition()); size_t iQuadVBO = CParticleSystemLibrary::Get()->GetQuadVBO(); size_t iQuadVBOSize = CParticleSystemLibrary::Get()->GetQuadVBOSize(); int iOrigin = c->GetUniform("vecOrigin"); int iAlpha = c->GetUniform("flAlpha"); int iRadius = c->GetUniform("flRadius"); int iYaw = c->GetUniform("flYaw"); int iColor = c->GetUniform("vecColor"); for (size_t i = 0; i < m_aParticles.size(); i++) { CParticle* pParticle = &m_aParticles[i]; if (!pParticle->m_bActive) continue; c->SetUniform(iOrigin, pParticle->m_vecOrigin); c->SetUniform(iAlpha, pParticle->m_flAlpha); c->SetUniform(iRadius, pParticle->m_flRadius); c->SetUniform(iYaw, (float)(pParticle->m_flBillboardYaw*M_PI/180)); c->SetUniform(iColor, clrParticle); c->BeginRenderVertexArray(iQuadVBO); c->SetPositionBuffer(0u, 20); c->SetTexCoordBuffer(12, 20); c->EndRenderVertexArray(iQuadVBOSize); } } }
void RabidEngine::OnIdle() { g_timer.Update(); const float dt = g_timer.GetTimeChange(); g_console->Update(dt); Transformation view; view.Rotate().FromEulerXYZ(cl_camrotx.GetFloat(), cl_camroty.GetFloat(), cl_camrotz.GetFloat()); // move const Vector3f forward = -view.Rotate().GetColumn(2); const Vector3f right = view.Rotate().GetColumn(0); const float vel = 50.0 * dt; if(keyState[B_FORWARD]) { cl_camx.SetFloat(cl_camx.GetFloat() + forward.x * vel); cl_camy.SetFloat(cl_camy.GetFloat() + forward.y * vel); cl_camz.SetFloat(cl_camz.GetFloat() + forward.z * vel); } if(keyState[B_BACKWARD]) { cl_camx.SetFloat(cl_camx.GetFloat() + -forward.x * vel); cl_camy.SetFloat(cl_camy.GetFloat() + -forward.y * vel); cl_camz.SetFloat(cl_camz.GetFloat() + -forward.z * vel); } if(keyState[B_RIGHT]) { cl_camx.SetFloat(cl_camx.GetFloat() + right.x * vel); cl_camy.SetFloat(cl_camy.GetFloat() + right.y * vel); cl_camz.SetFloat(cl_camz.GetFloat() + right.z * vel); } if(keyState[B_LEFT]) { cl_camx.SetFloat(cl_camx.GetFloat() + -right.x * vel); cl_camy.SetFloat(cl_camy.GetFloat() + -right.y * vel); cl_camz.SetFloat(cl_camz.GetFloat() + -right.z * vel); } if(keyState[B_RENDER]) { done.Set("0"); keyState[B_RENDER] = 0; } if(keyState[B_LIGHT_MODE]) { if(r_resid.GetBool()) r_resid.Set("0"); else r_resid.Set("1"); keyState[B_LIGHT_MODE] = 0; } if(keyState[B_TOGGLE_BRIGHTEST]) { if(r_showbrightest.GetBool()) r_showbrightest.Set("0"); else r_showbrightest.Set("1"); keyState[B_TOGGLE_BRIGHTEST] = 0; } static int pass; static int surf = -1; static int brightest; static int patches; if(done.GetBool()) { } else { if(pass == 0) { // clear accumulation buffers for(unsigned int i = 0; i < surfaces.Size(); i++) { // if(surfaces[i]->GetType() != S_LIGHT) // surfaces[i]->ClearAccum(); } } if(surf >= (int)surfaces.Size()) { surf = -2; pass++; done.Set("1"); } else if(surf == -1) { // Find Brightest Surface float maxPower = 0.0; for(unsigned int i = 0; i < surfaces.Size(); i++) { float p = surfaces[i]->GetPower(); if(p > maxPower) { brightest = i; maxPower = p; } } for(int i = 0; i < lights.Size(); i++) delete lights[i]; lights.Resize(0); surfaces[brightest]->CreateLights(lights); } else { Surface* lsurf = surfaces[surf]; bool skip = false; // lights can't receive light if(lsurf->GetType() == S_LIGHT) skip = true; // surface can light itself if(!skip && surf == brightest) { if(r_resid.GetBool()) lsurf->CopyResidualToLightMap(); skip = true; } if(!skip) { // Render each sub-light's contribution for(unsigned int l = 0; l < lights.Size(); l++) { Vector3f& p = lights[l]->p; Vector3f& d = lights[l]->d; float I = lights[l]->I; // light is on wrong side of surface if(Dot(p - lsurf->c, lsurf->N) < 0.1) continue; g_renderer->SetLight(0, p.x, p.y, p.z); g_renderer->SetLightDir(0, d.x, d.y, d.z); g_renderer->SetLightIntensity(0, I); g_renderer->SetLightFraction(0, 1.0 / (float)lights.Size()); lsurf->Frame(p); lsurf->CreateLightMap(p, d, surfaces); lsurf->AccumulateResidualLight(); lsurf->AccumulateLight(); g_renderer->SetViewMatrix(0); patches += lsurf->GetNumPatches(); } r_resid.Set(r_resid.GetBool() ? "1" : "0"); } } surf++; } if(r_resid.Changed()) { for(int i = 0; i < surfaces.Size(); i++) { Surface* lsurf = surfaces[i]; lsurf->Frame(lsurf->c + lsurf->N*10.0); if(r_resid.GetBool()) lsurf->CopyResidualToLightMap(); else lsurf->CopyAccumToLightMap(); } } // Render normal view view.Translate() = Vector3f(cl_camx.GetFloat(), cl_camy.GetFloat(), cl_camz.GetFloat()); view = view.Inverse(); g_renderer->SetViewport(0,0, GetWidth(),GetHeight()); g_renderer->SetViewMatrix(view); g_renderer->SetProjectionMatrix(0); g_renderer->SetClearColor(0.25f, 0.25f, 0.35f, 1.0f); g_renderer->BindMaterial(0); g_renderer->Clear(R_COLOR_BUFFER | R_DEPTH_BUFFER); g_renderer->SetColor(1,1,1); int bsurf = 0; float maxPower = 0.0; for(unsigned int i = 0; i < surfaces.Size(); i++) { float p = surfaces[i]->GetPower(); if(p > maxPower) { bsurf = i; maxPower = p; } } // draw all surfaces normally for(unsigned int i = 0; i < surfaces.Size(); i++) { if(r_showbrightest.GetBool()) { if(i == bsurf) g_renderDevice->SetColor(1.0, 1.0, 0.7); else g_renderDevice->SetColor(1,1,1); } surfaces[i]->Render(); } g_console->Draw(g_renderer); g_renderer->DrawTextP(15, 50, 16, r_resid.GetBool() ? "Residual" : "Accumulation"); g_renderer->DrawTextP(15, 30, 16, "Step: %d", pass); g_renderer->DrawTextP(15, 10, 16, "Patches: %d", patches); g_materialSystem->BindMaterial(logo); g_renderer->DrawRect(GetWidth()-200, 0, 200, 50, 0,0,1,1); g_renderer->Flip(); }
void CCharacter::PostRender(bool bTransparent) const { if (!bTransparent && debug_showplayervectors.GetBool()) ShowPlayerVectors(); }
void CPlayer::Instructor_Think() { if (!GameWindow()->GetInstructor()->IsInitialized()) GameWindow()->GetInstructor()->Initialize(); if (!m_apLessonProgress.size() && GameWindow()->GetInstructor()->GetLessons().size()) { for (auto it = GameWindow()->GetInstructor()->GetLessons().begin(); it != GameWindow()->GetInstructor()->GetLessons().end(); it++) { CLessonProgress& oProgress = m_apLessonProgress[it->first]; oProgress.m_sLessonName = it->first; } } if (m_flLastLesson < 0 || GameServer()->GetGameTime() > m_flLastLesson + lesson_nexttime.GetFloat()) { m_apLessonPriorities.clear(); for (auto it = m_apLessonProgress.begin(); it != m_apLessonProgress.end(); it++) { CLessonProgress* pLessonProgress = &it->second; CLesson* pLesson = GameWindow()->GetInstructor()->GetLesson(it->first); if (!pLesson->m_bRotation) continue; if (!pLesson) { TMsg("Couldn't find lesson '" + it->first + "'\n"); continue; } if (pLesson->m_iLessonType == CLesson::LESSON_ENVIRONMENT) continue; if (!Instructor_IsLessonValid(pLessonProgress)) continue; m_apLessonPriorities.push_back(pLessonProgress); push_heap(m_apLessonPriorities.begin(), m_apLessonPriorities.end(), LessonPriorityCompare); } if (lesson_debug.GetBool() && m_apLessonPriorities.size()) { TMsg("Instructor: Lesson priorities:\n"); for (size_t j = 0; j < m_apLessonPriorities.size(); j++) { CLesson* pLesson = GameWindow()->GetInstructor()->GetLesson(m_apLessonPriorities[j]->m_sLessonName); TMsg(tsprintf(" %d - " + m_apLessonPriorities[j]->m_sLessonName + " - %d\n", j + 1, pLesson->m_iPriority)); } } CLessonProgress* pBestLesson = Instructor_GetBestLesson(); if (pBestLesson) { if (lesson_debug.GetBool()) { CLesson* pLesson = GameWindow()->GetInstructor()->GetLesson(pBestLesson->m_sLessonName); TMsg(tsprintf("Instructor: New lesson: " + pBestLesson->m_sLessonName + " Priority: %d\n", pLesson->m_iPriority)); } m_flLastLesson = GameServer()->GetGameTime(); pBestLesson->m_flLastTimeShowed = GameServer()->GetGameTime(); GameWindow()->GetInstructor()->DisplayLesson(pBestLesson->m_sLessonName); } } }