port 2V2-d.2: Granny runtime on libgr2, main character model animates
Implement the Granny SDK 2.11 API the client uses on top of libgr2 (platform/EterGrnLib/GrannyRuntime.cpp, shim granny.h declared from the SDK header): file sections, type-definition vertex conversion, material textures by Usage, mesh/bone bindings, deformer, control clock/loop/ease and weighted SRT sampling. Port EterGrnLib (LODController, Material, Mesh, Model, ModelInstance*, Motion, Thing, ThingInstance, Util) plus EterLib GrpObjectInstance/GrpCollisionObject/CollisionData verbatim and drop their platform skeletons and pending stand-ins; register the gr2 resource factory; vertex/index buffers are CPU-side until the 2V2-e render adapter. app.UpdateGame/RenderGame now run 40250's bodies, reaching the CPythonApplication members through their singletons (the platform has no app object); CPythonGraphic joins GameSingletons in member order, and GetMousePosition reads the host cursor. port.login_flow asserts the main instance's PART_MAIN model has meshes, its diffuse image loaded and the WAIT motion moves the bones between frames; offline and live pass, port_gate macos PASS. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
shenlei
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
5266b00c6e
commit
668f48d6ec
@@ -0,0 +1,840 @@
|
||||
#include "StdAfx.h"
|
||||
#include "CollisionData.h"
|
||||
#include "Pool.h"
|
||||
#include "GrpScreen.h"
|
||||
#include "GrpMath.h"
|
||||
#include "lineintersect_utils.h"
|
||||
#include "StateManager.h"
|
||||
const float gc_fReduceMove = 0.5f;
|
||||
|
||||
//const float gc_fSlideMoveSpeed = 5.0f;
|
||||
/*inline D3DXVECTOR3 FitAtSpecifiedLength(const D3DXVECTOR3 & v3Vector, float length)
|
||||
{
|
||||
D3DXVECTOR3 v;
|
||||
D3DXVec3Normalize(&v,&v3Vector);
|
||||
return v*length;
|
||||
}
|
||||
*/
|
||||
CDynamicPool<CSphereCollisionInstance> gs_sci;
|
||||
CDynamicPool<CCylinderCollisionInstance> gs_cci;
|
||||
CDynamicPool<CPlaneCollisionInstance> gs_pci;
|
||||
CDynamicPool<CAABBCollisionInstance> gs_aci;
|
||||
CDynamicPool<COBBCollisionInstance> gs_oci;
|
||||
|
||||
void DestroyCollisionInstanceSystem()
|
||||
{
|
||||
gs_sci.Destroy();
|
||||
gs_cci.Destroy();
|
||||
gs_pci.Destroy();
|
||||
gs_aci.Destroy();
|
||||
gs_oci.Destroy();
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// Base
|
||||
CBaseCollisionInstance * CBaseCollisionInstance::BuildCollisionInstance(const CStaticCollisionData * c_pCollisionData, const D3DXMATRIX * pMat)
|
||||
{
|
||||
switch(c_pCollisionData->dwType)
|
||||
{
|
||||
case COLLISION_TYPE_PLANE:
|
||||
{
|
||||
CPlaneCollisionInstance * ppci = gs_pci.Alloc();
|
||||
D3DXMATRIX matRotation;
|
||||
D3DXMATRIX matTranslationLocal;
|
||||
D3DXMatrixRotationQuaternion(&matRotation, &c_pCollisionData->quatRotation);
|
||||
D3DXMatrixTranslation(&matTranslationLocal, c_pCollisionData->v3Position.x, c_pCollisionData->v3Position.y, c_pCollisionData->v3Position.z);
|
||||
D3DXMATRIX matTransform = matRotation * matTranslationLocal * *pMat;
|
||||
|
||||
TPlaneData & PlaneData = ppci->GetAttribute();
|
||||
D3DXVec3TransformCoord(&PlaneData.v3Position, &c_pCollisionData->v3Position, pMat);
|
||||
float fHalfWidth = c_pCollisionData->fDimensions[0] / 2.0f;
|
||||
float fHalfLength = c_pCollisionData->fDimensions[1] / 2.0f;
|
||||
|
||||
PlaneData.v3QuadPosition[0].x = -fHalfWidth;
|
||||
PlaneData.v3QuadPosition[0].y = -fHalfLength;
|
||||
PlaneData.v3QuadPosition[0].z = 0.0f;
|
||||
PlaneData.v3QuadPosition[1].x = +fHalfWidth;
|
||||
PlaneData.v3QuadPosition[1].y = -fHalfLength;
|
||||
PlaneData.v3QuadPosition[1].z = 0.0f;
|
||||
PlaneData.v3QuadPosition[2].x = -fHalfWidth;
|
||||
PlaneData.v3QuadPosition[2].y = +fHalfLength;
|
||||
PlaneData.v3QuadPosition[2].z = 0.0f;
|
||||
PlaneData.v3QuadPosition[3].x = +fHalfWidth;
|
||||
PlaneData.v3QuadPosition[3].y = +fHalfLength;
|
||||
PlaneData.v3QuadPosition[3].z = 0.0f;
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
D3DXVec3TransformCoord(&PlaneData.v3QuadPosition[i], &PlaneData.v3QuadPosition[i], &matTransform);
|
||||
D3DXVECTOR3 v3Line0 = PlaneData.v3QuadPosition[1] - PlaneData.v3QuadPosition[0];
|
||||
D3DXVECTOR3 v3Line1 = PlaneData.v3QuadPosition[2] - PlaneData.v3QuadPosition[0];
|
||||
D3DXVECTOR3 v3Line2 = PlaneData.v3QuadPosition[1] - PlaneData.v3QuadPosition[3];
|
||||
D3DXVECTOR3 v3Line3 = PlaneData.v3QuadPosition[2] - PlaneData.v3QuadPosition[3];
|
||||
D3DXVec3Normalize(&v3Line0, &v3Line0);
|
||||
D3DXVec3Normalize(&v3Line1, &v3Line1);
|
||||
D3DXVec3Normalize(&v3Line2, &v3Line2);
|
||||
D3DXVec3Normalize(&v3Line3, &v3Line3);
|
||||
D3DXVec3Cross(&PlaneData.v3Normal, &v3Line0, &v3Line1);
|
||||
D3DXVec3Normalize(&PlaneData.v3Normal, &PlaneData.v3Normal);
|
||||
|
||||
D3DXVec3Cross(&PlaneData.v3InsideVector[0], &PlaneData.v3Normal, &v3Line0 );
|
||||
D3DXVec3Cross(&PlaneData.v3InsideVector[1], &v3Line1, &PlaneData.v3Normal);
|
||||
D3DXVec3Cross(&PlaneData.v3InsideVector[2], &v3Line2, &PlaneData.v3Normal);
|
||||
D3DXVec3Cross(&PlaneData.v3InsideVector[3], &PlaneData.v3Normal, &v3Line3);
|
||||
|
||||
return ppci;
|
||||
}
|
||||
break;
|
||||
case COLLISION_TYPE_BOX:
|
||||
assert(false && "COLLISION_TYPE_BOX not implemented");
|
||||
break;
|
||||
case COLLISION_TYPE_AABB:
|
||||
{
|
||||
CAABBCollisionInstance * paci = gs_aci.Alloc();
|
||||
|
||||
D3DXMATRIX matTranslationLocal;
|
||||
D3DXMatrixTranslation(&matTranslationLocal, c_pCollisionData->v3Position.x, c_pCollisionData->v3Position.y, c_pCollisionData->v3Position.z);
|
||||
D3DXMATRIX matTransform = *pMat;
|
||||
|
||||
D3DXVECTOR3 v3Pos;
|
||||
v3Pos.x = matTranslationLocal._41;
|
||||
v3Pos.y = matTranslationLocal._42;
|
||||
v3Pos.z = matTranslationLocal._43;
|
||||
|
||||
TAABBData & AABBData = paci->GetAttribute();
|
||||
AABBData.v3Min.x = v3Pos.x - c_pCollisionData->fDimensions[0];
|
||||
AABBData.v3Min.y = v3Pos.y - c_pCollisionData->fDimensions[1];
|
||||
AABBData.v3Min.z = v3Pos.z - c_pCollisionData->fDimensions[2];
|
||||
AABBData.v3Max.x = v3Pos.x + c_pCollisionData->fDimensions[0];
|
||||
AABBData.v3Max.y = v3Pos.y + c_pCollisionData->fDimensions[1];
|
||||
AABBData.v3Max.z = v3Pos.z + c_pCollisionData->fDimensions[2];
|
||||
|
||||
D3DXVec3TransformCoord(&AABBData.v3Min, &AABBData.v3Min, &matTransform);
|
||||
D3DXVec3TransformCoord(&AABBData.v3Max, &AABBData.v3Max, &matTransform);
|
||||
|
||||
return paci;
|
||||
}
|
||||
break;
|
||||
case COLLISION_TYPE_OBB:
|
||||
{
|
||||
COBBCollisionInstance * poci = gs_oci.Alloc();
|
||||
|
||||
D3DXMATRIX matTranslationLocal; D3DXMatrixTranslation(&matTranslationLocal, c_pCollisionData->v3Position.x, c_pCollisionData->v3Position.y, c_pCollisionData->v3Position.z);
|
||||
D3DXMATRIX matRotation; D3DXMatrixRotationQuaternion(&matRotation, &c_pCollisionData->quatRotation);
|
||||
|
||||
D3DXMATRIX matTranslationWorld; D3DXMatrixIdentity(&matTranslationWorld);
|
||||
matTranslationWorld._41 = pMat->_41; matTranslationWorld._42 = pMat->_42; matTranslationWorld._43 = pMat->_43; matTranslationWorld._44 = pMat->_44;
|
||||
|
||||
D3DXVECTOR3 v3Min, v3Max;
|
||||
v3Min.x = c_pCollisionData->v3Position.x - c_pCollisionData->fDimensions[0];
|
||||
v3Min.y = c_pCollisionData->v3Position.y - c_pCollisionData->fDimensions[1];
|
||||
v3Min.z = c_pCollisionData->v3Position.z - c_pCollisionData->fDimensions[2];
|
||||
v3Max.x = c_pCollisionData->v3Position.x + c_pCollisionData->fDimensions[0];
|
||||
v3Max.y = c_pCollisionData->v3Position.y + c_pCollisionData->fDimensions[1];
|
||||
v3Max.z = c_pCollisionData->v3Position.z + c_pCollisionData->fDimensions[2];
|
||||
|
||||
D3DXVec3TransformCoord(&v3Min, &v3Min, pMat);
|
||||
D3DXVec3TransformCoord(&v3Max, &v3Max, pMat);
|
||||
D3DXVECTOR3 v3Position = (v3Min + v3Max) * 0.5f;
|
||||
|
||||
TOBBData & OBBData = poci->GetAttribute();
|
||||
OBBData.v3Min.x = v3Position.x - c_pCollisionData->fDimensions[0];
|
||||
OBBData.v3Min.y = v3Position.y - c_pCollisionData->fDimensions[1];
|
||||
OBBData.v3Min.z = v3Position.z - c_pCollisionData->fDimensions[2];
|
||||
OBBData.v3Max.x = v3Position.x + c_pCollisionData->fDimensions[0];
|
||||
OBBData.v3Max.y = v3Position.y + c_pCollisionData->fDimensions[1];
|
||||
OBBData.v3Max.z = v3Position.z + c_pCollisionData->fDimensions[2];
|
||||
|
||||
|
||||
|
||||
D3DXMATRIX matTransform = *pMat;
|
||||
|
||||
D3DXMatrixIdentity(&OBBData.matRot); OBBData.matRot = *pMat;
|
||||
OBBData.matRot._41 = 0; OBBData.matRot._42 = 0; OBBData.matRot._43 = 0; OBBData.matRot._44 = 1;
|
||||
|
||||
|
||||
|
||||
|
||||
return poci;
|
||||
}
|
||||
break;
|
||||
case COLLISION_TYPE_SPHERE:
|
||||
{
|
||||
CSphereCollisionInstance * psci = gs_sci.Alloc();
|
||||
|
||||
D3DXMATRIX matTranslationLocal;
|
||||
D3DXMatrixTranslation(&matTranslationLocal, c_pCollisionData->v3Position.x, c_pCollisionData->v3Position.y, c_pCollisionData->v3Position.z);
|
||||
matTranslationLocal = matTranslationLocal * *pMat;
|
||||
|
||||
TSphereData & SphereData = psci->GetAttribute();
|
||||
SphereData.v3Position.x = matTranslationLocal._41;
|
||||
SphereData.v3Position.y = matTranslationLocal._42;
|
||||
SphereData.v3Position.z = matTranslationLocal._43;
|
||||
SphereData.fRadius = c_pCollisionData->fDimensions[0];
|
||||
|
||||
return psci;
|
||||
}
|
||||
break;
|
||||
case COLLISION_TYPE_CYLINDER:
|
||||
{
|
||||
CCylinderCollisionInstance * pcci = gs_cci.Alloc();
|
||||
|
||||
D3DXMATRIX matTranslationLocal;
|
||||
D3DXMatrixTranslation(&matTranslationLocal, c_pCollisionData->v3Position.x, c_pCollisionData->v3Position.y, c_pCollisionData->v3Position.z);
|
||||
matTranslationLocal = matTranslationLocal * *pMat;
|
||||
|
||||
TCylinderData & CylinderData = pcci->GetAttribute();
|
||||
CylinderData.fRadius = c_pCollisionData->fDimensions[0];
|
||||
CylinderData.fHeight = c_pCollisionData->fDimensions[1];
|
||||
CylinderData.v3Position.x = matTranslationLocal._41;
|
||||
CylinderData.v3Position.y = matTranslationLocal._42;
|
||||
CylinderData.v3Position.z = matTranslationLocal._43 /*+ CylinderData.fHeight/2.0f*/;
|
||||
|
||||
return pcci;
|
||||
}
|
||||
break;
|
||||
}
|
||||
assert(false && "NOT_REACHED");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CBaseCollisionInstance::Destroy()
|
||||
{
|
||||
OnDestroy();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/*------------------------------------------------------Sphere---------------------------------------------------------------*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
TSphereData & CSphereCollisionInstance::GetAttribute()
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
const TSphereData & CSphereCollisionInstance::GetAttribute() const
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
void CSphereCollisionInstance::Render(D3DFILLMODE d3dFillMode)
|
||||
{
|
||||
static CScreen s;
|
||||
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, 0xffffffff);
|
||||
s.RenderSphere(NULL, m_attribute.v3Position.x, m_attribute.v3Position.y, m_attribute.v3Position.z, m_attribute.fRadius, d3dFillMode);
|
||||
}
|
||||
|
||||
void CSphereCollisionInstance::OnDestroy()
|
||||
{
|
||||
gs_sci.Free(this);
|
||||
}
|
||||
|
||||
bool CSphereCollisionInstance::OnMovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
if (square_distance_between_linesegment_and_point(s.v3LastPosition,s.v3Position,m_attribute.v3Position) < (m_attribute.fRadius+s.fRadius)*(m_attribute.fRadius+s.fRadius))
|
||||
{
|
||||
// NOTE : 거리가 가까워 졌을때만.. - [levites]
|
||||
if (GetVector3Distance(s.v3Position, m_attribute.v3Position) <
|
||||
GetVector3Distance(s.v3LastPosition, m_attribute.v3Position))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CSphereCollisionInstance::OnCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
//Tracef("OnCollisionDynamicSphere\n");
|
||||
|
||||
if (square_distance_between_linesegment_and_point(s.v3LastPosition,s.v3Position,m_attribute.v3Position)<(m_attribute.fRadius+s.fRadius)*(m_attribute.fRadius+s.fRadius))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 CSphereCollisionInstance::OnGetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
const auto _vv__ = (s.v3Position - m_attribute.v3Position);
|
||||
if (D3DXVec3LengthSq(&_vv__)>=(s.fRadius+m_attribute.fRadius)*(m_attribute.fRadius+s.fRadius))
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
D3DXVECTOR3 c;
|
||||
const auto _vv__2 = (s.v3Position - s.v3LastPosition);
|
||||
const auto _vv_s_2 = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
|
||||
D3DXVec3Cross(&c, &_vv__2, &_vv_s_2);
|
||||
|
||||
float sum = - D3DXVec3Dot(&c,&_vv__);
|
||||
float mul = (s.fRadius+m_attribute.fRadius)*(s.fRadius+m_attribute.fRadius)-D3DXVec3LengthSq(&_vv__);
|
||||
|
||||
if (sum*sum-4*mul<=0)
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
float sq = sqrt(sum*sum-4*mul);
|
||||
float t1=-sum-sq, t2=-sum+sq;
|
||||
t1*=0.5f;
|
||||
t2*=0.5f;
|
||||
|
||||
if (fabs(t1)<=fabs(t2))
|
||||
{
|
||||
return (gc_fReduceMove*t1)*c;
|
||||
}
|
||||
else
|
||||
return (gc_fReduceMove*t2)*c;
|
||||
|
||||
/*
|
||||
D3DXVECTOR3 p1 = s.v3Position+t1*c;
|
||||
D3DXVECTOR3 p2 = s.v3Position+t2*c;
|
||||
|
||||
if (D3DXVec3LengthSq(&(p2-s.v3Position))>D3DXVec3LengthSq(&(p1-s.v3Position)))
|
||||
{
|
||||
return p1-s.v3Position;
|
||||
}
|
||||
else
|
||||
{
|
||||
return p2-s.v3Position;
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// Plane
|
||||
TPlaneData & CPlaneCollisionInstance::GetAttribute()
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
const TPlaneData & CPlaneCollisionInstance::GetAttribute() const
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
bool CPlaneCollisionInstance::OnMovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 v3SpherePosition = s.v3Position - m_attribute.v3Position;
|
||||
D3DXVECTOR3 v3SphereLastPosition = s.v3LastPosition - m_attribute.v3Position;
|
||||
|
||||
float fPosition1 = D3DXVec3Dot(&m_attribute.v3Normal, &v3SpherePosition);
|
||||
float fPosition2 = D3DXVec3Dot(&m_attribute.v3Normal, &v3SphereLastPosition);
|
||||
|
||||
if (fPosition1 >0.0f && fPosition2 < 0.0f || fPosition1 <0.0f && fPosition2 >0.0f
|
||||
|| (fPosition1) <= s.fRadius && fPosition1 >= -s.fRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3QuadPosition1 = s.v3Position - m_attribute.v3QuadPosition[0];
|
||||
D3DXVECTOR3 v3QuadPosition2 = s.v3Position - m_attribute.v3QuadPosition[3];
|
||||
|
||||
if (D3DXVec3Dot(&v3QuadPosition1, &m_attribute.v3InsideVector[0]) > - s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition1, &m_attribute.v3InsideVector[1]) > -s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition2, &m_attribute.v3InsideVector[2]) > - s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition2, &m_attribute.v3InsideVector[3]) > - s.fRadius/*0.0f*/)
|
||||
{
|
||||
// NOTE : 거리가 가까워 졌을때만.. - [levites]
|
||||
const auto _vv__3 = (s.v3Position - m_attribute.v3Position);
|
||||
const auto _vv__4 = (s.v3LastPosition - m_attribute.v3Position);
|
||||
if (fabs(D3DXVec3Dot(&_vv__3, &m_attribute.v3Normal)) <
|
||||
fabs(D3DXVec3Dot(&_vv__4, &m_attribute.v3Normal)))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CPlaneCollisionInstance::OnCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
//Tracef("OnCollisionDynamicSphere\n");
|
||||
|
||||
D3DXVECTOR3 v3SpherePosition = s.v3Position - m_attribute.v3Position;
|
||||
D3DXVECTOR3 v3SphereLastPosition = s.v3LastPosition - m_attribute.v3Position;
|
||||
|
||||
float fPosition1 = D3DXVec3Dot(&m_attribute.v3Normal, &v3SpherePosition);
|
||||
float fPosition2 = D3DXVec3Dot(&m_attribute.v3Normal, &v3SphereLastPosition);
|
||||
|
||||
if (fPosition1 >0.0f && fPosition2 < 0.0f || fPosition1 <0.0f && fPosition2 >0.0f
|
||||
|| (fPosition1) <= s.fRadius && fPosition1 >= -s.fRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3QuadPosition1 = s.v3Position - m_attribute.v3QuadPosition[0];
|
||||
D3DXVECTOR3 v3QuadPosition2 = s.v3Position - m_attribute.v3QuadPosition[3];
|
||||
|
||||
if (D3DXVec3Dot(&v3QuadPosition1, &m_attribute.v3InsideVector[0]) > - s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition1, &m_attribute.v3InsideVector[1]) > -s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition2, &m_attribute.v3InsideVector[2]) > - s.fRadius/*0.0f*/)
|
||||
if (D3DXVec3Dot(&v3QuadPosition2, &m_attribute.v3InsideVector[3]) > - s.fRadius/*0.0f*/)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 CPlaneCollisionInstance::OnGetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 advance = s.v3Position-s.v3LastPosition;
|
||||
|
||||
float d = D3DXVec3Dot(&m_attribute.v3Normal, &advance);
|
||||
if (d>=-0.0001 && d<=0.0001)
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
const auto vv = (s.v3Position - m_attribute.v3Position);
|
||||
float t= - D3DXVec3Dot(&m_attribute.v3Normal, &vv)/d;
|
||||
|
||||
//D3DXVECTOR3 onplane = s.v3Position+t*advance;
|
||||
|
||||
if (D3DXVec3Dot(&m_attribute.v3Normal, &advance)>=0)
|
||||
{
|
||||
//return m_attribute.v3Normal*((-s.fRadius+D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position)))*gc_fReduceMove);
|
||||
return t*advance -s.fRadius*m_attribute.v3Normal;
|
||||
}
|
||||
else
|
||||
{
|
||||
//return m_attribute.v3Normal*((s.fRadius+D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position)))*gc_fReduceMove);
|
||||
return t*advance +s.fRadius*m_attribute.v3Normal;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*if (D3DXVec3Dot(&m_attribute.v3Normal, &advance)>=0)
|
||||
{
|
||||
Tracef("%f %f\n",s.fRadius,-(D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position))));
|
||||
return m_attribute.v3Normal*((-s.fRadius+D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position)))*gc_fReduceMove);
|
||||
}
|
||||
else
|
||||
{
|
||||
Tracef("%f %f\n",(s.fRadius),(D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position))));
|
||||
return m_attribute.v3Normal*((s.fRadius+D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position-m_attribute.v3Position)))*gc_fReduceMove);
|
||||
}*/
|
||||
|
||||
|
||||
/*
|
||||
D3DXVECTOR3 advance = s.v3Position-s.v3LastPosition;
|
||||
D3DXVECTOR3 slide(-advance.y,advance.x,advance.z);
|
||||
slide = m_attribute.v3Normal;
|
||||
|
||||
D3DXVECTOR3 radius_adjust = advance;
|
||||
D3DXVec3Normalize(&radius_adjust,&radius_adjust);
|
||||
radius_adjust*=s.fRadius;
|
||||
|
||||
float d = D3DXVec3Dot(&m_attribute.v3Normal, &slide);
|
||||
if (d>=-0.0001 && d<=0.0001)
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
|
||||
float t= - D3DXVec3Dot(&m_attribute.v3Normal, &(s.v3Position+radius_adjust-m_attribute.v3Position))
|
||||
/ d;*/
|
||||
|
||||
//D3DXVECTOR3 nextposition;
|
||||
//nextposition = s.v3Position + t*slide;
|
||||
//Tracef("$T %f",t);
|
||||
//if (D3DXVec3Dot(&m_attribute.v3Normal, &advance)>=0)
|
||||
// return (t*slide - m_attribute.v3Normal * s.fRadius)/**gc_fReduceMove*/;
|
||||
//else
|
||||
// return (t*slide + m_attribute.v3Normal * s.fRadius)/*gc_fReduceMove*/;
|
||||
//if (D3DXVec3Dot(&m_attribute.v3Normal, &advance)>=0)
|
||||
// return (t*slide + m_attribute.v3Normal * D3DXVec3Dot(&m_attribute.v3Normal,&(s.v3LastPosition-m_attribute.v3Position))/** s.fRadius*/)*gc_fReduceMove;
|
||||
//else
|
||||
// return (t*slide + m_attribute.v3Normal * D3DXVec3Dot(&m_attribute.v3Normal,&(s.v3LastPosition-m_attribute.v3Position))/*s.fRadius*/)*gc_fReduceMove;
|
||||
//
|
||||
}
|
||||
|
||||
void CPlaneCollisionInstance::Render(D3DFILLMODE /*d3dFillMode*/)
|
||||
{
|
||||
static CScreen s;
|
||||
s.RenderBar3d(m_attribute.v3QuadPosition);
|
||||
}
|
||||
|
||||
void CPlaneCollisionInstance::OnDestroy()
|
||||
{
|
||||
gs_pci.Free(this);
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// Cylinder
|
||||
TCylinderData & CCylinderCollisionInstance::GetAttribute()
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
const TCylinderData & CCylinderCollisionInstance::GetAttribute() const
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
bool CCylinderCollisionInstance::CollideCylinderVSDynamicSphere(const TCylinderData & c_rattribute, const CDynamicSphereInstance & s) const
|
||||
{
|
||||
if (s.v3Position.z + s.fRadius < c_rattribute.v3Position.z)
|
||||
return false;
|
||||
|
||||
if (s.v3Position.z - s.fRadius > c_rattribute.v3Position.z + c_rattribute.fHeight)
|
||||
return false;
|
||||
|
||||
/*D3DXVECTOR2 v2curDistance(s.v3Position.x - c_rattribute.v3Position.x, s.v3Position.y - c_rattribute.v3Position.y);
|
||||
float fDistance = D3DXVec2Length(&v2curDistance);
|
||||
if (fDistance <= s.fRadius + c_rattribute.fRadius)
|
||||
return true;
|
||||
*/
|
||||
|
||||
D3DXVECTOR3 oa, ob;
|
||||
IntersectLineSegments(c_rattribute.v3Position, D3DXVECTOR3(c_rattribute.v3Position.x,c_rattribute.v3Position.y,c_rattribute.v3Position.z+c_rattribute.fHeight), s.v3LastPosition, s.v3Position, oa, ob);
|
||||
const auto vv = (oa - ob);
|
||||
return (D3DXVec3LengthSq(&vv)<=(c_rattribute.fRadius+s.fRadius)*(c_rattribute.fRadius+s.fRadius));
|
||||
}
|
||||
|
||||
bool CCylinderCollisionInstance::OnMovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
if (CollideCylinderVSDynamicSphere(m_attribute, s))
|
||||
{
|
||||
// NOTE : 거리가 가까워 졌을때만.. - [levites]
|
||||
if (GetVector3Distance(s.v3Position, m_attribute.v3Position) <
|
||||
GetVector3Distance(s.v3LastPosition, m_attribute.v3Position))
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// NOTE : 이동 거리가 클 경우 빈틈없이 (원 크기 단위로) 이동하면서 전부 체크 해 본다 - [levites]
|
||||
D3DXVECTOR3 v3Distance = s.v3Position - s.v3LastPosition;
|
||||
float fDistance = D3DXVec3Length(&v3Distance);
|
||||
if (s.fRadius<=0.0001f)
|
||||
return false;
|
||||
if (fDistance >= s.fRadius*2.0f)
|
||||
{
|
||||
TCylinderData cylinder;
|
||||
cylinder = m_attribute;
|
||||
cylinder.v3Position = s.v3LastPosition;
|
||||
|
||||
int iStep = fDistance / s.fRadius*2.0f;
|
||||
D3DXVECTOR3 v3Step = v3Distance / float(iStep);
|
||||
|
||||
for (int i = 0; i < iStep; ++i)
|
||||
{
|
||||
cylinder.v3Position += v3Step;
|
||||
if (CollideCylinderVSDynamicSphere(cylinder, s))
|
||||
return true;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CCylinderCollisionInstance::OnCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
//Tracef("OnCollisionDynamicSphere\n");
|
||||
|
||||
return (CollideCylinderVSDynamicSphere(m_attribute, s));
|
||||
}
|
||||
|
||||
D3DXVECTOR3 CCylinderCollisionInstance::OnGetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 v3Position = m_attribute.v3Position;
|
||||
v3Position.z = s.v3Position.z;
|
||||
const auto vv = (s.v3Position - v3Position);
|
||||
if (D3DXVec3LengthSq(&vv)>=(s.fRadius+m_attribute.fRadius)*(m_attribute.fRadius+s.fRadius))
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
D3DXVECTOR3 c;
|
||||
D3DXVECTOR3 advance = s.v3Position - s.v3LastPosition;
|
||||
advance.z = 0;
|
||||
const auto vssa = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
|
||||
D3DXVec3Cross(&c, &advance, &vssa);
|
||||
|
||||
const auto svsvs = (s.v3Position - v3Position);
|
||||
float sum = - D3DXVec3Dot(&c,&svsvs);
|
||||
float mul = (s.fRadius+m_attribute.fRadius)*(s.fRadius+m_attribute.fRadius)-D3DXVec3LengthSq(&svsvs);
|
||||
|
||||
if (sum*sum-4*mul<=0)
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
float sq = sqrt(sum*sum-4*mul);
|
||||
float t1=-sum-sq, t2=-sum+sq;
|
||||
t1*=0.5f;
|
||||
t2*=0.5f;
|
||||
|
||||
|
||||
if (fabs(t1)<=fabs(t2))
|
||||
{
|
||||
return (gc_fReduceMove*t1)*c;
|
||||
}
|
||||
else
|
||||
return (gc_fReduceMove*t2)*c;
|
||||
|
||||
/*D3DXVECTOR3 p1 = s.v3Position+t1*c;
|
||||
D3DXVECTOR3 p2 = s.v3Position+t2*c;
|
||||
|
||||
if (D3DXVec3LengthSq(&(p2-s.v3Position))>D3DXVec3LengthSq(&(p1-s.v3Position)))
|
||||
{
|
||||
return p1-s.v3Position;
|
||||
}
|
||||
else
|
||||
{
|
||||
return p2-s.v3Position;
|
||||
}*/
|
||||
}
|
||||
|
||||
void CCylinderCollisionInstance::Render(D3DFILLMODE d3dFillMode)
|
||||
{
|
||||
static CScreen s;
|
||||
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, 0xffffffff);
|
||||
s.RenderCylinder(NULL, m_attribute.v3Position.x, m_attribute.v3Position.y, m_attribute.v3Position.z+m_attribute.fHeight/2, m_attribute.fRadius, m_attribute.fHeight, d3dFillMode);
|
||||
}
|
||||
|
||||
void CCylinderCollisionInstance::OnDestroy()
|
||||
{
|
||||
gs_cci.Free(this);
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// AABB (Aligned Axis Bounding Box)
|
||||
TAABBData & CAABBCollisionInstance::GetAttribute()
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
const TAABBData & CAABBCollisionInstance::GetAttribute() const
|
||||
{
|
||||
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
bool CAABBCollisionInstance::OnMovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 v;
|
||||
D3DXVECTOR3 v3center = (m_attribute.v3Min + m_attribute.v3Max) * 0.5f;
|
||||
|
||||
memcpy(&v, &s.v3Position, sizeof(D3DXVECTOR3));
|
||||
|
||||
if(v.x < m_attribute.v3Min.x) v.x = m_attribute.v3Min.x;
|
||||
if(v.x > m_attribute.v3Max.x) v.x = m_attribute.v3Max.x;
|
||||
if(v.y < m_attribute.v3Min.y) v.x = m_attribute.v3Min.y;
|
||||
if(v.y > m_attribute.v3Max.y) v.x = m_attribute.v3Max.y;
|
||||
if(v.z < m_attribute.v3Min.z) v.z = m_attribute.v3Min.z;
|
||||
if(v.z > m_attribute.v3Max.z) v.z = m_attribute.v3Max.z;
|
||||
|
||||
if(GetVector3Distance(v, s.v3Position) <= s.fRadius * s.fRadius)
|
||||
{
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
memcpy(&v, &s.v3LastPosition, sizeof(D3DXVECTOR3));
|
||||
|
||||
if(v.x < m_attribute.v3Min.x) v.x = m_attribute.v3Min.x;
|
||||
if(v.x > m_attribute.v3Max.x) v.x = m_attribute.v3Max.x;
|
||||
if(v.y < m_attribute.v3Min.y) v.x = m_attribute.v3Min.y;
|
||||
if(v.y > m_attribute.v3Max.y) v.x = m_attribute.v3Max.y;
|
||||
if(v.z < m_attribute.v3Min.z) v.z = m_attribute.v3Min.z;
|
||||
if(v.z > m_attribute.v3Max.z) v.z = m_attribute.v3Max.z;
|
||||
|
||||
if(GetVector3Distance(v, s.v3LastPosition) <= s.fRadius * s.fRadius)
|
||||
{
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CAABBCollisionInstance::OnCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 v;
|
||||
memcpy(&v, &s.v3Position, sizeof(D3DXVECTOR3));
|
||||
|
||||
if(v.x < m_attribute.v3Min.x) v.x = m_attribute.v3Min.x;
|
||||
if(v.x > m_attribute.v3Max.x) v.x = m_attribute.v3Max.x;
|
||||
if(v.y < m_attribute.v3Min.y) v.x = m_attribute.v3Min.y;
|
||||
if(v.y > m_attribute.v3Max.y) v.x = m_attribute.v3Max.y;
|
||||
if(v.z < m_attribute.v3Min.z) v.z = m_attribute.v3Min.z;
|
||||
if(v.z > m_attribute.v3Max.z) v.z = m_attribute.v3Max.z;
|
||||
|
||||
if(v.x > m_attribute.v3Min.x && v.x < m_attribute.v3Max.x &&
|
||||
v.y > m_attribute.v3Min.y && v.y < m_attribute.v3Max.y &&
|
||||
v.z > m_attribute.v3Min.z && v.z < m_attribute.v3Max.z) { return true; }
|
||||
|
||||
if(GetVector3Distance(v, s.v3Position) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
|
||||
memcpy(&v, &s.v3LastPosition, sizeof(D3DXVECTOR3));
|
||||
|
||||
if(v.x < m_attribute.v3Min.x) v.x = m_attribute.v3Min.x;
|
||||
if(v.x > m_attribute.v3Max.x) v.x = m_attribute.v3Max.x;
|
||||
if(v.y < m_attribute.v3Min.y) v.x = m_attribute.v3Min.y;
|
||||
if(v.y > m_attribute.v3Max.y) v.x = m_attribute.v3Max.y;
|
||||
if(v.z < m_attribute.v3Min.z) v.z = m_attribute.v3Min.z;
|
||||
if(v.z > m_attribute.v3Max.z) v.z = m_attribute.v3Max.z;
|
||||
|
||||
|
||||
|
||||
if(v.x > m_attribute.v3Min.x && v.x < m_attribute.v3Max.x &&
|
||||
v.y > m_attribute.v3Min.y && v.y < m_attribute.v3Max.y &&
|
||||
v.z > m_attribute.v3Min.z && v.z < m_attribute.v3Max.z) { return true; }
|
||||
|
||||
if(GetVector3Distance(v, s.v3LastPosition) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 CAABBCollisionInstance::OnGetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
|
||||
//Tracef("OnGetCollisionMovementAdjust v3Min.x = %f, v3Max.x = %f\n", m_attribute.v3Min.x, m_attribute.v3Max.x);
|
||||
/*
|
||||
float fARadius = D3DXVec3Length(&(m_attribute.v3Min - m_attribute.v3Max));
|
||||
if (D3DXVec3LengthSq(&(s.v3Position-(m_attribute.v3Max + m_attribute.v3Min)))>=(s.fRadius+fARadius)*(fARadius+s.fRadius))
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
D3DXVECTOR3 c;
|
||||
D3DXVec3Cross(&c, &(s.v3Position-s.v3LastPosition), &D3DXVECTOR3(0.0f,0.0f,1.0f) );
|
||||
|
||||
float sum = - D3DXVec3Dot(&c,&(s.v3Position-(m_attribute.v3Max + m_attribute.v3Min)));
|
||||
float mul = (s.fRadius+fARadius)*(s.fRadius+fARadius)-D3DXVec3LengthSq(&(s.v3Position-(m_attribute.v3Max + m_attribute.v3Min)));
|
||||
|
||||
if (sum*sum-4*mul<=0)
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
float sq = sqrt(sum*sum-4*mul);
|
||||
float t1=-sum-sq, t2=-sum+sq;
|
||||
t1*=0.5f;
|
||||
t2*=0.5f;
|
||||
|
||||
if (fabs(t1)<=fabs(t2))
|
||||
{
|
||||
return (gc_fReduceMove*t1)*c;
|
||||
}
|
||||
else
|
||||
return (gc_fReduceMove*t2)*c;
|
||||
*/
|
||||
|
||||
D3DXVECTOR3 v3Temp;
|
||||
if(s.v3Position.x + s.fRadius <= m_attribute.v3Min.x) { v3Temp.x = m_attribute.v3Min.x; }
|
||||
else if(s.v3Position.x - s.fRadius >= m_attribute.v3Max.x) { v3Temp.x = m_attribute.v3Max.x; }
|
||||
else if(s.v3Position.x + s.fRadius >= m_attribute.v3Min.x && s.v3Position.x + s.fRadius <= m_attribute.v3Max.x) { v3Temp.x = s.v3Position.x + s.fRadius; }
|
||||
else { v3Temp.x = s.v3Position.x - s.fRadius; }
|
||||
|
||||
if(s.v3Position.y + s.fRadius <= m_attribute.v3Min.y) { v3Temp.y = m_attribute.v3Min.y; }
|
||||
else if(s.v3Position.y - s.fRadius >= m_attribute.v3Max.y) { v3Temp.y = m_attribute.v3Max.y; }
|
||||
else if(s.v3Position.y + s.fRadius >= m_attribute.v3Min.y && s.v3Position.y + s.fRadius <= m_attribute.v3Max.y) { v3Temp.y = s.v3Position.y + s.fRadius; }
|
||||
else { v3Temp.y = s.v3Position.y - s.fRadius; }
|
||||
|
||||
if(s.v3Position.z + s.fRadius <= m_attribute.v3Min.z) { v3Temp.z = m_attribute.v3Min.z; }
|
||||
else if(s.v3Position.z - s.fRadius >= m_attribute.v3Max.z) { v3Temp.z = m_attribute.v3Max.z; }
|
||||
else if(s.v3Position.z + s.fRadius >= m_attribute.v3Min.z && s.v3Position.z + s.fRadius <= m_attribute.v3Max.z) { v3Temp.z = s.v3Position.z + s.fRadius; }
|
||||
else { v3Temp.z = s.v3Position.z - s.fRadius; }
|
||||
|
||||
|
||||
const auto vv = (v3Temp - s.v3Position);
|
||||
if(D3DXVec3LengthSq(&vv) < s.fRadius * s.fRadius)
|
||||
return D3DXVECTOR3(.0f, .0f, .0f);
|
||||
|
||||
return D3DXVECTOR3(.0f, .0f, .0f);
|
||||
|
||||
}
|
||||
|
||||
void CAABBCollisionInstance::Render(D3DFILLMODE d3dFillMode)
|
||||
{
|
||||
static CScreen s;
|
||||
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, 0xffffffff);
|
||||
s.RenderCube(m_attribute.v3Min.x, m_attribute.v3Min.y, m_attribute.v3Min.z, m_attribute.v3Max.x, m_attribute.v3Max.y, m_attribute.v3Max.z);
|
||||
return;
|
||||
}
|
||||
|
||||
void CAABBCollisionInstance::OnDestroy()
|
||||
{
|
||||
gs_aci.Free(this);
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// OBB
|
||||
|
||||
TOBBData & COBBCollisionInstance::GetAttribute()
|
||||
{
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
const TOBBData & COBBCollisionInstance::GetAttribute() const
|
||||
{
|
||||
|
||||
return m_attribute;
|
||||
}
|
||||
|
||||
bool COBBCollisionInstance::OnMovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
D3DXVECTOR3 v3Center = 0.5f * (m_attribute.v3Min + m_attribute.v3Max);
|
||||
D3DXVECTOR3 v3Sphere = s.v3Position - v3Center;
|
||||
D3DXVec3TransformCoord(&v3Sphere, &v3Sphere, &m_attribute.matRot);
|
||||
v3Sphere = v3Sphere + v3Center;
|
||||
|
||||
D3DXVECTOR3 v3Point = v3Sphere;
|
||||
if(v3Point.x < m_attribute.v3Min.x) { v3Point.x = m_attribute.v3Min.x; }
|
||||
if(v3Point.x > m_attribute.v3Max.x) { v3Point.x = m_attribute.v3Max.x; }
|
||||
if(v3Point.y < m_attribute.v3Min.y) { v3Point.y = m_attribute.v3Min.y; }
|
||||
if(v3Point.y > m_attribute.v3Max.y) { v3Point.y = m_attribute.v3Max.y; }
|
||||
if(v3Point.z < m_attribute.v3Min.z) { v3Point.z = m_attribute.v3Min.z; }
|
||||
if(v3Point.z > m_attribute.v3Max.z) { v3Point.z = m_attribute.v3Max.z; }
|
||||
|
||||
if(GetVector3Distance(v3Point, v3Sphere) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
v3Sphere = s.v3LastPosition - v3Center;
|
||||
D3DXVec3TransformCoord(&v3Sphere, &v3Sphere, &m_attribute.matRot);
|
||||
v3Sphere = v3Sphere + v3Center;
|
||||
|
||||
v3Point = v3Sphere;
|
||||
if(v3Point.x < m_attribute.v3Min.x) { v3Point.x = m_attribute.v3Min.x; }
|
||||
if(v3Point.x > m_attribute.v3Max.x) { v3Point.x = m_attribute.v3Max.x; }
|
||||
if(v3Point.y < m_attribute.v3Min.y) { v3Point.y = m_attribute.v3Min.y; }
|
||||
if(v3Point.y > m_attribute.v3Max.y) { v3Point.y = m_attribute.v3Max.y; }
|
||||
if(v3Point.z < m_attribute.v3Min.z) { v3Point.z = m_attribute.v3Min.z; }
|
||||
if(v3Point.z > m_attribute.v3Max.z) { v3Point.z = m_attribute.v3Max.z; }
|
||||
|
||||
if(GetVector3Distance(v3Point, v3Sphere) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool COBBCollisionInstance::OnCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
|
||||
D3DXVECTOR3 v3Center = 0.5f * (m_attribute.v3Min + m_attribute.v3Max);
|
||||
D3DXVECTOR3 v3Sphere = s.v3Position - v3Center;
|
||||
D3DXVec3TransformCoord(&v3Sphere, &v3Sphere, &m_attribute.matRot);
|
||||
v3Sphere = v3Sphere + v3Center;
|
||||
|
||||
D3DXVECTOR3 v3Point = v3Sphere;
|
||||
if(v3Point.x < m_attribute.v3Min.x) { v3Point.x = m_attribute.v3Min.x; }
|
||||
if(v3Point.x > m_attribute.v3Max.x) { v3Point.x = m_attribute.v3Max.x; }
|
||||
if(v3Point.y < m_attribute.v3Min.y) { v3Point.y = m_attribute.v3Min.y; }
|
||||
if(v3Point.y > m_attribute.v3Max.y) { v3Point.y = m_attribute.v3Max.y; }
|
||||
if(v3Point.z < m_attribute.v3Min.z) { v3Point.z = m_attribute.v3Min.z; }
|
||||
if(v3Point.z > m_attribute.v3Max.z) { v3Point.z = m_attribute.v3Max.z; }
|
||||
|
||||
if(GetVector3Distance(v3Point, v3Sphere) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
v3Sphere = s.v3LastPosition - v3Center;
|
||||
D3DXVec3TransformCoord(&v3Sphere, &v3Sphere, &m_attribute.matRot);
|
||||
v3Sphere = v3Sphere + v3Center;
|
||||
|
||||
v3Point = v3Sphere;
|
||||
if(v3Point.x < m_attribute.v3Min.x) { v3Point.x = m_attribute.v3Min.x; }
|
||||
if(v3Point.x > m_attribute.v3Max.x) { v3Point.x = m_attribute.v3Max.x; }
|
||||
if(v3Point.y < m_attribute.v3Min.y) { v3Point.y = m_attribute.v3Min.y; }
|
||||
if(v3Point.y > m_attribute.v3Max.y) { v3Point.y = m_attribute.v3Max.y; }
|
||||
if(v3Point.z < m_attribute.v3Min.z) { v3Point.z = m_attribute.v3Min.z; }
|
||||
if(v3Point.z > m_attribute.v3Max.z) { v3Point.z = m_attribute.v3Max.z; }
|
||||
|
||||
if(GetVector3Distance(v3Point, v3Sphere) <= s.fRadius * s.fRadius) { return true; }
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 COBBCollisionInstance::OnGetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
|
||||
return D3DXVECTOR3(.0f, .0f, .0f);
|
||||
|
||||
}
|
||||
|
||||
void COBBCollisionInstance::Render(D3DFILLMODE d3dFillMode)
|
||||
{
|
||||
static CScreen s;
|
||||
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, 0xffffffff);
|
||||
s.RenderCube(m_attribute.v3Min.x, m_attribute.v3Min.y, m_attribute.v3Min.z, m_attribute.v3Max.x, m_attribute.v3Max.y, m_attribute.v3Max.z, m_attribute.matRot);
|
||||
return;
|
||||
}
|
||||
|
||||
void COBBCollisionInstance::OnDestroy()
|
||||
{
|
||||
gs_oci.Free(this);
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
#include "StdAfx.h"
|
||||
#include "GrpCollisionObject.h"
|
||||
|
||||
bool CGraphicCollisionObject::IntersectBoundBox(const D3DXMATRIX* c_pmatWorld, const TBoundBox& c_rboundBox, float* pu, float* pv, float* pt)
|
||||
{
|
||||
return IntersectCube(c_pmatWorld, c_rboundBox.sx, c_rboundBox.sy, c_rboundBox.sz, c_rboundBox.ex, c_rboundBox.ey, c_rboundBox.ez, ms_vtPickRayOrig, ms_vtPickRayDir, pu, pv, pt);
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectCube(const D3DXMATRIX* c_pmatWorld, float sx, float sy, float sz, float ex, float ey, float ez,
|
||||
D3DXVECTOR3 & RayOriginal, D3DXVECTOR3 & RayDirection, float* pu, float* pv, float* pt)
|
||||
{
|
||||
TPosition posVertices[8];
|
||||
|
||||
posVertices[0] = TPosition(sx, sy, sz);
|
||||
posVertices[1] = TPosition(ex, sy, sz);
|
||||
posVertices[2] = TPosition(sx, ey, sz);
|
||||
posVertices[3] = TPosition(ex, ey, sz);
|
||||
posVertices[4] = TPosition(sx, sy, ez);
|
||||
posVertices[5] = TPosition(ex, sy, ez);
|
||||
posVertices[6] = TPosition(sx, ey, ez);
|
||||
posVertices[7] = TPosition(ex, ey, ez);
|
||||
|
||||
static const WORD c_awFillCubeIndices[36] = {
|
||||
0, 1, 2, 1, 3, 2,
|
||||
2, 0, 6, 0, 4, 6,
|
||||
0, 1, 4, 1, 5, 4,
|
||||
1, 3, 5, 3, 7, 5,
|
||||
3, 2, 7, 2, 6, 7,
|
||||
4, 5, 6, 5, 7, 6,
|
||||
};
|
||||
|
||||
return IntersectIndexedMesh(
|
||||
c_pmatWorld,
|
||||
posVertices,
|
||||
sizeof(TPosition),
|
||||
8,
|
||||
c_awFillCubeIndices,
|
||||
36,
|
||||
RayOriginal,
|
||||
RayDirection,
|
||||
pu,
|
||||
pv,
|
||||
pt
|
||||
);
|
||||
}
|
||||
|
||||
const int c_iLimitVertexCount = 1024;
|
||||
|
||||
bool CGraphicCollisionObject::IntersectIndexedMesh(const D3DXMATRIX* c_pmatWorld, const void* vertices, int step, int vtxCount, const void* indices, int idxCount,
|
||||
D3DXVECTOR3 & RayOriginal, D3DXVECTOR3 & RayDirection, float* pu, float* pv, float* pt)
|
||||
{
|
||||
static D3DXVECTOR3 s_v3PositionArray[c_iLimitVertexCount];
|
||||
static DWORD s_dwPositionCount;
|
||||
|
||||
if (vtxCount > c_iLimitVertexCount)
|
||||
{
|
||||
Tracef("The vertex count of mesh which is worked collision detection is too much : %d / %d", vtxCount, c_iLimitVertexCount);
|
||||
return false;
|
||||
}
|
||||
|
||||
s_dwPositionCount = 0;
|
||||
|
||||
char* pcurVtx = (char*)vertices;
|
||||
|
||||
while (vtxCount--)
|
||||
{
|
||||
float* pos = (float*)pcurVtx;
|
||||
|
||||
D3DXVec3TransformCoord(&s_v3PositionArray[s_dwPositionCount++], (D3DXVECTOR3*)pos, c_pmatWorld);
|
||||
|
||||
pcurVtx += step;
|
||||
}
|
||||
|
||||
WORD* pcurIdx = (WORD*)indices;
|
||||
|
||||
int triCount = idxCount / 3;
|
||||
while (triCount--)
|
||||
{
|
||||
if (IntersectTriangle(RayOriginal, RayDirection,
|
||||
s_v3PositionArray[pcurIdx[0]],
|
||||
s_v3PositionArray[pcurIdx[1]],
|
||||
s_v3PositionArray[pcurIdx[2]],
|
||||
pu, pv, pt))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
pcurIdx += 3;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectMesh(const D3DXMATRIX * c_pmatWorld, const void * vertices, DWORD dwStep, DWORD dwvtxCount, D3DXVECTOR3 & RayOriginal, D3DXVECTOR3 & RayDirection, float* pu, float* pv, float* pt)
|
||||
{
|
||||
char * pcurVtx = (char *) vertices;
|
||||
|
||||
D3DXVECTOR3 v3Vertex[3];
|
||||
|
||||
for (DWORD i = 0; i < dwvtxCount; i += 3)
|
||||
{
|
||||
D3DXVec3TransformCoord(&v3Vertex[0], (D3DXVECTOR3*)pcurVtx, c_pmatWorld);
|
||||
pcurVtx += dwStep;
|
||||
|
||||
D3DXVec3TransformCoord(&v3Vertex[1], (D3DXVECTOR3*)pcurVtx, c_pmatWorld);
|
||||
pcurVtx += dwStep;
|
||||
|
||||
D3DXVec3TransformCoord(&v3Vertex[2], (D3DXVECTOR3*)pcurVtx, c_pmatWorld);
|
||||
pcurVtx += dwStep;
|
||||
|
||||
if (IntersectTriangle(RayOriginal, RayDirection,
|
||||
v3Vertex[0], v3Vertex[1], v3Vertex[2],
|
||||
pu, pv, pt))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectTriangle(const D3DXVECTOR3& c_orig,
|
||||
const D3DXVECTOR3& c_dir,
|
||||
const D3DXVECTOR3& c_v0,
|
||||
const D3DXVECTOR3& c_v1,
|
||||
const D3DXVECTOR3& c_v2,
|
||||
float * pu,
|
||||
float * pv,
|
||||
float * pt)
|
||||
{
|
||||
D3DXVECTOR3 edge1 = c_v1 - c_v0;
|
||||
D3DXVECTOR3 edge2 = c_v2 - c_v0;
|
||||
D3DXVECTOR3 pvec;
|
||||
D3DXVec3Cross(&pvec, &c_dir, &edge2);
|
||||
|
||||
FLOAT det = D3DXVec3Dot(&edge1, &pvec);
|
||||
D3DXVECTOR3 tvec;
|
||||
|
||||
if (det > 0)
|
||||
{
|
||||
tvec = c_orig - c_v0;
|
||||
}
|
||||
else
|
||||
{
|
||||
tvec = c_v0 - c_orig;
|
||||
det = -det;
|
||||
}
|
||||
|
||||
if (det < 0.0001f)
|
||||
return false;
|
||||
|
||||
float u, v, t;
|
||||
u = D3DXVec3Dot(&tvec, &pvec);
|
||||
if (u < 0.0f || u > det)
|
||||
return false;
|
||||
|
||||
D3DXVECTOR3 qvec;
|
||||
D3DXVec3Cross(&qvec, &tvec, &edge1);
|
||||
|
||||
v = D3DXVec3Dot(&c_dir, &qvec);
|
||||
if (v < 0.0f || u + v > det)
|
||||
return false;
|
||||
|
||||
t = D3DXVec3Dot(&edge2, &qvec);
|
||||
FLOAT fInvDet = 1.0f / det;
|
||||
t *= fInvDet;
|
||||
u *= fInvDet;
|
||||
v *= fInvDet;
|
||||
|
||||
D3DXVECTOR3 spot = edge1 * u + edge2 * v;
|
||||
spot += c_v0;
|
||||
|
||||
*pu = spot.x;
|
||||
*pv = spot.y;
|
||||
*pt = t;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectSphere(const D3DXVECTOR3 & c_rv3Position, float fRadius, const D3DXVECTOR3 & c_rv3RayOriginal, const D3DXVECTOR3 & c_rv3RayDirection)
|
||||
{
|
||||
D3DXVECTOR3 v3RayOriginal = c_rv3RayOriginal - c_rv3Position;
|
||||
|
||||
float a = D3DXVec3Dot(&c_rv3RayDirection, &c_rv3RayDirection);
|
||||
float b = 2 * D3DXVec3Dot(&v3RayOriginal, &c_rv3RayDirection);
|
||||
float c = D3DXVec3Dot(&v3RayOriginal, &v3RayOriginal) - fRadius * fRadius;
|
||||
|
||||
float D = b * b - 4 * a * c;
|
||||
|
||||
if (D >= 0)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectCylinder(const D3DXVECTOR3 & c_rv3Position, float fRadius, float fHeight, const D3DXVECTOR3 & c_rv3RayOriginal, const D3DXVECTOR3 & c_rv3RayDirection)
|
||||
{
|
||||
D3DXVECTOR3 v3RayOriginal = c_rv3RayOriginal - c_rv3Position;
|
||||
|
||||
float a = c_rv3RayDirection.x * c_rv3RayDirection.x + c_rv3RayDirection.y * c_rv3RayDirection.y;
|
||||
float b = 2 * (v3RayOriginal.x * c_rv3RayDirection.x + v3RayOriginal.y * c_rv3RayDirection.y);
|
||||
float c = v3RayOriginal.x * v3RayOriginal.x + v3RayOriginal.y * v3RayOriginal.y - fRadius*fRadius;
|
||||
|
||||
float D = b * b - 4 * a * c;
|
||||
if (D > 0)
|
||||
if (0.0f != a)
|
||||
{
|
||||
float tPlus = (-b + sqrtf(D)) / (2 * a);
|
||||
float tMinus = (-b - sqrtf(D)) / (2 * a);
|
||||
float fzPlus = v3RayOriginal.z + tPlus * c_rv3RayDirection.z;
|
||||
float fzMinus = v3RayOriginal.z + tMinus * c_rv3RayDirection.z;
|
||||
|
||||
if (fzPlus > 0.0f && fzPlus <= fHeight)
|
||||
return true;
|
||||
if (fzMinus > 0.0f && fzMinus <= fHeight)
|
||||
return true;
|
||||
if (fzMinus * fzPlus < 0.0f)
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectSphere(const D3DXVECTOR3 & c_rv3Position, float fRadius)
|
||||
{
|
||||
return CGraphicCollisionObject::IntersectSphere(c_rv3Position, fRadius, ms_vtPickRayOrig, ms_vtPickRayDir);
|
||||
}
|
||||
|
||||
bool CGraphicCollisionObject::IntersectCylinder(const D3DXVECTOR3 & c_rv3Position, float fRadius, float fHeight)
|
||||
{
|
||||
return CGraphicCollisionObject::IntersectCylinder(c_rv3Position, fRadius, fHeight, ms_vtPickRayOrig, ms_vtPickRayDir);
|
||||
}
|
||||
|
||||
CGraphicCollisionObject::CGraphicCollisionObject()
|
||||
{
|
||||
}
|
||||
|
||||
CGraphicCollisionObject::~CGraphicCollisionObject()
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,441 @@
|
||||
#include "StdAfx.h"
|
||||
#include "GrpObjectInstance.h"
|
||||
#include "../EterBase/Timer.h"
|
||||
|
||||
void CGraphicObjectInstance::OnInitialize()
|
||||
{
|
||||
ZeroMemory(m_abyPortalID, sizeof(m_abyPortalID));
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Clear()
|
||||
{
|
||||
if (m_CullingHandle)
|
||||
{
|
||||
CCullingManager::Instance().Unregister(m_CullingHandle);
|
||||
m_CullingHandle = NULL;
|
||||
}
|
||||
|
||||
ClearHeightInstance();
|
||||
|
||||
m_isVisible = TRUE;
|
||||
|
||||
m_v3Position.x = m_v3Position.y = m_v3Position.z = 0.0f;
|
||||
m_v3Scale.x = m_v3Scale.y = m_v3Scale.z = 0.0f;
|
||||
//m_fRotation = 0.0f;
|
||||
m_fYaw = m_fPitch = m_fRoll = 0.0f;
|
||||
D3DXMatrixIdentity(&m_worldMatrix);
|
||||
|
||||
ZeroMemory(m_abyPortalID, sizeof(m_abyPortalID));
|
||||
|
||||
OnClear();
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::Render()
|
||||
{
|
||||
/*
|
||||
if (m_CullingHandle)
|
||||
{
|
||||
SpherePack * ps = m_CullingHandle->GetParent();
|
||||
CScreen s;
|
||||
s.SetColorOperation();
|
||||
//s.SetDiffuseColor(1,isShow()?1:0,0);
|
||||
//s.RenderCircle2d(m_CullingHandle->GetCenter().x,m_CullingHandle->GetCenter().y,m_CullingHandle->GetCenter().z,m_CullingHandle->GetRadius());
|
||||
s.SetDiffuseColor(1,isShow()?1:0,ps->HasSpherePackFlag(SPF_PARTIAL)?1:0);
|
||||
s.RenderCircle2d(ps->GetCenter().x,ps->GetCenter().y,ps->GetCenter().z,ps->GetRadius());
|
||||
}
|
||||
//*/
|
||||
if (!isShow())
|
||||
return false;
|
||||
|
||||
OnRender();
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::BlendRender()
|
||||
{
|
||||
if (!isShow())
|
||||
return;
|
||||
|
||||
OnBlendRender();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::RenderToShadowMap()
|
||||
{
|
||||
if (!isShow())
|
||||
return;
|
||||
|
||||
OnRenderToShadowMap();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::RenderShadow()
|
||||
{
|
||||
if (!isShow())
|
||||
return;
|
||||
|
||||
OnRenderShadow();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::RenderPCBlocker()
|
||||
{
|
||||
if (!isShow())
|
||||
return;
|
||||
|
||||
OnRenderPCBlocker();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Update()
|
||||
{
|
||||
OnUpdate();
|
||||
|
||||
UpdateBoundingSphere();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Deform()
|
||||
{
|
||||
if (!isShow())
|
||||
return;
|
||||
|
||||
OnDeform();
|
||||
}
|
||||
|
||||
|
||||
void CGraphicObjectInstance::Transform()
|
||||
{
|
||||
m_worldMatrix = m_mRotation;
|
||||
|
||||
m_worldMatrix._41 += m_v3Position.x;
|
||||
m_worldMatrix._42 += m_v3Position.y;
|
||||
m_worldMatrix._43 += m_v3Position.z;
|
||||
}
|
||||
|
||||
const D3DXVECTOR3 & CGraphicObjectInstance::GetPosition() const
|
||||
{
|
||||
return m_v3Position;
|
||||
}
|
||||
|
||||
const D3DXVECTOR3 & CGraphicObjectInstance::GetScale() const
|
||||
{
|
||||
return m_v3Scale;
|
||||
}
|
||||
|
||||
float CGraphicObjectInstance::GetRotation()
|
||||
{
|
||||
return GetRoll();
|
||||
}
|
||||
|
||||
float CGraphicObjectInstance::GetYaw()
|
||||
{
|
||||
return m_fYaw;
|
||||
}
|
||||
|
||||
float CGraphicObjectInstance::GetPitch()
|
||||
{
|
||||
return m_fPitch;
|
||||
}
|
||||
|
||||
float CGraphicObjectInstance::GetRoll()
|
||||
{
|
||||
return m_fRoll;
|
||||
}
|
||||
|
||||
D3DXMATRIX & CGraphicObjectInstance::GetTransform()
|
||||
{
|
||||
return m_worldMatrix;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetRotationQuaternion(const D3DXQUATERNION &q)
|
||||
{
|
||||
D3DXMatrixRotationQuaternion(&m_mRotation, &q);
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetRotationMatrix(const D3DXMATRIX & m)
|
||||
{
|
||||
m_mRotation = m;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetRotation(float fRotation)
|
||||
{
|
||||
m_fYaw = 0;
|
||||
m_fPitch = 0;
|
||||
m_fRoll = fRotation;
|
||||
|
||||
D3DXMatrixRotationZ(&m_mRotation, D3DXToRadian(fRotation));
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetRotation(float fYaw, float fPitch, float fRoll)
|
||||
{
|
||||
//m_fRotation = fRotation;
|
||||
m_fYaw = fYaw;
|
||||
m_fPitch = fPitch;
|
||||
m_fRoll = fRoll;
|
||||
|
||||
D3DXMatrixRotationYawPitchRoll(&m_mRotation, D3DXToRadian(fYaw), D3DXToRadian(fPitch), D3DXToRadian(fRoll));
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetPosition(float x, float y, float z)
|
||||
{
|
||||
m_v3Position.x = x;
|
||||
m_v3Position.y = y;
|
||||
m_v3Position.z = z;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetPosition(const D3DXVECTOR3 & newposition)
|
||||
{
|
||||
m_v3Position = newposition;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetScale(float x, float y, float z)
|
||||
{
|
||||
m_v3Scale.x = x;
|
||||
m_v3Scale.y = y;
|
||||
m_v3Scale.z = z;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Show()
|
||||
{
|
||||
m_isVisible = true;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Hide()
|
||||
{
|
||||
m_isVisible = false;
|
||||
}
|
||||
bool CGraphicObjectInstance::isShow()
|
||||
{
|
||||
return m_isVisible;
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
D3DXVECTOR4 & CGraphicObjectInstance::GetWTBBoxVertex(const unsigned char & c_rucNumTBBoxVertex)
|
||||
{
|
||||
return m_v4TBBox[c_rucNumTBBoxVertex];
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::isIntersect(const CRay & c_rRay, float * pu, float * pv, float * pt)
|
||||
{
|
||||
D3DXVECTOR3 v3Start, v3Dir;
|
||||
float fRayRange;
|
||||
c_rRay.GetStartPoint(&v3Start);
|
||||
c_rRay.GetDirection(&v3Dir, &fRayRange);
|
||||
|
||||
TPosition posVertices[8];
|
||||
|
||||
posVertices[0] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMin.y, m_v3TBBoxMin.z);
|
||||
posVertices[1] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMin.y, m_v3TBBoxMin.z);
|
||||
posVertices[2] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMax.y, m_v3TBBoxMin.z);
|
||||
posVertices[3] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMax.y, m_v3TBBoxMin.z);
|
||||
posVertices[4] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMin.y, m_v3TBBoxMax.z);
|
||||
posVertices[5] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMin.y, m_v3TBBoxMax.z);
|
||||
posVertices[6] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMax.y, m_v3TBBoxMax.z);
|
||||
posVertices[7] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMax.y, m_v3TBBoxMax.z);
|
||||
|
||||
TIndex Indices[36] = {0, 1, 2, 1, 3, 2,
|
||||
2, 0, 6, 0, 4, 6,
|
||||
0, 1, 4, 1, 5, 4,
|
||||
1, 3, 5, 3, 7, 5,
|
||||
3, 2, 7, 2, 6, 7,
|
||||
4, 5, 6, 5, 7, 6};
|
||||
|
||||
int triCount = 12;
|
||||
WORD* pcurIdx = (WORD*)Indices;
|
||||
|
||||
while (triCount--)
|
||||
{
|
||||
if (IntersectTriangle(v3Start, v3Dir,
|
||||
posVertices[pcurIdx[0]],
|
||||
posVertices[pcurIdx[1]],
|
||||
posVertices[pcurIdx[2]],
|
||||
pu, pv, pt))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
pcurIdx += 3;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
CGraphicObjectInstance::CGraphicObjectInstance()
|
||||
{
|
||||
m_CullingHandle = 0;
|
||||
Initialize();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::Initialize()
|
||||
{
|
||||
if (m_CullingHandle)
|
||||
CCullingManager::Instance().Unregister(m_CullingHandle);
|
||||
m_CullingHandle = 0;
|
||||
|
||||
m_pHeightAttributeInstance = NULL;
|
||||
|
||||
m_isVisible = TRUE;
|
||||
|
||||
m_BlockCamera = false;
|
||||
|
||||
m_v3Position.x = m_v3Position.y = m_v3Position.z = 0.0f;
|
||||
m_v3Scale.x = m_v3Scale.y = m_v3Scale.z = 0.0f;
|
||||
m_fYaw = m_fPitch = m_fRoll = 0.0f;
|
||||
|
||||
D3DXMatrixIdentity(&m_worldMatrix);
|
||||
D3DXMatrixIdentity(&m_mRotation);
|
||||
|
||||
OnInitialize();
|
||||
}
|
||||
|
||||
CGraphicObjectInstance::~CGraphicObjectInstance()
|
||||
{
|
||||
Initialize();
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::UpdateBoundingSphere()
|
||||
{
|
||||
if (m_CullingHandle)
|
||||
{
|
||||
Vector3d center;
|
||||
float radius;
|
||||
GetBoundingSphere(center,radius);
|
||||
if (radius != m_CullingHandle->GetRadius())
|
||||
m_CullingHandle->NewPosRadius(center,radius);
|
||||
else
|
||||
m_CullingHandle->NewPos(center);
|
||||
}
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::RegisterBoundingSphere()
|
||||
{
|
||||
if (m_CullingHandle)
|
||||
CCullingManager::Instance().Unregister(m_CullingHandle);
|
||||
|
||||
m_CullingHandle = CCullingManager::Instance().Register(this);
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::AddCollision(const CStaticCollisionData * pscd, const D3DXMATRIX* pMat)
|
||||
{
|
||||
m_StaticCollisionInstanceVector.push_back(CBaseCollisionInstance::BuildCollisionInstance(pscd, pMat));
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::ClearCollision()
|
||||
{
|
||||
CCollisionInstanceVector::iterator it;
|
||||
for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
|
||||
{
|
||||
(*it)->Destroy();
|
||||
}
|
||||
m_StaticCollisionInstanceVector.clear();
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::CollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
CCollisionInstanceVector::const_iterator it;
|
||||
for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
|
||||
{
|
||||
if ((*it)->CollisionDynamicSphere(s))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::MovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
CCollisionInstanceVector::const_iterator it;
|
||||
for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
|
||||
{
|
||||
if ((*it)->MovementCollisionDynamicSphere(s))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 CGraphicObjectInstance::GetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
|
||||
{
|
||||
CCollisionInstanceVector::const_iterator it;
|
||||
for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
|
||||
{
|
||||
if ((*it)->MovementCollisionDynamicSphere(s))
|
||||
return (*it)->GetCollisionMovementAdjust(s);
|
||||
}
|
||||
|
||||
return D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::UpdateCollisionData(const CStaticCollisionDataVector * pscdVector)
|
||||
{
|
||||
ClearCollision();
|
||||
OnUpdateCollisionData(pscdVector);
|
||||
}
|
||||
|
||||
DWORD CGraphicObjectInstance::GetCollisionInstanceCount()
|
||||
{
|
||||
return m_StaticCollisionInstanceVector.size();
|
||||
}
|
||||
|
||||
CBaseCollisionInstance * CGraphicObjectInstance::GetCollisionInstanceData(DWORD dwIndex)
|
||||
{
|
||||
if (dwIndex>m_StaticCollisionInstanceVector.size())
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return m_StaticCollisionInstanceVector[dwIndex];
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Height
|
||||
|
||||
void CGraphicObjectInstance::SetHeightInstance(CAttributeInstance * pAttributeInstance)
|
||||
{
|
||||
m_pHeightAttributeInstance = pAttributeInstance;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::ClearHeightInstance()
|
||||
{
|
||||
m_pHeightAttributeInstance = NULL;
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::UpdateHeightInstance(CAttributeInstance * pAttributeInstance)
|
||||
{
|
||||
ClearHeightInstance();
|
||||
OnUpdateHeighInstance(pAttributeInstance);
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::IsObjectHeight()
|
||||
{
|
||||
if (m_pHeightAttributeInstance)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CGraphicObjectInstance::GetObjectHeight(float fX, float fY, float * pfHeight)
|
||||
{
|
||||
if (!m_pHeightAttributeInstance)
|
||||
return false;
|
||||
|
||||
return OnGetObjectHeight(fX, fY, pfHeight);
|
||||
}
|
||||
|
||||
void CGraphicObjectInstance::SetPortal(DWORD dwIndex, int iID)
|
||||
{
|
||||
if (dwIndex >= PORTAL_ID_MAX_NUM)
|
||||
{
|
||||
assert(dwIndex < PORTAL_ID_MAX_NUM);
|
||||
return;
|
||||
}
|
||||
|
||||
m_abyPortalID[dwIndex] = iID;
|
||||
}
|
||||
|
||||
int CGraphicObjectInstance::GetPortal(DWORD dwIndex)
|
||||
{
|
||||
if (dwIndex >= PORTAL_ID_MAX_NUM)
|
||||
{
|
||||
assert(dwIndex < PORTAL_ID_MAX_NUM);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return m_abyPortalID[dwIndex];
|
||||
}
|
||||
Reference in New Issue
Block a user