void CGameRenderer::DrawBackground(float x){
const float delta = 2.0f * g_nScreenWidth;
float fQuantizeX = delta * (int)(100/delta - 1.0f) + g_nScreenWidth; ///< Quantized x coordinate
//set vertex buffer to background
m_d3ddevice->SetStreamSource(0, m_pBackgroundVB, 0, sizeof(BILLBOARDVERTEX));
m_d3ddevice->SetFVF(BILLBOARDVERTEX::FVF); //flexible vertex format
//draw floor
if(g_bWireFrame)m_d3ddevice->SetTexture(0, m_pWireframeTexture); //set wireframe texture
else m_d3ddevice->SetTexture(0, m_pBackgroundTexture); //set floor texture
SetWorldMatrix(fQuantizeX);
m_d3ddevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
SetWorldMatrix(fQuantizeX-delta);
m_d3ddevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
/*draw backdrop
if(!g_bWireFrame)
m_d3ddevice->SetTexture(0, m_pBackgroundTexture); //set cloud texture
SetWorldMatrix(fQuantizeX);
m_d3ddevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 2, 2);
SetWorldMatrix(fQuantizeX-delta);
m_d3ddevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 2, 2);
*/
} //DrawBackground
void CModel::ResetTransform(){
for( CEntity *child=Children();child;child=child->Next() ){
if( CModel *model=dynamic_cast<CModel*>( child ) ) model->ResetTransform();
}
TransformSurfaces( WorldMatrix() );
SetWorldMatrix( CMat4() );
}
//-----------------------------------------------------------------------------
// Desc: 渲染场景
//-----------------------------------------------------------------------------
VOID Render()
{
// 清除缓冲区
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );
//开始渲染场景
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
SetWorldMatrix(); //设置世界矩阵
//逐块渲染网格模型
for( DWORD i=0; i<g_dwNumMaterials; i++ )
{
//设置材料和纹理
g_pd3dDevice->SetMaterial( &g_pMeshMaterials[i] );
g_pd3dDevice->SetTexture( 0, g_pMeshTextures[i] );
//渲染模型
g_pMesh->DrawSubset( i );
}
//场景渲染结束
g_pd3dDevice->EndScene();
}
//在屏幕上显示场景
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
//プレートの作成
void GameStage::CreatePlate(){
//ステージへのゲームオブジェクトの追加
auto Ptr = AddGameObject<GameObject>();
auto PtrTransMatrix = Ptr->GetComponent<TransformMatrix>();
Quaternion Qt;
Qt.RotationRollPitchYawFromVector(Vector3(XM_PIDIV2, 0, 0));
Matrix4X4 WorldMat;
WorldMat.DefTransformation(
Vector3(200.0f, 200.0f, 1.0f),
Qt,
Vector3(0.0f, 0.0f, 0.0f)
);
PtrTransMatrix->SetWorldMatrix(WorldMat);
//描画コンポーネントの追加
auto DrawComp = Ptr->AddComponent<PNTStaticDraw>();
//描画コンポーネントに形状（メッシュ）を設定
DrawComp->SetMeshResource(L"DEFAULT_SQUARE");
//描画コンポーネントテクスチャの設定
DrawComp->SetTextureResource(L"SKY_TX");
//自分に影が映りこむようにする
DrawComp->SetOwnShadowActive(true);
}
bool DX9RenderSystem::Begin2d( )
{
SetCullMode( CullMode::NONE );
SetFillMode( FillMode::SOLID );
SetProjectionMatrix( Matrix4::CreateOrthoLH( (float)mSize.x, -(float)mSize.y, 0.0f, 1.0f ) );
SetViewMatrix( Matrix4::IDENTITY );
SetWorldMatrix( Matrix4::IDENTITY );
SetVertexDeclaration( m2dDecl );
SetTextureStageState( 0, TextureState::TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
SetTextureStageState( 0, TextureState::COLOROP, BlendOp::MODULATE );
SetTextureStageState( 0, TextureState::COLORARG1, BlendArg::TEXTURE );
SetTextureStageState( 0, TextureState::COLORARG2, BlendArg::DIFFUSE );
SetTextureStageState( 0, TextureState::ALPHAOP, BlendOp::MODULATE );
SetTextureStageState( 0, TextureState::ALPHAARG1, BlendArg::TEXTURE );
SetTextureStageState( 0, TextureState::ALPHAARG2, BlendArg::DIFFUSE );
SetTextureStageState( 1, TextureState::COLOROP, BlendOp::DISABLE );
SetTextureStageState( 1, TextureState::ALPHAOP, BlendOp::DISABLE );
SetAlphaBlendEnabled( true );
SetAlphaTestEnabled( false );
SetDepthWriteEnabled( true );
SetDepthBufferEnabled( false );
SetSpecularEnabled( false );
return true;
};
void Update ( void )
{
NxVec3 forceDir ( -1, 0, 0 );
NxReal forceStrength = 100;
NxVec3 forceVec = forceStrength*forceDir;
this->tractor->addForce(forceVec);
g_iValue = 10;
for (int i=0; i<2; i++)
{
NxMat34 pose = frontWheels [ i ].wheel->getGlobalPose ( );
NxMat33 orient = pose.M;
NxVec3 pos = pose.t;
float glmat[16];
orient.getColumnMajorStride4(&(glmat[0]));
pos.get(&(glmat[12]));
glmat[3] = glmat[7] = glmat[11] = 0.0f;
glmat[15] = 1.0f;
SetWorldMatrix ( g_iValue, ( D3DXMATRIX* ) &glmat );
sObject* pObject = dbGetObject ( g_iValue++ );
pObject->position.vecPosition = D3DXVECTOR3 ( glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
}
for (int i=0; i<2; i++)
{
NxMat34 pose = steerWheels [ i ].wheel.wheel->getGlobalPose ( );
NxMat33 orient = pose.M;
NxVec3 pos = pose.t;
float glmat[16];
orient.getColumnMajorStride4(&(glmat[0]));
pos.get(&(glmat[12]));
glmat[3] = glmat[7] = glmat[11] = 0.0f;
glmat[15] = 1.0f;
SetWorldMatrix ( g_iValue, ( D3DXMATRIX* ) &glmat );
sObject* pObject = dbGetObject ( g_iValue++ );
pObject->position.vecPosition = D3DXVECTOR3 ( glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
}
//dbPositionObject ( g_iValue, glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
}
// 初期化
void CMglMatrixManager::Init( CMglGraphicManager* in_myudg )
{
//CMglDgBase::Init(in_myudg);
CMglCameraMatrixManager::Init(in_myudg);
// デフォルトワールドマトリックスを設定しておく
SetWorldMatrix(m_initWorld);
}
void Transform::CalculateWordlMatrix()
{
if( parent )
{
SetWorldMatrix( parent->GetWordlMatrix() * GetLocalMatrix() );
}else
{
mWorldMatrix = GetLocalMatrix();
}
}
void NsRendererOGL3::ResetMatrices()
{
mWorldMatrix = NsMatrix4::Identity();
mViewMatrix = NsMatrix4::Identity();
mProjMatrix = NsMatrix4::Identity();
SetWorldMatrix(NsMatrix4::Identity());
SetViewMatrix(NsMatrix4::Identity());
SetProjectionMatrix(NsMatrix4::Identity());
}
void Display()
{
d3d.ClearScene();
d3d.BeginScene();
//render at here
SetWorldMatrix();
//设置环境光
d3d.GetD3DDevice()->SetRenderState(D3DRS_AMBIENT,0x00ffffff);
TryModel.Draw();
d3d.EndScene();
}
//===============================================
//処理
//===============================================
//[input]
// なし
//[return]
// なし
//===============================================
void CField::Exec()
{
//::D3DXVec3TransformCoord(&vAxisX, &vAxisX, &m_matRotate);
//::D3DXVec3TransformCoord(&vAxisZ, &vAxisZ, &m_matRotate);
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_LEFT) )
//{
// m_vPos -= vAxisX*0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_RIGHT) )
//{
// m_vPos += vAxisX*0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_UP) )
//{
// m_vPos -= vAxisZ * 0.1f;
// //m_vPos.z -= 0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_DOWN) )
//{
// m_vPos += vAxisZ * 0.1f;
// //m_vPos.z += 0.1f;
// //m_Anim += 1.0f;
//}
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_BUTTON_02) )
//{
// m_vRot.x += 0.1f;
//}
// Update(0.000f);
Translation(m_vPos.x, m_vPos.y, m_vPos.z);
Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
Heading(m_vRot.x);
Pitching(m_vRot.x);
Rolling(m_vRot.x);
Render(Joker::GetDevice());
SetWorldMatrix();
}
void PhysUpdate ( void )
{
int iObject = 1;
// Render all the actors in the scene
int nbActors = gScene->getNbActors();
NxActor** actors = gScene->getActors();
while (nbActors--)
{
NxActor* actor = *actors++;
// Get an OpenGL transform (float[16]) from a Novodex shape’s global pose
// (NxMat34)
NxShape* shape = NULL;
NxMat34 pose = actor->getGlobalPose();
NxMat33 orient = pose.M;
NxVec3 pos = pose.t;
float glmat[16]; // 4x4 column major OpenGL matrix
orient.getColumnMajorStride4(&(glmat[0]));
pos.get(&(glmat[12]));
// clear the elements we don't need:
glmat[3] = glmat[7] = glmat[11] = 0.0f;
glmat[15] = 1.0f;
{
sPhysObject* pPhys = ( sPhysObject* ) actor->userData;
if ( pPhys )
{
SetWorldMatrix ( pPhys->iID, ( D3DXMATRIX* ) &glmat );
sObject* pObject = dbGetObject ( pPhys->iID );
pObject->position.vecPosition = D3DXVECTOR3 ( glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
}
}
}
}
BOOL CGeometry::TransformLights(D3DVECTOR *CameraRotation,D3DVECTOR *CameraPosition)
{
HRESULT ddrval;
for(int i=0; i<MAXLIGHTS; i++) {
if(m_Lights[i].InUse) {
D3DVECTOR RelVec = m_Lights[i].Position;
RelVec.x -= CameraPosition->x;
RelVec.y -= CameraPosition->y;
RelVec.z -= CameraPosition->z;
SetWorldMatrix(CameraRotation);
RotateVector(&RelVec,&m_Lights[i].LightDesc.dvPosition);
if(m_Lights[i].Transform) {
RelVec = m_Lights[i].Direction;
RotateVector(&RelVec,&m_Lights[i].LightDesc.dvDirection);
}
DXCALL(m_Lights[i].Light->SetLight(&m_Lights[i].LightDesc));
}
}
return TRUE;
}
//===============================================
//処理
//===============================================
void CCursor::Exec()
{
if( !m_IsEnd )
{
Translation(m_vPos.x, m_vPos.y, m_vPos.z);
//Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
//Heading(m_vRot.x);
//
//Pitching(m_vRot.x);
//
//Rolling(m_vRot.x);
// Update(0.000f);
Render(Joker::GetDevice());
SetWorldMatrix();
}
//m_CurTex.Draw(m_vPos.x, m_vPos.y);
}
//===============================================
//処理
//===============================================
void CEffect::Exec()
{
//SetPosition(
if(m_IsVariable)
{
Translation(m_vPos.x, m_vPos.y, m_vPos.z);
Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
//Heading(m_vRot.x);
//
Pitching(m_vRot.x);
//
//Rolling(m_vRot.x);
Render(Joker::GetDevice());
m_pAnimController->AdvanceTime(m_AnimSpeed, NULL);
SetWorldMatrix();
}
}
/*virtual*/ void D3D9Renderer::RenderBucket(
Bucket* pBucket, const ViewportPass* const pViewportPass) {
XTRACE_FUNCTION;
PROFILE_FUNCTION;
if (pBucket->m_RenderTarget) {
SetRenderTarget(pBucket->m_RenderTarget);
if (pViewportPass) {
SetViewport(pViewportPass);
}
}
if (pBucket->m_ClearFlags != CLEAR_NONE) {
Clear(pBucket->m_ClearFlags, pBucket->m_ClearColor, pBucket->m_ClearDepth);
}
if (pBucket->m_View) {
View* const pView = pViewportPass ? pViewportPass->GetView(pBucket->m_View)
: pBucket->m_View;
m_View = *pView;
m_View.ApplyToRenderer(*this);
}
if (pBucket->m_Flags & MAT_ALPHA) {
pBucket->Sort(m_View);
} else if (m_DoMaterialSort && pBucket->m_SortByMaterial) {
pBucket->SortByMaterials();
}
Mesh* pMesh = NULL;
D3D9VertexBuffer* VertexBuffer = NULL;
D3D9IndexBuffer* IndexBuffer = NULL;
IVertexDeclaration* pVertexDeclaration = NULL;
uint NumMeshes = pBucket->m_Meshes.Size();
Frustum ViewFrustum(GetViewMatrix() * GetProjectionMatrix());
#if BUILD_DEBUG
if (pBucket->m_DEBUGUseFrustum) {
pBucket->m_DEBUGFrustumView.ApplyToFrustum(ViewFrustum);
}
#endif
for (uint MeshIndex = 0; MeshIndex < NumMeshes; ++MeshIndex) {
XTRACE_NAMED(RenderBucketMesh);
pMesh = pBucket->m_Meshes[MeshIndex];
DEVASSERT(pMesh);
DEVASSERT(pMesh->m_VertexBuffer->GetNumVertices() > 0);
const uint MaterialFlags = pMesh->GetMaterialFlags();
// Frustum culling--I can't do this earlier, when a mesh is added, because
// it might be visible in one view (e.g., shadow map depth) and not to
// player.
if (!m_DoFrustumCulling || pBucket->m_Flags & MAT_HUD ||
pBucket->m_Flags & MAT_INWORLDHUD ||
#if BUILD_DEV
pBucket->m_Flags & MAT_DEBUG_ALWAYS ||
MaterialFlags & MAT_DEBUG_ALWAYS ||
#endif
pBucket->m_Flags & MAT_ALWAYS || MaterialFlags & MAT_ALWAYS ||
ViewFrustum.Intersects(pMesh->m_AABB)) {
VertexBuffer = (D3D9VertexBuffer*)pMesh->m_VertexBuffer;
IndexBuffer = (D3D9IndexBuffer*)pMesh->m_IndexBuffer;
// RENDERTODO: It might be useful to adapt this for material overrides in
// the future
// Shader = (D3D9Shader*)( pBucket->m_OverrideShader ?
// pBucket->m_OverrideShader : pMesh->m_OLDMaterial.m_Shader );
if (pMesh->m_VertexDeclaration != pVertexDeclaration) {
XTRACE_NAMED(SetVertexDeclaration);
m_D3DDevice->SetVertexDeclaration(
(IDirect3DVertexDeclaration9*)
pMesh->m_VertexDeclaration->GetDeclaration());
}
pVertexDeclaration = pMesh->m_VertexDeclaration;
DEVASSERT(VertexBuffer);
DEVASSERT(pVertexDeclaration);
DEVASSERT(IndexBuffer);
SetWorldMatrix(pMesh->GetConcatenatedTransforms());
{
XTRACE_NAMED(SetStreams);
uint VertexSignature = pVertexDeclaration->GetSignature();
uint Index = 0;
#define SETSTREAM(STREAM, SIGNATURE, TYPE) \
if (SIGNATURE == (VertexSignature & SIGNATURE)) { \
IDirect3DVertexBuffer9* const pBuffer = \
static_cast<IDirect3DVertexBuffer9*>(VertexBuffer->Get##STREAM()); \
DEVASSERT(pBuffer); \
m_D3DDevice->SetStreamSource(Index++, pBuffer, 0, sizeof(TYPE)); \
}
SETSTREAM(Positions, VD_POSITIONS, Vector);
SETSTREAM(Colors, VD_COLORS, uint);
#if USE_HDR
SETSTREAM(FloatColors1, VD_FLOATCOLORS, Vector4);
SETSTREAM(FloatColors2, VD_BASISCOLORS, Vector4);
SETSTREAM(FloatColors3, VD_BASISCOLORS, Vector4);
// For SM2 cards, an alternative way to do HDR colors
SETSTREAM(FloatColors1, VD_FLOATCOLORS_SM2, Vector4);
SETSTREAM(FloatColors2, VD_BASISCOLORS_SM2, Vector4);
SETSTREAM(FloatColors3, VD_BASISCOLORS_SM2, Vector4);
#endif
SETSTREAM(UVs, VD_UVS, Vector2);
SETSTREAM(Normals, VD_NORMALS, Vector);
SETSTREAM(Tangents, VD_TANGENTS, Vector4);
SETSTREAM(BoneIndices, VD_BONEINDICES, SBoneData);
SETSTREAM(BoneWeights, VD_BONEWEIGHTS, SBoneData);
#undef SETSTREAM
m_D3DDevice->SetIndices(
(IDirect3DIndexBuffer9*)IndexBuffer->GetIndices());
}
ApplyMaterial(pMesh->m_Material, pMesh, m_View);
if (VertexBuffer->GetNumVertices() > 0) {
XTRACE_NAMED(DrawIndexedPrimitive);
m_D3DDevice->DrawIndexedPrimitive(IndexBuffer->GetPrimitiveType(), 0, 0,
VertexBuffer->GetNumVertices(), 0,
IndexBuffer->GetNumPrimitives());
}
#if BUILD_DEBUG
++m_DEBUGRenderStats.NumMeshes;
m_DEBUGRenderStats.NumPrimitives += IndexBuffer->GetNumPrimitives();
#endif
}
#if BUILD_DEV
// WARNING: This assumes the mesh is only in one bucket, which could be bad
if (pMesh->m_IsDebugMesh) {
m_DeferredDeleteDebugMeshes.PushBackUnique(pMesh);
}
#endif
}
}
bool Graphics::CreateDefaultShader()
{
HRESULT r = 0;
ID3DBlob* vsBuffer = 0;
ID3DBlob* buffer = 0;
ID3DBlob* Errors = 0;
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG;
bool b = CompileD3DShader("..\\te010\\DefaultShader.fx", 0, "fx_5_0", &buffer);
if (!b)
{
if (buffer)
{
buffer->Release();
}
NAIA_FATAL("Unnable to compile default shader");
}
r = D3DX11CreateEffectFromMemory(buffer->GetBufferPointer(), buffer->GetBufferSize(), 0 , m_Device, &m_Effect);
if (FAILED(r))
{
NAIA_FATAL("Unnable to create effect");
}
m_Technique = m_Effect->GetTechniqueByName("DefaultTechnique");
if (!m_Technique)
{
NAIA_FATAL("Can not find DefaultTechnique in default shader");
}
D3D11_INPUT_ELEMENT_DESC defaultLayout[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0}
};
unsigned int totalLayoutElements = ARRAYSIZE(defaultLayout);
D3DX11_PASS_DESC descPASS;
m_Technique->GetPassByIndex(0)->GetDesc(&descPASS);
r = m_Device->CreateInputLayout(defaultLayout, totalLayoutElements, descPASS.pIAInputSignature, descPASS.IAInputSignatureSize, &m_InputLayout);
if (FAILED(r))
{
NAIA_FATAL("Failed to create input layout");
}
m_Context->IASetInputLayout(m_InputLayout);
Mat4x4 world = Mat4x4::g_Identity;
SetWorldMatrix(world);
Mat4x4 view = Mat4x4::g_Identity;
Vec3 eye(6.0f, 6.0f, 6.0f);
Vec3 at(0.f,0.f,0.f);
Vec3 up(0.f,1.0f,0.f);
D3DXMatrixLookAtLH(&view, &eye, &at, &up);
SetViewMatrix(view);
Mat4x4 proj = Mat4x4::g_Identity;
D3DXMatrixPerspectiveFovLH(&proj, NAIA_PI/2, Application::instance()->m_Width/(float)Application::instance()->m_Height, 0.01f, 100.0f);
SetProjectionMatrix(proj);
#pragma region Create constant buffers
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(CBNeverChanges);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
r = m_Device->CreateBuffer(&bd, NULL, &m_cbNeverChanges);
if (FAILED(r))
{
NAIA_FATAL("Can not create constant buffer (Never changes)");
}
bd.ByteWidth = sizeof(CBChangeOnResize);
r = m_Device->CreateBuffer(&bd, NULL, &m_cbChangesOnResize);
if (FAILED(r))
{
NAIA_FATAL("Can not create constant buffer (Changes on resize)");
}
bd.ByteWidth = sizeof(CBChangesEveryFrame);
r = m_Device->CreateBuffer(&bd, NULL, &m_cbChangesEveryFrame);
if (FAILED(r))
{
NAIA_FATAL("Can not create constant buffer (Changes every frame)");
}
#pragma endregion
CBNeverChanges cbNeverChanges;
cbNeverChanges.View = view;
m_Context->UpdateSubresource(m_cbNeverChanges, 0, NULL, &cbNeverChanges, 0, 0);
CBChangeOnResize cbChangesOnResize;
cbChangesOnResize.Projection = proj;
m_Context->UpdateSubresource(m_cbChangesOnResize, 0, NULL, &cbChangesOnResize, 0, 0);
CBChangesEveryFrame cbChangesEveryFrame;
cbChangesEveryFrame.World = world;
m_Context->UpdateSubresource(m_cbChangesEveryFrame, 0, NULL, &cbChangesEveryFrame, 0, 0);
return true;
}
void TickCar ( void )
{
g_iValue = 10;
NxReal steeringAngle = gSteeringValue * gMaxSteeringAngle;
NxArray<CarWheelContact>::iterator i = wheelContactPoints.begin();
while(i != wheelContactPoints.end())
{
CarWheelContact& cwc = *i;
WheelShapeUserData* wheelData = (WheelShapeUserData *)(cwc.wheel->userData);
/*
struct CarWheelContact
{
NxActor* car;
NxShape* wheel;
NxVec3 contactPoint;
NxVec3 contactNormalForce;
NxVec3 contactFrictionForce;
};
*/
{
NxMat34 pose = cwc.wheel->getGlobalPose ( );
NxMat33 orient = pose.M;
NxVec3 pos = pose.t;
float glmat[16];
orient.getColumnMajorStride4(&(glmat[0]));
pos.get(&(glmat[12]));
glmat[3] = glmat[7] = glmat[11] = 0.0f;
glmat[15] = 1.0f;
SetWorldMatrix ( g_iValue, ( D3DXMATRIX* ) &glmat );
sObject* pObject = dbGetObject ( g_iValue );
pObject->position.vecPosition = D3DXVECTOR3 ( glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
//dbPositionObject ( g_iValue, glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
g_iValue++;
}
//apply to powered wheels only.
if (wheelData->frontWheel)
{
//steering:
NxMat33 wheelOrientation = cwc.wheel->getLocalOrientation();
wheelOrientation.setColumn(0, NxVec3(NxMath::cos(steeringAngle), 0, NxMath::sin(steeringAngle) ));
wheelOrientation.setColumn(2, NxVec3(NxMath::sin(steeringAngle), 0, -NxMath::cos(steeringAngle) ));
cwc.wheel->setLocalOrientation(wheelOrientation);
if (frontWheelIsPowered)
{
//get the world space orientation:
wheelOrientation = cwc.wheel->getGlobalOrientation();
NxVec3 steeringDirection;
wheelOrientation.getColumn(0, steeringDirection);
//the power direction of the front wheel is the wheel's axis as it is steered.
if (gMotorForce)
{
cwc.car->addForceAtPos(steeringDirection * gMotorForce,cwc.contactPoint);
}
}
}
if (!wheelData->frontWheel && rearWheelIsPowered)
{
//get the orientation of this car:
NxMat33 m = cwc.car->getGlobalOrientation();
NxVec3 carForwardAxis;
m.getColumn(0, carForwardAxis);
//the power direction of the rear wheel is always the car's length axis.
cwc.car->addForceAtPos(carForwardAxis * gMotorForce,cwc.contactPoint);
}
i++;
}
wheelContactPoints.clear();
}
void NsRendererOGL3::Draw(const NsQuad3D & quad)
{
SetDrawColor(0.4f, 0.12f, 1.f);
SetWorldMatrix(quad.GetWorldTransform());
if(quad.bUseASCIIShader && !quad.shaderID < 1)
{
GLuint fontID = NsOGLResourceManager::Instance()->GetResourceID("/Textures/ASCII/ascii.png");
glUseProgram(quad.shaderID);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glActiveTexture(GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, quad.textureID);
GLint iTextureUniform = glGetUniformLocation(quad.shaderID, "colorMap");
glUniform1i(iTextureUniform, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture (GL_TEXTURE_2D, fontID);
GLint iASCIIUniform = glGetUniformLocation(quad.shaderID, "asciiMap");
glUniform1i(iASCIIUniform, 1);
glBegin (GL_QUADS);
{
glTexCoord2f (0.0, 0.0);
glVertex3f (0.0, 0.0, 0.0);
glTexCoord2f (1.0, 0.0);
glVertex3f (quad.fWidth, 0.0, 0.0);
glTexCoord2f (1.0, 1.0);
glVertex3f (quad.fWidth, quad.fHeight, 0.0);
glTexCoord2f (0.0, 1.0);
glVertex3f (0.0, quad.fHeight, 0.0);
}
glEnd ();
glUseProgram(0);
glDisable(GL_TEXTURE_2D);
}
else
{
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glActiveTexture(GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, quad.textureID);
glBegin (GL_QUADS);
{
glTexCoord2f (0.0, 0.0);
glVertex3f (0.0, 0.0, 0.0);
glTexCoord2f (1.0, 0.0);
glVertex3f (quad.fWidth, 0.0, 0.0);
glTexCoord2f (1.0, 1.0);
glVertex3f (quad.fWidth, quad.fHeight, 0.0);
glTexCoord2f (0.0, 1.0);
glVertex3f (0.0, quad.fHeight, 0.0);
}
glEnd ();
glDisable(GL_TEXTURE_2D);
}
}
