void LineModel::RotateVertsAroundOrigin( Vector3 Rotation )
{
SetRotation(Rotation);
Vector3 tempOrigin = newOrigin;
ChangeOrigin(-newOrigin);
for (int i = 0; i < FinalList.size(); i++)
{
D3DXVECTOR3 outv;
D3DXVECTOR3 temp (FinalList[i].X,FinalList[i].Y,FinalList[i].Z);
D3DXMatrixRotationYawPitchRoll(&rotationMatrix,Rotation.Y,Rotation.X,Rotation.Z);
D3DXVec3TransformCoord(&outv, &temp, &rotationMatrix);
FinalList[i] = Vector3(outv.x,outv.y,outv.z);
}
ChangeOrigin(tempOrigin);
}
void GetMatrixWorld(MyMath::MatrixF* pWorld) const
{
// スケーリングは考慮しない。
#if 0
D3DXMatrixRotationYawPitchRoll(pWorld,
m_vRotation.y,
m_vRotation.x,
m_vRotation.z);
#else
MyMath::CreateMatrixRotationZXY(pWorld, &m_vRotation);
#endif
pWorld->_41 = m_vTranslation.x;
pWorld->_42 = m_vTranslation.y;
pWorld->_43 = m_vTranslation.z;
}
Missile1::Missile1(D3DXVECTOR3 spawnPosition, D3DXVECTOR3 direction,float scale)
{
position = startPosition = spawnPosition;
this->direction = direction;
D3DXMatrixScaling(&scaleMat, scale, scale, scale);
D3DXMatrixRotationYawPitchRoll(&rotateMat, 0, 0,-1.55f);
destroyObject = isExpanding = false;
m_rotateAngle = 0;
projectileType = MISSILE1;
isBlastMesh = false;
blastRadiusScale = 0.0f;
radiusTimeTrack = 0.0;
Initialize();
}
void Camera::updateView(float dt)
{
//rotation
D3DXMatrixRotationYawPitchRoll(&rotationMatrix, heading, pitch, 0);
D3DXVec3TransformCoord(&view,&dV,&rotationMatrix);
D3DXVec3TransformCoord(&up,&dU,&rotationMatrix);
D3DXVec3Normalize(&forward,&view);
D3DXVec3Cross(&strafeRight,&up,&view);
D3DXVec3Normalize(&strafeRight,&strafeRight);
view = eye + view;
D3DXMatrixLookAtLH(&viewMatrix,&eye,&view,&up);
}
void CameraClass::Render()
{
D3DXVECTOR3 lookAt;
float yaw, pitch, roll;
D3DXMATRIX rotationMatrix;
// Setup the vector that points upwards.
m_up.x = 0.0f;
m_up.y = 1.0f;
m_up.z = 0.0f;
// Setup the position of the camera in the world.
//position.x = m_positionX;
//position.y = m_positionY;
//position.z = m_positionZ;
// Setup where the camera is looking by default.
m_direction.x = 0.0f;
m_direction.y = 0.0f;
m_direction.z = 1.0f;
// Set the yaw (Y axis), pitch (X axis), and roll (Z axis) rotations in radians.
pitch = m_rotationX * 0.0174532925f;
yaw = m_rotationY * 0.0174532925f;
roll = m_rotationZ * 0.0174532925f;
// Create the rotation matrix from the yaw, pitch, and roll values.
D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pitch, roll);
// Transform the lookAt and up vector by the rotation matrix so the view is correctly rotated at the origin.
D3DXVec3TransformCoord(&m_direction, &m_direction, &rotationMatrix);
D3DXVec3TransformCoord(&m_up, &m_up, &rotationMatrix);
//m_direction = D3DXVECTOR3(lookAt);
m_right.x = -(m_direction.y*m_up.z - m_direction.z*m_up.y);
m_right.y = -(m_direction.z*m_up.x - m_direction.x*m_up.z);
m_right.z = -(m_direction.x*m_up.y - m_direction.y*m_up.x);
// Translate the rotated camera position to the location of the viewer.
lookAt = m_position + m_direction;
// Finally create the view matrix from the three updated vectors.
D3DXMatrixLookAtLH(&m_viewMatrix, &m_position, &lookAt, &m_up);
return;
}
void MESHINSTANCE::Render()
{
//Set World-Transform, then render the mesh
if(m_pMesh != NULL)
{
D3DXMATRIX p, r, s;
D3DXMatrixTranslation(&p, m_pos.x, m_pos.y, m_pos.z);
D3DXMatrixRotationYawPitchRoll(&r, m_rot.y, m_rot.x, m_rot.z);
D3DXMatrixScaling(&s, m_sca.x, m_sca.y, m_sca.z);
D3DXMATRIX world = s * r * p;
m_pMesh->m_pDevice->SetTransform(D3DTS_WORLD, &world);
m_pMesh->Render();
}
}
// 座標変換
void Camera::TransForm(D3DXVECTOR3 pos, D3DXVECTOR3 rota)
{
D3DXMATRIX *m_temp = new D3DXMATRIX;
D3DXMatrixIdentity(&m_view);
D3DXMatrixIdentity(m_temp);
// 行列を回転する
D3DXMatrixRotationYawPitchRoll(m_temp, rota.y, rota.x, rota.z);
m_view *= *m_temp;
// 行列を平行移動させる
D3DXMatrixTranslation(m_temp, pos.x, pos.y, pos.z);
m_view *= *m_temp;
delete m_temp;
}
void EffectSwirl::apply()
{
D3DXVECTOR3 pos;
D3DXMATRIX mat;
for (int i = 0; i < swirlImages; i++)
{
float offset = (float)i * 2*3.14159f / (float)swirlImages;
D3DXMatrixRotationYawPitchRoll(&mat, 0,0,offset);
pos.z = 3.0f+2.5f*sin(m_pSettings->frame*0.007f+offset);
//Pretty sinusoidal swimming
pos.x = minx + scalex/2.0f + (float)7.0f/20.0f*minscale*sin(m_pSettings->frame*0.035f);
pos.y = miny + scaley/2.0f +(float)7.0f/20.0f*minscale*cos(m_pSettings->frame*0.045f);
TransformCoord(&pos,&pos,&mat);
m_pSettings->waterField->SetHeight(pos.x,pos.y,2.5f,-2.5f*(invertSwirls ? (i%2)*2-1:1), palette[i]);
}
}
Map::Map(void)
{
//マップ登録
D3DXMATRIX cube_rot_mat;
D3DXVECTOR3 cube_vec[3];
cube_vec[0] = D3DXVECTOR3(1.0f, 0.0f, 0.0f);
cube_vec[1] = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
cube_vec[2] = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
D3DXMatrixRotationYawPitchRoll( &cube_rot_mat, 0, 0, 0 );
D3DXVec3TransformCoord(&cube_vec[0], &cube_vec[0], &cube_rot_mat);
D3DXVec3TransformCoord(&cube_vec[1], &cube_vec[1], &cube_rot_mat);
D3DXVec3TransformCoord(&cube_vec[2], &cube_vec[2], &cube_rot_mat);
obb->SetNormDirect(cube_vec[0], cube_vec[1], cube_vec[2]);
D3DXVECTOR3 cube_length(1.0f, 1.0f, 1.0f);
obb->SetLength(cube_length.x, cube_length.y, cube_length.z);
}
/////////////////////////////////////////////////////////////////////////
// ’e”ŽË
/////////////////////////////////////////////////////////////////////////
void MoveShell(Shell &shell, Tank(&tank)[myTANKNUM], float speed, float cd)
{
D3DXVECTOR3 vec;
if (shell.fireOK == false)
{
if (shell.time < cd / FPS * 60.f)
{
shell.time += fpTimeDelta;
}
else
{
shell.fireOK = true;
shell.time = cd / FPS * 60.f;
}
}
if (shell.fireOK &&key&mLbtn)
{
shell.hitmax += 1;
shell.active = true;
shell.fireOK = false;
shell.time = 0.f;
}
if (shell.active == false)
{
shell.position = tank[myGUN].position;
shell.prePos = tank[myGUN].position;
D3DXMatrixRotationYawPitchRoll(&shell.mat, D3DXToRadian(tank[myGUN].direction), tank[myGUN].pitch, tank[myGUN].roll);
D3DXMatrixMultiply(&shell.mat, &shell.mat, &tank[myGUN].mat);
D3DXVec3TransformCoord(&vec, &D3DXVECTOR3(0.f, 0.f, 0.5f), &shell.mat);
D3DXVec3Add(&shell.position, &tank[myGUN].position, &vec);
}
else if (shell.active)
{
shell.prePos = shell.position;
D3DXVECTOR3 dist(0.0f, 0.0f, speed / 150.f);
D3DXVec3TransformCoord(&dist, &dist, &shell.mat);
D3DXVec3Add(&shell.position, &shell.position, &dist);
if (D3DXVec3Length(D3DXVec3Subtract(&vec, &shell.position, &tank[myGUN].position)) > 600.f)
{
shell.active = false;
}
}
}
void CDofEditing::UpdateAngles(void)
{
CString Angle;
Angle.Format("%05.2f", D3DXToDegree(m_Yaw));
m_YawAngle.SetWindowText(Angle);
Angle.Format("%05.2f", D3DXToDegree(m_Pitch));
m_PitchAngle.SetWindowText(Angle);
Angle.Format("%05.2f", D3DXToDegree(m_Roll));
m_RollAngle.SetWindowText(Angle);
D3DXMatrixRotationYawPitchRoll(&m_Dof->dof.rotation, m_Yaw, m_Pitch, m_Roll);
Angle.Format("%7.3f", m_Dof->dof.translation.x);
m_XPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.translation.y);
m_YPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.translation.z);
m_ZPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.x);
m_XScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.y);
m_YScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.z);
m_ZScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.multiplier);
m_DofCx.SetWindowText(Angle);
m_DofInvCheck.SetCheck(m_Dof->dof.flags&XDOF_NEGATE);
m_DofLimits.SetCheck(m_Dof->dof.flags&XDOF_MINMAX);
m_DofDegrees.SetCheck(m_Dof->dof.flags&XDOF_ISDOF);
m_DofScale.SetCheck(m_Dof->dof.flags&XDOF_SUBRANGE);
Angle.Format("%7.3f", (m_Dof->dof.flags&XDOF_ISDOF)?D3DXToDegree(m_Dof->dof.max):m_Dof->dof.max);
m_DofMax.SetWindowText(Angle);
Angle.Format("%7.3f", (m_Dof->dof.flags&XDOF_ISDOF)?D3DXToDegree(m_Dof->dof.min):m_Dof->dof.min);
m_DofMin.SetWindowText(Angle);
CString Caption;
Caption.Format("DOF Nr : %03d", m_Dof->dof.dofNumber);
SetWindowText(Caption);
m_DofList.SetCurSel(m_Dof->dof.Type);
}
void Meshes::draw_meshes(LPDIRECT3DDEVICE9 pD3DDevice)
{
D3DXMatrixRotationYawPitchRoll(&matRotate, D3DXToRadian(rot.y), D3DXToRadian(rot.x), D3DXToRadian(rot.z));
D3DXMatrixScaling(&matScale, scale.x, scale.y, scale.z);
D3DXMatrixTranslation(&matTranslate, pos.x, pos.y, pos.z);
pD3DDevice->SetTransform(D3DTS_WORLD, &(matRotate* matScale * matTranslate));
for(DWORD i = 0; i < numMaterials; i++)
{
pD3DDevice->SetMaterial(&material[i]);
pD3DDevice->SetTexture(0,texture[i]);
Model->DrawSubset(i);
//return;
}
}
//----[ getTransform ]-------------------------------------------------------
void Mesh::getTransform(D3DXMATRIX* matrix) {
D3DXMATRIX s, r, t;
D3DXMatrixScaling(&s,
scaling_.getX()->getValue(),
scaling_.getY()->getValue(),
scaling_.getZ()->getValue());
D3DXMatrixRotationYawPitchRoll(&r,
D3DXToRadian(rotation_.getY()->getValue()),
D3DXToRadian(rotation_.getX()->getValue()),
D3DXToRadian(rotation_.getZ()->getValue()));
D3DXMatrixTranslation(&t,
translation_.getX()->getValue(),
translation_.getY()->getValue(),
translation_.getZ()->getValue());
D3DXMatrixMultiply(matrix, &s, &r);
D3DXMatrixMultiply(matrix, matrix, &t);
}
void DXFrame::rotateCam(cam& camr, float dist, float rot, float angle) {
D3DXMATRIX total;
D3DXMATRIX temp;
D3DXVECTOR3 out;
D3DXVECTOR3 scal;
D3DXQUATERNION r;
D3DXMatrixIdentity(&total);
temp = total;
D3DXMatrixTranslation(&total,0,0,-dist);
D3DXMatrixRotationYawPitchRoll(&temp,D3DXToRadian(rot),D3DXToRadian(angle),0);
total *= temp;
D3DXMatrixIdentity(&temp);
D3DXMatrixTranslation(&temp,camr.cam_look_pos.x,camr.cam_look_pos.y,camr.cam_look_pos.z);
total *= temp;
D3DXMatrixDecompose(&scal,&r,&out,&total);
camr.cam_pos = out;
}
Map::Map(D3DXVECTOR3 posi, FLOAT length_x, FLOAT length_y, FLOAT length_z)
{
//マップ登録
D3DXMATRIX cube_rot_mat;
D3DXVECTOR3 cube_vec[3];
cube_vec[0] = D3DXVECTOR3(1.0f, 0.0f, 0.0f);
cube_vec[1] = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
cube_vec[2] = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
D3DXMatrixRotationYawPitchRoll( &cube_rot_mat, 0, 0, 0 );
D3DXVec3TransformCoord(&cube_vec[0], &cube_vec[0], &cube_rot_mat);
D3DXVec3TransformCoord(&cube_vec[1], &cube_vec[1], &cube_rot_mat);
D3DXVec3TransformCoord(&cube_vec[2], &cube_vec[2], &cube_rot_mat);
obb->SetPos(posi);
obb->SetNormDirect(cube_vec[0], cube_vec[1], cube_vec[2]);
obb->SetLength(length_x, length_y, length_z);
}
void DXCamera::Update(float _dt)
{
D3DXMatrixRotationYawPitchRoll(&m_matrixRotation, m_yaw, m_pitch, 0);
D3DXVec3TransformCoord(&m_vec3Target, &m_vec3DefaultForward, &m_matrixRotation);
D3DXVec3Normalize(&m_vec3Target, &m_vec3Target);
switch (m_type)
{
case eCamera::ECAMERA_DEFAULT:
{
D3DXVec3TransformNormal(&m_vec3Right, &m_vec3DefaultRight, &m_matrixRotation);
D3DXVec3TransformNormal(&m_vec3Forward, &m_vec3DefaultForward, &m_matrixRotation);
D3DXVec3Cross(&m_vec3Up, &m_vec3Forward, &m_vec3Right);
}
break;
case eCamera::ECAMERA_FPS:
{
D3DXMATRIX RotateYTempMatrix;
D3DXMatrixRotationY(&RotateYTempMatrix, m_yaw);
D3DXVec3TransformNormal(&m_vec3Right, &m_vec3DefaultRight, &RotateYTempMatrix);
D3DXVec3TransformNormal(&m_vec3Up, &m_vec3DefaultUp, &RotateYTempMatrix);
D3DXVec3TransformNormal(&m_vec3Forward, &m_vec3DefaultForward, &RotateYTempMatrix);
}
break;
case eCamera::ECAMERA_THIRD:
{
// TODO
}
break;
}
// Update position
m_vec3Position += m_moveLR * m_vec3Right * _dt;
m_vec3Position += m_moveFB * m_vec3Forward * _dt;
// Reset the movement
m_moveLR = 0.0f;
m_moveFB = 0.0f;
// Adjust the target
m_vec3Target = m_vec3Position + m_vec3Target;
D3DXMatrixLookAtLH(&m_matrixView, &m_vec3Position, &m_vec3Target, &m_vec3Up);
}
void BlastRadius::Update(float dt)
{
m_rotateAngle += 0.5 ;
if(m_rotateAngle >=360) m_rotateAngle = 0;
D3DXMatrixRotationYawPitchRoll(&rotateMat,
D3DXToRadian(m_rotateAngle), D3DXToRadian(0), 0);
// Set the translate matrix based on the player's current position
D3DXMatrixTranslation(&translateMat, position.x, position.y, position.z);
// Set the world matrix
// Note: world = scale * rotate * translate
worldMat = scaleMat * rotateMat* translateMat;
// Set the collision box based on the player's world position
//meshBox.xform(worldMat, meshBox);
}
void Camera::GetBillboardedWorldMatrix(D3DXMATRIX & out, D3DXVECTOR3 position) const
{
D3DXMATRIX rotationMatrix, translationMatrix;
D3DXVECTOR3 up = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
D3DXVECTOR3 direction = D3DXVECTOR3(position.x - m_positionX, position.y - m_positionY, position.z - m_positionZ);
//D3DXVECTOR3 direction = D3DXVECTOR3(m_positionX - position.x, m_positionY - position.y , m_positionZ - position.z);
D3DXVECTOR3 right;
D3DXVec3Cross(&right, &direction, &up);
float magnitude = D3DXVec3Length(&direction);
float yaw = atan2(direction.x, direction.z);
float pitch = float(D3DX_PI/2 - acos(-direction.y / magnitude));
D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pitch, 0.0f);
D3DXMatrixTranslation(&translationMatrix, position.x, position.y, position.z);
out = rotationMatrix * translationMatrix;
}
//座標変換
void Object::TransForm()
{
D3DXMATRIX m_temp;
D3DXMatrixIdentity(&m_world);
D3DXMatrixIdentity(&m_temp);
//行列を拡大縮小
D3DXMatrixScaling(&m_temp, scale.x, scale.y, scale.z);
m_world *= m_temp;
//行列を拡大縮小する
D3DXMatrixRotationYawPitchRoll(&m_temp, rotation.y, rotation.x, rotation.z);
m_world *= m_temp;
//行列を平行移動する
D3DXMatrixTranslation(&m_temp, position.x, position.y, position.z);
m_world *= m_temp;
}
void Mesh::Transform()
{
//set rotation matrix
double x = D3DXToRadian(rotation.x);
double y = D3DXToRadian(rotation.y);
double z = D3DXToRadian(rotation.z);
D3DXMatrixRotationYawPitchRoll(&matRotate, (float)x, (float)y, (float)z);
//set scaling matrix
D3DXMatrixScaling(&matScale, scale.x, scale.y, scale.z);
//set translation matrix
D3DXMatrixTranslation(&matTranslate, position.x, position.y, position.z);
//transform the mesh
matWorld = matRotate * matScale * matTranslate;
g_engine->getDevice()->SetTransform(D3DTS_WORLD, &matWorld);
}
enINITERROR Shield::Init( void )
{
m_vPos = D3DXVECTOR3(5, 1, 0);
m_vRot = D3DXVECTOR3(0, 0, 0);
m_vScale= D3DXVECTOR3(1, 1, 1);
D3DXMatrixIdentity(&m_mTM);
D3DXMatrixIdentity(&m_mScale);
D3DXMatrixIdentity(&m_mRot);
D3DXMatrixIdentity(&m_mTrans);
// 변환행렬 //
D3DXMatrixScaling(&m_mScale, m_vScale.x, m_vScale.y, m_vScale.z);
D3DXMatrixRotationYawPitchRoll(&m_mRot, m_vRot.x, m_vRot.y, m_vRot.z);
D3DXMatrixTranslation(&m_mTrans, m_vPos.x, m_vPos.y, m_vPos.z);
return InitVTX();
}
void CubeEnvMapping::render()
{
if(m_pEffect == NULL)
return;
HRESULT hr;
//-- ÉèÖÃeffect²ÎÊý
hr = m_pEffect->SetTexture("cubeMapTexture",m_pCubeMap);
hr = m_pEffect->SetTexture("sphereMapTexture",m_pSphereMap);
hr = m_pEffect->SetFloatArray("eyePos",(float*)&g_camera.getEyePos(),3);
D3DXMATRIX matWorld;
float t = timeGetTime()/4000.0f;
float r = D3DX_PI;
float yaw = sinf(t) * r;
float pitch = cosf(t) * r;
D3DXMatrixRotationYawPitchRoll(&matWorld,yaw,pitch,(yaw+pitch)*0.5f);
D3DXMATRIX matTmp;
D3DXMatrixTranslation(&matTmp,sinf(t)*100,0,0);
matWorld = matWorld*matTmp;
D3DXMATRIX matWorldViewProj = matWorld * g_camera.getViewMat() * g_camera.getProjectMat();
m_pEffect->SetMatrix("matWorldViewPrj",&matWorldViewProj);
hr = m_pEffect->SetMatrix("matWorld",&matWorld);
hr = m_pEffect->SetMatrix("matView",&g_camera.getViewMat());
//-- äÖȾÇòÌå
UINT numPass = 0;
hr = m_pEffect->Begin(&numPass,0);
for(UINT i=0;i<numPass;i++)
{
m_pEffect->BeginPass(i);
drawMesh();
m_pEffect->EndPass();
}
hr = m_pEffect->End();
DrawingUtil::getInst()->drawText("Key S : sphere, Key C : cube", 0, 32);
ShaderSimpler::render();
}
//**関数***************************************************************************
// 概要 : アフィン
//*********************************************************************************
void CObjBase::Affine()
{
if(!m_bUseFlg) // 描画しないときは処理なし
return;
D3DXMATRIX matTrans , matRot , matScall;
// 初期化
D3DXMatrixIdentity(&matTrans);
D3DXMatrixIdentity(&matRot);
D3DXMatrixIdentity(&matScall);
// アフィン
D3DXMatrixTranslation(&matTrans , m_Pos.x , m_Pos.y , m_Pos.z); // 移動
D3DXMatrixRotationYawPitchRoll(&matRot , m_Rot.y , m_Rot.x , m_Rot.z); // 回転
D3DXMatrixScaling(&matScall , m_Scall.x , m_Scall.y , m_Scall.z); // 拡縮
m_Matrix = matRot * matScall * matTrans;
}
void MoveEmyShell(Shell &shell, Enemy(&enemy)[eTANKNUM], float speed, float cd)
{
D3DXVECTOR3 vec;
if (shell.fireOK == false)
{
if (shell.time < cd / FPS * 60.f)
{
shell.time += fpTimeDelta;
}
else
{
shell.fireOK = true;
}
}
else if (shell.fireOK)
{
shell.active = true;
shell.fireOK = false;
shell.time = 0.f;
}
if (shell.active == false)
{
shell.position = enemy[eGUN].position;
shell.prePos = enemy[eGUN].position;
D3DXMatrixRotationYawPitchRoll(&shell.mat, D3DXToRadian(enemy[eGUN].direction), enemy[eGUN].pitch, enemy[eGUN].roll);
D3DXMatrixMultiply(&shell.mat, &shell.mat, &enemy[eGUN].mat);
}
else if (shell.active)
{
shell.prePos = shell.position;
D3DXVECTOR3 dist;
dist = { 0.0f, 0.0f, speed / 150.f };
D3DXVec3TransformCoord(&dist, &dist, &shell.mat);
D3DXVec3Add(&shell.position, &shell.position, &dist);
if (D3DXVec3Length(D3DXVec3Subtract(&vec, &shell.position, &enemy[eGUN].position)) > 600.f)
{
shell.active = false;
}
}
}
void CameraClass::Render()
{
D3DXVECTOR3 up, position, lookAt;
float yaw, pich, roll;
D3DXMATRIX rotationMatrix;
// Setup the vector, points upwards
up.x = 0.0f;
up.y = 1.0f;
up.z = 0.0f;
// Setup the position of the camera in the world
position.x = m_positionX;
position.y = m_positionY;
position.z = m_positionZ;
// Setup camera direction
lookAt.x = 0.0f;
lookAt.y = 0.0f;
lookAt.z = 1.0f;
// Set the yaw (Y axis), pitch (X axis) and roll (Z axis) rotation in radians.
pich = m_rotationX * 0.0174532925f;
yaw = m_rotationY * 0.0174532925f;
roll = m_rotationZ * 0.0174532925f;
// Create the rotation matrix from the yaw, pitch and roll values
D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pich, roll);
// Transform the lookAt and up vector by the rotation matrix
// so the view is correctly rotated at the origin.
D3DXVec3TransformCoord(&lookAt, &lookAt, &rotationMatrix);
D3DXVec3TransformCoord(&up, &up, &rotationMatrix);
// Translate the rotated camera position to the location of the viewer.
lookAt = position + lookAt;
// Create the view matrix from updated vectors
D3DXMatrixLookAtLH(&m_viewMatrix, &position, &lookAt, &up);
return;
}
//*****************************************************************************
// 描画
// 引数：
// LPDIRECT3DDEVICE9 pDevice：デバイスポインタ
// 戻り値：
// なし
//*****************************************************************************
void CPlayer::Draw(LPDIRECT3DDEVICE9 pDevice)
{
//マトリックス変数宣言
D3DXMATRIX mTrans,mScale,mRotate; //左から座標、大きさ、回転
//描画タイプの変更
CRenderer::SetRenderType(CRenderer::NOMAL);
//マトリックス初期化
D3DXMatrixIdentity(&m_mtxWorld);
//大きさ設定
D3DXMatrixScaling(&mScale, 0.6f, 0.6f, 0.6f);
//合成
D3DXMatrixMultiply(&m_mtxWorld,&m_mtxWorld,&mScale);
//角度設定
D3DXMatrixRotationYawPitchRoll(&mRotate, D3DX_PI * m_Vertex_3d.Rot_vtx.y + D3DX_PI, D3DX_PI * m_Vertex_3d.Rot_vtx.x, D3DX_PI * m_Vertex_3d.Rot_vtx.z);
//合成
D3DXMatrixMultiply(&m_mtxWorld,&m_mtxWorld,&mRotate);
//座標設定
D3DXMatrixTranslation(&mTrans, m_Vertex_3d.vtx.x, m_Vertex_3d.vtx.y, m_Vertex_3d.vtx.z);
//合成
D3DXMatrixMultiply(&m_mtxWorld,&m_mtxWorld,&mTrans);
//セッティング
pDevice->SetTransform(D3DTS_WORLD,&m_mtxWorld);
//モデルの各パーツの描画
for(int i = 0 ; i < MODELPARTS_MAX; i++)
{
if(m_apModel[i])
{
m_apModel[i]->Draw(pDevice);
}
}
}
void CameraClass::RenderReflection(float height)
{
D3DXVECTOR3 up, position, lookAt;
float yaw, pitch, roll;
D3DXMATRIX rotationMatrix;
// Setup the vector that points upwards.
up.x = 0.0f;
up.y = 1.0f;
up.z = 0.0f;
// Setup the position of the camera in the world. For planar reflection invert the Y position of the camera.
position.x = m_positionX;
position.y = -m_positionY + (height * 2.0f);
position.z = m_positionZ;
// Setup where the camera is looking by default.
lookAt.x = 0.0f;
lookAt.y = 0.0f;
lookAt.z = 1.0f;
// Set the yaw (Y axis), pitch (X axis), and roll (Z axis) rotations in radians. Invert the X rotation for reflection.
pitch = -m_rotationX * 0.0174532925f;
yaw = m_rotationY * 0.0174532925f;
roll = m_rotationZ * 0.0174532925f;
// Create the rotation matrix from the yaw, pitch, and roll values.
D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pitch, roll);
// Transform the lookAt and up vector by the rotation matrix so the view is correctly rotated at the origin.
D3DXVec3TransformCoord(&lookAt, &lookAt, &rotationMatrix);
D3DXVec3TransformCoord(&up, &up, &rotationMatrix);
// Translate the rotated camera position to the location of the viewer.
lookAt = position + lookAt;
// Finally create the reflection view matrix from the three updated vectors.
D3DXMatrixLookAtLH(&m_reflectionViewMatrix, &position, &lookAt, &up);
return;
}
void gShadowRender()
{
// position the light camera
gLightIntensity = gUISldLightIntensity->getValue() * 0.1f;
gShadowYaw = D3DXToRadian( gUISldLightYaw->getValue() );
gShadowPitch = D3DXToRadian( gUISldLightPitch->getValue() );
D3DXMatrixRotationYawPitchRoll( &gShadowLight.mWorldMat, gShadowYaw, gShadowPitch, 0.0f );
gShadowLight.mWorldMat.getOrigin() = gSceneCenter;
gShadowLight.mWorldMat.getOrigin() -= gShadowLight.mWorldMat.getAxisZ() * gShadowDist;
gLightPos = gSceneCenter;
gLightPos -= gShadowLight.mWorldMat.getAxisZ() * gShadowDist * 20.0f;
gShadowDist = gSceneRadius * 1.5f;
gShadowLight.setOrthoParams( gSceneRadius*2, gSceneRadius*2, gSceneRadius*0.3f, gSceneRadius*4.0f );
// update matrices
gShadowLight.setOntoRenderContext();
gShadowLightViewProj = G_RENDERCTX->getCamera().getViewProjMatrix();
gfx::textureProjectionWorld( gShadowLightViewProj, SZ_SHADOWMAP, SZ_SHADOWMAP, gShadowTexProj );
//gShadowBias = gSceneRadius * 0.001f;
// render shadow map
CD3DDevice& dx = CD3DDevice::getInstance();
if( gUseDSTShadows ) {
dx.setRenderTarget( RGET_S_SURF(RT_SHADOW_DSTRT) );
dx.setZStencil( RGET_S_SURF(RT_SHADOW) );
dx.getStateManager().SetRenderState( D3DRS_COLORWRITEENABLE, 0 );
dx.clearTargets( false, true, false, 0xFFffffff, 1.0f );
} else {
dx.setRenderTarget( RGET_S_SURF(RT_SHADOW) );
dx.setZStencil( RGET_S_SURF(RT_SHADOWZ) );
dx.clearTargets( true, true, false, 0xFFffffff, 1.0f );
}
G_RENDERCTX->applyGlobalEffect();
G_RENDERCTX->attach( *gMeshCaster );
G_RENDERCTX->perform();
if( gUseDSTShadows ) {
dx.getStateManager().SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_ALPHA );
}
}
void TransformNode::Update(float elapsedTime)
{
//Yo, update here dogg.
float movement = 0.01f;
D3DXMATRIXA16 mRotate;
D3DXMatrixIdentity( &mRotate );
D3DXMatrixRotationYawPitchRoll( &mRotate, movement, movement, movement );
m_Transform = m_Transform * mRotate ;
std::vector<SceneGraphNode*> children = this->GetChildren();
for(std::vector<SceneGraphNode*>::iterator iterator = children.begin();
iterator != children.end();
iterator++)
{
(*iterator)->Update(elapsedTime);
}
}
// Draws and rotates our cube
void DrawAndRotateCube()
{
const float kAngleInc = DEG2RAD(2); // Add 2° each update
static float angle = 0; // The angle of rotation
D3DXMATRIXA16 matrix;
g3D->begin(); // Begin the scene
g3D->clear(D3DCOLOR_XRGB(200, 0, 0)); // Clear the viewport
// Rotate the cube
D3DXMatrixRotationYawPitchRoll(&matrix, angle, angle, angle);
g3D->setWorldMatrix(&matrix);
// Render the cube
g3D->render(gCubeVerts, kCubeVertCount, gCubeIndices, kCubeIndiceCount);
g3D->end(); // End the scene
angle += kAngleInc; // Update the angle for next render
}
