void CMyObject::setRotAngels(D3DXVECTOR3 rotAngels)
{
D3DXMATRIX mtxRotX;
D3DXMATRIX mtxRotY;
D3DXMATRIX mtxRotZ;
m_rotAngles = rotAngels;
D3DXMatrixRotationX(&mtxRotX,m_rotAngles.x);
D3DXMatrixRotationY(&mtxRotY,m_rotAngles.y);
D3DXMatrixRotationZ(&mtxRotZ,m_rotAngles.z);
m_mtxRot = mtxRotX * mtxRotY * mtxRotZ;
}
void AmjuGLDX9::RotateX(float degs)
{
AMJU_CALL_STACK;
Assert(s_matrixMode == AmjuGL::AMJU_MODELVIEW_MATRIX);
D3DXMATRIX m;
D3DXMatrixIdentity(&m);
D3DXMatrixRotationX(&m, D3DXToRadian(degs));
g_matrixStack->MultMatrixLocal( &m);
dd->SetTransform(D3DTS_WORLD, g_matrixStack->GetTop());
}
Node::Node()
{
D3DXMatrixTranslation( &this->matTranslate,0,0,0 );
D3DXMatrixTranslation( &this->matTranslate_Relative,0,0,0 );
D3DXMatrixRotationX( &this->matRotateX, 0 ); // Pitch
D3DXMatrixRotationY( &this->matRotateY, 0 ); // Yaw
D3DXMatrixRotationZ( &this->matRotateZ, 0 ); // Roll
D3DXMatrixScaling( &this->matScale,1,1,1 );
this->hasParent = false;
this->hasChildren = false;
}
//-----------------------------------------------------------------------------
// Desc: 设置世界矩阵
//-----------------------------------------------------------------------------
VOID SetupWorldMatrice()
{
//建立一个绕X轴动态旋转的世界矩阵
D3DXMATRIX matWorld;
UINT iTime = timeGetTime() % 1000;
FLOAT fAngle = iTime * (2.0f * D3DX_PI) / 1000.0f;
D3DXMatrixIdentity( &matWorld );
D3DXMatrixRotationX( &matWorld, fAngle );
//设置世界矩阵
g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
}
void cPart::Update(float delta, D3DXMATRIXA16* pmatParentWorld){
if (m_eState == E_STATE_WALK){
if (m_epart != PT_fist){
m_fAngle += m_fAngleSpeed * delta;
D3DXMatrixRotationX(&m_matRot, m_fAngle);
}
}
else if (m_eState == E_STATE_ATTACK && m_epart == PT_arm_right){
m_fXAngle -= D3DXToRadian(-360) * delta;
D3DXMatrixRotationX(&m_matRot, m_fXAngle);
}
else {
D3DXMatrixRotationX(&m_matRot, m_fAngle);
}
if (m_fAngle < -D3DX_PI / 4.0f)
{
m_fAngle = (-D3DX_PI / 4.0f);
m_fAngleSpeed *= -1;
}
if (m_fAngle > D3DX_PI / 4.0f)
{
m_fAngle = (D3DX_PI / 4.0f);
m_fAngleSpeed *= -1;
}
m_matWorldTM = m_matPrevT * m_matRot * m_matPostT;
if (pmatParentWorld)
{
m_matWorldTM = m_matWorldTM * (*pmatParentWorld);
}
for each (auto p in m_vecChildren)
{
p->Update(delta, &m_matWorldTM);
}
// Sets the object's rotation.
void SceneObject::SetRotation( float x, float y, float z )
{
m_rotation.x = x;
m_rotation.y = y;
m_rotation.z = z;
D3DXMATRIX rotationX, rotationY;
D3DXMatrixRotationX( &rotationX, m_rotation.x );
D3DXMatrixRotationY( &rotationY, m_rotation.y );
D3DXMatrixRotationZ( &m_rotationMatrix, m_rotation.z );
D3DXMatrixMultiply( &m_rotationMatrix, &m_rotationMatrix, &rotationX );
D3DXMatrixMultiply( &m_rotationMatrix, &m_rotationMatrix, &rotationY );
}
/**-----------------------------------------------------------------------------
* 애니메이션 설정
*------------------------------------------------------------------------------
*/
VOID Animate()
{
D3DXMATRIXA16 matX;
D3DXMATRIXA16 matY;
D3DXMatrixRotationX( &matX, g_xRot );
D3DXMatrixRotationY( &matY, g_yRot );
g_matWorld = matX * matY;
g_pd3dDevice->SetTransform( D3DTS_WORLD, &g_matWorld ); /// 디바이스에 월드행렬 설정
SetupLights();
SetupPS();
LogFPS(); // 로깅
}
void SetupRotation()
{
D3DXMATRIX matWorld, matWorldX, matWorldY, matWorldZ;
D3DXMatrixRotationX(&matWorldX, timeGetTime()/400.0f);
D3DXMatrixRotationY(&matWorldY, timeGetTime()/400.0f);
D3DXMatrixRotationZ(&matWorldZ, timeGetTime()/400.0f);
D3DXMatrixMultiply(&matWorld, &matWorldX, &matWorldY);
D3DXMatrixMultiply(&matWorld, &matWorld, &matWorldZ);
g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);
}
//----------------------------------------------------------------
void Renderer::rotateX (float fAngle)
{
D3DXMATRIX kTempMatrix;
// generate translation matrix
D3DXMatrixRotationX(&kTempMatrix, fAngle);
// convert from MatrixMode to D3DTRANSFORMSTATETYPE
D3DTRANSFORMSTATETYPE eMatMode = static_cast<D3DTRANSFORMSTATETYPE>(m_eCurrentMatMode);
// set the matrix
m_pkDevice->MultiplyTransform(eMatMode, &kTempMatrix);
}
/// Draws a sphere of a given radius at a given place.
/// Very good for bounding spheres
void QDrawSphere(IDirect3DDevice9* pDev,const D3DXVECTOR3& pos,float radius,D3DCOLOR col)
{
const int STEPS=32;
D3DXVECTOR3 points[STEPS+1];
pDev->SetMaterial(&InitMtrl(BLACK_COL,BLACK_COL,BLACK_COL,col,0)); // set colour
pDev->SetTexture(0,NULL); // no texture
pDev->SetFVF(D3DFVF_XYZ);
// xz loop
for(int i=0;i<STEPS+1;i++)
{
float ang=D3DX_PI*2*i/STEPS;
points[i].x=sin(ang);
points[i].y=0;
points[i].z=cos(ang);
}
D3DXMATRIX trans,rot,scale;
D3DXMatrixTranslation(&trans,pos.x,pos.y,pos.z);
D3DXMatrixScaling(&scale,radius,radius,radius);
D3DXMatrixRotationX(&rot,D2R(0));
pDev->SetTransform(D3DTS_WORLD,&(scale*rot*trans));
pDev->DrawPrimitiveUP(D3DPT_LINESTRIP, //PrimitiveType
STEPS, //PrimitiveCount
points, //pVertexStreamZeroData
sizeof(D3DXVECTOR3)); //VertexStreamZeroStride
D3DXMatrixRotationX(&rot,D2R(90));
pDev->SetTransform(D3DTS_WORLD,&(scale*rot*trans));
pDev->DrawPrimitiveUP(D3DPT_LINESTRIP, //PrimitiveType
STEPS, //PrimitiveCount
points, //pVertexStreamZeroData
sizeof(D3DXVECTOR3)); //VertexStreamZeroStride
D3DXMatrixRotationZ(&rot,D2R(90));
pDev->SetTransform(D3DTS_WORLD,&(scale*rot*trans));
pDev->DrawPrimitiveUP(D3DPT_LINESTRIP, //PrimitiveType
STEPS, //PrimitiveCount
points, //pVertexStreamZeroData
sizeof(D3DXVECTOR3)); //VertexStreamZeroStride
}
//--------------------------------------------------------------------------------------
// Handle updates to the scene. This is called regardless of which D3D API is used
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameMove( double fTime, float fElapsedTime, void* pUserContext )
{
// Update the camera's position based on user input
g_Camera.FrameMove( fElapsedTime );
if( g_bSpinning )
D3DXMatrixRotationY( &g_World, 60.0f * DEG2RAD((float)fTime) );
else
D3DXMatrixRotationY( &g_World, DEG2RAD( 180.0f ) );
D3DXMATRIX mRot;
D3DXMatrixRotationX( &mRot, DEG2RAD( -90.0f ) );
g_World = mRot * g_World;
}
void PRTHierarchy::UpdateTransformationMatrices() {
D3DXMATRIX rotX, rotY, rotYInverse;
D3DXMatrixRotationY(&rotY, mRotationY);
D3DXMatrixRotationX(&rotX, mRotationX);
D3DXMatrixIdentity(&mWorldTransform);
D3DXMATRIX rot = rotX * rotY;
mWorldTransform = mScaleMatrix * rot;
mRenderMesh->SetWorldTransformation(mWorldTransform);
mApproxMesh->SetWorldTransformation(mWorldTransform);
mRenderMesh->SetRotationMatrix(rot);
mApproxMesh->SetRotationMatrix(rot);
}
void xForm::SetCameraPosition(const xVec3& origin, const xMat3& axis)
{
xMat4 m(axis, origin); // camera to world space
m.InverseSelf(); // world to camera space
D3DXMATRIX mat = dxMat(m), out, out2;
D3DXMatrixRotationZ(&out, DEG2RAD(90));
D3DXMatrixMultiply(&out2, &mat, &out); // result in out2
D3DXMatrixRotationX(&out, DEG2RAD(-90));
D3DXMatrixMultiply(&mat, &out2, &out); // result in mat
m_pd3dDevice->SetTransform(D3DTS_VIEW, &mat);
}
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);
}
bool Sample::Frame() {
D3DXMATRIX matRotation, matScale;
D3DXMatrixScaling(&matScale, 100, 100, 100);
D3DXMatrixRotationX(&matRotation, D3DXToRadian(90.0f));
m_matWorld[2] = matScale * matRotation;
if (I_Input.m_DIMouseState.rgbButtons[0])
{
m_vDir.y += m_fSpeed * g_fSecPerFrame * I_Input.m_DIMouseState.lX;
m_vDir.x += m_fSpeed * g_fSecPerFrame * I_Input.m_DIMouseState.lY;
}
if (I_Input.KeyCheck(DIK_SPACE))
{
m_fSpeed += g_fSecPerFrame * 20.0f;
if (m_fSpeed >= 50.0f) m_fSpeed = 50.0f;
}
else
{
m_fSpeed -= g_fSecPerFrame * 10.0f;
if (m_fSpeed <= 5.0f) m_fSpeed = 5.0f;
}
if (I_Input.KeyCheck(DIK_W))
{
m_Camera.MoveLook(g_fSecPerFrame* m_fSpeed);
}
if (I_Input.KeyCheck(DIK_S))
{
m_Camera.MoveLook(-g_fSecPerFrame* m_fSpeed);
}
m_vDir.w = 0.0f;
if (I_Input.m_DIMouseState.lZ != 0)
{
m_vDir.w = m_fSpeed * g_fSecPerFrame * I_Input.m_DIMouseState.lZ;
}
if (I_Input.KeyCheck(DIK_F4))
{
m_bCameraType = !m_bCameraType;
}
if (m_bCameraType)
{
m_Camera.Update(m_vDir);
}
else
{
m_Camera.Frame(m_vDir);
}
return true;
};
void CAnimationView::Update(void)
{
_matrix matScale, matRotX, matRotY, matRotZ, matTrans;
D3DXMatrixScaling(&matScale, m_vScale.x, m_vScale.y, m_vScale.z);
D3DXMatrixRotationX(&matRotX, m_fAngle[ANGLE_X]);
D3DXMatrixRotationY(&matRotY, m_fAngle[ANGLE_Y]);
D3DXMatrixRotationZ(&matRotZ, m_fAngle[ANGLE_Z]);
D3DXMatrixTranslation(&matTrans, m_vPosition.x, m_vPosition.y, m_vPosition.z);
m_matWorld = matScale * matRotX * matRotY * matRotZ * matTrans;
Engine::GetGraphicDev() ->SetTransform(D3DTS_WORLD , &m_matWorld);
}
int CInfo::Update(void)
{
D3DXMATRIX matScale, matRotX, matRotY, matRotZ, matTrans;
//½÷����°ר
D3DXMatrixScaling(&matScale, m_vScale.x, m_vScale.y, m_vScale.z);
D3DXMatrixRotationX(&matRotX, m_fAngle[ANGLE_X]);
D3DXMatrixRotationY(&matRotY, m_fAngle[ANGLE_Y]);
D3DXMatrixRotationZ(&matRotZ, m_fAngle[ANGLE_Z]);
D3DXMatrixTranslation(&matTrans, m_vPos.x, m_vPos.y, m_vPos.z);
m_matWorld = matScale * matRotX * matRotY * matRotZ * matTrans;
return 0;
}
void CTourist::UpdateWorldMatrix()
{
D3DXMATRIX mRot, mRotX, mRotZ, mRotY, mTrans, mat;
D3DXMatrixRotationX(&mRotX, m_vAngle.x);
D3DXMatrixRotationY(&mRotY, m_vAngle.y);
D3DXMatrixRotationZ(&mRotZ, m_vAngle.z);
D3DXMatrixMultiply(&mRot, &mRotY, &mRotX);
D3DXMatrixMultiply(&mRot, &mRotZ, &mRot);
D3DXMatrixIdentity(&mat);
D3DXMatrixMultiply(&m_mOrientation, &mat, &mRot);
D3DXMatrixTranslation(&mTrans, m_vPos.x, m_vPos.y, m_vPos.z);
D3DXMatrixMultiply(&m_mOrientation, &m_mOrientation, &mTrans);
}
/////////////////////////////////////
// Name:
// Purpose:
// Output:
// Return:
/////////////////////////////////////
PUBLIC void OBJRotX(hOBJ obj, float radian)
{
obj->wrldRot[eX] += radian;
D3DXMATRIX mtxR;
//set the rotation matrix
D3DXMatrixRotationX(&mtxR, radian);
D3DXMatrixMultiply(&obj->wrldMtx.mtxRot,&obj->wrldMtx.mtxRot,&mtxR);
//set the world matrix
D3DXMatrixMultiply(&obj->wrldMtx.mtxWrld,&obj->wrldMtx.mtxScale,&obj->wrldMtx.mtxRot);
D3DXMatrixMultiply(&obj->wrldMtx.mtxWrld,&obj->wrldMtx.mtxWrld,&obj->wrldMtx.mtxTrans);
}
void Node::Rotate(float x, float y, float z)
{
D3DXMATRIX rotationX;
D3DXMATRIX rotationY;
D3DXMATRIX rotationZ;
D3DXMatrixRotationX( &rotationX, x ); // Pitch
D3DXMatrixRotationY( &rotationY, y ); // Yaw
D3DXMatrixRotationZ( &rotationZ, z ); // Roll
this->matRotateX *= rotationX;
this->matRotateY *= rotationY;
this->matRotateZ *= rotationZ;
}
//-----------------------------------------------------------------------------
// Name: SetupMatrices()
// Desc: Sets up the world, view, and projection transform matrices.
//-----------------------------------------------------------------------------
VOID SetupMatrices()
{
HRESULT hr;
if( 0 == g_StartTime )
{
srand( timeGetTime());
g_StartTime = (DWORD)(timeGetTime()/2000.0f);
}
// For our world matrix, we will just leave it as the identity
D3DXMATRIX matWorld;
D3DXMatrixIdentity( &matWorld );
D3DXMatrixRotationX( &matWorld, (FLOAT)(timeGetTime()/2000.0f - g_StartTime + D3DX_PI/2.0));
hr = g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
if (FAILED(hr))
{
Msg(TEXT("Could not set D3DTS_WORLD transform! hr=0x%x"), hr);
}
// Set up our view matrix. A view matrix can be defined given an eye point,
// a point to look at, and a direction for which way is up. Here, we set the
// eye five units back along the z-axis and up three units, look at the
// origin, and define "up" to be in the y-direction.
D3DXMATRIX matView;
D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 3.0f,-3.0f ),
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
hr = g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
if (FAILED(hr))
{
Msg(TEXT("Could not set D3DTS_VIEW transform! hr=0x%x"), hr);
}
// For the projection matrix, we set up a perspective transform (which
// transforms geometry from 3D view space to 2D viewport space, with
// a perspective divide making objects smaller in the distance). To build
// a perpsective transform, we need the field of view (1/4 pi is common),
// the aspect ratio, and the near and far clipping planes (which define at
// what distances geometry should be no longer be rendered).
D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
hr = g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
if (FAILED(hr))
{
Msg(TEXT("Could not set D3DTS_PROJECTION transform! hr=0x%x"), hr);
}
}
void Cube_Textured::Update()
{
float tick = (float)GameManager::GetTick();
jumpTime += tick;
if ((GetAsyncKeyState('A') & 0x8000) != 0)
{
rotationAxisY -= (rotationSpeed * tick);
}
else if ((GetAsyncKeyState('D') & 0x8000) != 0)
{
rotationAxisY += (rotationSpeed * tick);
}
if ((GetAsyncKeyState('W') & 0x8000) != 0)
{
position += (direction * moveSpeed * tick);
}
else if ((GetAsyncKeyState('S') & 0x8000) != 0)
{
position -= (direction * moveSpeed * tick);
}
if ((GetAsyncKeyState(VK_SPACE) & 0x8000) != 0 && isJumping == false )
{
isJumping = true;
jumpTime = 0.0f;
}
D3DXMATRIX rotX, rotY, move;
D3DXMatrixRotationX(&rotX, rotationAxisX);
D3DXMatrixRotationY(&rotY, rotationAxisY);
world = rotX * rotY;
D3DXVECTOR3 baseDirection(0, 0, 1);
D3DXVec3TransformCoord(&direction, &baseDirection, &world);
if (isJumping)
{
position.y = jumpPower * jumpTime - 4.9f/*0.5f * ( 9.8f ) */* jumpTime * jumpTime;
if (position.y < 0.0)
{
isJumping = false;
position.y = 0.0f;
}
}
D3DXMatrixTranslation(&move, position.x, position.y, position.z);
world *= move;
}
bool graphics::RenderSceneToTexTure2()
{
D3DXMATRIX worldMatrix, lightViewMatrix, lightProjectionMatrix, translateMatrix,tempA,tempB,tempC;
float posX, posY, posZ;
// Set the render target to be the render to texture.
_renderTexture2->SetRenderTarget(_D3D->GetDevice());
// Clear the render to texture.
_renderTexture2->ClearRenderTarget(_D3D->GetDevice(), 0.0f, 0.0f, 0.0f, 1.0f);
// Generate the light view matrix based on the light's position.
_light2->GenerateViewMatrix();
// Get the world matrix from the d3d object.
_D3D->GetWorldMatrix(worldMatrix);
// Get the view and orthographic matrices from the light object.
_light2->GetViewMatrix(lightViewMatrix);
_light2->GetProjectionMatrix(lightProjectionMatrix);
D3DXMatrixRotationY(&worldMatrix,_rotation1);
// Setup the translation matrix for the cube model.
_model2->RenderToGraphics(_D3D->GetDevice());
_depthShader->Render(_D3D->GetDevice(), _model2->GetIndexCount(), worldMatrix, lightViewMatrix, lightProjectionMatrix);
_D3D->GetWorldMatrix(worldMatrix);
D3DXMatrixTranslation(&tempA,0.0f,1.0f,0.5f);
D3DXMatrixRotationX(&tempB, 90.0f);
D3DXMatrixMultiply(&worldMatrix,&tempA,&tempB);
D3DXMatrixScaling(&tempC,2.0f,2.0f,2.0f);
D3DXMatrixMultiply(&worldMatrix,&worldMatrix,&tempC);
_model->RenderToGraphics(_D3D->GetDevice());
_depthShader->Render(_D3D->GetDevice(), _model->GetIndexCount(), worldMatrix, lightViewMatrix, lightProjectionMatrix);
// Render the cube model with the depth shader.
// Reset the render target back to the original back buffer and not the render to texture anymore.
_D3D->SetBackBufferRenderTarget();
// Reset the viewport back to the original.
_D3D->ResetViewport();
return true;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: �� �����Ӹ��� ȣ���. �ִϸ��̼� ó���� ���
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
// UFO�� �����δ�
m_pos.x = 1.5f*(FLOAT)cos(1.0f*this->m_fTime)+1.0f;
m_pos.z = 1.5f*(FLOAT)sin(1.0f*this->m_fTime);
m_pos.y = 1.3f;
UpdateInput( &m_UserInput ); // �Էµ����� ����
//---------------------------------------------------------
// �Է¿� ���� ��ǥ�踦 �����Ѵ�
//---------------------------------------------------------
// ȸ��
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else
if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else
if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &m_mWorld, &matRotY, &matRotX );
//---------------------------------------------------------
// ����� ����
//---------------------------------------------------------
// ��
if( m_UserInput.bZoomIn && !m_UserInput.bZoomOut )
m_fViewZoom += m_fElapsedTime;
else if( m_UserInput.bZoomOut && !m_UserInput.bZoomIn )
m_fViewZoom -= m_fElapsedTime;
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -m_fViewZoom );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, &vFromPt, &vLookatPt, &vUpVec );
return S_OK;
}
void CAXModel::UpdateMatrix(void)
{
D3DXMATRIX matPosition;
D3DXMATRIX matSize;
D3DXMATRIX matRotate;
D3DXMATRIX matAnchorPoint;
D3DXMATRIX matComplate;
D3DXMATRIX mT;
{
AVector3 vLeft(1.0f, 0.0f, 0.0f);
AVector3 vUp(0.0f, 1.0f, 0.0f);
AVector3 vLook(0.0f, 0.0f, 1.0f);
AVector3 vUpNew, vLeftNew, vLookNew;
D3DXMATRIX mX, mY, mZ;
D3DXMatrixRotationX(&mX, m_fRotX);
D3DXMatrixRotationY(&mY, m_fRotY);
D3DXMatrixRotationZ(&mZ, -m_fRotZ);
D3DXMatrixTranslation(&mT, vUp.x, vUp.y, vUp.z);
mT *= mX; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mY; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mZ; vUpNew = AVector3(mT._41, mT._42, mT._43);
D3DXMatrixTranslation(&mT, vLeft.x, vLeft.y, vLeft.z);
mT *= mX; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mY; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mZ; vLeftNew = AVector3(mT._41, mT._42, mT._43);
D3DXMatrixTranslation(&mT, vLook.x, vLook.y, vLook.z);
mT *= mX; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mY; D3DXMatrixTranslation(&mT, mT._41, mT._42, mT._43);
mT *= mZ; vLookNew = AVector3(mT._41, mT._42, mT._43);
mT._11 = vLeftNew.x; mT._12 = vLeftNew.y; mT._13 = vLeftNew.z; mT._14 = 0.0f; // Left Vector
mT._21 = vUpNew.x; mT._22 = vUpNew.y; mT._23 = vUpNew.z; mT._24 = 0.0f; // Up Vector
mT._31 = vLookNew.x; mT._32 = vLookNew.y; mT._33 = vLookNew.z; mT._34 = 0.0f; // Front Vector
mT._41 = 0.0f; mT._42 = 0.0f; mT._43 = 0.0f; mT._44 = 1.0f; // Translation
}
D3DXMatrixTranslation(&matAnchorPoint, m_vAnchorPoint.x, m_vAnchorPoint.y, m_vAnchorPoint.z);
D3DXMatrixScaling(&matSize, m_vSize.x, m_vSize.y, m_vSize.z);
D3DXMatrixTranslation(&matPosition, m_vPosition.x, m_vPosition.y, m_vPosition.z);
m_matComplate = matAnchorPoint * matSize * mT * matPosition;
m_bUpdateMatrix = false;
}
void CMyObject::Rotate(float x, float y, float z)
{
D3DXMATRIX mtxRotX;
D3DXMATRIX mtxRotY;
D3DXMATRIX mtxRotZ;
m_rotAngles.x += x;
m_rotAngles.y += y;
m_rotAngles.z += z;
D3DXMatrixRotationX(&mtxRotX,m_rotAngles.x);
D3DXMatrixRotationY(&mtxRotY,m_rotAngles.y);
D3DXMatrixRotationZ(&mtxRotZ,m_rotAngles.z);
m_mtxRot = mtxRotX * mtxRotY * mtxRotZ;
}
void
CGameObject::setupRotation()
{
D3DXMATRIX matWorldX, matWorldY, matWorldZ;
// Rotate to global orientation
D3DXMatrixRotationX(&matWorldX, m_Rotation.x);
D3DXMatrixRotationY(&matWorldY, m_Rotation.y);
D3DXMatrixRotationZ(&matWorldZ, m_Rotation.z);
// Combine the transformations by multiplying them together
D3DXMatrixMultiply(&m_MatWorld, &matWorld, &matWorldX);
D3DXMatrixMultiply(&m_MatWorld, &m_MatWorld, &matWorldY);
D3DXMatrixMultiply(&m_MatWorld, &m_MatWorld, &matWorldZ);
}
Vector3 Vector::RotateX(Vector3 * v, float fAngle)
{
Vector3 rV = *v;
D3DXVec3Normalize(&rV, &rV);
Matrix4x4 matRotX, matRotY;
// x축으로 먼저 회전 시킨다음, y축으로 회전
D3DXMatrixRotationX(&matRotX, D3DXToRadian(fAngle));
// x가 양수면 z축 방향을 바라봄, x가 음수면 -z축 방향을 바라봄
Vector3 vAxisZ(0, 0, 1);
D3DXMatrixRotationY(&matRotY, GetAngleY(&rV));
D3DXVec3TransformNormal(&rV, &vAxisZ, &(matRotX * matRotY));
return rV;
}
void OrbitX::draw(int m){
D3DXMATRIX Rotate, Rotate2;
D3DXMatrixRotationX(&Rotate, yaw);
D3DXMatrixRotationY(&Rotate2, initPos+(Tools::g->CurrentTime - Networks::timediff)*(speeds));
World = Rotate*Rotate2;
if(rotateSelf) World = Rotate2*World;
Tools::m4_inverse(WorldInverse, World);
PaintableX::draw(m);
}
bool Display(float timeDelta)
{
if( Device )
{
//
// Update: Rotate the cube.
//
D3DXMATRIX xRot;
D3DXMatrixRotationX(&xRot, D3DX_PI * 0.2f);
static float y = 0.0f;
D3DXMATRIX yRot;
D3DXMatrixRotationY(&yRot, y);
y += timeDelta;
if( y >= 6.28f )
y = 0.0f;
CubeWorldMatrix = xRot * yRot; // 合并旋转
//
// Render
//
Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 1.0f, 0);
Device->BeginScene();
// draw back drop
D3DXMATRIX I;
D3DXMatrixIdentity(&I);
Device->SetStreamSource(0, BackDropVB, 0, sizeof(Vertex));
Device->SetFVF(FVF_VERTEX);
Device->SetTexture(0, BackDropTex);
Device->SetTransform(D3DTS_WORLD, &I);
Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
// draw cube
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
if(Box)
Box->draw(&CubeWorldMatrix, 0, CrateTex);
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
Device->EndScene();
Device->Present(0, 0, 0, 0);
}
return true;
}
