//----------------------------------------------------------------------------- // Purpose: // Input : flags - // Output : int //----------------------------------------------------------------------------- int CSprite::DrawModel( int flags, const RenderableInstance_t &instance ) { VPROF_BUDGET( "CSprite::DrawModel", VPROF_BUDGETGROUP_PARTICLE_RENDERING ); //See if we should draw if ( !IsVisible() || ( m_bReadyToDraw == false ) ) return 0; // Tracker 16432: If rendering a savegame screenshot then don't draw sprites // who have viewmodels as their moveparent if ( g_bRenderingScreenshot || !r_drawviewmodel.GetBool() ) { C_BaseViewModel *vm = ToBaseViewModel( GetMoveParent() ); if ( vm ) { return 0; } } //Must be a sprite if ( modelinfo->GetModelType( GetModel() ) != mod_sprite ) { const char *modelName = modelinfo->GetModelName( GetModel() ); char msg[256]; V_snprintf( msg, 256, "Sprite %d has non-mod_sprite model %s (type %d)\n", entindex(), modelName, modelinfo->GetModelType( GetModel() ) ); AssertMsgOnce( 0, msg ); return 0; } float renderscale = GetRenderScale(); if ( m_bWorldSpaceScale ) { CEngineSprite *psprite = ( CEngineSprite * )modelinfo->GetModelExtraData( GetModel() ); float flMinSize = MIN( psprite->GetWidth(), psprite->GetHeight() ); renderscale /= flMinSize; } //Draw it int drawn = DrawSprite( this, GetModel(), GetAbsOrigin(), GetAbsAngles(), m_flFrame, // sprite frame to render m_hAttachedToEntity, // attach to m_nAttachment, // attachment point GetRenderMode(), // rendermode GetRenderFX(), (float)( GetRenderBrightness() * instance.m_nAlpha ) * ( 1.0f / 255.0f ) + 0.5f, // alpha GetRenderColorR(), GetRenderColorG(), GetRenderColorB(), renderscale, // sprite scale GetHDRColorScale() // HDR Color Scale ); return drawn; }
//----------------------------------------------------------------------------- // Purpose: check if weapon viewmodel should be drawn //----------------------------------------------------------------------------- bool C_BaseViewModel::ShouldDraw() { if ( g_bEngineIsHLTV ) { return ( HLTVCamera()->GetMode() == OBS_MODE_IN_EYE && HLTVCamera()->GetPrimaryTarget() == GetOwner() ); } #if defined( REPLAY_ENABLED ) else if ( engine->IsReplay() ) { return ( ReplayCamera()->GetMode() == OBS_MODE_IN_EYE && ReplayCamera()->GetPrimaryTarget() == GetOwner() ); } #endif else { Assert( !IsEffectActive( EF_NODRAW ) ); Assert( GetRenderMode() != kRenderNone ); if ( vm_draw_always.GetBool() ) return true; if ( GetOwner() != C_BasePlayer::GetLocalPlayer() ) return false; return BaseClass::ShouldDraw(); } }
void VertexArraysRequest::Draw() const { RENDER_MODE renderMode = GetRenderMode(); GLint startIndex = GetStartDrawIndex(); GLuint elementsCount = GetDrawElementsCount(); glDrawArrays(renderMode, startIndex, elementsCount); CheckError(); }
void VertexArraysByteIndicesRequest::Draw() const { RENDER_MODE renderMode = GetRenderMode(); GLuint elementsCount = GetDrawElementsCount(); GLint startIndex = GetStartDrawIndex(); GLvoid *pIndices = (GLvoid *)(&m_indices->at(startIndex)); glDrawElements(renderMode, elementsCount, DATA_TYPE_UNSIGNED_BYTE, pIndices); CheckError(); }
void VertexArraysIndexBufferRequest::Draw() const { RENDER_MODE renderMode = GetRenderMode(); GLuint elementsCount = GetDrawElementsCount(); DATA_TYPE dataType = m_indexBuffer->GetDataType(); GLvoid *indicesOffset = (GLvoid *)(m_indexBuffer->GetElementSize() * GetStartDrawIndex()); glDrawElements(renderMode, elementsCount, dataType, indicesOffset); CheckError(); }
//----- IncreaseRenderMode() ------------------------------------------------ DirectXRenderMode DirectXMeshCollision::IncreaseRenderMode() { DirectXRenderMode oldMode (GetRenderMode()); int renderMode(oldMode + 1); if (renderMode >= DXRM_SOLID) renderMode = 0; SetRenderMode((DirectXRenderMode) renderMode); return oldMode; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CSprite::GetToolRecordingState( KeyValues *msg ) { if ( !ToolsEnabled() ) return; VPROF_BUDGET( "CSprite::GetToolRecordingState", VPROF_BUDGETGROUP_TOOLS ); BaseClass::GetToolRecordingState( msg ); // Use attachment point if ( m_hAttachedToEntity ) { C_BaseEntity *ent = m_hAttachedToEntity->GetBaseEntity(); if ( ent ) { BaseEntityRecordingState_t *pState = (BaseEntityRecordingState_t*)msg->GetPtr( "baseentity" ); // override position if we're driven by an attachment QAngle temp; pState->m_vecRenderOrigin = GetAbsOrigin(); ent->GetAttachment( m_nAttachment, pState->m_vecRenderOrigin, temp ); // override viewmodel if we're driven by an attachment bool bViewModel = ToBaseViewModel( ent ) != NULL; msg->SetInt( "viewmodel", bViewModel ); } } float renderscale = GetRenderScale(); if ( m_bWorldSpaceScale ) { CEngineSprite *psprite = ( CEngineSprite * )modelinfo->GetModelExtraData( GetModel() ); float flMinSize = MIN( psprite->GetWidth(), psprite->GetHeight() ); renderscale /= flMinSize; } color24 c = GetRenderColor(); // sprite params static SpriteRecordingState_t state; state.m_flRenderScale = renderscale; state.m_flFrame = m_flFrame; state.m_flProxyRadius = m_flGlowProxySize; state.m_nRenderMode = GetRenderMode(); state.m_nRenderFX = GetRenderFX() ? true : false; state.m_Color.SetColor( c.r, c.g, c.b, GetRenderBrightness() ); msg->SetPtr( "sprite", &state ); }
void C_Prop_ASW_Fade::OnDataChanged(DataUpdateType_t updateType) { BaseClass::OnDataChanged(updateType); if (updateType == DATA_UPDATE_CREATED) { SetNextClientThink(CLIENT_THINK_ALWAYS); if (GetRenderMode() == kRenderNormal) { SetRenderMode(kRenderTransTexture); } m_bFaded = false; m_nNormalOpacity = GetRenderAlpha(); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- int CSpriteTrail::DrawModel( int flags ) { VPROF_BUDGET( "CSpriteTrail::DrawModel", VPROF_BUDGETGROUP_PARTICLE_RENDERING ); // Must have at least one point if ( m_nStepCount < 1 ) return 1; //See if we should draw if ( !IsVisible() || ( m_bReadyToDraw == false ) ) return 0; CEngineSprite *pSprite = Draw_SetSpriteTexture( GetModel(), m_flFrame, GetRenderMode() ); if ( pSprite == NULL ) return 0; // Specify all the segments. CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); CBeamSegDraw segDraw; segDraw.Start( pRenderContext, m_nStepCount + 1, pSprite->GetMaterial() ); // Setup the first point, always emanating from the attachment point TrailPoint_t *pLast = GetTrailPoint( m_nStepCount-1 ); TrailPoint_t currentPoint; currentPoint.m_flDieTime = gpGlobals->curtime + m_flLifeTime; ComputeScreenPosition( ¤tPoint.m_vecScreenPos ); currentPoint.m_flTexCoord = pLast->m_flTexCoord + currentPoint.m_vecScreenPos.DistTo(pLast->m_vecScreenPos) * m_flTextureRes; currentPoint.m_flWidthVariance = 0.0f; #if SCREEN_SPACE_TRAILS VMatrix viewMatrix; materials->GetMatrix( MATERIAL_VIEW, &viewMatrix ); viewMatrix = viewMatrix.InverseTR(); #endif TrailPoint_t *pPrevPoint = NULL; float flTailAlphaDist = m_flMinFadeLength; for ( int i = 0; i <= m_nStepCount; ++i ) { // This makes it so that we're always drawing to the current location TrailPoint_t *pPoint = (i != m_nStepCount) ? GetTrailPoint(i) : ¤tPoint; float flLifePerc = (pPoint->m_flDieTime - gpGlobals->curtime) / m_flLifeTime; flLifePerc = clamp( flLifePerc, 0.0f, 1.0f ); BeamSeg_t curSeg; curSeg.m_vColor.x = (float) m_clrRender->r / 255.0f; curSeg.m_vColor.y = (float) m_clrRender->g / 255.0f; curSeg.m_vColor.z = (float) m_clrRender->b / 255.0f; float flAlphaFade = flLifePerc; if ( flTailAlphaDist > 0.0f ) { if ( pPrevPoint ) { float flDist = pPoint->m_vecScreenPos.DistTo( pPrevPoint->m_vecScreenPos ); flTailAlphaDist -= flDist; } if ( flTailAlphaDist > 0.0f ) { float flTailFade = Lerp( (m_flMinFadeLength - flTailAlphaDist) / m_flMinFadeLength, 0.0f, 1.0f ); if ( flTailFade < flAlphaFade ) { flAlphaFade = flTailFade; } } } curSeg.m_flAlpha = ( (float) GetRenderBrightness() / 255.0f ) * flAlphaFade; #if SCREEN_SPACE_TRAILS curSeg.m_vPos = viewMatrix * pPoint->m_vecScreenPos; #else curSeg.m_vPos = pPoint->m_vecScreenPos; #endif if ( m_flEndWidth >= 0.0f ) { curSeg.m_flWidth = Lerp( flLifePerc, m_flEndWidth.Get(), m_flStartWidth.Get() ); } else { curSeg.m_flWidth = m_flStartWidth.Get(); } curSeg.m_flWidth += pPoint->m_flWidthVariance; if ( curSeg.m_flWidth < 0.0f ) { curSeg.m_flWidth = 0.0f; } curSeg.m_flTexCoord = pPoint->m_flTexCoord; segDraw.NextSeg( &curSeg ); // See if we're done with this bad boy if ( pPoint->m_flDieTime <= gpGlobals->curtime ) { // Push this back onto the top for use ++m_nFirstStep; --i; --m_nStepCount; } pPrevPoint = pPoint; } segDraw.End(); return 1; }
//----------------------------------------------------------------------------- // Purpose: Render the weapon. Draw the Viewmodel if the weapon's being carried // by this player, otherwise draw the worldmodel. //----------------------------------------------------------------------------- int C_BaseViewModel::DrawModel( int flags, const RenderableInstance_t &instance ) { if ( !m_bReadyToDraw ) return 0; if ( flags & STUDIO_RENDER ) { // Determine blending amount and tell engine float blend = (float)( instance.m_nAlpha / 255.0f ); // Totally gone if ( blend <= 0.0f ) return 0; // Tell engine render->SetBlend( blend ); float color[3]; GetColorModulation( color ); render->SetColorModulation( color ); } CMatRenderContextPtr pRenderContext( materials ); if ( ShouldFlipViewModel() ) pRenderContext->CullMode( MATERIAL_CULLMODE_CW ); int ret = 0; C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); C_BaseCombatWeapon *pWeapon = GetOwningWeapon(); // If the local player's overriding the viewmodel rendering, let him do it if ( pPlayer && pPlayer->IsOverridingViewmodel() ) { ret = pPlayer->DrawOverriddenViewmodel( this, flags, instance ); } else if ( pWeapon && pWeapon->IsOverridingViewmodel() ) { ret = pWeapon->DrawOverriddenViewmodel( this, flags, instance ); } else { ret = BaseClass::DrawModel( flags, instance ); } pRenderContext->CullMode( MATERIAL_CULLMODE_CCW ); // Now that we've rendered, reset the animation restart flag if ( flags & STUDIO_RENDER ) { if ( m_nOldAnimationParity != m_nAnimationParity ) { m_nOldAnimationParity = m_nAnimationParity; } // Tell the weapon itself that we've rendered, in case it wants to do something if ( pWeapon ) { pWeapon->ViewModelDrawn( this ); } if ( vm_debug.GetBool() ) { MDLCACHE_CRITICAL_SECTION(); int line = 16; CStudioHdr *hdr = GetModelPtr(); engine->Con_NPrintf( line++, "%s: %s(%d), cycle: %.2f cyclerate: %.2f playbackrate: %.2f\n", (hdr)?hdr->pszName():"(null)", GetSequenceName( GetSequence() ), GetSequence(), GetCycle(), GetSequenceCycleRate( hdr, GetSequence() ), GetPlaybackRate() ); if ( hdr ) { for( int i=0; i < hdr->GetNumPoseParameters(); ++i ) { const mstudioposeparamdesc_t &Pose = hdr->pPoseParameter( i ); engine->Con_NPrintf( line++, "pose_param %s: %f", Pose.pszName(), GetPoseParameter( i ) ); } } // Determine blending amount and tell engine float blend = (float)( instance.m_nAlpha / 255.0f ); float color[3]; GetColorModulation( color ); engine->Con_NPrintf( line++, "blend=%f, color=%f,%f,%f", blend, color[0], color[1], color[2] ); engine->Con_NPrintf( line++, "GetRenderMode()=%d", GetRenderMode() ); engine->Con_NPrintf( line++, "m_nRenderFX=0x%8.8X", GetRenderFX() ); color24 c = GetRenderColor(); unsigned char a = GetRenderAlpha(); engine->Con_NPrintf( line++, "rendercolor=%d,%d,%d,%d", c.r, c.g, c.b, a ); engine->Con_NPrintf( line++, "origin=%f, %f, %f", GetRenderOrigin().x, GetRenderOrigin().y, GetRenderOrigin().z ); engine->Con_NPrintf( line++, "angles=%f, %f, %f", GetRenderAngles()[0], GetRenderAngles()[1], GetRenderAngles()[2] ); if ( IsEffectActive( EF_NODRAW ) ) { engine->Con_NPrintf( line++, "EF_NODRAW" ); } } } return ret; }
extern "C" LRESULT CALLBACK Atari_WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int nx, ny; switch (message) { HANDLE_MSG(hWnd, WM_SIZE, OnSize); HANDLE_MSG(hWnd, WM_ACTIVATEAPP, OnActivateApp); HANDLE_MSG(hWnd, WM_SYSCHAR, OnSysChar); HANDLE_MSG(hWnd, WM_CLOSE, OnClose); HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy); HANDLE_MSG(hWnd, WM_COMMAND, OnCommand); case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_RBUTTONDOWN: case WM_RBUTTONUP: INPUT_mouse_buttons = ((wParam & MK_LBUTTON) ? 1 : 0) | ((wParam & MK_RBUTTON) ? 2 : 0) | ((wParam & MK_MBUTTON) ? 4 : 0); // handle mouse clicks in the config UI if (UI_is_active) { switch (INPUT_mouse_buttons) { case 1: getnativecoords(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), &nx, &ny); SetMouseIndex(nx, ny); keycommand.keystroke = AKEY32_UI_MOUSE_CLICK; break; case 2: keycommand.keystroke = AKEY_ESCAPE; keycommand.function = -1; break; case 4: keycommand.keystroke = AKEY_RETURN; keycommand.function = -1; break; } } break; case WM_LBUTTONDBLCLK: if (UI_is_active && UI_mouse_click.y != -1) { keycommand.keystroke = AKEY_RETURN; keycommand.function = -1; } break; case WM_MOUSEWHEEL: if (UI_is_active) { if (GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA > 0) keycommand.keystroke = AKEY_UP; else if (GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA < 0) keycommand.keystroke = AKEY_DOWN; } break; case WM_MOUSEHWHEEL: if (UI_is_active) { if (GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA > 0) keycommand.keystroke = AKEY_RIGHT; else if (GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA < 0) keycommand.keystroke = AKEY_LEFT; } break; case WM_SETCURSOR: if (GetRenderMode() == DIRECTDRAW) { SetCursor(NULL); return TRUE; } break; case WM_ENTERMENULOOP: Sound_Pause(); break; case WM_EXITMENULOOP: if (!UI_is_active) Sound_Continue(); break; } return DefWindowProc(hWnd, message, wParam, lParam); }
void CSDKPlayer::UpdateThirdCamera(const Vector& vecEye, const QAngle& angEye) { if (!IsInThirdPerson()) return; CWeaponSDKBase * pWeapon = NULL; if (GetActiveWeapon() != NULL){ pWeapon = GetActiveSDKWeapon(); } Assert(pWeapon); #ifdef CLIENT_DLL if (m_vecThirdCamera.DistTo(vecEye) < da_cam_fade_distance.GetFloat()){ m_flCurrentAlphaVal = Approach(da_cam_fade_alpha_val.GetFloat(), m_flCurrentAlphaVal, 500.0f * gpGlobals->frametime); if (GetRenderMode() != kRenderTransTexture){ SetRenderMode(kRenderTransTexture); } SetRenderColorA(m_flCurrentAlphaVal); if (pWeapon){ if (pWeapon->GetRenderMode() != kRenderTransTexture){ pWeapon->SetRenderMode(kRenderTransTexture); } pWeapon->SetRenderColorA(m_flCurrentAlphaVal); } }else{ m_flCurrentAlphaVal = Approach(255.0f, m_flCurrentAlphaVal, 500.0f * gpGlobals->frametime); if (GetRenderMode() != kRenderNormal){ SetRenderMode(kRenderNormal); } SetRenderColorA(m_flCurrentAlphaVal); if (pWeapon){ if (pWeapon->GetRenderMode() != kRenderNormal){ pWeapon->SetRenderMode(kRenderNormal); } pWeapon->SetRenderColorA(m_flCurrentAlphaVal); } } #endif m_vecThirdCamera = CalculateThirdPersonCameraPosition(vecEye, angEye); Vector vecShoot; AngleVectors(angEye, &vecShoot); // Trace to see where the camera is pointing trace_t tr; UTIL_TraceLine( m_vecThirdCamera, m_vecThirdCamera + vecShoot * 99999, MASK_VISIBLE|CONTENTS_DEBRIS|CONTENTS_HITBOX, this, COLLISION_GROUP_NONE, &tr ); m_vecThirdTarget = tr.endpos; }
//----------------------------------------------------------------------------- // Purpose: // Input : flags - // Output : int //----------------------------------------------------------------------------- int CSprite::DrawModel( int flags ) { VPROF_BUDGET( "CSprite::DrawModel", VPROF_BUDGETGROUP_PARTICLE_RENDERING ); //See if we should draw if ( !IsVisible() || ( m_bReadyToDraw == false ) ) return 0; #ifdef PORTAL if ( ( !g_pPortalRender->IsRenderingPortal() && !m_bDrawInMainRender ) || ( g_pPortalRender->IsRenderingPortal() && !m_bDrawInPortalRender ) ) { return 0; } #endif //#ifdef PORTAL // Tracker 16432: If rendering a savegame screenshot then don't draw sprites // who have viewmodels as their moveparent if ( g_bRenderingScreenshot || !r_drawviewmodel.GetBool() ) { C_BaseViewModel *vm = dynamic_cast< C_BaseViewModel * >( GetMoveParent() ); if ( vm ) { return 0; } } //Must be a sprite if ( modelinfo->GetModelType( GetModel() ) != mod_sprite ) { Assert( 0 ); return 0; } float renderscale = GetRenderScale(); if ( m_bWorldSpaceScale ) { CEngineSprite *psprite = ( CEngineSprite * )modelinfo->GetModelExtraData( GetModel() ); float flMinSize = MIN( psprite->GetWidth(), psprite->GetHeight() ); renderscale /= flMinSize; } //Draw it int drawn = DrawSprite( this, GetModel(), GetAbsOrigin(), GetAbsAngles(), m_flFrame, // sprite frame to render m_hAttachedToEntity, // attach to m_nAttachment, // attachment point GetRenderMode(), // rendermode m_nRenderFX, GetRenderBrightness(), // alpha m_clrRender->r, m_clrRender->g, m_clrRender->b, renderscale, // sprite scale GetHDRColorScale() // HDR Color Scale ); return drawn; }