void VFmodManager::OneTimeInit() { if (!PROFILING_FMOD_OVERALL) { PROFILING_FMOD_OVERALL = Vision::Profiling.GetFreeElementID(); PROFILING_FMOD_PUREUPDATE = Vision::Profiling.GetFreeElementID(); PROFILING_FMOD_PURGE = Vision::Profiling.GetFreeElementID(); Vision::Profiling.AddGroup("Fmod"); VProfilingNode *pOverall = Vision::Profiling.AddElement(PROFILING_FMOD_OVERALL, "Overall", TRUE); VProfilingNode *pUpdate = Vision::Profiling.AddElement(PROFILING_FMOD_PUREUPDATE, " Pure update", TRUE, pOverall); Vision::Profiling.AddElement(PROFILING_FMOD_PURGE, " Purge instances", TRUE, pOverall); } Vision::RegisterModule(&g_FmodModule); m_pSoundResourceManager = new VFmodSoundResourceManager(); Vision::ResourceSystem.RegisterResourceManager(m_pSoundResourceManager, VColorRef(0,255,100)); m_pEventGroupManager = new VFmodEventGroupManager(); Vision::ResourceSystem.RegisterResourceManager(m_pEventGroupManager, VColorRef(255,255,100)); Vision::Callbacks.OnEngineInit += this; Vision::Callbacks.OnEngineDeInit += this; Vision::Callbacks.OnWorldInit += this; Vision::Callbacks.OnWorldDeInit += this; Vision::Callbacks.OnUpdateSceneFinished += this; #if defined(_VISION_MOBILE) Vision::Callbacks.OnLeaveForeground += this; Vision::Callbacks.OnEnterForeground += this; #endif IVScriptManager::OnRegisterScriptFunctions += this; IVScriptManager::OnScriptProxyCreation += this; }
void RPG_Effect::DebugDisplayParticleInformation(const VisParticleEffect_cl* particleEffect) { if (!m_debugDisplay) { return; } const float crossSize = 100.0f; VColorRef crossColor = VColorRef(208, 24, 208); const VColorRef linkColor = VColorRef(24, 208, 208); // find the actual position of the effect elements and draw it hkvVec3 const& pos = particleEffect->GetPosition(); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(crossSize, 0.f, 0.f), crossColor); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(-crossSize, 0.f, 0.f), crossColor); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(0.f, crossSize, 0.f), crossColor); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(0.f, -crossSize, 0.f), crossColor); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(0.f, 0.f, crossSize), crossColor); Vision::Game.DrawSingleLine(pos, pos + hkvVec3(0.f, 0.f, -crossSize), crossColor); // draw a link to the parent if any if (m_parentEntity) { Vision::Game.DrawSingleLine(pos, GetPosition(), linkColor); } }
bool RPG_AiControllerComponent::FleeFromPosition(hkvVec3 const& targetPosition, float const fleeDistance /*= 300.f*/) { VASSERT(m_characterOwner); hkvVec3 const& currentPosition = m_characterOwner->GetPosition(); // find a position away from the target hkvVec3 const& fleeDirection = (currentPosition - targetPosition).getNormalized(); //direction from target to me hkvVec3 const& fleePosition = currentPosition + fleeDirection * fleeDistance; // if fleePosition is valid, just use it if (RPG_ControllerUtil::IsPointOnNavmesh(fleePosition)) { m_characterOwner->GetActionHandler().PerformAction(AT_Move, false, NULL, fleePosition); if (m_characterOwner->ShouldDisplayDebugStateInformation()) { Vision::Game.DrawSingleLine(currentPosition, fleePosition, VColorRef(24, 208, 208), 3.0f); } return true; } else { hkvVec3 nearestFleePosition; if (RPG_ControllerUtil::GetClosestPointOnNavMesh(fleePosition, 5.0f, nearestFleePosition)) { m_characterOwner->GetActionHandler().PerformAction(AT_Move, false, NULL, nearestFleePosition); if (m_characterOwner->ShouldDisplayDebugStateInformation()) { Vision::Game.DrawSingleLine(currentPosition, nearestFleePosition, VColorRef(24, 208, 208), 3.0f); } return true; } } return false; }
void MenuController::Enable(){ this->m_pMainMenuDialog = spContext->ShowDialog("Assets\\MainMenu.xml"); this->enabled=true; /*Screen Dimensions */ int x = Vision::Video.GetXRes(); int y = Vision::Video.GetYRes(); /* Create Buttons */ VPushButton* buttonGR = new VPushButton(); VPushButton* buttonToD = new VPushButton(); VPushButton* buttonScene3 = new VPushButton(); VPushButton* buttonScene4 = new VPushButton(); VPushButton* buttonScene5 = new VPushButton(); VPushButton* buttonScene6 = new VPushButton(); VPushButton* buttonArray[6] = {buttonGR, buttonToD, buttonScene3, buttonScene4, buttonScene5, buttonScene6}; char *sceneNames[6] = {"Gravity Room", "Tower of Doom", "Particle Rain", "Tumbler", "Car Derby", "Water Simulation"}; for(int i = 0; i < 6; i++){ buttonArray[i]->SetPosition((x/2) - x/4, y * i/6 + y/20); buttonArray[i]->SetText(sceneNames[i]); buttonArray[i]->SetSize(x/2, y/20); buttonArray[i]->SetDialogResult(i+1); //every scene has a dialog result used for loading call buttonArray[i]->SetEnabled(true); //not sure if this is necessary buttonArray[i]->Text().SetFont(Vision::Fonts.FindFont("MenuFont")); buttonArray[i]->Text().SetColor(VColorRef (100,40,245,255)); buttonArray[i]->Text().SetHorizontalAlignment(VisFont_cl::ALIGN_CENTER); buttonArray[i]->Text().SetVerticalAlignment(VisFont_cl::ALIGN_CENTER); m_pMainMenuDialog->AddControl(buttonArray[i]); } }
void CRBX_ModelViewCtrl::SetBkgColor(UCHAR r, UCHAR g, UCHAR b) { VisionRenderLoop_cl *pRL = (VisionRenderLoop_cl *)VisRenderContext_cl::GetMainRenderContext()->GetRenderLoop(); VColorRef clearColor = Vision::Renderer.GetDefaultClearColor(); clearColor.SetNoAlpha(VColorRef(r,g,b)); Vision::Renderer.SetDefaultClearColor(clearColor); }
void SimpleSkeletalAnimatedObject_cl::ThinkFunction() { // Check whether the object is active. if (GetAnimConfig() == NULL) return; const float dtime = Vision::GetTimer()->GetTimeDifference(); // highlight the bone after animation event if (m_fBoneHighlightDuration > 0.0f && !m_sHighlightedBoneName.IsEmpty()) { int iColorVal = static_cast<int>(m_fBoneHighlightDuration / BONE_HIGHLIGHT_FADEOUTTIME * 255.0f); DrawBoneBoundingBox(m_sHighlightedBoneName, VColorRef(iColorVal,iColorVal, 0), 2.f); m_fBoneHighlightDuration -= Vision::GetTimer()->GetTimeDifference(); } // update the LookAt if (m_eSampleMode == MODE_LOOKAT) { VASSERT(m_pLookAtTarget); // rotate the object around the character m_fLookAtRotationPhase = hkvMath::mod(m_fLookAtRotationPhase + dtime*0.7f, hkvMath::pi() * 2.0f); hkvVec3 vNewPos(100.f*hkvMath::sinRad(m_fLookAtRotationPhase), 100.0f*hkvMath::cosRad(m_fLookAtRotationPhase), 160.0f); vNewPos += GetPosition(); m_pLookAtTarget->SetPosition(vNewPos); // update the LookAt orientation UpdateLookatHeadRotation(dtime); } }
void Vehicle::CacheEffects() { VisParticleEffectFile_cl* fxDustTrail = VisParticleGroupManager_cl::GlobalManager().LoadFromFile("Particles\\Car_DustTrail_Sand_SingleTire.xml"); VASSERT(fxDustTrail); VisParticleEffectFile_cl* fxTyreMark = VisParticleGroupManager_cl::GlobalManager().LoadFromFile("Particles\\Car_Tyremark_Sand.xml"); VASSERT(fxTyreMark); for (int wi = 0; wi < 4; wi ++) { m_wheelFX[wi] = fxDustTrail->CreateParticleEffectInstance(hkvVec3(0.f, 0.f, 0.f), hkvVec3(0.f, 0.f, 0.f), 1.0f); m_tyremarkFX[wi] = fxTyreMark->CreateParticleEffectInstance(hkvVec3(0.f, 0.f, 0.f), hkvVec3(0.f, 0.f, 0.f), 1.0f); // Tweak the particle color m_wheelFX[wi]->SetAmbientColor(VColorRef(75, 75, 75, 255)); m_tyremarkFX[wi]->SetAmbientColor(VColorRef(75, 75, 75, 255)); } }
/// should be called at plugin initialization time void vHavokBehaviorResourceManager::OneTimeInit() { Vision::ResourceSystem.RegisterResourceManager(this, VColorRef(25,60,200)); // Set project asset manager vHavokBehaviorModule* behaviorModule = vHavokBehaviorModule::GetInstance(); m_projectAssetManager = behaviorModule->GetProjectAssetManager(); m_projectAssetManager->addReference(); }
void VisParticleGroupManager_cl::OneTimeInit() { Vision::ResourceSystem.RegisterResourceManager(this, VColorRef(100,200,255)); Vision::Callbacks.OnWorldDeInit += this; // register callback Vision::Callbacks.OnUpdateSceneFinished += this; // register callback Vision::Callbacks.OnReassignShaders += this; // register callback Vision::Callbacks.OnAfterSceneUnloaded += this; // register callback }
void RPG_DestructibleEntity::SetEffectDefaults() { RPG_DestructibleEntityEffect_e effectType; effectType = DEFX_TakeHit; { m_effectDefinitions[effectType].m_shaderFlashDuration = 1.f; m_effectDefinitions[effectType].m_shaderFlashColor = VColorRef(150, 200, 255); } }
VDialog::VDialog() { m_Frame.SetOwner(this); m_uiDialogFlags = 0; m_iOrder = DIALOG_ORDER_FRONT; m_iDialogResult = 0; m_fFadeInPos = 1.f; m_fFadeInSpeed = 0.f; m_iStatus = ITEMSTATUS_VISIBLE|ITEMSTATUS_ENABLED; m_vClientMin.set(16.f,16.f); m_vClientMax.set(8192.0f, 8192.0f); // 8192.0f is enough for everyone (greetings from the past!) m_iBackFadeColor = VColorRef(100,100,100,255); m_fBackFadePos = 0.f; m_fBackFadeSpeed = 1.f; m_bFadeBack = false; m_eStartPos = AbsolutePos; m_iBackColor = VColorRef(0,0,0,0); // a=0 -> no constant color m_pImage = NULL; }
void RPG_GuiManager_VisionGUI::AddSkillButtonsToParentDialog() { InitializeButtonDefinitions(); // add skill buttons for (int i = 0; i < BTN_Count; ++i) { VASSERT(!m_skillButtons[i]); m_skillButtons[i] = new VPushButton(); VASSERT(m_skillButtons[i]); // button image(s) VTextureObject *buttonTexture = Vision::TextureManager.Load2DTexture(m_skillButtonDefinitions[i].m_imageFileName.AsChar()); VASSERT_MSG(buttonTexture, "Button texture failed to load."); VASSERT_MSG(buttonTexture->IsTexturePowerOfTwo(), "Button texture's dimensions must be a power of two."); m_skillButtons[i]->Image().SetTexture(buttonTexture); // set all 4 textures for now m_skillButtons[i]->Image().SetTransparency(VIS_TRANSP_ALPHA); m_skillButtons[i]->Image().m_States[VWindowBase::MOUSEOVER].SetColor(VColorRef(128,128,255,255)); m_skillButtons[i]->Image().m_States[VWindowBase::SELECTED].SetColor(VColorRef(208,24,24,255)); m_skillButtons[i]->Image().m_States[VWindowBase::DISABLED].SetColor(VColorRef(128,128,128,255)); // position, size and visibility hkvVec2 const position = FindButtonPosition(m_skillButtonDefinitions[i].m_positionOffsetFromCorner, m_skillButtonDefinitions[i].m_positionCorner); m_skillButtons[i]->SetPosition(position.x, position.y); m_skillButtons[i]->SetSize(m_skillButtonDefinitions[i].m_size.x, m_skillButtonDefinitions[i].m_size.y); m_skillButtons[i]->SetVisible(m_skillButtonDefinitions[i].m_initiallyVisible); VASSERT(m_parentDialog); m_parentDialog->AddControl(m_skillButtons[i]); } #if defined(_VISION_MOBILE) MapTouchArea(m_skillButtons[BTN_RangedAttack], PI_ShiftModifier); MapTouchArea(m_skillButtons[BTN_PowerAttack], PI_SecondaryShiftModifier); MapTouchArea(m_skillButtons[BTN_AoeAttack], PI_SpecialAction01); MapTouchArea(m_skillButtons[BTN_RangedAttackAlt], PI_ShiftModifier); MapTouchArea(m_skillButtons[BTN_PowerAttackAlt], PI_SecondaryShiftModifier); MapTouchArea(m_skillButtons[BTN_AoeAttackAlt], PI_SpecialAction01); #endif }
void RPG_AiControllerComponent::DebugDisplayStateInformation() const { const float vOffset = 0.f; VString msg, tempLine, stateName; RPG_AIState_e const state = GetState(); switch(state) { case ST_None: stateName = "None"; case ST_Spawning: stateName = "Spawning"; break; case ST_Wandering: stateName = "Wandering"; break; case ST_Challenging: stateName = "Challenging"; break; case ST_MovingToPosition: stateName = "Moving to Position"; break; case ST_MeleeAttacking: stateName = "Melee Attacking"; break; case ST_RangedAttacking: stateName = "Ranged Attacking"; break; case ST_AoeAttacking: stateName = "AoE Attacking"; break; case ST_Fleeing: stateName = "Fleeing"; break; case ST_Healing: stateName = "Healing"; break; default: VASSERT_MSG(false, "Hey developer! Update your DebugDisplayStateInformation() to accommodate any newly-defined states."); break; } tempLine.Format("State: %s\n", stateName.AsChar()); msg += tempLine; VASSERT(m_characterOwner); const hkvVec3 vPos = m_characterOwner->GetPosition() + hkvVec3(0.0f, 0.0f, vOffset); Vision::Message.SetTextColor(VColorRef(208,127,127,255)); Vision::Message.DrawMessage3D(msg, vPos); Vision::Message.SetTextColor(); // restore default white }
/// \brief /// Constructor; Sets defaults inline VStateGroupBlendBase() { memset(this, 0, sizeof(VStateGroupBlendBase)); ///< turn off everything by default m_cBlendOp = BLEND_OP_ADD; m_cSrcBlend = BLEND_ONE; m_cDestBlend = BLEND_ONE; m_cBlendOpAlpha = BLEND_OP_ADD; m_cSrcBlendAlpha = BLEND_ONE; m_cDestBlendAlpha = BLEND_ONE; m_iRenderTargetWriteMask = 0xffffffff; m_cAlphaTestFunc = COMPARISON_GREATER_EQUAL; m_cAlphaTestRef = 128; m_blendFactor = VColorRef(255,255,255,255); }
void RPG_GuiManager_VisionGUI::UpdateManaBarGlow(float const deltaTime) { float const endTime = m_manaGlowStartTime + m_manaGlowDuration; float const remainingTime = endTime - Vision::GetTimer()->GetTime(); if (remainingTime > 0.f) { UBYTE const alphaInterp = static_cast<UBYTE>(remainingTime * 255.f / m_manaGlowDuration); m_manaBarGlow->Image().m_States->SetColor(VColorRef(255, 255, 255, alphaInterp)); } else { m_manaGlowDuration = 0.f; m_manaBarGlow->SetVisible(false); } }
void RPG_Action_RangedAttack::DisplayDamage() const { const float vOffset = 400.f; VString msg, tempLine; tempLine.Format("Dealing Damage: %i\n", m_outgoingDamage); msg += tempLine; VASSERT(m_characterOwner); const hkvVec3 vPos = m_characterOwner->GetPosition() + hkvVec3(0.0f, 0.0f, vOffset); Vision::Message.SetTextColor(VColorRef(208,127,127,255)); Vision::Message.DrawMessage3D(msg, vPos); Vision::Message.SetTextColor(); // restore default white }
bool vHavokAiModule::ComputeAndDrawPath(IVRenderInterface *pRenderer, hkvVec3* startPoint, hkvVec3* endPoint, float radius, float height, float displayOffset, unsigned int color) const { hkaiPathfindingUtil::FindPathInput input(1); hkaiPathfindingUtil::FindPathOutput output; bool foundPath = _ComputePath(m_aiWorld, startPoint, endPoint, radius, input, output); if (input.m_startFaceKey != HKAI_INVALID_PACKED_KEY && input.m_goalFaceKeys[0] != HKAI_INVALID_PACKED_KEY) { vHavokAiNavMeshDebugDisplayHandler displayHandler; hkReal displayOffsetHavokScale = VIS2HK_FLOAT_SCALED(displayOffset); hkaiNavMeshDebugUtils::_drawPathWithRadius(input, output, color, hkColor::ORANGE, &displayHandler, 0, displayOffsetHavokScale); } hkvVec3 vStartPos; vHavokConversionUtils::PhysVecToVisVecWorld(input.m_startPoint,vStartPos); hkvVec3 vEndPos; vHavokConversionUtils::PhysVecToVisVecWorld(input.m_goalPoints[0],vEndPos); hkvVec3 vScaledDir ( 0.f, 0.f, height ); VSimpleRenderState_t state(VIS_TRANSP_NONE, RENDERSTATEFLAG_FRONTFACE|RENDERSTATEFLAG_WRITETOZBUFFER); int sd = (input.m_startFaceKey != HKAI_INVALID_PACKED_KEY) ? 1 : 2; int ed = (input.m_goalFaceKeys[0] != HKAI_INVALID_PACKED_KEY) ? 1 : 2; pRenderer->RenderCylinder(vStartPos, vScaledDir, radius, VColorRef(255/sd, 165/sd, 0/sd), state, RENDERSHAPEFLAGS_SOLID|RENDERSHAPEFLAGS_CAP1); pRenderer->RenderCylinder(vEndPos, vScaledDir, radius, VColorRef(0/ed, 128/ed, 0/ed), state, RENDERSHAPEFLAGS_SOLID|RENDERSHAPEFLAGS_CAP1); return foundPath; }
void MenuController::Enable(VInputMap* inputMap){ //VDialogCollection openDialogs = spContext-> //for(int i = 0; i < openDialogs.Count(); i++){ //spContext->CloseDialog(openDialogs.GetAt(i)); //} this->enabled=true; #if defined(WIN32) this->m_pMainMenuDialog = spContext->ShowDialog("Assets\\MainMenu.xml"); /*Screen Dimensions */ int x = Vision::Video.GetXRes(); int y = Vision::Video.GetYRes(); /* Create Buttons */ VPushButton* buttonGR = new VPushButton(); VPushButton* buttonToD = new VPushButton(); VPushButton* buttonScene3 = new VPushButton(); VPushButton* buttonScene4 = new VPushButton(); //VPushButton* buttonScene5 = new VPushButton(); //VPushButton* buttonScene6 = new VPushButton(); VPushButton* buttonArray[4] = {buttonGR, buttonToD, buttonScene3, buttonScene4};//, buttonScene5, buttonScene6}; char *sceneNames[4] = {"Gravity Room", "Tower of Doom", "Particle Rain", "Tumbler"};//, "Car Derby", "Water Simulation"}; for(int i = 0; i < 4; i++){ buttonArray[i]->SetPosition(0, y * i/6 + y/20); buttonArray[i]->SetText(sceneNames[i]); buttonArray[i]->SetSize(x, y/20); buttonArray[i]->SetDialogResult(i+1); //every scene has a dialog result used for loading call buttonArray[i]->SetEnabled(true); //not sure if this is necessary buttonArray[i]->Text().SetFont(Vision::Fonts.FindFont("MenuFont")); buttonArray[i]->Text().SetColor(VColorRef (50,50,255,255)); buttonArray[i]->Text().SetHorizontalAlignment(VisFont_cl::ALIGN_CENTER); buttonArray[i]->Text().SetVerticalAlignment(VisFont_cl::ALIGN_CENTER); m_pMainMenuDialog->AddControl(buttonArray[i]); } #endif #if defined(_VISION_ANDROID) AndroidMenu(inputMap); #endif }
void AttachedTorch_cl::Show() { if (m_bVisible) return; m_bVisible = true; SetVisibleBitmask( 1 ); SetCastShadows(FALSE); m_pShadowCaster->SetVisibleBitmask( ENTITY_CAST_SHADOW ); m_pShadowCaster->SetCastShadows(TRUE); V_SAFE_DISPOSEOBJECT(m_pLight); if (m_spTorchParticles) { m_spTorchParticles->Dispose(); m_spTorchParticles = NULL; } m_pTorchFX = VisParticleGroupManager_cl::GlobalManager().LoadFromFile("Data\\Vision\\Samples\\Engine\\Common\\Models\\Warrior\\TorchFire.xml"); VASSERT(m_pTorchFX); m_pTorchFX->SetResourceFlag(VRESOURCEFLAG_AUTODELETE); m_pLight = new VisLightSource_cl(VIS_LIGHT_POINT, 800); VASSERT(m_pLight); m_pLight->SetMultiplier(1.5f); m_pLight->SetLightInfluenceBitMasks(0xFFFFFFFF, 0xFFFFFFFF); m_pLight->SetColor(VColorRef(255,180,105)); m_pLight->SetAttenuation(VIS_LIGHT_ATTEN_CUSTOM); #if defined(SUPPORTS_SHADOW_MAPS) && !defined(_VISION_MOBILE) && !defined( HK_ANARCHY ) VShadowMapComponentPoint* pShadowMapComponent = new VShadowMapComponentPoint(); pShadowMapComponent->SetShadowMapSize(256); pShadowMapComponent->SetShadowMappingMode(SHADOW_MAPPING_MODE_PCF8); m_pLight->AddComponent(pShadowMapComponent); #endif hkvVec3 vPdir(0.0f, -90.0f, 0.0f); m_spTorchParticles = m_pTorchFX->CreateParticleEffectInstance(GetPosition(), vPdir); }
void VLogoOverlay::Init() { #if defined(SHOW_LOGO) Vision::Callbacks.OnVideoChanged += this; #if defined( HK_ANARCHY ) m_spLogoOverlay = new VisScreenMask_cl("Textures/Anarchy_Logo_128x128.dds"); #else m_spLogoOverlay = new VisScreenMask_cl("Textures/Havok_Logo_128x64.dds"); #endif m_spLogoOverlay->SetDepthWrite(FALSE); m_spLogoOverlay->SetTransparency (VIS_TRANSP_ALPHA); m_spLogoOverlay->SetFiltering(FALSE); RefreshLayout(); m_spLogoOverlay->SetColor(VColorRef(255, 255, 255, 255)); m_spLogoOverlay->GetTextureObject()->SetResourceFlag(VRESOURCEFLAG_AUTODELETE); #endif }
void VUINodeRotator::OnPaint(VGraphicsInfo &Graphics, const VItemRenderInfo &parentState) { const VRectanglef rect = GetClientRect(); hkvVec2 vCenter = ( rect.m_vMin + rect.m_vMax ) / 2.0f; hkvVec2 vSize = GetSize(); VColorRef color = VColorRef(255,128,128,255); Overlay2DVertex_t v[6]; float fWidth = vSize.x / 2; float fHeight = vSize.y / 2; IVRender2DInterface::CreateQuadVertices(-fWidth,-fHeight,fWidth,fHeight,0,0,1,1,color ,v); for ( int i = 0 ; i < 6 ; i++ ) { Overlay2DVertex_t vertex = v[i]; float fx = v[i].screenPos.x; float fy = v[i].screenPos.y; v[i].screenPos.x = vCenter.x + (fx * hkvMath::cosDeg (m_fAngle) + fy * hkvMath::sinDeg (m_fAngle)); v[i].screenPos.y = vCenter.y + (-fx * hkvMath::sinDeg (m_fAngle) + fy * hkvMath::cosDeg (m_fAngle)); } VTextureObject *pTex = Image().m_States[VWindowBase::NORMAL].GetCurrentTexture(); Graphics.Renderer.Draw2DBuffer(6, v, pTex, VSimpleRenderState_t(VIS_TRANSP_ALPHA,RENDERSTATEFLAG_ALWAYSVISIBLE|RENDERSTATEFLAG_DOUBLESIDED)); VItemRenderInfo thisState(parentState,this,1.f); m_TextCfg.OnPaint(Graphics,thisState); return; }
// RPG_AttackableComponent RPG_AttackableComponent::RPG_AttackableComponent() : RPG_HighlightableComponent() { SetColor(VColorRef(32, 32, 32)); }
void RPG_Action_RangedAttack::Tick(float const deltaTime) { RPG_Action_AttackBase::Tick(deltaTime); if(m_attacking) { // RangedAttacking was set to true when the action was initiated. Is reset to false by Behavior when the attack anim finishes. vHavokBehaviorComponent *const behaviorComponent = m_characterOwner->GetBehaviorComponent(); VVERIFY_OR_RET(behaviorComponent); VASSERT(!m_behaviorTriggerVarName.IsEmpty()); if (!RPG_VisionHavokBehaviorHelper::BehaviorGetVarNamed<bool>(*behaviorComponent, m_behaviorTriggerVarName.AsChar())) { if (m_flags == 1) { if(m_updatedInteraction) { m_updatedInteraction = false; if(!m_updatedInteractionEntity && m_interactionEntity) { // Do not lose the player's intended target ValidateInteractionEntity(); if(!m_interactionEntity->Components().GetComponentOfType(V_RUNTIME_CLASS(RPG_AttackableComponent))) { m_interactionEntity = NULL; } else { if(m_interactionEntity->GetPosition().getDistanceToSquared(m_updatedInteractionPosition) > s_retargetingRadius * s_retargetingRadius) { m_interactionEntity = NULL; } } } else { m_interactionEntity = m_updatedInteractionEntity; ValidateInteractionEntity(); } m_interactionPosition = m_updatedInteractionPosition; } m_startTime = Vision::GetTimer()->GetTime(); StartAttack(); } else { // if we've gotten to the end and haven't fired the projectile, fire it now if (!m_hasFired) { VString msg; msg.Format("RPG_Action_RangedAttack never received expected %s event from Behavior.", m_behaviorFireEventName.AsChar()); Vision::Error.Warning(msg.AsChar()); //VASSERT_MSG(false, msg.AsChar()); FireAttack(); } End(); } } else { // we're currently attacking hkvVec3 const targetPosition = m_interactionEntity ? m_interactionEntity->GetPosition() : m_interactionPosition; FaceTargetPoint(targetPosition); #ifdef _DEBUG if (m_debugDisplayInfo) { Vision::Game.DrawSingleLine(m_characterOwner->GetPosition(), targetPosition, VColorRef(255, 0, 255)); } #endif } } else { StartAttack(); } }
void VRendererNodeCommon::RenderSceneTextureWithDepth(bool bHalfSize) { PushAndDisableGlobalWireframeState(); if (m_spSceneDepthTechnique == NULL) { Vision::Shaders.LoadShaderLibrary("\\Shaders\\BaseShaders.ShaderLib", SHADERLIBFLAG_HIDDEN); m_spSceneDepthTechnique = Vision::Shaders.CreateTechnique("CopyWithDepthOutput", NULL); VASSERT(m_spSceneDepthTechnique != NULL); } #ifdef _VISION_XENON if(bHalfSize) { // first make sure the stencil buffer is cleared. // we clear it to all 1's, and then reset all geometry pixels to 0 // For this the shader simply checks a pixels depth and does a discard on sky pixels (depth == 1.0). // On all pixels that pass the test, the stencil value is set to zero. Vision::RenderLoopHelper.ClearScreen(VisRenderLoopHelper_cl::VCTF_DepthStencil, VColorRef (0, 0, 0, 0), 1.0f, 255); #endif IVRender2DInterface *pRenderer = Vision::RenderLoopHelper.BeginOverlayRendering(); VCompiledShaderPass *pPass = m_spSceneDepthTechnique->GetShader(0); VStateGroupTexture *pStateGroupTexture = pPass->GetStateGroupTexture(VSS_PixelShader, 0); if (pStateGroupTexture != NULL) pStateGroupTexture->m_spCustomTex = m_spColorReadTarget; pStateGroupTexture = pPass->GetStateGroupTexture(VSS_PixelShader, 1); #ifdef _VISION_PS3 if (m_spDummyDepthTexture == NULL) m_spDummyDepthTexture = RenderingOptimizationHelpers_cl::CreateAndPatchDummyTexture(m_spDepthReadTarget); if (pStateGroupTexture != NULL) { pStateGroupTexture->m_spCustomTex = m_spDummyDepthTexture; pPass->m_bModified = true; } #else if (pStateGroupTexture != NULL) { pStateGroupTexture->m_spCustomTex = m_spDepthReadTarget; pPass->m_bModified = true; } #endif Overlay2DVertex_t *pVertices; if (bHalfSize) pVertices = GetRendererNodeHelper()->GetOverlayVerticesHalfSize(); else pVertices = GetRendererNodeHelper()->GetOverlayVertices(); pRenderer->Draw2DBufferWithShader(6, pVertices, NULL, *pPass); Vision::RenderLoopHelper.EndOverlayRendering(); #ifdef _VISION_XENON } else { if(m_spDepthOnlyTechnique360 == NULL) { m_spDepthOnlyTechnique360 = Vision::Shaders.CreateTechnique("CopyDepthOnly_360", NULL); VASSERT(m_spDepthOnlyTechnique360 != NULL); } VASSERT_MSG(m_bDepthRestoreInitialized, "Fast depth restore has not been initialized"); //Restore color first (can't do this in one step because of a certification issue with Depth only rendering right after MRT rendering) RenderSceneTexture(bHalfSize); //Restore depth and stencil with xbox 360 specific implementation VisHiZHelper_cl::FastDepthRestore(m_fastRestoreData, m_spDepthOnlyTechnique360->GetShader(0)); } #endif PopGlobalWireframeState(); }
void RPG_Boss::InitializeCharacterEffects() { // @todo: this is a bit of an off-topic place for this. Organize better once we data-drive this bit. m_projectileMeshFilename = "Models/Effects/ProjectileStandIn.model"; RPG_CharacterEffect_e effectType; //const VString& fmodEventGroup = "Characters/Boss"; //VVERIFY_MSG(RPG_VisionEffectHelper::LoadFmodEventGroup(fmodEventGroup), fmodEventGroup.AsChar()); // pre-load this character's sounds effectType = FX_Ambient; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Idle.xml"; } // Ranged Attack //////////////////////////////////////////////////////////// effectType = FX_RangedAttackFire; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Ranged_Attack_Fire_mobile.xml"; //m_characterEffectDefinitions[effectType].m_fmodEventGroupName = fmodEventGroup; //m_characterEffectDefinitions[effectType].m_fmodEventName = "Ranged_Attack_Fire"; } effectType = FX_RangedAttackProjectile; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Ranged_Attack_Proj_mobile.xml"; } effectType = FX_RangedAttackImpact; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Ranged_Attack_Impact_mobile.xml"; } // AoE Attack /////////////////////////////////////////////////////////////// effectType = FX_AoeAttackFire; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Aoe_Attack_mobile.xml"; m_characterEffectDefinitions[effectType].m_fmodEventGroupName = "Characters/Guardian/Caster"; m_characterEffectDefinitions[effectType].m_fmodEventName = "Aoe_Attack_Cast"; } effectType = FX_ReceiveHeal; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Any_Character_Receive_Heal.xml"; //m_characterEffectDefinitions[effectType].m_fmodEventGroupName = fmodEventGroup; //m_characterEffectDefinitions[effectType].m_fmodEventName = "Receive_Heal"; m_characterEffectDefinitions[effectType].m_shaderFlashDuration = 1.f; m_characterEffectDefinitions[effectType].m_shaderFlashColor = VColorRef(0, 208, 24); } effectType = FX_TakeHit; { m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_TakeHit.xml"; //m_characterEffectDefinitions[effectType].m_fmodEventGroupName = fmodEventGroup; //m_characterEffectDefinitions[effectType].m_fmodEventName = "Take_Hit"; m_characterEffectDefinitions[effectType].m_shaderFlashDuration = 1.f; m_characterEffectDefinitions[effectType].m_shaderFlashColor = VColorRef(150, 200, 255); } effectType = FX_Die; { //m_characterEffectDefinitions[effectType].m_vfxFilename = "Particles/CharacterEffects/Boss_Die.xml"; //m_characterEffectDefinitions[effectType].m_fmodEventGroupName = fmodEventGroup; //m_characterEffectDefinitions[effectType].m_fmodEventName = "Die"; } }
// RPG_InteractableComponent RPG_InteractableComponent::RPG_InteractableComponent() : RPG_HighlightableComponent() { SetColor(VColorRef(0, 127, 0)); }
void VPrefabManager::OneTimeInit() { Vision::ResourceSystem.RegisterResourceManager(this, VColorRef(200,100,0)); }
bool RPG_AiControllerComponent::HasLineOfSightToTarget(bool& left, bool& center, bool& right) const { VASSERT(m_characterOwner); VASSERT(m_target); RPG_ClosestRaycastResultIgnoreSourceTarget raycastResult(m_characterOwner, m_target); hkvVec3 rayStart; m_characterOwner->CalcPositionForTargeting(rayStart); hkvVec3 rayEnd; m_target->CalcPositionForTargeting(rayEnd); hkvVec3 directionToTarget = rayEnd - rayStart; directionToTarget.normalizeIfNotZero(); // check from the center center = true; raycastResult.Reset(); raycastResult.vRayStart = rayStart; raycastResult.vRayEnd = rayEnd; Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult); if (m_characterOwner->ShouldDisplayDebugStateInformation()) { if(raycastResult.bHit) { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f); } else { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f); } } if(raycastResult.bHit) { center = false; } // check from the left side left = true; raycastResult.Reset(); raycastResult.vRayStart = rayStart + hkvVec3(-directionToTarget.y, directionToTarget.x, 0.0f) * m_characterOwner->GetCollisionRadius(); raycastResult.vRayEnd = rayEnd + hkvVec3(-directionToTarget.y, directionToTarget.x, 0.0f) * m_characterOwner->GetCollisionRadius(); Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult); if (m_characterOwner->ShouldDisplayDebugStateInformation()) { if(raycastResult.bHit) { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f); } else { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f); } } if(raycastResult.bHit) { left = false; } // check from the right side right = true; raycastResult.Reset(); raycastResult.vRayStart = rayStart + hkvVec3(directionToTarget.y, -directionToTarget.x, 0.0f) * m_characterOwner->GetCollisionRadius(); raycastResult.vRayEnd = rayEnd + hkvVec3(directionToTarget.y, -directionToTarget.x, 0.0f) * m_characterOwner->GetCollisionRadius(); Vision::GetApplication()->GetPhysicsModule()->PerformRaycast(&raycastResult); if (m_characterOwner->ShouldDisplayDebugStateInformation()) { if(raycastResult.bHit) { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(208, 24, 24), 3.0f); } else { Vision::Game.DrawSingleLine(raycastResult.vRayStart, raycastResult.vRayEnd, VColorRef(24, 208, 24), 3.0f); } } if(raycastResult.bHit) { right = false; } return left && center && right; }
void VDebugOptions::Init() { Vision::Callbacks.OnUpdateSceneBegin += this; Vision::Callbacks.OnBeforeSwapBuffers += this; Vision::Callbacks.OnRenderHook += this; // Setup graph for displaying un-/filtered time steps VGraphProps timeStepGraphProps; timeStepGraphProps.vPosition.set(-0.85f, -0.3f); timeStepGraphProps.fWidth = 0.25f; timeStepGraphProps.fHeight = 0.25f; timeStepGraphProps.iResolution = 64; timeStepGraphProps.bRangeAdaptation = true; m_pTimeStepGraph = new VGraphObject(timeStepGraphProps); m_pTimeStepGraph->AddCurve("Unfiltered Time Step", VColorRef(0, 255, 0), new VUnfilteredTimeDiffUpdater); m_pTimeStepGraph->AddCurve("Filtered Time Step", VColorRef(255, 0, 0), new VFilteredTimeDiffUpdater); m_pTimeStepGraph->Init(); m_pTimeStepGraph->SetVisible(false); #if defined(WIN32) GetParent()->GetInputMap()->MapTrigger(TOGGLE_FPS, VInputManager::GetKeyboard(), CT_KB_F2, VInputOptions::Once(ONCE_ON_RELEASE)); GetParent()->GetInputMap()->MapTrigger(TOGGLE_WIREFRAME, VInputManager::GetKeyboard(), CT_KB_F3, VInputOptions::Once(ONCE_ON_RELEASE)); #endif VAppMenu* pMainMenu = GetParent()->GetAppModule<VAppMenu>(); if (pMainMenu == NULL) return; // General Debug Options // Note: OPTION_FPS, OPTION_WIREFRAME, and OPTION_RELOAD_RESOURCES are added directly to the menu's root, the other options // are added to the menu's root as a group called 'Debug Options' m_callbacks.Append(pMainMenu->RegisterItem(VAppMenuItem("Toggle FPS Display", OPTION_FPS, VAPP_DEFAULT_SORTING_0, true))); // wireframe rendering is not supported on GLES2 #if !defined(_VR_GLES2) m_callbacks.Append(pMainMenu->RegisterItem(VAppMenuItem("Wireframe", OPTION_WIREFRAME, VAPP_DEFAULT_SORTING_0 + 1, true))); #endif m_callbacks.Append(pMainMenu->RegisterItem(VAppMenuItem("Reload Modified Resources", OPTION_RELOAD_RESOURCES, VAPP_DEFAULT_SORTING_0 + 2, false))); VAppMenuItems items; items.Add(VAppMenuItem("Show Time Step Graph", OPTION_TIME_STEP_GRAPH, 0, true)); items.Add(VAppMenuItem("Save Screenshot", OPTION_SAVE_SCREENSHOT, 0, false)); #if defined(SUPPORTS_MULTITOUCH) items.Add(VAppMenuItem("Touch Area Debug Rendering", OPTION_MULTITOUCH, 0, true)); #endif m_callbacks.Append(pMainMenu->RegisterGroup("Debug Options", items, NULL, VAPP_DEFAULT_SORTING_0 + 3, true)); RegisterCallbacks(); // Debug Render Flags items.RemoveAll(); items.Add(VAppMenuItem("Display Object Triangle Count", DEBUGRENDERFLAG_OBJECT_TRIANGLECOUNT, 0, true)); items.Add(VAppMenuItem("Display Object Visibility BoundingBox", DEBUGRENDERFLAG_OBJECT_VISBBOX, 0, true)); items.Add(VAppMenuItem("Display Object vis. Area Assignment", DEBUGRENDERFLAG_OBJECT_VISIBILITYZONES, 0, true)); items.Add(VAppMenuItem("Display Light Influence BoundingBox", DEBUGRENDERFLAG_LIGHT_INFLUENCEBOX, 0, true)); items.Add(VAppMenuItem("Display Trace Lines", DEBUGRENDERFLAG_TRACELINES, 0, true)); items.Add(VAppMenuItem("Display Visibility Objects", DEBUGRENDERFLAG_VISIBILITYOBJECTS, 0, true)); items.Add(VAppMenuItem("Display Portals", DEBUGRENDERFLAG_PORTALS, 0, true)); items.Add(VAppMenuItem("Display Visibility Zones", DEBUGRENDERFLAG_VISIBILITYZONES, 0, true)); items.Add(VAppMenuItem((Vision::GetScriptManager() != NULL) ? "Scripting Statistics" : "Scripting Statistics (no script man.)", DEBUGRENDERFLAG_SCRIPTSTATISTICS, 0, true)); items.Add(VAppMenuItem("Display Object Render Order", DEBUGRENDERFLAG_OBJECTRENDERORDER, 0, true)); items.Add(VAppMenuItem("Display Thread Workload", DEBUGRENDERFLAG_THREADWORKLOAD, 0, true)); items.Add(VAppMenuItem("Display Streaming Zones", DEBUGRENDERFLAG_ZONES, 0, true)); items.Add(VAppMenuItem("Display Resource Stats", DEBUGRENDERFLAG_RESOURCE_STATISTICS, 0, true)); items.Add(VAppMenuItem("Display Memory Stats", DEBUGRENDERFLAG_MEMORY_STATISTICS, 0, true)); m_debugInfos = pMainMenu->RegisterGroup("Debug Infos", items, "Debug Options"); RegisterCallbacks(m_debugInfos); }
void VDebugOptions::OnHandleCallback(IVisCallbackDataObject_cl* pData) { if (pData->m_pSender == &Vision::Callbacks.OnUpdateSceneBegin) { #if defined(WIN32) if (GetParent()->GetInputMap()->GetTrigger(TOGGLE_FPS)) { SetFrameRateVisible(!IsFrameRateVisible()); } else if (GetParent()->GetInputMap()->GetTrigger(TOGGLE_WIREFRAME)) { SetWireframe(!IsWireframe()); } #endif // FPS accumulation { m_iFrameCounter++; m_fTimeAccumulator += Vision::GetUITimer()->GetTimeDifference(); if (m_fTimeAccumulator >= 1.0f) { m_fCurrentFrameTime = m_fTimeAccumulator / m_iFrameCounter; m_fCurrentFps = m_iFrameCounter / m_fTimeAccumulator; m_fTimeAccumulator = 0.0f; m_iFrameCounter = 0; } } if (m_bFpsVisible) Vision::Message.Print(1, 10, Vision::Video.GetYRes() - 35, "FPS : %.1f\nFrame Time : %.2f", m_fCurrentFps, m_fCurrentFrameTime * 1000.0f); } else if (pData->m_pSender == &Vision::Callbacks.OnBeforeSwapBuffers) { if (m_bSaveScreenshot) { VScreenShotHelper helper; helper.Capture(); if (helper.PendingDataInBuffer()) { if (helper.SaveBufferToFile("", NULL, 1.0f, 1.0f)) Vision::Message.Add(0, "Screenshot saved to \"%s\".\n", helper.GetScreenShotPath()); else Vision::Message.Add(0, "Screenshot could not be saved.\n"); } // Re-enable the VAppMenu again VAppMenu* pMainMenu = GetParent()->GetAppModule<VAppMenu>(); if (pMainMenu) pMainMenu->SetVisible(true); m_bSaveScreenshot = false; } } else if (pData->m_pSender == &Vision::Callbacks.OnRenderHook) { VisRenderHookDataObject_cl *pRenderHookData = (VisRenderHookDataObject_cl *)pData; if (pRenderHookData->m_iEntryConst == VRH_PRE_SCREENMASKS) { // Debug drawing of all visible touch areas. #if defined(SUPPORTS_MULTITOUCH) if (m_bTouchAreaDebug) { IVMultiTouchInput* pMultiTouchInput = NULL; pMultiTouchInput = static_cast<IVMultiTouchInput*>(&VInputManager::GetInputDevice(INPUT_DEVICE_TOUCHSCREEN)); VPListT<VTouchArea> touchAreas = pMultiTouchInput->GetTouchAreas(); const float fBorderWidth = 3.0f; VSimpleRenderState_t alphaState(VIS_TRANSP_ALPHA, RENDERSTATEFLAG_FRONTFACE|RENDERSTATEFLAG_NOWIREFRAME|RENDERSTATEFLAG_ALWAYSVISIBLE); IVRender2DInterface *pRI = Vision::RenderLoopHelper.BeginOverlayRendering(); { for (int i=0; i<touchAreas.GetLength(); ++i) { const VRectanglef& rect = touchAreas.Get(i)->GetArea(); const VColorRef color = touchAreas.Get(i)->GetTouchPointIndex() < 0 ? VColorRef(0, 255, 0, 64) : VColorRef(0, 255, 0, 96); pRI->DrawSolidQuad(rect.m_vMin, rect.m_vMax, color, alphaState); pRI->DrawSolidQuad(rect.m_vMin, hkvVec2(rect.m_vMax.x, rect.m_vMin.y + fBorderWidth), VColorRef(0, 255, 0, 255), alphaState); pRI->DrawSolidQuad(hkvVec2(rect.m_vMin.x, rect.m_vMax.y - fBorderWidth), rect.m_vMax, VColorRef(0, 255, 0, 255), alphaState); pRI->DrawSolidQuad(hkvVec2(rect.m_vMin.x, rect.m_vMin.y + fBorderWidth), hkvVec2(rect.m_vMin.x + fBorderWidth, rect.m_vMax.y - fBorderWidth), VColorRef(0, 255, 0, 255), alphaState); pRI->DrawSolidQuad(hkvVec2(rect.m_vMax.x - fBorderWidth, rect.m_vMin.y + fBorderWidth), hkvVec2(rect.m_vMax.x, rect.m_vMax.y - fBorderWidth), VColorRef(0, 255, 0, 255), alphaState); } } Vision::RenderLoopHelper.EndOverlayRendering(); } #endif } } int iIndex = GetCallbackIndex(pData); if (iIndex >= 0) { if (iIndex == OPTION_FPS) { m_bFpsVisible = !m_bFpsVisible; } else if (iIndex == OPTION_WIREFRAME) { if (Vision::Renderer.GetWireframeMode()) Vision::Renderer.SetWireframeMode(false); else Vision::Renderer.SetWireframeMode(true); } else if (iIndex == OPTION_RELOAD_RESOURCES) { int iCount = Vision::ResourceSystem.ReloadModifiedResourceFiles(NULL, VURO_HOT_RELOAD); // Clear effect caches so that material shaders will be re-created (not re-used). Vision::Shaders.GetShaderFXLibManager().ResetCompiledEffectCaches(); // Reassign all material shaders. Vision::Shaders.ReloadAllShaderAssignmentFiles(); Vision::Message.Add(1, "%i resources were outdated and have been reloaded.", iCount); } else if (iIndex == OPTION_TIME_STEP_GRAPH) { m_pTimeStepGraph->SetVisible(!m_pTimeStepGraph->IsVisible()); } #if defined(SUPPORTS_MULTITOUCH) else if (iIndex == OPTION_MULTITOUCH) { m_bTouchAreaDebug = !m_bTouchAreaDebug; } #endif else if (iIndex == OPTION_SAVE_SCREENSHOT) { m_bSaveScreenshot = true; // We don't want the menu to be visible in the screenshot VAppMenu* pMainMenu = GetParent()->GetAppModule<VAppMenu>(); if (pMainMenu != NULL) pMainMenu->SetVisible(false); } } iIndex = GetCallbackIndex(m_debugInfos, pData); if (iIndex >= 0) Vision::Profiling.ToggleDebugRenderFlags((unsigned int)iIndex); }