void BUMPMAP::SetMatrix( D3DXMATRIX* pMatWorld, D3DXVECTOR4* pCameraPos, D3DXVECTOR4* pLightDir )
{
if( m_pEffect )
{
D3DXMATRIX m, m1;
D3DXVECTOR4 LightDir;
D3DXVECTOR4 v;
m = (*pMatWorld) * m_matView * m_matProj;
m_pEffect->SetMatrix( m_pWVP, &m );
//カメラ位置
m1 = (*pMatWorld) * m_matView;
D3DXMatrixInverse( &m1, NULL, &m1 );
D3DXVec4Transform( &v, pCameraPos, &m1 );
m_pEffect->SetVector( m_pEyePos, &v );
//Light
LightDir = *pLightDir;
D3DXMatrixInverse( &m1, NULL, pMatWorld );
D3DXVec4Transform( &v, &LightDir, &m1 );
D3DXVec3Normalize( (D3DXVECTOR3*)&v, (D3DXVECTOR3*)&v );
m_pEffect->SetVector( m_pLightDir, &v );
}
else
m_spD3DDevice->SetTransform( D3DTS_WORLD, pMatWorld );
}
bool GStillEntity::pick ( const POINT& pt )
{
D3DXMATRIX matView, matProj;
Content::Device.getD9Device()->GetTransform ( D3DTS_VIEW, &matView );
Content::Device.getD9Device()->GetTransform ( D3DTS_PROJECTION, &matProj );
////射线的起点为眼睛（在视图空间中为坐标原点（0,0,0））
D3DXVECTOR4 vOrigin ( 0, 0, 0, 1 );
////射线方向为眼睛看向鼠标的朝向
D3DXVECTOR4 vDir;
//将鼠标位置从2D平面转换到3D的视图空间中
vDir.x = ( ( ( 2.0f * pt.x ) / Content::Device.mWidth ) - 1 ) / matProj._11;
vDir.y = - ( ( ( 2.0f * pt.y ) / Content::Device.mHeight ) - 1 ) / matProj._22;
vDir.z = 1.0f;
vDir.w = 0.0f;
D3DXMatrixInverse ( &matView, NULL, &matView );
//将vDir和vPos转换到世界坐标系中
D3DXVec4Transform ( &vDir, &vDir, &matView );
D3DXVec4Normalize ( &vDir, &vDir );
D3DXVec4Transform ( &vOrigin, &vOrigin, &matView );
return checkIntersect ( vOrigin, vDir, false );
}
Vec3f VecProject(Vec3f obj, const D3D10_VIEWPORT& vp, const D3DXMATRIX& proj, const D3DXMATRIX& view, const D3DXMATRIX& model)
{
D3DXVECTOR3 in(obj[0], obj[1], obj[2]);
D3DXVECTOR3 out;
D3DXVec3Project(&out, &in, &vp, &proj, &view, &model);
return Vec3f(out.x, out.y, out.z);
// Vec4f in = Vec4f(obj[0], obj[1], obj[2], 1) * model;
// in = in * view;
// in = in * proj;
#if 0
D3DXVECTOR4 in(obj[0], obj[1], obj[2], 1);
D3DXVECTOR4 out;
D3DXVec4Transform(&out, &in, &model);
D3DXVec4Transform(&in, &out, &view);
D3DXVec4Transform(&out, &in, &proj);
in = out;
// transform_point_unaligned(out, in, model);
// transform_point_unaligned(in, out, proj);
if (in[3] == 0.0f)
{
// ??
in[3] = 0.00001f;
// return GL_FALSE;
}
in[0] /= in[3];
in[1] /= in[3];
in[2] /= in[3];
/* Map x, y and z to range 0-1 */
in[0] = in[0] * 0.5 + 0.5;
in[1] = in[1] * 0.5 + 0.5;
in[2] = in[2] * 0.5 + 0.5;
/* Map x,y to viewport */
in[0] = in[0] * vp.Width + vp.TopLeftX;
in[1] = in[1] * vp.Height + vp.TopLeftY;
// in[2] = 1 -in[2];
return Vec3f(in[0], in[1], in[2]);
/*
// window coordinates
win[0] = viewport[0]+(1+in[0])*viewport[2]/2;
win[1] = viewport[1]+(1+in[1])*viewport[3]/2;
// win[1] = viewport[3] - win[1];
// 0..1
win[2] = (1+in[2])/2;
*/
#endif
}
Vector3 CameraBase::worldToScreenF(const Vector3& wpt) const
{
Vector4 trans(wpt.x,wpt.y,wpt.z,1.0f);
D3DXVec4Transform(&trans,&trans,&m_matView);
D3DXVec4Transform(&trans,&trans,&m_matPrj);
trans /= trans.w;
return Vector3(trans.x,trans.y,trans.z);
}
void Shape::rotate(float rotation)
{
// Setup variables and create the rotation matrix
D3DXMATRIX rotationMatrix;
D3DXVECTOR4 vector;
vector.z = 0;
vector.w = 1;
D3DXMatrixRotationZ(&rotationMatrix, rotation);
/* Calculate the new position on the origin based on the rotation
- Rotating around an axis other than the origin makes the origins position change
- Therefor this step is done
- mRotationAxis is the distance from the origin to the rotation axis
*/
// Get the rotation axis (local coordinates)
vector.x = mRotationAxis.x;
vector.y = mRotationAxis.y;
// Do the rotation
D3DXVec4Transform(&vector, &vector, &rotationMatrix);
// Set the new position
setOrigin(Vector(vector.x, vector.y) + (getOrigin() - mRotationAxis));
// Set the new rotation axis offset
mRotationAxis = Vector(vector.x, vector.y);
// For proper updating of the bounding box
resetBoundingBox();
// Calculate each points new local position when they rotate around the axis (0,0)
for(int i = 0; i < pointList.size(); i++)
{
vector.x = pointList[i].x;
vector.y = pointList[i].y;
D3DXVec4Transform(&vector, &vector, &rotationMatrix);
pointList[i].x = vector.x;
pointList[i].y = vector.y;
// Update the bounding box
updateBoundingBox(pointList[i]);
}
// Add to the rotation
mRotation += rotation;
// To avoid big numbers
if(mRotation > 2*3.14)
mRotation = rotation;
else if(mRotation < -2*3.14)
mRotation = rotation;
}
void r3dConvertTubeLightToFocalParams( const r3dLight& l, const D3DXMATRIX& lmat, EllipsoidParams* oEP )
{
float len = l.GetLength() ;
D3DXVECTOR4 p0( -len * 0.5f, 0, 0, 1 );
D3DXVECTOR4 p1( +len * 0.5f, 0, 0, 1 );
D3DXVec4Transform( &p0, &p0, &lmat );
D3DXVec4Transform( &p1, &p1, &lmat );
oEP->Focal1 = r3dPoint3D( p0.x, p0.y, p0.z ) ;
oEP->Focal2 = r3dPoint3D( p1.x, p1.y, p1.z ) ;
oEP->Ax2 = len + 2 * l.Radius2 ;
}
Helper::AABB3f Geometry::CreateAABB() const
{
const Helper::AABB3f& worldAABB = mModel->GetAABB();
float width = worldAABB.GetWidth();
float height = worldAABB.GetHeight();
std::vector<D3DXVECTOR3> vertices(8);
vertices[0] = D3DXVECTOR3(worldAABB.Corners[0].X, worldAABB.Corners[0].Y, worldAABB.Corners[0].Z);
vertices[1] = D3DXVECTOR3(worldAABB.Corners[0].X, worldAABB.Corners[0].Y + height, worldAABB.Corners[0].Z);
vertices[2] = D3DXVECTOR3(worldAABB.Corners[0].X + width, worldAABB.Corners[0].Y + height, worldAABB.Corners[0].Z);
vertices[3] = D3DXVECTOR3(worldAABB.Corners[0].X + width, worldAABB.Corners[0].Y, worldAABB.Corners[0].Z);
vertices[4] = D3DXVECTOR3(worldAABB.Corners[0].X, worldAABB.Corners[0].Y, worldAABB.Corners[1].Z);
vertices[5] = D3DXVECTOR3(worldAABB.Corners[0].X, worldAABB.Corners[0].Y + height, worldAABB.Corners[1].Z);
vertices[6] = D3DXVECTOR3(worldAABB.Corners[0].X + width, worldAABB.Corners[0].Y + height, worldAABB.Corners[1].Z);
vertices[7] = D3DXVECTOR3(worldAABB.Corners[0].X + width, worldAABB.Corners[0].Y, worldAABB.Corners[1].Z);
D3DXVECTOR3 minV(10e9, 10e9, 10e9);
D3DXVECTOR3 maxV = -minV;
for (int i = 0; i < vertices.size(); ++i)
{
D3DXVECTOR4 v(vertices[i], 1.0f);
D3DXVec4Transform(&v, &v, &mWorld);
minV.x = min(minV.x, v.x);
minV.y = min(minV.y, v.y);
minV.z = min(minV.z, v.z);
maxV.x = max(maxV.x, v.x);
maxV.y = max(maxV.y, v.y);
maxV.z = max(maxV.z, v.z);
}
return Helper::AABB3f(Helper::Point3f(minV.x, minV.y, minV.z), Helper::Point3f(maxV.x, maxV.y, maxV.z));
}
void GraphD3D9::set_cursor( long cx, long cy )
{
float w = float(m_rect.right-m_rect.left);
float h = float(m_rect.bottom-m_rect.top);
float x = (float(cx) / w)*2-1;
float y = (float(cy) / h)*2-1;
D3DXVECTOR4 v1(x,-y,0,1);
D3DXVECTOR4 v2;
D3DXVec4Transform(&v2,&v1,&m_transform_inverse);
m_cursor_x = v2.x;
m_cursor_y = v2.y;
m_selected = NULL;
for(size_t i=0; i<m_bars.size(); ++i)
{
BarInfo& bi = m_bars[i];
if( m_cursor_x >= bi.x1 && m_cursor_x <= bi.x2 &&
m_cursor_y >= bi.y1 && m_cursor_y <= bi.y2 )
{
m_selected = &bi;
}
}
}
//行列設定
//引数1:ワールド行列 , 引数2:ライト , 引数3:ライトの方向
void CShaderDepthBufferShadow::SetMatrix( const D3DXMATRIX& world , const D3DXMATRIX& light , const D3DXVECTOR4& light_dir )
{
if( m_Sdr )
{
D3DXMATRIX m , m1 , m2;
D3DXVECTOR4 LightDir;
D3DXVECTOR4 v;
//カメラ基準の行列変換マトリックスをセットする
m = world * m_MatView * m_MatProj;
m_Sdr->SetMatrix( m_SdrWvmp , &m );
//ライトの方向ベクトルを計算
LightDir = light_dir;
D3DXMatrixInverse( &m1 , NULL , &world );
D3DXVec4Transform( &v, &LightDir , &m1 );
//XYZ成分について正規化する
D3DXVec3Normalize( (D3DXVECTOR3*)&v, (D3DXVECTOR3*)&v );
m_Sdr->SetVector( m_LightDir , &v );
//ライト基準の行列変換マトリックスをセットする
m = world * light;
m_Sdr->SetMatrix( m_LWVP , &m );
//ライト基準の行列変換マトリックスをテクスチャー座標系へ変換
D3DXMatrixScaling( &m1 , 0.5f , -0.5f , 1.0f );
D3DXMatrixTranslation( &m2 , 0.5f , 0.5f , 0.0f );
m = m * m1 * m2;
m_Sdr->SetMatrix( m_LWVPT, &m );
}
else
{
CGraphicsManager::m_pD3dDevice->SetTransform( D3DTS_WORLD , &world );
}
}
D3DXVECTOR2 Viewport::TransformToViewport(const D3DXVECTOR2& vector) const
{
D3DXVECTOR4 transformedVector;
D3DXVec4Transform(&transformedVector, &D3DXVECTOR4(vector.x, vector.y, 1, 0), &mViewSpaceTransform);
return D3DXVECTOR2(transformedVector.x, transformedVector.y);
}
//--------------------------------------------------------------------------------------
// Render the scene using the D3D11 device
//--------------------------------------------------------------------------------------
void PerlinFire::OnD3D11FrameRender( ID3D11DeviceContext* pd3dDevice,D3DXMATRIX mView, D3DXMATRIX mProj)
{
const float dt = 1.0f/60.0f;
m_time += dt;
// Set matrices
D3DXMATRIX mWorld;
D3DXMatrixIdentity(&mWorld);
D3DXMATRIX mViewProj = mView * mProj;
D3DXMATRIX mWorldView = mWorld * mView;
D3DXMATRIX mWorldViewProj = mWorldView * mProj;
float rnd = (float)rand() / RAND_MAX * 0.5f + 0.5f;
float lightPos[] = { 0.25f * (rnd - 0.5f), 5.7f, 1.0f * (rnd - 0.5f), 1.0f };
g_pvLightPos->SetFloatVector( lightPos );
g_pfNoiseScale->SetFloat( g_fNoiseScale );
g_pfRoughness->SetFloat( g_fRoughness );
g_pfFrequencyWeights->SetFloatArray( g_fFrequencyWeights, 0, 5 );
g_pfTime->SetFloat( (float)m_time * g_fSpeed );
g_pfStepSize->SetFloat( (float)1.0f / g_nSamplingRate );
g_pbJitter->SetBool( g_bJitter );
pd3dDevice->IASetInputLayout( g_pGeometryVertexLayout );
// Render fire volume
D3DXMATRIX mTranslate, mScale, mWorldViewInv;
D3DXMatrixRotationZ(&mTranslate, -1.5708);
D3DXMatrixScaling( &mScale, 10.0f * g_fShapeSize, 10.0f * g_fShapeSize, 10.0f * g_fShapeSize);
D3DXMatrixTranslation(&mWorld, FirePosition.x, FirePosition.y, FirePosition.z);
mWorldView = mTranslate * mScale * mWorld * mView;
mWorldViewProj = mWorldView * mProj;
D3DXMatrixInverse( &mWorldViewInv, NULL, &mWorldView );
D3DXVECTOR4 vEye;
D3DXVECTOR4 v(0, 0, 0, 1);
D3DXVec4Transform( &vEye, &v, &mWorldViewInv );
g_pmWorldViewProj->SetMatrix ( (float *) & mWorldViewProj );
g_pvEyePos->SetFloatVector ( (float *) &vEye );
g_pfLightIntensity->SetFloat( rnd );
g_pCurrentTechnique->GetPassByIndex(0)->Apply(0,pd3dDevice);
UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
pd3dDevice->IASetVertexBuffers( 0, 1, &g_pBuffer, &stride, &offset );
pd3dDevice->IASetIndexBuffer( g_pIndex, DXGI_FORMAT_R16_UINT, 0 );
pd3dDevice->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
pd3dDevice->DrawIndexedInstanced(36,1,0,0,0);
}
Ray PickVisitor::PickInvMatrix(
Ray ray,
D3DXMATRIX a_Matrix)
{
// Get the inverse view matrix
D3DXMATRIX matrix;
D3DXMatrixInverse( &matrix, NULL, &a_Matrix );
Ray result;
// Transform the pick ray (normaly WorldView) into object space
D3DXVec4Transform(&result.orig, &ray.orig, &matrix);
D3DXVec4Transform(&result.dir, &ray.dir, &matrix);
//TODO: test ray with and without normalize
D3DXVec3Normalize((D3DXVECTOR3*)&result.dir, (D3DXVECTOR3*)&result.dir);
result.dir.w=0.0;
return result;
}
void CObject3D::Render(const D3DXMATRIX* world, int lod, float currentFrame, int nextFrame, int textureEx, int alpha)
{
m_group = m_LOD ? &m_groups[lod] : &m_groups[0];
D3DXMATRIX mat;
int i;
if (textureEx != m_group->currentTextureEx)
_setTextureEx(textureEx);
if (m_group->updates)
_animate(currentFrame, nextFrame);
if (m_frameCount && !m_externBones && m_motion)
{
if (m_motion)
m_motion->Animate(m_baseBones, currentFrame, nextFrame);
if (m_sendVS)
{
for (i = 0; i < m_boneCount; i++)
{
mat = m_baseInvBones[i] * m_baseBones[i];
D3DXMatrixTranspose(&mat, &mat);
m_device->SetVertexShaderConstantF(i * 3, (float*)&mat, 3);
}
}
mat = *world * g_global3D.view * g_global3D.proj;
D3DXMatrixTranspose(&mat, &mat);
m_device->SetVertexShaderConstantF(84, (float*)&mat, 4);
D3DXVECTOR4 vLight;
D3DXMatrixInverse(&mat, null, world);
D3DXVec4Transform(&vLight, &g_global3D.lightVec, &mat);
D3DXVec4Normalize(&vLight, &vLight);
m_device->SetVertexShaderConstantF(92, (float*)&vLight, 1);
}
for (i = 0; i < m_group->objectCount; i++)
{
const GMObject& obj = m_group->objects[i];
if (obj.type == GMT_SKIN)
_renderSkin(obj, world, alpha);
else
{
if (!g_global3D.night && obj.light)
continue;
mat = m_group->updates[i] * *world;
_renderNormal(obj, &mat, alpha);
}
}
}
void SpaceShip::UpdateCamera()
{
// Update the camera
D3DXMATRIX matrix;
D3DXVECTOR4 vec = D3DXVECTOR4(0, 6, -16, 1);
D3DXVec4Transform(&vec, &vec, D3DXMatrixRotationQuaternion(&matrix, &m_QuatY));
Vector3D eye = Vector3D(vec.x + m_Position.X, vec.y + m_Position.Y, vec.z + m_Position.Z);
m_Camera->SetAllVectors(eye, m_Position, Vector3D(0, 1, 0));
}
/*************************************************************************
* D3DXVec4TransformArray
*/
D3DXVECTOR4* WINAPI D3DXVec4TransformArray(
D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR4* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
UINT i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec4Transform(
(D3DXVECTOR4*)((char*)out + outstride * i),
(CONST D3DXVECTOR4*)((const char*)in + instride * i),
matrix);
}
return out;
}
void Chunk::Render(Camera* p_pCamera)
{
D3DXMATRIX _Mat = p_pCamera->GetViewMatrix() * p_pCamera->GetProjMatrix();
D3D11_MAPPED_SUBRESOURCE _CBMSR;
m_pDevCon->Map(m_pConstantBufferMatrix, 0, D3D11_MAP::D3D11_MAP_WRITE_DISCARD, 0, &_CBMSR);
memcpy(_CBMSR.pData, &_Mat, sizeof(D3DXMATRIX));
m_pDevCon->Unmap(m_pConstantBufferMatrix, 0);
D3DXMATRIX _SunRotation;
D3DXMatrixRotationX(&_SunRotation, TimeSinceStart);
ChunkConstantBuffer _CCB;
D3DXVECTOR3 _LightDir(2, -3, 1);
D3DXVec3Normalize(&_LightDir, &_LightDir);
_CCB.LightDir = D3DXVECTOR4(_LightDir.x, _LightDir.y, _LightDir.z, 0);
D3DXVec4Transform(&_CCB.LightDir, &_CCB.LightDir, &_SunRotation);
float Intensity = 1;
_CCB.RGBLightColor_ALightIntensity = D3DXVECTOR4(1 * Intensity, 1 * Intensity, 0.7f * Intensity, 0);
m_pDevCon->Map(m_pConstantBufferLight, 0, D3D11_MAP::D3D11_MAP_WRITE_DISCARD, 0, &_CBMSR);
memcpy(_CBMSR.pData, &_CCB, sizeof(ChunkConstantBuffer));
m_pDevCon->Unmap(m_pConstantBufferLight, 0);
UINT stride = sizeof(ChunkVertexStruct);
UINT offset = 0;
m_pDevCon->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT::DXGI_FORMAT_R32_UINT, 0);
m_pDevCon->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);
m_pDevCon->IASetInputLayout(m_pInputLayout);
m_pDevCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY::D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
m_pDevCon->VSSetShader(m_pVertexShader, nullptr, 0);
m_pDevCon->VSSetConstantBuffers(0, 1, &m_pConstantBufferMatrix);
m_pDevCon->PSSetShader(m_pPixelShader, nullptr, 0);
m_pDevCon->PSSetShaderResources(0, 1, &m_pDirtTexture);
m_pDevCon->PSSetConstantBuffers(0, 1, &m_pConstantBufferLight);
m_pDevCon->DrawIndexed(FaceCount * 2 * 3, 0, 0);
}
void GameCamera::PreUpdate()
{
if (GetInput().IsMouseMove()) {
//マウスが動いた。
D3DXVECTOR2 mouseMove = GetInput().GetMouseMove();
//テスト
D3DXMATRIX mRot;
D3DXMatrixRotationY(&mRot, (mouseMove.x / WINDOW_WIDTH) * 1.0f);
D3DXVec4Transform(&toEyePos, &toEyePos, &mRot);
}
cameraDir = D3DXVECTOR3(toEyePos);
cameraDir.y = 0.0f;
D3DXVec3Normalize(&cameraDir, &cameraDir);
}
void GraphD3D9::client_to_time( long cx, long cy, float& tx, float& ty )
{
float w = float(m_rect.right-m_rect.left);
float h = float(m_rect.bottom-m_rect.top);
float x = (float(cx) / w)*2-1;
float y = (float(cy) / h)*2-1;
D3DXVECTOR4 v1(x,-y,0,1);
D3DXVECTOR4 v2;
D3DXVec4Transform(&v2,&v1,&m_transform_inverse);
tx = v2.x;
ty = v2.y;
}
void ScreenToDir(int x, int y, float* dx, float* dy, float* dz)
{
D3DXMATRIX matView, matProj, matInvView;
GetDevice()->GetTransform(D3DTS_VIEW, &matView);
GetDevice()->GetTransform(D3DTS_PROJECTION, &matProj);
D3DXMatrixInverse(&matInvView, NULL, &matView);
D3DXVECTOR4 vecDir;
vecDir.x = (2 * x / (float)GetScreenWidth()- 1) / matProj._11;
vecDir.y = (2 * (1 - y / (float)GetScreenHeight()) - 1) / matProj._22;
vecDir.z = 1;
vecDir.w = 0;
D3DXVec4Transform(&vecDir, &vecDir, &matInvView);
*dx = vecDir.x;
*dy = vecDir.y;
*dz = vecDir.z;
}
void PTGScene::onObjRender(HwSceneObject *sender)
{
HwMaterial *mat = sender->getMaterial();
HwShader *shd = mat->getPass(0)->getShader();
HwCamera *cam = pEng->getScene()->getCamera();
if (shd == NULL)
return;
if (mat->getCurrTechn() == 0)
{
D3DXMATRIX wvm = sender->worldMatrix() * cam->viewM();
shd->getPass(0)->vp()->setConst("g_mWorldView", wvm);
shd->getPass(0)->vp()->setConst("g_mProj", cam->projM());
}
else
{
D3DXMATRIX mLightView = pLCam->viewM();
D3DXMATRIXA16 mViewToLightProj = cam->viewM();
D3DXMatrixInverse( &mViewToLightProj, NULL, &mViewToLightProj );
mViewToLightProj = mViewToLightProj * mLightView * pLCam->projM();
shd->getPass(0)->vp()->setConst("g_mViewToLightProj", mViewToLightProj);
D3DXMATRIX wvm = sender->worldMatrix() * cam->viewM();
shd->getPass(0)->vp()->setConst("g_mWorldView", wvm);
shd->getPass(0)->vp()->setConst("g_mProj", cam->projM());
shd->getPass(0)->pp()->setConst("g_fCosTheta", cosf(D3DX_PI / 4));
shd->getPass(0)->pp()->setConst( "g_vLightDiffuse", D3DXVECTOR4(1, 1, 1, 1.0));
shd->getPass(0)->pp()->setConst( "g_vMaterial", D3DXVECTOR4(1, 1, 1, 1.0));
shd->getPass(0)->pp()->setConst( "g_vLightAmbient", D3DXVECTOR4(0.3, 0.3, 0.3, 1.0));
D3DXVECTOR3 v = pLCam->getEye();
D3DXVECTOR4 v4;
D3DXVec3Transform( &v4, &v, &cam->viewM());
shd->getPass(0)->pp()->setConst( "g_vLightPos", v4);
v4 = D3DXVECTOR4(pLCam->getDirection(), 0);
D3DXVec4Transform( &v4, &v4, &cam->viewM() ); // Direction in view space
D3DXVec3Normalize( ( D3DXVECTOR3* )&v4, ( D3DXVECTOR3* )&v4 );
shd->getPass(0)->pp()->setConst( "g_vLightDir", v4);
}
}
/*************************************************************************
* D3DXIntersectTri
*/
BOOL WINAPI D3DXIntersectTri(CONST D3DXVECTOR3 *p0, CONST D3DXVECTOR3 *p1, CONST D3DXVECTOR3 *p2, CONST D3DXVECTOR3 *praypos, CONST D3DXVECTOR3 *praydir, FLOAT *pu, FLOAT *pv, FLOAT *pdist)
{
D3DXMATRIX m;
D3DXVECTOR4 vec;
m.u.m[0][0] = p1->x - p0->x;
m.u.m[1][0] = p2->x - p0->x;
m.u.m[2][0] = -praydir->x;
m.u.m[3][0] = 0.0f;
m.u.m[0][1] = p1->y - p0->z;
m.u.m[1][1] = p2->y - p0->z;
m.u.m[2][1] = -praydir->y;
m.u.m[3][1] = 0.0f;
m.u.m[0][2] = p1->z - p0->z;
m.u.m[1][2] = p2->z - p0->z;
m.u.m[2][2] = -praydir->z;
m.u.m[3][2] = 0.0f;
m.u.m[0][3] = 0.0f;
m.u.m[1][3] = 0.0f;
m.u.m[2][3] = 0.0f;
m.u.m[3][3] = 1.0f;
vec.x = praypos->x - p0->x;
vec.y = praypos->y - p0->y;
vec.z = praypos->z - p0->z;
vec.w = 0.0f;
if ( D3DXMatrixInverse(&m, NULL, &m) )
{
D3DXVec4Transform(&vec, &vec, &m);
if ( (vec.x >= 0.0f) && (vec.y >= 0.0f) && (vec.x + vec.y <= 1.0f) && (vec.z >= 0.0f) )
{
*pu = vec.x;
*pv = vec.y;
*pdist = fabs( vec.z );
return TRUE;
}
}
return FALSE;
}
void Renderer::set_lighting_constant_values()
{
const vector<Light*> &lights_to_render = scene_to_render->get_lights();
if (lights_to_render.size() > 0)
{
Light* first_light = lights_to_render[0];
lighting_contants_buffer_cpu.light_color = first_light->get_color();
lighting_contants_buffer_cpu.ws_light_position = first_light->get_position();
D3DXMATRIX viewProjection = camera_->get_view_projection_matrix();
D3DXVECTOR4 ss_light_p;
D3DXVec4Transform(&ss_light_p, &lighting_contants_buffer_cpu.ws_light_position, &viewProjection);
ss_light_p = ss_light_p / ss_light_p.w;
ss_light_p.x = ss_light_p.x * 0.5 + 0.5;
ss_light_p.y = ss_light_p.y * 0.5 + 0.5;
lighting_contants_buffer_cpu.ss_light_position = ss_light_p;
UpdateBuffer(&lighting_contants_buffer_cpu, sizeof(LightingConstantsBuffer), lighting_constants_buffer_gpu);
}
}
bool CObjCHAR_Collision2NPC::CollisionPosition2OBBOnOff(D3DXMATRIX *m, float xLength, float yLength, float zLength, D3DXVECTOR3 *pPosition)
{
D3DXMATRIX invM;
D3DXVECTOR4 vWorldPos, vLocalPos;
D3DXMatrixInverse(&invM, NULL, m);
vWorldPos = (D3DXVECTOR4)*pPosition;
vWorldPos.w = 1.0f;
D3DXVec4Transform(&vLocalPos, &vWorldPos, &invM);
if(fabsf(vLocalPos.x ) < xLength)
{
if(fabsf(vLocalPos.y ) < yLength)
{
if(fabsf(vLocalPos.z ) < zLength)
{
return true;
}
}
}
return false;
}
//-------------------------------------------------------------
// Name: Render()
// Desc: 화면 렌더
//-------------------------------------------------------------
HRESULT CMyD3DApplication::Render()
{
D3DXMATRIX m, mT, mR, mL, mView, mProj;
D3DXVECTOR4 v, light_pos;
D3DMATERIAL9 *pMtrl;
DWORD i;
//---------------------------------------------------------
// 렌더
//---------------------------------------------------------
if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
{
m_pd3dDevice->Clear(0L, NULL
, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER
, D3DCOLOR_RGBA(0,0,0,0), 1.0f, 0L);
//-------------------------------------------------
// 그냥 평범하게 렌더
//-------------------------------------------------
m_pd3dDevice->SetTransform( D3DTS_WORLD, &m_mWorld);
m_pd3dDevice->SetTransform( D3DTS_VIEW, &m_mView );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_mProj );
TSS( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
m_pMeshBg->Render( m_pd3dDevice );
// 비행모델 렌더
TSS( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
TSS( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
//-------------------------------------------------
// 확대한 모델 출력
//-------------------------------------------------
if( m_pEffect != NULL )
{
m_pEffect->SetTechnique( m_hTechnique );
m_pEffect->Begin( NULL, 0 );
// 로컬-월드 행렬
D3DXMatrixTranslation( &m, 1.0f, 0.0f ,0.0f );
D3DXMatrixRotationY( &mR, 3.0f*m_fTime );
D3DXMatrixTranslation( &mT, 1.0f, 1.0f ,0.0f );
mL = m * mR * mT * m_mWorld;
// 광원방향
D3DXMatrixInverse( &m, NULL, &mL);
light_pos = D3DXVECTOR4(1,1,-1,0);
D3DXVec4Transform( &v, &light_pos, &m );
v.w = 0;
D3DXVec4Normalize( &v, &v );
m_pEffect->SetVector( m_hvLightDir, &v );
// 시점
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -m_fViewZoom );
D3DXVec3Transform( &v, &vFromPt, &m );
m_pEffect->SetVector( m_hvEyePos, &v );
// 로컬-투영변환행렬
m = mL * m_mView;
m_pEffect->SetMatrix( m_hmWV, &m );
m_pEffect->SetMatrix( m_hmVP, &m_mProj );
// 1프레임 직전 행렬
m_pEffect->SetMatrix( m_hmLastWV, &m_mLastWV );
m_mLastWV = m;
for(int pass = 0; pass<2; pass++){
m_pEffect->Pass( pass );// 패스를 바꿔서 출력
if(1==pass){
RS( D3DRS_ZWRITEENABLE, FALSE);
RS( D3DRS_ALPHABLENDENABLE, TRUE);
RS( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
RS( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
pMtrl = m_pMesh->m_pMaterials;
for( i=0; i<m_pMesh->m_dwNumMaterials; i++ ) {
v.x = pMtrl->Diffuse.r;
v.y = pMtrl->Diffuse.g;
v.z = pMtrl->Diffuse.b;
v.w = pMtrl->Diffuse.a;
m_pEffect->SetVector( m_hvCol, &v );
m_pMesh->m_pLocalMesh->DrawSubset( i ); // 렌더
pMtrl++;
}
}
m_pEffect->End();
RS( D3DRS_ALPHABLENDENABLE, FALSE);
RS( D3DRS_ZWRITEENABLE, TRUE);
}
RenderText(); // 도움말 출력
m_pd3dDevice->EndScene(); // 렌더종료
}
Sleep(100);
return S_OK;
}
void RenderSSAOEffect( bool lightWeight )
{
if ( !r_ssao->GetBool() )
return;
PostFX_UpdateResources();
r3dSetRestoreFSQuadVDecl setRestoreVDECL; (void)setRestoreVDECL;
#if R3D_ALLOW_TEMPORAL_SSAO
int doSSAOTemporalOptimize = R3D_SSAO_TEMPORAL_OPTIMIZE == r_ssao_temporal_filter->GetInt() ;
if( ++g_SSAO_ResetCount >= r_ssao_temporal_reset_freq->GetInt() )
{
g_SSAO_ResetCount = 0 ;
doSSAOTemporalOptimize = 0 ;
}
#else
int doSSAOTemporalOptimize = 0 ;
#endif
const SSAOSettings& sts = g_SSAOSettings[ lightWeight ? SSM_DEFAULT : SSM_HQ ];
int detailEnable = sts.DetailPathEnable ;
r3dRenderer->SetVertexShader( "VS_SSAO" ) ;
SSAOPShaderId psid ;
psid.num_rays = !lightWeight ;
psid.optimized = !!r_optimized_ssao->GetInt() ;
psid.detail_radius = detailEnable ;
#if R3D_ALLOW_TEMPORAL_SSAO
psid.temporal_optimisation = doSSAOTemporalOptimize ;
psid.temporal_show_passed = g_SSAO_Temporal_Reveal ;
psid.output_stability_mask = r_ssao_temporal_filter->GetInt() == R3D_SSAO_TEMPORAL_FILTER ;
#endif
r3dRenderer->SetPixelShader( gSSAOPSIds[ psid.Id ] ) ;
r3dRenderer->SetRenderingMode(R3D_BLEND_NOALPHA | R3D_BLEND_NZ);
r3dRenderer->pd3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
r3dRenderer->pd3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
float noiseScaleK = r_half_scale_ssao->GetInt() ? 0.5f : 1.0f;
D3DXVECTOR4 vconst = D3DXVECTOR4( 0.5f / r3dRenderer->ScreenW, 0.5f / r3dRenderer->ScreenH, r3dRenderer->ScreenW * 0.25f * noiseScaleK, r3dRenderer->ScreenH * 0.25f * noiseScaleK );
r3dRenderer->pd3ddev->SetVertexShaderConstantF( 0, (float *)&vconst, 1 );
// mat proj
float fNear = -r3dRenderer->ProjMatrix._43/(r3dRenderer->ProjMatrix._33);
float fFar = fNear / ( 1.0f - 1.0f/(r3dRenderer->ProjMatrix._33) );
const int RAYS_START = 7 + 3 + 3 + 3 ;
#define SSAO_ALT_DETAIL_NUM_RAYS 24
TL_STATIC_ASSERT( SSAO_ALT_DETAIL_NUM_RAYS > SSAO_ALT_NUM_RAYS );
const int RADIUS_SPLIT = SSAO_ALT_NUM_RAYS;
// NOTE: sync with ssao_alt_ps.hls
const int NUM_RAYS =
lightWeight ?
SSAO_LW_NUM_RAYS
:
( detailEnable ? SSAO_ALT_DETAIL_NUM_RAYS : SSAO_ALT_NUM_RAYS );
if( !g_PrevSSAO_Valid )
{
D3DXMatrixIdentity( &g_PrevSSAO_View ) ;
}
float aspect = 1.0f ;
D3DXVECTOR4 pconsts[ RAYS_START + SSAO_ALT_DETAIL_NUM_RAYS ];
// float4 g_vZScale0_ColorControl : register ( c0 );
pconsts[ 0 ] = D3DXVECTOR4( sts.DepthRange / sts.Radius, 128.0f / sts.Radius, sts.Contrast, sts.Brightness * sts.Contrast - 1.5f * sts.Contrast + 0.5f );
// float4 g_vProjScaleTrans : register ( c1 );
pconsts[ 1 ] = D3DXVECTOR4( 0.5f*r3dRenderer->ProjMatrix._11, -0.5f*r3dRenderer->ProjMatrix._22, 0.5f, 0.5f );
// float4 g_vInvProjScaleTrans : register ( c2 );
pconsts[ 2 ] = D3DXVECTOR4( 2.0f / r3dRenderer->ProjMatrix._11, -2.0f / r3dRenderer->ProjMatrix._22, -1.0f / r3dRenderer->ProjMatrix._11, 1.0f / r3dRenderer->ProjMatrix._22 );
// float4 g_vInvRes_DepthFadeRange : register ( c3 );
pconsts[ 3 ] = D3DXVECTOR4( 1.0f / r3dRenderer->ScreenW, 1.0f / r3dRenderer->ScreenH, 0.985f * fFar, 0.99f * fFar );
// float4 g_vExpandRanges : register ( c4 );
pconsts[ 4 ] = D3DXVECTOR4( sts.RadiusExpandStart, sts.DetailRadiusExpandStart, sts.RadiusExpandCoef, sts.DetailRadiusExpandCoef );
// float4 g_vDetail_Fade_ZScale1 : register ( c5 );
pconsts[ 5 ] = D3DXVECTOR4( sts.DetailStrength, sts.DetailFadeOut * sts.DetailRadius, sts.DetailDepthRange / sts.DetailRadius, 128.0f / sts.DetailRadius );
// float4 g_vTempoCtrl : register ( c6 );
pconsts[ 6 ] = D3DXVECTOR4( 0.00125f * sts.TemporalTolerance, 1.f / 512.f, aspect / 512.f, 0.f );
if( doSSAOTemporalOptimize )
{
pconsts[ 6 ].w = r_half_scale_ssao->GetInt() ? 0.5f : 1.0f ;
}
// float4x3 g_mViewMtx : register ( c7 );
D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[7], &r3dRenderer->ViewMatrix );
// ^^^^
// NOTE : last row is overwritten below
D3DXMATRIX toPrevViewMtx = r3dRenderer->InvViewMatrix * g_PrevSSAO_View ;
// float4x3 g_mToPrevViewMtx : register ( c10 );
D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[10], &toPrevViewMtx );
// ^^^^
// NOTE : last row is overwritten below
// float4x3 g_mFromPrevViewMtx : register ( c13 );
D3DXMATRIX fromPrevViewMtx ;
D3DXMatrixInverse( &fromPrevViewMtx, NULL, &toPrevViewMtx ) ;
D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[13], &fromPrevViewMtx );
// ^^^^
// NOTE : last row is overwritten below
int r = 0;
if( !lightWeight )
{
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.18486f, 0.32808f, 0.00708f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.22890f, 0.93380f,-0.09171f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.36097f, 0.18230f,-0.38227f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.06232f, 0.32664f, 0.21049f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.68342f, 0.25225f,-0.06311f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.05478f, 0.09994f, 0.34463f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.01732f, 0.36483f,-0.49192f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.72131f, 0.22451f,-0.09716f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.32283f, 0.33296f, 0.11536f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.27977f, 0.18833f, 0.16797f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.50663f, 0.08494f, 0.63250f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.35578f, 0.11564f, 0.50909f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.54817f, 0.23470f,-0.61668f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.15970f, 0.08904f,-0.66253f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.73055f, 0.08323f, 0.30949f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.68126f, 0.50000f, 0.10878f, 0 );
}
if( detailEnable || lightWeight )
{
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.01209f, 0.95443f, 0.11314f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.79393f, 0.23041f, 0.11043f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.77869f, 0.26835f,-0.35691f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.24429f, 0.15942f, 0.46862f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.32674f, 0.51379f,-0.52337f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.34767f, 0.07975f, 0.67386f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.13244f, 0.06251f,-0.58013f, 0 );
pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.30083f, 0.50000f, 0.09436f, 0 );
}
r3d_assert( r == NUM_RAYS );
for( int i = 0, e = RADIUS_SPLIT; i < e; i ++ )
{
pconsts[ RAYS_START + i ] *= sts.Radius;
}
for( int i = RADIUS_SPLIT, e = NUM_RAYS; i < e; i ++ )
{
pconsts[ RAYS_START + i ] *= sts.DetailRadius;
}
if( !r_optimized_ssao->GetInt() )
{
for( int i = 0, e = NUM_RAYS; i < e; i ++ )
{
D3DXVec4Transform( pconsts + RAYS_START + i, pconsts + RAYS_START + i, &r3dRenderer->ViewMatrix );
}
}
r3dRenderer->pd3ddev->SetPixelShaderConstantF( 0, (float*)pconsts, RAYS_START + NUM_RAYS );
r3dSetFiltering( R3D_POINT, 0 );
r3dSetFiltering( R3D_POINT, 1 );
r3dSetFiltering( R3D_POINT, 2 );
r3dRenderer->SetMipMapBias( -6, 2 );
extern r3dScreenBuffer* gBuffer_Normal;
r3dRenderer->SetTex( DepthBuffer->Tex , 0 );
r3dRenderer->SetTex( gBuffer_Normal->Tex , 1 );
r3dRenderer->SetTex( SSAO_RotTex2D , 2 );
if( doSSAOTemporalOptimize )
{
r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
r3dRenderer->pd3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
r3dSetFiltering( R3D_BILINEAR, 3 );
r3dSetFiltering( R3D_POINT, 4 );
r3dRenderer->SetTex( PrevDepthBuffer->Tex , 3 );
r3dRenderer->SetTex( PrevSSAOBuffer->Tex , 4 );
}
#if R3D_ALLOW_TEMPORAL_SSAO
if( r_ssao_temporal_filter->GetInt() == R3D_SSAO_TEMPORAL_FILTER )
r3dRenderer->pd3ddev->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN );
else
#endif
r3dRenderer->pd3ddev->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED );
r3dDrawFullScreenQuad(!!r_half_scale_ssao->GetInt());
r3dRenderer->SetMipMapBias(0, 2);
r3dRenderer->SetVertexShader();
r3dRenderer->SetPixelShader();
r3dRenderer->pd3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, 0xffffffff );
}
//------------------------------------------------------------------------------
TEST_F(Test_Vector4, Basic)
{
Vector4 sample1(1, 2, 3, 4);
// コンストラクタ
{
Vector4 v1;
Vector4 v2(1, 2, 3, 4);
Vector4 v3(Vector2(1, 2), 3, 4);
Vector4 v4(Vector3(1, 2, 3), 4);
ASSERT_VEC4_NEAR(0, 0, 0, 0, v1);
ASSERT_VEC4_NEAR(1, 2, 3, 4, v2);
ASSERT_VEC4_NEAR(1, 2, 3, 4, v3);
ASSERT_VEC4_NEAR(1, 2, 3, 4, v4);
}
// this->Set
{
Vector4 v1;
v1.set(1, 2, 3, 4);
ASSERT_VEC4_NEAR(1, 2, 3, 4, v1);
}
// this->xy
{
Vector2 v = sample1.xy();
ASSERT_VEC2_NEAR(1, 2, v);
}
// this->xyz
{
Vector3 v = sample1.xyz();
ASSERT_VEC3_NEAR(1, 2, 3, v);
}
// this->GetLength / lengthSquared
{
ASSERT_NEAR(5.477226, sample1.length(), LN_FLOAT_THRESHOLD);
ASSERT_NEAR(30.000000, sample1.lengthSquared(), LN_FLOAT_THRESHOLD);
}
// this->Clamp
{
Vector4 v1(1, 2, 3, 4);
v1.clamp(Vector4(0, 4, 2, 3), Vector4(0.5, 5, 3, 8));
ASSERT_VEC4_NEAR(0.5, 4, 3, 4, v1);
Vector4 v2(1, 2, 3, 4);
v2.clamp(2, 3);
ASSERT_VEC4_NEAR(2, 2, 3, 3, v2);
}
// this->IsNaNOrInf
{
Vector4 v(1, 2, 3, 4);
ASSERT_FALSE(v.isNaNOrInf());
volatile float d = 0.0f;
v.x /= d;
ASSERT_TRUE(v.isNaNOrInf());
}
// Vector4::normalize
{
Vector4 v1 = Vector4::normalize(sample1);
ASSERT_VEC4_NEAR(0.182574, 0.365148, 0.547723, 0.730297, v1);
}
// Vector4::dot
{
Vector4 v1(5, 6, 7, 8);
float d = Vector4::dot(sample1, v1);
ASSERT_FLOAT_EQ(70.000000, d);
}
// Vector4::min / max
{
Vector4 v1 = Vector4::min(Vector4(1, 3, 5, 7), Vector4(4, 2, 6, 8));
ASSERT_VEC4_NEAR(1, 2, 5, 7, v1);
Vector4 v2 = Vector4::max(Vector4(1, 3, 5, 7), Vector4(4, 2, 6, 8));
ASSERT_VEC4_NEAR(4, 3, 6, 8, v2);
}
// Vector4::transform
{
Matrix m = Matrix::makeRotationYawPitchRoll(1, 2, 3);
Vector4 v1 = Vector4::transform(sample1, m);
ASSERT_VEC4_NEAR(-3.144919, -1.962654, -0.507415, 4.000000, v1);
}
// Vector4::Lerp()
{
Vector4 v1 = Vector4::lerp(
Vector4(1, 2, 3, 4),
Vector4(3, 4, 7, 8),
0.75);
ASSERT_VEC4_NEAR(2.500000, 3.500000, 6.000000, 7.000000, v1);
}
// Vector4::Hermite()
{
Vector4 v1 = Vector4::hermite(
Vector4(1, 2, 3, 4),
Vector4(3, 4, 7, 8),
Vector4(0.3f, 0.4f, -0.5f, -0.7f),
Vector4(0.03f, 0.04f, -1.5f, 2.5f),
0.75);
ASSERT_VEC4_NEAR(0.545781, 0.831875, 0.585938, 0.057813, v1);
}
// Vector4::CatmullRom()
{
Vector4 v1 = Vector4::catmullRom(
Vector4(1, 2, 3, 4),
Vector4(3, 4, 7, 8),
Vector4(0.3f, 0.4f, -0.5f, -0.7f),
Vector4(0.03f, 0.04f, -1.5f, 2.5f),
0.75);
ASSERT_VEC4_NEAR(0.914297, 1.203437, 1.187500, 0.935937, v1);
}
// assign operator
{
Vector4 v1;
v1.set(1, 2, 3, 4);
v1 += Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(2, 4, 6, 8, v1);
v1.set(1, 2, 3, 4);
v1 += 5;
ASSERT_VEC4_NEAR(6, 7, 8, 9, v1);
v1.set(1, 2, 3, 4);
v1 -= Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(0, 0, 0, 0, v1);
v1.set(1, 2, 3, 4);
v1 -= 5;
ASSERT_VEC4_NEAR(-4, -3, -2, -1, v1);
v1.set(1, 2, 3, 4);
v1 *= Vector4(5, 6, 7, 8);
ASSERT_VEC4_NEAR(5, 12, 21, 32, v1);
v1.set(1, 2, 3, 4);
v1 *= 5;
ASSERT_VEC4_NEAR(5, 10, 15, 20, v1);
v1.set(1, 2, 3, 4);
v1 /= Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(1, 1, 1, 1, v1);
v1.set(10, 20, 30, 40);
v1 /= 5;
ASSERT_VEC4_NEAR(2, 4, 6, 8, v1);
}
// binary operator
{
Vector4 v1;
v1 = Vector4(1, 2, 3, 4) + Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(2, 4, 6, 8, v1);
v1 = Vector4(1, 2, 3, 4) + 5;
ASSERT_VEC4_NEAR(6, 7, 8, 9, v1);
v1 = 6 + Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(7, 8, 9, 10, v1);
v1 = Vector4(1, 2, 3, 4) - Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(0, 0, 0, 0, v1);
v1 = Vector4(1, 2, 3, 4) - 5;
ASSERT_VEC4_NEAR(-4, -3, -2, -1, v1);
v1 = 6 - Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(5, 4, 3, 2, v1);
v1 = Vector4(1, 2, 3, 4) * Vector4(5, 6, 7, 8);
ASSERT_VEC4_NEAR(5, 12, 21, 32, v1);
v1 = Vector4(1, 2, 3, 4) * 5;
ASSERT_VEC4_NEAR(5, 10, 15, 20, v1);
v1 = 6 * Vector4(1, 2, 3, 4);
ASSERT_VEC4_NEAR(6, 12, 18, 24, v1);
v1 = Vector4(10, 20, 30, 40) / Vector4(10, 20, 30, 40);
ASSERT_VEC4_NEAR(1, 1, 1, 1, v1);
v1 = Vector4(10, 20, 30, 40) / 5;
ASSERT_VEC4_NEAR(2, 4, 6, 8, v1);
v1 = 20 / Vector4(1, 2, 4, 5);
ASSERT_VEC4_NEAR(20, 10, 5, 4, v1);
v1.set(2, 4, 6, 8);
ASSERT_TRUE(v1 == Vector4(2, 4, 6, 8));
ASSERT_FALSE(v1 != Vector4(2, 4, 6, 8));
}
// unary operator
{
Vector4 v1(1, 2, 3, 4);
v1 = -v1;
ASSERT_VEC4_NEAR(-1, -2, -3, -4, v1);
}
#ifdef D3DX9_TEST
D3DXVECTOR4 dxsample1(1, 2, 3, 4);
// D3DXVec4Length
{
//dumpFLOAT("D3DXVec4Length", D3DXVec4Length(&dxsample1));
//dumpFLOAT("D3DXVec4LengthSq", D3DXVec4LengthSq(&dxsample1));
}
// D3DXVec4Normalize
{
D3DXVECTOR4 v1;
D3DXVec4Normalize(&v1, &dxsample1);
//dumpD3DXVECTOR4("D3DXVec4Normalize", v1);
}
// D3DXVec4Dot
{
D3DXVECTOR4 v1(5, 6, 7, 8);
//dumpFLOAT("D3DXVec4Dot", D3DXVec4Dot(&dxsample1, &v1));
}
// D3DXVec4Transform
{
D3DXMATRIX m1;
D3DXMatrixRotationYawPitchRoll(&m1, 1, 2, 3);
D3DXVECTOR4 v1;
D3DXVec4Transform(&v1, &dxsample1, &m1);
}
// D3DXVec4Lerp
{
D3DXVECTOR4 dxv;
D3DXVECTOR4 dxv1(1, 2, 3, 4);
D3DXVECTOR4 dxv2(3, 4, 7, 8);
D3DXVec4Lerp(&dxv, &dxv1, &dxv2, 0.75);
//dumpD3DXVECTOR4("D3DXVec4Lerp", dxv);
}
// D3DXVec4Hermite
{
D3DXVECTOR4 dxv;
D3DXVECTOR4 dxv1(1, 2, 3, 4);
D3DXVECTOR4 dxv2(3, 4, 7, 8);
D3DXVECTOR4 dxv3(0.3f, 0.4f, -0.5f, -0.7f);
D3DXVECTOR4 dxv4(0.03f, 0.04f, -1.5f, 2.5f);
D3DXVec4Hermite(&dxv, &dxv1, &dxv2, &dxv3, &dxv4, 0.75);
//dumpD3DXVECTOR4("D3DXVec4Hermite", dxv);
}
// D3DXVec4CatmullRom
{
D3DXVECTOR4 dxv;
D3DXVECTOR4 dxv1(1, 2, 3, 4);
D3DXVECTOR4 dxv2(3, 4, 7, 8);
D3DXVECTOR4 dxv3(0.3f, 0.4f, -0.5f, -0.7f);
D3DXVECTOR4 dxv4(0.03f, 0.04f, -1.5f, 2.5f);
D3DXVec4CatmullRom(&dxv, &dxv1, &dxv2, &dxv3, &dxv4, 0.75);
//dumpD3DXVECTOR4("D3DXVec4CatmullRom", dxv);
}
#endif
}
bool CObjCHAR_Collision2NPC::ContactRay2OBBIn(D3DXMATRIX *m, float xLength, float yLength, float zLength, D3DXVECTOR3 *pPosition)
{
D3DXMATRIX invM;
float fPreAvaterPositionXYZ[3];
D3DXVECTOR4 bufferV1, bufferV2;
D3DXVECTOR3 localPosition, localDirection;
D3DXVECTOR3 boxDim;
D3DXMatrixInverse(&invM, NULL, m);
::getPrevPosition (m_hNodeModel, fPreAvaterPositionXYZ);
bufferV1.x = fPreAvaterPositionXYZ[0] + m_vLocalCollisionPoint.x;
bufferV1.y = fPreAvaterPositionXYZ[1] + m_vLocalCollisionPoint.y;
bufferV1.z = fPreAvaterPositionXYZ[2] + m_vLocalCollisionPoint.z;
bufferV1.w = 1.0f;
D3DXVec4Transform(&bufferV2, &bufferV1, &invM);
localPosition = (D3DXVECTOR3)bufferV2;
bufferV1.x = -m_vModelDirection.x;
bufferV1.y = -m_vModelDirection.y;
bufferV1.z = -m_vModelDirection.z;
bufferV1.w = 0.0f;
D3DXVec4Transform(&bufferV2, &bufferV1, &invM);
localDirection = (D3DXVECTOR3)bufferV2;
boxDim.x = xLength;
boxDim.y = yLength;
boxDim.z = zLength;
D3DXVECTOR3 Normal;
float D;
D3DXVECTOR3 Contact;
for(int i = 0 ; i < 6; i += 1)
{
switch(i)
{
case 0:
Normal.x = 1.0f; Normal.y = 0.0f; Normal.z = 0.0f;
D = boxDim.x;
break;
case 1:
Normal.x = -1.0f; Normal.y = 0.0f; Normal.z = 0.0f;
D = boxDim.x;
break;
case 2:
Normal.x = 0.0f; Normal.y = 1.0f; Normal.z = 0.0f;
D = boxDim.y;
break;
case 3:
Normal.x = 0.0f; Normal.y = -1.0f; Normal.z = 0.0f;
D = boxDim.y;
break;
case 4:
Normal.x = 0.0f; Normal.y = 0.0f; Normal.z = 1.0f;
D = boxDim.z;
break;
case 5:
Normal.x = 0.0f; Normal.y = 0.0f; Normal.z = -1.0f;
D = boxDim.z;
break;
}
if(D3DXVec3Dot(&localDirection, &Normal) < 0.0f)
{
Contact = localPosition + (-(D + D3DXVec3Dot(&localPosition, &Normal)))/(D3DXVec3Dot(&localDirection, &Normal))*localDirection;
if(i < 2)
{
if(fabsf(Contact.y) < boxDim.y && fabsf(Contact.z) < boxDim.z)
{
bufferV1 = (D3DXVECTOR4)Contact;
bufferV1.w = 1.0f;
D3DXVec4Transform(&bufferV2, &bufferV1, m);
*pPosition = (D3DXVECTOR3)bufferV2 - m_vLocalCollisionPoint;
return true;
}
}
else if(i < 4)
{
if(fabsf(Contact.x) < boxDim.x && fabsf(Contact.z) < boxDim.z)
{
bufferV1 = (D3DXVECTOR4)Contact;
bufferV1.w = 1.0f;
D3DXVec4Transform(&bufferV2, &bufferV1, m);
*pPosition = (D3DXVECTOR3)bufferV2 - m_vLocalCollisionPoint;
return true;
}
}
else
{
if(fabsf(Contact.x) < boxDim.x && fabsf(Contact.y) < boxDim.y)
{
bufferV1 = (D3DXVECTOR4)Contact;
bufferV1.w = 1.0f;
D3DXVec4Transform(&bufferV2, &bufferV1, m);
*pPosition = (D3DXVECTOR3)bufferV2 - m_vLocalCollisionPoint;
return true;
}
}
}
}
return false;
}
//-------------------------------------------------------------
// Name: Render()
// Desc: 화면 렌더
//-------------------------------------------------------------
HRESULT CMyD3DApplication::Render()
{
D3DXMATRIX m, mT, mR, mL, mView, mProj;
D3DXVECTOR4 v, light_pos;
D3DMATERIAL9 *pMtrl;
LPDIRECT3DSURFACE9 pOldBackBuffer, pOldZBuffer;
D3DVIEWPORT9 oldViewport;
DWORD i;
// 뷰포트
D3DVIEWPORT9 viewport = {0,0 // 좌측상단
, MAP_WIDTH // 폭
, MAP_HEIGHT // 높이
, 0.0f,1.0f}; // 전면,후면
//-------------------------------------------------
// 렌더링타겟 보존
//-------------------------------------------------
m_pd3dDevice->GetRenderTarget(0, &pOldBackBuffer);
m_pd3dDevice->GetDepthStencilSurface(&pOldZBuffer);
m_pd3dDevice->GetViewport(&oldViewport);
TVERTEX Vertex[4] = {
// x y z rhw tu tv
{ 0, 0,0, 1, 0, 0,},
{oldViewport.Width, 0,0, 1, 1, 0,},
{oldViewport.Width,oldViewport.Height,0, 1, 1, 1,},
{ 0,oldViewport.Height,0, 1, 0, 1,},
};
//---------------------------------------------------------
// 렌더
//---------------------------------------------------------
if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
{
// 렌더링타겟 변경
m_pd3dDevice->SetRenderTarget(0, m_pSurfBg);
m_pd3dDevice->SetDepthStencilSurface(m_pZBg);
m_pd3dDevice->SetViewport(&viewport);
m_pd3dDevice->Clear(0L, NULL
, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER
, D3DCOLOR_RGBA(0,0,0,0), 1.0f, 0L);
//-------------------------------------------------
// 배경렌더
//-------------------------------------------------
m_pd3dDevice->SetTransform( D3DTS_WORLD, &m_mWorld);
m_pd3dDevice->SetTransform( D3DTS_VIEW, &m_mView );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_mProj );
TSS( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
m_pMeshBg->Render( m_pd3dDevice );
//-------------------------------------------------
// 배경을 프레임버퍼에 렌더
//-------------------------------------------------
// 렌더링타겟 복구
m_pd3dDevice->SetRenderTarget(0, pOldBackBuffer);
m_pd3dDevice->SetDepthStencilSurface(pOldZBuffer);
m_pd3dDevice->SetViewport(&oldViewport);
RS( D3DRS_ZENABLE, FALSE);
m_pd3dDevice->SetFVF( D3DFVF_XYZRHW | D3DFVF_TEX1 );
m_pd3dDevice->SetTexture( 0, m_pTexBg );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLEFAN
, 2, Vertex, sizeof( TVERTEX ) );
RS( D3DRS_ZENABLE, TRUE);
// 비행모델 렌더
TSS( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
TSS( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
if( m_pEffect != NULL )
{
m_pEffect->SetTechnique( m_hTechnique );
m_pEffect->Begin( NULL, 0 );
// 로컬-월드 행렬
D3DXMatrixTranslation( &m, 1.0f, 0.0f ,0.0f );
D3DXMatrixRotationY( &mR, m_fTime );
D3DXMatrixTranslation( &mT, 1.0f, 1.0f ,0.0f );
mL = m * mR * mT * m_mWorld;
// 광원방향
D3DXMatrixInverse( &m, NULL, &mL);
light_pos = D3DXVECTOR4(1,1,-1,0);
D3DXVec4Transform( &v, &light_pos, &m );
v.w = 0;
D3DXVec4Normalize( &v, &v );
m_pEffect->SetVector( m_hvLightDir, &v );
// 시점
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -m_fViewZoom );
D3DXVec3Transform( &v, &vFromPt, &m );
m_pEffect->SetVector( m_hvEyePos, &v );
// 로컬-투영변환행렬
m = mL * m_mView;
m_pEffect->SetMatrix( m_hmWV, &m );
m_pEffect->SetMatrix( m_hmVP, &m_mProj );
// 1프레임 직전 행렬
m_pEffect->SetMatrix( m_hmLastWV, &m_mLastWV );
m_mLastWV = m;
for(int pass = 0; pass<2; pass++){
m_pEffect->Pass( pass );// 패스를 바꿔서 출력
switch(pass){
case 0:
// 렌더링타겟 변경
m_pd3dDevice->SetRenderTarget(0, m_pSurfObj);
m_pd3dDevice->SetDepthStencilSurface(m_pZObj);
m_pd3dDevice->Clear(0L, NULL
, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER
, D3DCOLOR_RGBA(0,0,0,0), 1.0f, 0L);
break;
case 1:
// 렌더링타겟 변경
m_pd3dDevice->SetRenderTarget(0, m_pSurfBg);
m_pd3dDevice->SetDepthStencilSurface(m_pZBg);
m_pd3dDevice->Clear(0L, NULL
, D3DCLEAR_TARGET
, D3DCOLOR_RGBA(0,0,0,0), 1.0f, 0L);
m_pEffect->SetTexture(m_htSrcMap, m_pTexObj);
break;
}
// 모델렌더
pMtrl = m_pMesh->m_pMaterials;
for( i=0; i<m_pMesh->m_dwNumMaterials; i++ ) {
v.x = pMtrl->Diffuse.r;
v.y = pMtrl->Diffuse.g;
v.z = pMtrl->Diffuse.b;
v.w = pMtrl->Diffuse.a;
m_pEffect->SetVector( m_hvCol, &v );
m_pMesh->m_pLocalMesh->DrawSubset( i ); // 렌더
pMtrl++;
}
}
m_pEffect->End();
}
// 렌더링타겟 복구
m_pd3dDevice->SetRenderTarget(0, pOldBackBuffer);
m_pd3dDevice->SetDepthStencilSurface(pOldZBuffer);
m_pd3dDevice->SetViewport(&oldViewport);
// 생성한 화면 합성
RS( D3DRS_ZENABLE, FALSE);
RS( D3DRS_ALPHABLENDENABLE, TRUE);
RS( D3DRS_SRCBLEND, D3DBLEND_ONE);
RS( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
TSS( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
TSS( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
TSS( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
m_pd3dDevice->SetFVF( D3DFVF_XYZRHW | D3DFVF_TEX1 );
m_pd3dDevice->SetTexture( 0, m_pTexBg );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLEFAN
, 2, Vertex, sizeof( TVERTEX ) );
RS( D3DRS_ZENABLE, TRUE);
RS( D3DRS_ALPHABLENDENABLE, FALSE);
RenderText(); // 도움말 출력
#if 0 // 디버그용 텍스처 출력
{
m_pd3dDevice->SetTextureStageState(0,D3DTSS_COLOROP, D3DTOP_SELECTARG1);
m_pd3dDevice->SetTextureStageState(0,D3DTSS_COLORARG1, D3DTA_TEXTURE);
m_pd3dDevice->SetTextureStageState(1,D3DTSS_COLOROP, D3DTOP_DISABLE);
m_pd3dDevice->SetVertexShader(NULL);
m_pd3dDevice->SetFVF( D3DFVF_XYZRHW | D3DFVF_TEX1 );
m_pd3dDevice->SetPixelShader(0);
float scale = 128.0f;
for(DWORD i=0; i<2; i++){
TVERTEX Vertex[4] = {
// x y z rhw tu tv
{ 0,(i+0)*scale,0, 1, 0, 0,},
{scale,(i+0)*scale,0, 1, 1, 0,},
{scale,(i+1)*scale,0, 1, 1, 1,},
{ 0,(i+1)*scale,0, 1, 0, 1,},
};
if(0==i) m_pd3dDevice->SetTexture( 0, m_pTexObj );
if(1==i) m_pd3dDevice->SetTexture( 0, m_pTexBg );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, 2, Vertex, sizeof( TVERTEX ) );
}
}
#endif
m_pd3dDevice->EndScene(); // 렌더종료
}
pOldBackBuffer->Release();
pOldZBuffer->Release();
Sleep(50);
return S_OK;
}
// Takes model * view * projection as input
void MatrixToFrustum(const Matrix4x4 &viewProj, Frustum &frustum)
{
// The viewProj matrix converts world to projection space
// Therefore the inverse will convert from projection space to world space
//Matrix invVP = viewProj.Invert();
Matrix4x4 invVP;
D3DXMatrixInverse( &invVP, NULL, &viewProj );
//-----------------------------------------------------------------------------
// Near plane
//-----------------------------------------------------------------------------
Vector4 nearNormal ( 0,0,1,0 );
Vector4 nearPosition ( 0,0,0,1 );
// Transform to world space
//nearNormal = invVP * nearNormal;
//nearPosition = invVP * nearPosition;
D3DXVec4Transform ( &nearNormal, &nearNormal, &invVP );
D3DXVec4Transform ( &nearPosition, &nearPosition, &invVP );
frustum.planes[Frustum::Plane_Near].normal = D3DXVECTOR3( nearNormal.x, nearNormal.y, nearNormal.z );
D3DXVECTOR3 nearPosition3 ( nearPosition.x, nearPosition.y, nearPosition.z );
D3DXVECTOR3 nearNormal3 ( nearNormal.x, nearNormal.y, nearNormal.z );
frustum.planes[Frustum::Plane_Near].distance = D3DXVec3Dot( &nearPosition3, &nearNormal3 );
//-----------------------------------------------------------------------------
// Far plane
//-----------------------------------------------------------------------------
Vector4 farNormal ( 0,0,-1,0 );
Vector4 farPosition ( 0,0,150,0 );
D3DXVec4Transform ( &farNormal, &farNormal, &invVP );
D3DXVec4Transform ( &farPosition, &farPosition, &invVP );
frustum.planes[Frustum::Plane_Far].normal = D3DXVECTOR3( farNormal.x, farNormal.y, farNormal.z );
D3DXVECTOR3 farPosition3 ( farPosition.x, farPosition.y, farPosition.z );
D3DXVECTOR3 farNormal3 ( farNormal.x, farNormal.y, farNormal.z );
frustum.planes[Frustum::Plane_Far].distance = D3DXVec3Dot( &farPosition3, &farNormal3 );
//-----------------------------------------------------------------------------
// Top plane
//-----------------------------------------------------------------------------
Vector4 topNormal ( 0,-1,0,0 );
Vector4 topPosition ( 0,1,0,1 );
D3DXVec4Transform ( &topNormal, &topNormal, &invVP );
D3DXVec4Transform ( &topPosition, &topPosition, &invVP );
frustum.planes[Frustum::Plane_Top].normal = D3DXVECTOR3( topNormal.x, topNormal.y, topNormal.z );
D3DXVECTOR3 topPosition3 ( topPosition.x, topPosition.y, topPosition.z );
D3DXVECTOR3 topNormal3 ( topNormal.x, topNormal.y, topNormal.z );
frustum.planes[Frustum::Plane_Top].distance = D3DXVec3Dot( &topPosition3, &topNormal3 );
//-----------------------------------------------------------------------------
// Bottom plane
//-----------------------------------------------------------------------------
Vector4 bottomNormal ( 0,1,0,0 );
Vector4 bottomPosition ( 0,-1,0,1 );
D3DXVec4Transform ( &bottomNormal, &bottomNormal, &invVP );
D3DXVec4Transform ( &bottomPosition, &bottomPosition, &invVP );
frustum.planes[Frustum::Plane_Bottom].normal = D3DXVECTOR3( bottomNormal.x, bottomNormal.y, bottomNormal.z );
D3DXVECTOR3 bottomPosition3 ( bottomPosition.x, bottomPosition.y, bottomPosition.z );
D3DXVECTOR3 bottomNormal3 ( bottomNormal.x, bottomNormal.y, bottomNormal.z );
frustum.planes[Frustum::Plane_Bottom].distance = D3DXVec3Dot( &bottomPosition3, &bottomNormal3 );
//-----------------------------------------------------------------------------
// Left plane
//-----------------------------------------------------------------------------
Vector4 leftNormal ( 1,0,0,0 );
Vector4 leftPosition ( -1,0,0,1 );
D3DXVec4Transform ( &leftNormal, &leftNormal, &invVP );
D3DXVec4Transform ( &leftPosition, &leftPosition, &invVP );
frustum.planes[Frustum::Plane_Left].normal = D3DXVECTOR3( leftNormal.x, leftNormal.y, leftNormal.z );
D3DXVECTOR3 leftPosition3 ( leftPosition.x, leftPosition.y, leftPosition.z );
D3DXVECTOR3 leftNormal3 ( leftNormal.x, leftNormal.y, leftNormal.z );
frustum.planes[Frustum::Plane_Left].distance = D3DXVec3Dot( &leftPosition3, &leftNormal3 );
//-----------------------------------------------------------------------------
// Right plane
//-----------------------------------------------------------------------------
Vector4 rightNormal ( -1,0,0,0 );
Vector4 rightPosition ( 1,0,0,1 );
D3DXVec4Transform ( &rightNormal, &rightNormal, &invVP );
D3DXVec4Transform ( &rightPosition, &rightPosition, &invVP );
frustum.planes[Frustum::Plane_Right].normal = D3DXVECTOR3( rightNormal.x, rightNormal.y, rightNormal.z );
D3DXVECTOR3 rightPosition3 ( rightPosition.x, rightPosition.y, rightPosition.z );
D3DXVECTOR3 rightNormal3 ( rightNormal.x, rightNormal.y, rightNormal.z );
frustum.planes[Frustum::Plane_Right].distance = D3DXVec3Dot( &rightPosition3, &rightNormal3 );
}
void CObjCHAR_Collision2NPC::CollisionPosition2OBBResponse(D3DXMATRIX *m, float xLength, float yLength, float zLength, D3DXVECTOR3 *pPosition, D3DXVECTOR3 *pContactPosition)
{
D3DXMATRIX invM;
D3DXVECTOR4 vWorldPos, vLocalPos;
D3DXMatrixInverse(&invM, NULL, m);
vWorldPos = (D3DXVECTOR4)*pPosition;
vWorldPos.w = 1.0f;
D3DXVec4Transform(&vLocalPos, &vWorldPos, &invM);
float fMinDistance;
fMinDistance = 100000000.0f;
D3DXVECTOR3 vNormal;
D3DXVECTOR3 vPosition;
D3DXVECTOR3 vContactLocalPosition;
D3DXVECTOR4 vContactWorldPosition;
float fD;
float fDistance;
bool bContactOnOff = false;
vPosition = (D3DXVECTOR3)vLocalPos;
for(int i = 0; i < 6; i += 1)
{
switch(i)
{
case 0:
vNormal.x = -1.0f; vNormal.y = 0.0f; vNormal.z = 0.0f;
fD = -xLength;
break;
case 1:
vNormal.x = 1.0f; vNormal.y = 0.0f; vNormal.z = 0.0f;
fD = -xLength;
break;
case 2:
vNormal.x = 0.0f; vNormal.y = -1.0f; vNormal.z = 0.0f;
fD = -yLength;
break;
case 3:
vNormal.x = 0.0f; vNormal.y = 1.0f; vNormal.z = 0.0f;
fD = -yLength;
break;
case 4:
vNormal.x = 0.0f; vNormal.y = 0.0f; vNormal.z = -1.0f;
fD = -zLength;
break;
case 5:
vNormal.x = 0.0f; vNormal.y = 0.0f; vNormal.z = 1.0f;
fD = -zLength;
break;
}
fDistance = -(D3DXVec3Dot(&vPosition, &vNormal) + fD);
if(fDistance < fMinDistance )
{
fMinDistance = fDistance;
vContactLocalPosition = vNormal*(fDistance + 5.0f) + vPosition;
bContactOnOff = true;
}
}
pContactPosition->x = pPosition->x;
pContactPosition->y = pPosition->y;
pContactPosition->z = pPosition->z;
if(bContactOnOff)
{
D3DXVec4Transform(&vContactWorldPosition, &D3DXVECTOR4(vContactLocalPosition.x, vContactLocalPosition.y, vContactLocalPosition.z, 1.0f), m);
pContactPosition->x =vContactWorldPosition.x;
pContactPosition->y =vContactWorldPosition.y;
pContactPosition->z =vContactWorldPosition.z;
}
}
