void cBillboard::UpdateGraphics(cCamera3D *apCamera,float afFrameTime, cRenderList *apRenderList)
{
if(mbIsHalo==false) return;
////////////////////////
//Set the alpha
float fAlpha = 0;
if(mlLastRenderCount == apRenderList->GetLastRenderCount())
{
if(mMaxQueryObject.mpQuery->GetSampleCount()>0)
{
fAlpha = (float)mQueryObject.mpQuery->GetSampleCount() /
(float)mMaxQueryObject.mpQuery->GetSampleCount();
}
}
SetHaloAlpha(fAlpha);
mlLastRenderCount = apRenderList->GetRenderCount();
////////////////////////
//Add the queries
if(mbHaloSourceIsParent)
{
iRenderable *pParent = static_cast<iRenderable*>(GetEntityParent());
if(pParent==NULL)
{
Error("Billboard %s has no parent!\n",msName.c_str());
return;
}
iVertexBuffer *pVtxBuffer = pParent->GetVertexBuffer();
if(pVtxBuffer==NULL)
{
Error("Billboard '%s' parent '%s' as NULL vertex buffer!\n",msName.c_str(),
pParent->GetName().c_str());
return;
}
mQueryObject.mpMatrix = pParent->GetModelMatrix(apCamera);
mQueryObject.mpVtxBuffer = pVtxBuffer;
mMaxQueryObject.mpMatrix = pParent->GetModelMatrix(apCamera);
mMaxQueryObject.mpVtxBuffer = pVtxBuffer;
}
else
{
mQueryObject.mpMatrix = &GetWorldMatrix();
mQueryObject.mpVtxBuffer = mpHaloSourceBuffer;
mMaxQueryObject.mpMatrix = &GetWorldMatrix();
mMaxQueryObject.mpVtxBuffer = mpHaloSourceBuffer;
}
mQueryObject.mbDepthTest = true;
mMaxQueryObject.mbDepthTest = false;
apRenderList->AddOcclusionQuery(&mQueryObject);
apRenderList->AddOcclusionQuery(&mMaxQueryObject);
}
cMatrixf* cBillboard::GetModelMatrix(cCamera3D *apCamera)
{
if(apCamera==NULL)return &GetWorldMatrix();
m_mtxTempTransform = GetWorldMatrix();
cVector3f vForward, vRight, vUp;
cVector3f vCameraForward = apCamera->GetPosition() - GetWorldPosition();
vCameraForward.Normalise();
if(mType == eBillboardType_Point)
{
vForward = vCameraForward;
vRight = cMath::Vector3Cross(apCamera->GetViewMatrix().GetUp(), vForward);
vUp = cMath::Vector3Cross(vForward,vRight);
}
else if(mType == eBillboardType_Axis)
{
vUp = cMath::MatrixMul(GetWorldMatrix().GetRotation(),mvAxis);
vUp.Normalise();
if(vUp == vForward)
{
vRight = cMath::Vector3Cross(vUp, vCameraForward);
Warning("Billboard Right vector is not correct! Contact programmer!\n");
}
else
vRight = cMath::Vector3Cross(vUp, vCameraForward);
vRight.Normalise();
vForward = cMath::Vector3Cross(vRight, vUp);
//vForward.Normalise();
//vUp.Normalise();
}
if(mfForwardOffset!=0)
{
cVector3f vPos = m_mtxTempTransform.GetTranslation();
vPos += vCameraForward * mfForwardOffset;
m_mtxTempTransform.SetTranslation(vPos);
}
//Set right vector
m_mtxTempTransform.m[0][0] = vRight.x;
m_mtxTempTransform.m[1][0] = vRight.y;
m_mtxTempTransform.m[2][0] = vRight.z;
//Set up vector
m_mtxTempTransform.m[0][1] = vUp.x;
m_mtxTempTransform.m[1][1] = vUp.y;
m_mtxTempTransform.m[2][1] = vUp.z;
//Set forward vector
m_mtxTempTransform.m[0][2] = vForward.x;
m_mtxTempTransform.m[1][2] = vForward.y;
m_mtxTempTransform.m[2][2] = vForward.z;
return &m_mtxTempTransform;
}
void CD3DWOWM2RibbonEmitter::BuildRibbon(CD3DWOWM2ModelResource::RIBBON_EMITTER_INFO * pRibbonEmitterInfo,CD3DWOWM2ModelResource::RIBBON_PARAM * pParam)
{
if(m_RibbonCount>=m_MaxRibbonCount)//||RibbonLen>=m_ClipLength*pRibbonEmitterInfo->Resolution)
{
for(UINT i=0;i<m_RibbonCount-1;i++)
{
m_pRibbonVertexBuffer[i].Vertex[0]=m_pRibbonVertexBuffer[i+1].Vertex[0];
m_pRibbonVertexBuffer[i].Vertex[1]=m_pRibbonVertexBuffer[i+1].Vertex[1];
}
m_pRibbonVertexBuffer[m_RibbonCount-1].Vertex[0].Pos=CD3DVector3(pParam->Above,0,0)*GetWorldMatrix();
m_pRibbonVertexBuffer[m_RibbonCount-1].Vertex[0].Color=pParam->Color;
m_pRibbonVertexBuffer[m_RibbonCount-1].Vertex[1].Pos=CD3DVector3(-pParam->Below,0,0)*GetWorldMatrix();
m_pRibbonVertexBuffer[m_RibbonCount-1].Vertex[1].Color=pParam->Color;
}
else
{
m_pRibbonVertexBuffer[m_RibbonCount].Vertex[0].Pos=CD3DVector3(pParam->Above,0,0)*GetWorldMatrix();
m_pRibbonVertexBuffer[m_RibbonCount].Vertex[0].Color=pParam->Color;
m_pRibbonVertexBuffer[m_RibbonCount].Vertex[1].Pos=CD3DVector3(-pParam->Below,0,0)*GetWorldMatrix();
m_pRibbonVertexBuffer[m_RibbonCount].Vertex[1].Color=pParam->Color;
m_RibbonCount++;
}
for(UINT i=0;i<m_RibbonCount;i++)
{
m_pRibbonVertexBuffer[i].Vertex[0].Tex.x=i*1.0f/(m_RibbonCount-1);
m_pRibbonVertexBuffer[i].Vertex[1].Tex.x=i*1.0f/(m_RibbonCount-1);
}
}
//! Draws the objects model.
void AnimatedObject::Draw(GLib::Graphics* pGraphics)
{
mSkinnedModel->SetAnimation(mCurrentAnimIndex);
//mSkinnedModel->SetElapsedTime(mElapsedTime);
Effects::BasicFX->SetMaterial(GetMaterial());
mSkinnedModel->Draw(pGraphics, GetWorldMatrix());
Effects::BasicFX->SetUseAnimation(false);
Effects::BasicFX->Apply(GetD3DContext());
if(IsBoundingBoxVisible())
pGraphics->DrawBoundingBox(&GetBoundingBox(), GetWorldMatrix(), Material(Colors::Blue));
}
FWCamera::Visibility FWCamera::SphereVisible(const Vector3& rkOrigin, FLOAT32 fRadius)
{
Vector3 kOrigin = rkOrigin * GetWorldMatrix();
// COMMENT : Accounts for scaling matrix
// TODO : Only enables scales along X-Axis
Vector3 kRadius(fRadius, 0.0f, 0.0f);
Core3D::Vec3TransformNormal(kRadius, kRadius, GetWorldMatrix());
Plane* pkFrustum = m_akFrustum;
for(UINT32 i = 0; i < 6; ++i, ++pkFrustum)
{
if((*pkFrustum * kOrigin) < -fRadius) {return VISIBILITY_COMPLETYOUT;}
}
return VISIBILITY_COMPLETYIN;
}
bool BitmapFontClass::Render(ID3D11DeviceContext* deviceContext, XMMATRIX& viewMatrix, XMMATRIX& projectionMatrix, char* message, float startX, float startY, XMFLOAT4 pixelColor)
{
unsigned int stride = sizeof(VertexPos);
unsigned int offset = 0;
deviceContext->IASetInputLayout(m_inputLayout);
deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
deviceContext->VSSetShader(m_textureVS, 0, 0);
deviceContext->PSSetShader(m_texturePS, 0, 0);
deviceContext->PSSetShaderResources(0, 1, &m_textureView);
deviceContext->PSSetSamplers(0, 1, &m_samplerState);
XMMATRIX viewProjectionMatrix = DirectX::XMMatrixMultiply(viewMatrix, projectionMatrix);
XMMATRIX modelViewProjectionMatrix = DirectX::XMMatrixMultiply(GetWorldMatrix(), viewProjectionMatrix);
modelViewProjectionMatrix = DirectX::XMMatrixTranspose(modelViewProjectionMatrix);
deviceContext->UpdateSubresource(m_constantBuffer, 0, 0, &modelViewProjectionMatrix, 0, 0);
deviceContext->VSSetConstantBuffers(0, 1, &m_constantBuffer);
DrawString(deviceContext, message, startX, startY, pixelColor);
//DrawString(deviceContext, "Hello World", startX, startY, pixelColor);
return true;
}
void Transform::SetParent(Transform* newParent)
{
if( newParent == this )
return;
if( parent == newParent )
return;
if( parent != 0 )
parent->RemoveChild(this);
parent = newParent;
if( newParent != 0 )
{
nextSibling = newParent->firstChild;
newParent->firstChild = this;
const Float4x4& world = newParent->GetWorldMatrix();
Float4x4 invWorld = world;
invWorld.Wx = -DotProduct(world.XAxis, world.WAxis);
invWorld.Wy = -DotProduct(world.YAxis, world.WAxis);
invWorld.Wz = -DotProduct(world.ZAxis, world.WAxis);
invWorld.transpose3x3();
Float4x4 newLocal;
Multiply( newLocal, GetWorldMatrix(), invWorld );
SetLocalMatrix(newLocal);
}
}
bool PrismTexturedModel::Render(ID3D11DeviceContext* deviceContext, XMFLOAT4X4 viewMatrix, XMFLOAT4X4 projectionMatrix, ColorShader* colorShader, TextureShader* textureShader){
if(!textureShader) return false; //we were not provided with a shader
const int NUMBER_OF_TEXTURES = 3; //one for the sides and one each for top and bottom
for(int i=0; i<NUMBER_OF_TEXTURES; i++){
// Put the game model vertex and index buffers on the graphics pipeline to prepare them for drawing.
m_VertexModelArray[i]->Render(deviceContext);
//render the game model
//render the game model
bool result = textureShader->Render(deviceContext,
m_VertexModelArray[i]->GetIndexCount(),
GetWorldMatrix(),
viewMatrix,
projectionMatrix,
GetTexture(i) //get the texture to render
);
if(!result) return false;
}
return true;
}
//-----------------------------------------------------------------------------
void CPUTModel::UpdateBoundsWorldSpace()
{
// If an object is rigid, then it's object-space bounding box doesn't change.
// However, if it moves, then it's world-space bounding box does change.
// Call this function when the model moves
float4x4 *pWorld = GetWorldMatrix();
float4 center = float4(mBoundingBoxCenterObjectSpace, 1.0f); // W = 1 because we want the xlation (i.e., center is a position)
float4 half = float4(mBoundingBoxHalfObjectSpace, 0.0f); // W = 0 because we don't want xlation (i.e., half is a direction)
// TODO: optimize this
float4 positions[8] = {
center + float4( 1.0f, 1.0f, 1.0f, 0.0f ) * half,
center + float4( 1.0f, 1.0f,-1.0f, 0.0f ) * half,
center + float4( 1.0f,-1.0f, 1.0f, 0.0f ) * half,
center + float4( 1.0f,-1.0f,-1.0f, 0.0f ) * half,
center + float4(-1.0f, 1.0f, 1.0f, 0.0f ) * half,
center + float4(-1.0f, 1.0f,-1.0f, 0.0f ) * half,
center + float4(-1.0f,-1.0f, 1.0f, 0.0f ) * half,
center + float4(-1.0f,-1.0f,-1.0f, 0.0f ) * half
};
float4 minPosition( FLT_MAX, FLT_MAX, FLT_MAX, 1.0f );
float4 maxPosition(-FLT_MAX, -FLT_MAX, -FLT_MAX, 1.0f );
for( UINT ii=0; ii<8; ii++ )
{
float4 position = positions[ii] * *pWorld;
minPosition = Min( minPosition, position );
maxPosition = Max( maxPosition, position );
}
mBoundingBoxCenterWorldSpace = (maxPosition + minPosition) * 0.5f;
mBoundingBoxHalfWorldSpace = (maxPosition - minPosition) * 0.5f;
}
//! Returns the bounding box in world space. [NOTE] Does not work [TODO].
AxisAlignedBox AnimatedObject::GetBoundingBox()
{
//AxisAlignedBox aabb = mSkinnedModel->GetBoundingBox(); // [WIP] The precalculated AABB for the model.
SkinnedMeshList* meshList = mSkinnedModel->GetMeshList();
XNA::AxisAlignedBox aabb = meshList->operator[](0)->GetPrimitive()->GetBoundingBox();
XMFLOAT3 min = aabb.Center - aabb.Extents;
XMFLOAT3 max = aabb.Center + aabb.Extents;
for(int i = 1; i < meshList->size(); i++)
{
AxisAlignedBox meshAABB = (*meshList)[i]->GetPrimitive()->GetBoundingBox();
XMFLOAT3 meshMin = meshAABB.Center - meshAABB.Extents;
XMFLOAT3 meshMax = meshAABB.Center + meshAABB.Extents;
XMStoreFloat3(&min, XMVectorMin(XMLoadFloat3(&meshMin), XMLoadFloat3(&min)));
XMStoreFloat3(&max, XMVectorMax(XMLoadFloat3(&meshMax), XMLoadFloat3(&max)));
}
aabb.Center = (min + max) * 0.5f;
aabb.Extents = (max - min) * 0.5f;
// Break up the world matrix into it's components.
XMVECTOR scale, rotation, translation;
XMMatrixDecompose(&scale, &rotation, &translation, GetWorldMatrix());
// Transform the AABB with the components.
TransformAxisAlignedBoxCustom(&aabb, &aabb, scale, rotation, translation);
aabb.Center = GetPosition(); // [NOTE] Not like this in StaticObject.
return aabb;
}
bool CubeTexturedModel::Render(ID3D11DeviceContext* deviceContext, XMFLOAT4X4 viewMatrix, XMFLOAT4X4 projectionMatrix, ColorShaderClass* colorShader, TextureShaderClass* textureShader){
if(!textureShader) return false; //we were not provided with a shader
for(int i=0; i<NUMBER_OF_CUBE_FACES; i++){
// Put the game model vertex and index buffers on the graphics pipeline to prepare them for drawing.
m_VertexModelArray[i]->Render(deviceContext);
//render the game model
//render the game model
bool result = textureShader->Render(deviceContext,
m_VertexModelArray[i]->GetIndexCount(),
GetWorldMatrix(),
viewMatrix,
projectionMatrix,
GetTexture(i) //get the texture to render
);
if(!result) return false;
}
return true;
}
//=============================================================================
// 描画
//=============================================================================
void CObjectModel::Draw(CObject3DData* object_3d_data)
{
MATRIX4x4 matrix = GetWorldMatrix(object_3d_data);
CModel* model = object_3d_data->model_manager()->Get(model_name_);
object_3d_data->object_3d()->Draw(matrix,model,object_3d_data->renderstate_manager(),object_3d_data->renderstate_list());
}
PSystem::PSystem(LPCWSTR fxName,
const std::string& techName,
LPCWSTR texName,
const D3DXVECTOR3& accel,
const AABB& box,
int maxNumParticles,
float timePerParticle)
: mAccel(accel), mBox(box), mTime(0.0f),
mMaxNumParticles(maxNumParticles), mTimePerParticle(timePerParticle)
{
// Allocate memory for maximum number of particles.
mParticles.resize(mMaxNumParticles);
mAliveParticles.reserve(mMaxNumParticles);
mDeadParticles.reserve(mMaxNumParticles);
// They start off all dead.
for(int i = 0; i < mMaxNumParticles; ++i)
{
mParticles[i].lifeTime = -1.0f;
mParticles[i].initialTime = 0.0f;
}
D3DXMatrixIdentity(&mWorld);
D3DXMatrixIdentity(&mInvWorld);
// Create the texture.
HR(D3DXCreateTextureFromFile(sCore.DeviceHandler(), texName, &mTex));
// Create the FX.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(sCore.DeviceHandler(), fxName,
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (LPCWSTR)errors->GetBufferPointer(), 0, 0);
mhTech = mFX->GetTechniqueByName(techName.c_str());
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhEyePosL = mFX->GetParameterByName(0, "gEyePosL");
mhTex = mFX->GetParameterByName(0, "gTex");
mhTime = mFX->GetParameterByName(0, "gTime");
mhAccel = mFX->GetParameterByName(0, "gAccel");
mhViewportHeight = mFX->GetParameterByName(0, "gViewportHeight");
// We don't need to set these every frame since they do not change.
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetValue(mhAccel, mAccel, sizeof(D3DXVECTOR3)));
HR(mFX->SetTexture(mhTex, mTex));
HR(sCore.DeviceHandler()->CreateVertexBuffer(mMaxNumParticles*sizeof(Particle),
D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
0, D3DPOOL_DEFAULT, &mVB, 0));
mWorld = GetWorldMatrix();
// Compute the change of coordinates matrix that changes coordinates
// relative to world space so that they are relative to the particle
// system's local space.
D3DXMatrixInverse(&mInvWorld, 0, &mWorld);
}
BSPHERE MESHINSTANCE::GetBoundingSphere()
{
if(m_pMesh == NULL || m_pMesh->m_pMesh == NULL)return BSPHERE();
if(m_pMesh->m_pMesh->GetFVF() != ObjectVertex::FVF) // XYZ and NORMAL and UV
return BSPHERE();
BBOX bBox = GetBoundingBox();
BSPHERE bSphere;
D3DXMATRIX World = GetWorldMatrix();
bSphere.center = (bBox.max + bBox.min) / 2.0f;
ObjectVertex* vertexBuffer = NULL;
m_pMesh->m_pMesh->LockVertexBuffer(0,(void**)&vertexBuffer);
//Get radius
for(int i=0;i<(int)m_pMesh->m_pMesh->GetNumVertices();i++)
{
D3DXVECTOR3 pos;
D3DXVec3TransformCoord(&pos, &vertexBuffer[i]._pos, &World);
float l = D3DXVec3Length(&(pos - bSphere.center));
if(l > bSphere.radius)
bSphere.radius = l;
}
m_pMesh->m_pMesh->UnlockVertexBuffer();
return bSphere;
}
//! Draws the objects model.
void AnimatedObject::Draw(Graphics* pGraphics)
{
mSkinnedModel->SetAnimation(mCurrentAnimIndex);
mSkinnedModel->SetElapsedTime(mElapsedTime);
mSkinnedModel->Draw(pGraphics, GetWorldMatrix());
//pGraphics->DrawBoundingBox(&GetBoundingBox(), GetWorldMatrix(), Material(Colors::Green));
}
Air::U1 MeshEntity::RayCast( const Ray& ray ,float* pOutDistance)
{
#if 1
if(!GetWorldBoundingBox().RayCast(ray.GetOrigin(),ray.GetDirection())){//.Intersect(GetWorldBoundingBox())){
return false;
}
#endif
Matrix matWorld = *GetWorldMatrix();
Matrix matWorldInv = matWorld;
matWorldInv.Inverse();
Float3 vStart = ray.m_vStart;
Float3 vLookAt = vStart + ray.m_vDirection;
vStart = matWorldInv*vStart;
vLookAt = matWorldInv*vLookAt;
Float3 vDir = (vLookAt - vStart);
vDir.Normalize();
Ray objSpaceRay(vStart,vDir);
float fDistance = 999999.0f;
U1 bHit = m_pMesh->RayCast(objSpaceRay,&fDistance);
if(bHit && pOutDistance!=NULL){
Float3 vObjSpaceHitPostion = vStart + vDir*fDistance;
Float3 vWorldSpaceHiPosition = matWorld*vObjSpaceHitPostion;
*pOutDistance = (vWorldSpaceHiPosition - ray.m_vStart).Length();
}
return bHit;
}
void iEntity3D::SetTransformUpdated(bool abUpdateCallbacks)
{
mbTransformUpdated = true;
mlCount++;
//Perhaps not update this yet? This is baaaad!
if(mbApplyTransformToBV)
mBoundingVolume.SetTransform(GetWorldMatrix());
mbUpdateBoundingVolume = true;
//Update children
for(tEntity3DListIt EntIt = mlstChildren.begin(); EntIt != mlstChildren.end();++EntIt)
{
iEntity3D *pChild = *EntIt;
pChild->SetTransformUpdated(true);
}
//Update callbacks
if(mlstCallbacks.empty() || abUpdateCallbacks==false) return;
tEntityCallbackListIt it = mlstCallbacks.begin();
for(; it!= mlstCallbacks.end(); ++it)
{
iEntityCallback* pCallback = *it;
pCallback->OnTransformUpdate(this);
}
}
void CGameObject::Render()
{
UINT stride = sizeof( m_meshData );
UINT offset = 0;
theContext->IASetInputLayout( m_inputLayout );
theContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
theContext->IASetVertexBuffers( 0, 1, &m_vertexBuffer, &stride, &offset );
theContext->IASetIndexBuffer( m_indexBuffer, DXGI_FORMAT_R32_UINT, 0 );
XMMATRIX world = GetWorldMatrix();
m_pFXWorld->SetMatrix( reinterpret_cast<float*>(&world) );
m_pFXTexture->SetResource( m_material.GetDiffuse() );
m_pFXTextureSampler->SetSampler( 0, m_pTextureSampler );
D3DX11_TECHNIQUE_DESC techDesc = {};
m_effectTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
m_effectTech->GetPassByIndex( p )->Apply( 0, theContext );
theContext->DrawIndexed( m_meshData.indices.size(), 0, 0 );
}
}
void iLight3D::OnFlickerOff()
{
//Particle system
if(msFlickerOffPS!=""){
cParticleSystem3D *pPS = mpWorld3D->CreateParticleSystem(GetName() + "_PS",
msFlickerOffPS, cVector3f(1,1,1),GetWorldMatrix());
}
}
void MESHINSTANCE::Render()
{
if(m_pMesh != NULL)
{
m_pMesh->m_pDevice->SetTransform(D3DTS_WORLD, &GetWorldMatrix());
m_pMesh->Render();
}
}
void CMinotaur::Activate()
{
if (m_bIsActive == false)
{
SetPosition(m_tSpawnPosition);
for (unsigned int i = 0; i < GetColliders().size(); i++)
{
if (GetColliders()[i]->GetBounds()->GetType() == Bounds::Capsule)
{
((CCapsule*)GetColliders()[i]->GetBounds())->SetStart(XMFLOAT3(GetWorldMatrix()._41, GetWorldMatrix()._42 + 150.0f, GetWorldMatrix()._43));
((CCapsule*)GetColliders()[i]->GetBounds())->SetEnd(XMFLOAT3(GetWorldMatrix()._41, GetWorldMatrix()._42 + 135.0f, GetWorldMatrix()._43));
((CCapsule*)GetColliders()[i]->GetBounds())->SetRadius(150.0f);
}
else if (GetColliders()[i]->GetBounds()->GetType() == Bounds::AABB)
{
((CAABB*)GetColliders()[i]->GetBounds())->SetCenter({ GetWorldMatrix()._41, GetWorldMatrix()._42 + 45, GetWorldMatrix()._43 });
}
GetColliders()[i]->UpdatePosition(GetWorldVelocity());
}
m_cpRenderMesh->GetRender() = true;
m_cDropShadow->GetRender() = true;
m_cpRenderMesh->SetTexture(L"../Game/Assets/Art/2D/Textures/Minotaur.dds");
IObject::UpdatePosition();
// Create a AddObj Message
CAddObjectMessage* addObj = new CAddObjectMessage(this, CObjectManager::AI);
CAddObjectMessage* addObj2 = new CAddObjectMessage(m_pMinotaurZone, CObjectManager::AI);
//ChangeState(eIdleState);
// Send the message
ChangeState(ePatrolState);
addObj->Send();
addObj2->Send();
m_fCurrentHealth = m_fMaxHealth;
m_bInvincible = false;
m_bIsActive = true;
m_vDoors = m_cpObjectManager->FindObjectsWithTag("Door", CObjectManager::Static);
m_pCamera = (CCamera*)m_cpObjectManager->GetCamera();
AudioSystemWwise::Get()->PostEvent(AK::EVENTS::MINOALERT, m_tSpawnPosition);
}
}
// Set the render state before drawing this object
//-----------------------------------------------------------------------------
void CPUTModelDX11::UpdateShaderConstants(CPUTRenderParameters &renderParams)
{
ID3D11DeviceContext *pContext = ((CPUTRenderParametersDX*)&renderParams)->mpContext;
D3D11_MAPPED_SUBRESOURCE mapInfo;
pContext->Map( mpModelConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapInfo );
{
CPUTModelConstantBuffer *pCb = (CPUTModelConstantBuffer*)mapInfo.pData;
// TODO: remove construction of XMM type
XMMATRIX world((float*)GetWorldMatrix());
pCb->World = world;
CPUTCamera *pCamera = renderParams.mpCamera;
XMVECTOR cameraPos = XMLoadFloat3(&XMFLOAT3( 0.0f, 0.0f, 0.0f ));
if( pCamera )
{
XMMATRIX view((float*)pCamera->GetViewMatrix());
XMMATRIX projection((float*)pCamera->GetProjectionMatrix());
float *pCameraPos = (float*)&pCamera->GetPosition();
cameraPos = XMLoadFloat3(&XMFLOAT3( pCameraPos[0], pCameraPos[1], pCameraPos[2] ));
// Note: We compute viewProjection to a local to avoid reading from write-combined memory.
// The constant buffer uses write-combined memory. We read this matrix when computing WorldViewProjection.
// It is very slow to read it directly from the constant buffer.
XMMATRIX viewProjection = view * projection;
pCb->ViewProjection = viewProjection;
pCb->WorldViewProjection = world * viewProjection;
XMVECTOR determinant = XMMatrixDeterminant(world);
pCb->InverseWorld = XMMatrixInverse(&determinant, XMMatrixTranspose(world));
}
// TODO: Have the lights set their render states?
XMVECTOR lightDirection = XMLoadFloat3(&XMFLOAT3( gLightDir.x, gLightDir.y, gLightDir.z ));
pCb->LightDirection = XMVector3Normalize(lightDirection);
pCb->EyePosition = cameraPos;
float *bbCWS = (float*)&mBoundingBoxCenterWorldSpace;
float *bbHWS = (float*)&mBoundingBoxHalfWorldSpace;
float *bbCOS = (float*)&mBoundingBoxCenterObjectSpace;
float *bbHOS = (float*)&mBoundingBoxHalfObjectSpace;
pCb->BoundingBoxCenterWorldSpace = XMLoadFloat3(&XMFLOAT3( bbCWS[0], bbCWS[1], bbCWS[2] )); ;
pCb->BoundingBoxHalfWorldSpace = XMLoadFloat3(&XMFLOAT3( bbHWS[0], bbHWS[1], bbHWS[2] )); ;
pCb->BoundingBoxCenterObjectSpace = XMLoadFloat3(&XMFLOAT3( bbCOS[0], bbCOS[1], bbCOS[2] )); ;
pCb->BoundingBoxHalfObjectSpace = XMLoadFloat3(&XMFLOAT3( bbHOS[0], bbHOS[1], bbHOS[2] )); ;
// Shadow camera
XMMATRIX shadowView, shadowProjection;
CPUTCamera *pShadowCamera = gpSample->GetShadowCamera();
if( pShadowCamera )
{
shadowView = XMMATRIX((float*)pShadowCamera->GetViewMatrix());
shadowProjection = XMMATRIX((float*)pShadowCamera->GetProjectionMatrix());
pCb->LightWorldViewProjection = world * shadowView * shadowProjection;
}
}
pContext->Unmap(mpModelConstantBuffer,0);
}
const cMatrixf& cLight3DSpot::GetViewMatrix()
{
if(mlViewMatrixCount != GetTransformUpdateCount())
{
mlViewMatrixCount = GetTransformUpdateCount();
m_mtxView = cMath::MatrixInverse(GetWorldMatrix());
}
return m_mtxView;
}
void CCrackedWall::Initialize()
{
for( size_t i = 0; i < m_cpIndicatorBomb.size(); i++ )
{
m_cpIndicatorBomb[i]->GetTransformMatrix() = GetWorldMatrix();
}
SetBombPosition();
SetupParticle();
m_bInitialized = true;
}
void UNIT::Render()
{
if(m_type < (int)unitMeshes.size() && unitMeshes[m_type] != NULL)
{
SetAnimation(m_animation);
unitMeshes[m_type]->SetPose(GetWorldMatrix(), m_pAnimControl, m_time);
unitMeshes[m_type]->Render(NULL);
m_time = 0.0f;
}
}
void cPhysicsBodyNewton::AddImpulse(const cVector3f &a_vImpulse)
{
cVector3f vMassCentre = GetMassCentre();
if (vMassCentre != cVector3f(0,0,0))
{
cVector3f vCentreOffset = cMath::MatrixMul(GetWorldMatrix().GetRotation(), vMassCentre);
cVector3f vWorldPosition = GetWorldPosition() + vCentreOffset;
NewtonBodyAddImpulse(m_pNewtonBody, a_vImpulse.v, vWorldPosition.v);
}
else
NewtonBodyAddImpulse(m_pNewtonBody, a_vImpulse.v, GetWorldPosition().v);
}
//-----------------------------------------------------------------------------
void CPUTCamera::Update( float deltaSeconds ) {
// TODO: Do only if required (i.e. if dirty)
if( mMode == CPUT_PERSPECTIVE )
{
mProjection = float4x4PerspectiveFovLH( mFov, mAspectRatio, mFarPlaneDistance, mNearPlaneDistance );
}
else if ( mMode == CPUT_ORTHOGRAPHIC )
{
mProjection = float4x4OrthographicLH(mWidth, mHeight, mFarPlaneDistance, mNearPlaneDistance);
}
mView = inverse(*GetWorldMatrix());
mFrustum.InitializeFrustum(this);
};
bool ModelClass::FlipGravityS(std::vector<BoundingBox>& bb)
{
FallDamage = false;
/*
D3DXVECTOR3 temp;
temp = (bBox.max - bBox.min) / 2.0f;
D3DXVECTOR3 temp2;
D3DXVec3Cross(&temp2, &worldAxis, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
if (!Rotated)
{
position.x -= (temp.x * temp2.x) * (2.5f);
position.y -= (temp.y * temp2.y) * (2.5f);
position.z -= (temp.z * temp2.z) * (2.5f);
}
else
{
position.x += (temp.x * temp2.x) * (2.5f);
position.y += (temp.y * temp2.y) * (2.5f);
position.z += (temp.z * temp2.z) * (2.5f);
}
*/
D3DXVECTOR3 tempWorldAxis;
tempWorldAxis = worldAxis;
D3DXVec3Cross(&worldAxis, &worldAxis, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
GetWorldMatrix();
/*
if (HorizontalCollisionTest(D3DXVECTOR3(0.0f, 0.0f, 0.0f), bb, 0.0f))
{
worldAxis = tempWorldAxis;
}
*/
D3DXVECTOR3 tempMax = bBox.max;
D3DXVECTOR3 tempMin = bBox.min;
tempMax = position + tempMax;
tempMin = position + tempMin;
for (int j = 0; j < bb.size(); j++)
{
if (tempMax.x > bb[j].min.x &&
tempMin.x < bb[j].max.x &&
tempMax.y > bb[j].min.y &&
tempMin.y < bb[j].max.y &&
tempMax.z > bb[j].min.z &&
tempMin.z < bb[j].max.z)
{
worldAxis = tempWorldAxis;
return false;
}
}
return true;
}
void COGModelSkeleton::GetWorldMatrix(OGMatrix& _mOut, unsigned int _NodeId, unsigned int _Frame) const
{
OGModelNode* pNode = m_Nodes[_NodeId];
if (pNode->mTransformList.size() > _Frame)
_mOut = pNode->mTransformList[_Frame];
else
_mOut = pNode->mTransformList[0];
if(pNode->nIdxParent < 0)
return;
OGMatrix mTmp;
GetWorldMatrix(mTmp, pNode->nIdxParent, _Frame);
MatrixMultiply(_mOut, _mOut, mTmp);
}
bool CUpFloor::IsHitPlayer(D3DXVECTOR3 pos, float radius)
{
m_WorldMatrix = GetWorldMatrix();
D3DXMatrixInverse(&m_InvWorld, nullptr, &m_WorldMatrix);
PlayerPos = m_player->GetPos();
D3DXVec3Transform(&dimension, &PlayerPos, &m_InvWorld);
if (fabsf(dimension.x) < 1.5f && fabsf(dimension.z) < 1.5f && dimension.y <= 1.7f && dimension.y >= 0.6f)
{
return true;
}
return false;
}
