bool InitScene()
{
///////////////**************new**************////////////////////
if(!LoadObjModel(d3d11Device, L"dragonbone_male.obj", groundModel, material, textureMgr, true, true))
return false;
///////////////**************new**************////////////////////
if(!LoadObjModel(d3d11Device, L"Female.obj", groundModel1, material1, textureMgr1, true, true))
return false;
if(!LoadObjModel(d3d11Device, L"ground.obj", groundModel2, material2, textureMgr2, true, true))
return false;
// Compile Shaders from shader file
hr = D3DX11CompileFromFile(L"Effects.fx", 0, 0, "VS", "vs_4_0", 0, 0, 0, &VS_Buffer, 0, 0);
hr = D3DX11CompileFromFile(L"Effects.fx", 0, 0, "PS", "ps_4_0", 0, 0, 0, &PS_Buffer, 0, 0);
// Create the Shader Objects
hr = d3d11Device->CreateVertexShader(VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), NULL, &VS);
hr = d3d11Device->CreatePixelShader(PS_Buffer->GetBufferPointer(), PS_Buffer->GetBufferSize(), NULL, &PS);
// Set Vertex and Pixel Shaders
d3d11DevCon->VSSetShader(VS, 0, 0);
d3d11DevCon->PSSetShader(PS, 0, 0);
light.pos = XMFLOAT3(0.0f, 7.0f, 0.0f);
light.dir = XMFLOAT3(0.5f, 0.75f, -0.5f);
light.range = 1000.0f;
light.cone = 12.0f;
light.att = XMFLOAT3(0.4f, 0.02f, 0.000f);
light.ambient = XMFLOAT4(0.2f, 0.2f, 0.2f, 1.0f);
light.diffuse = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
// Create the Input Layout
hr = d3d11Device->CreateInputLayout( layout, numElements, VS_Buffer->GetBufferPointer(),
VS_Buffer->GetBufferSize(), &vertLayout );
// Set the Input Layout
d3d11DevCon->IASetInputLayout( vertLayout );
// Set Primitive Topology
d3d11DevCon->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
// Create the Viewport
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = Width;
viewport.Height = Height;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
// Set the Viewport
d3d11DevCon->RSSetViewports(1, &viewport);
// Create the buffer to send to the cbuffer in effect file
D3D11_BUFFER_DESC cbbd;
ZeroMemory(&cbbd, sizeof(D3D11_BUFFER_DESC));
cbbd.Usage = D3D11_USAGE_DEFAULT;
cbbd.ByteWidth = sizeof(cbPerObject);
cbbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbbd.CPUAccessFlags = 0;
cbbd.MiscFlags = 0;
hr = d3d11Device->CreateBuffer(&cbbd, NULL, &cbPerObjectBuffer);
// Create the buffer to send to the cbuffer per frame in effect file
ZeroMemory(&cbbd, sizeof(D3D11_BUFFER_DESC));
cbbd.Usage = D3D11_USAGE_DEFAULT;
cbbd.ByteWidth = sizeof(cbPerFrame);
cbbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbbd.CPUAccessFlags = 0;
cbbd.MiscFlags = 0;
hr = d3d11Device->CreateBuffer(&cbbd, NULL, &cbPerFrameBuffer);
// Camera information
camPosition = XMVectorSet( 0.0f, 5.0f, -8.0f, 0.0f );
camTarget = XMVectorSet( 0.0f, 0.5f, 0.0f, 0.0f );
camUp = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );
// Set the View matrix
camView = XMMatrixLookAtLH( camPosition, camTarget, camUp );
// Set the Projection matrix
camProjection = XMMatrixPerspectiveFovLH( 0.4f*3.14f, Width/Height, 1.0f, 1000.0f);
// Describe the Sample State
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory( &sampDesc, sizeof(sampDesc) );
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
//Create the Sample State
hr = d3d11Device->CreateSamplerState( &sampDesc, &LinearSamplerState );
D3D11_RASTERIZER_DESC cmdesc;
ZeroMemory(&cmdesc, sizeof(D3D11_RASTERIZER_DESC));
cmdesc.FillMode = D3D11_FILL_SOLID;
cmdesc.CullMode = D3D11_CULL_BACK;
cmdesc.FrontCounterClockwise = true;
hr = d3d11Device->CreateRasterizerState(&cmdesc, &CCWcullMode);
cmdesc.FrontCounterClockwise = false;
hr = d3d11Device->CreateRasterizerState(&cmdesc, &CWcullMode);
cmdesc.CullMode = D3D11_CULL_NONE;
//cmdesc.FillMode = D3D11_FILL_WIREFRAME;
hr = d3d11Device->CreateRasterizerState(&cmdesc, &RSCullNone);
D3D11_BLEND_DESC blendDesc;
ZeroMemory( &blendDesc, sizeof(blendDesc) );
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory( &rtbd, sizeof(rtbd) );
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.DestBlend = D3D11_BLEND_SRC_ALPHA;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.DestBlendAlpha = D3D11_BLEND_SRC_ALPHA;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
d3d11Device->CreateBlendState(&blendDesc, &Transparency);
return true;
}
void UpdateScene(double time)
{
//the loaded models world space
groundModel.World = XMMatrixIdentity();
groundModel1.World = XMMatrixIdentity();
groundModel2.World = XMMatrixIdentity();
Rotation = XMMatrixRotationY(3.14f);
Scale = XMMatrixScaling( 1.0f, 1.0f, 1.0f );
Translation = XMMatrixTranslation( 0.0f, 0.0f, 0.0f );
groundModel.World = Rotation * Scale * Translation;
groundModel1.World = Rotation * Scale * Translation;
groundModel2.World = Rotation * Scale * Translation;
}
void DrawObject(ObjModel &groundModels,std::vector<SurfaceMaterial> &material,TextureManager &textureMgr){
for(int i = 0; i < groundModels.Subsets; ++i)
{
// Only draw the NON-transparent parts of the model.
if(!material1[groundModels.SubsetMaterialID].IsTransparent)
{
cbPerObj.difColor = material[groundModels.SubsetMaterialID].Diffuse; // Let shader know which color to draw the model
// (if no diffuse texture we defined)
cbPerObj.hasTexture = material[groundModels.SubsetMaterialID].HasDiffTexture; // Let shader know if we need to use a texture
cbPerObj.hasNormMap = material[groundModels.SubsetMaterialID].HasNormMap; // Let shader know if we need to do normal mapping
d3d11DevCon->UpdateSubresource( cbPerObjectBuffer, 0, NULL, &cbPerObj, 0, 0 );
d3d11DevCon->VSSetConstantBuffers( 0, 1, &cbPerObjectBuffer );
d3d11DevCon->PSSetConstantBuffers( 1, 1, &cbPerObjectBuffer );
// If this subset has a diffuse texture, send it to the pixel shader
if(material[groundModels.SubsetMaterialID].HasDiffTexture)
d3d11DevCon->PSSetShaderResources( 0, 1, &textureMgr.TextureList[material[groundModels.SubsetMaterialID].DiffuseTextureID] );
// If this subset has a normal (bump) map, send it to the pixel shader
if(material[groundModels.SubsetMaterialID].HasNormMap)
d3d11DevCon->PSSetShaderResources( 1, 1, &textureMgr.TextureList[material[groundModels.SubsetMaterialID].NormMapTextureID] );
// Draw the NON-transparent stuff
int indexStart = groundModels.SubsetIndexStart;
int indexDrawAmount = groundModels.SubsetIndexStart[i+1] - indexStart;
d3d11DevCon->DrawIndexed( indexDrawAmount, indexStart, 0 );
}
}
}
void DrawTransObject(ObjModel &groundModel,std::vector<SurfaceMaterial> &material,TextureManager &textureMgr){
for(int i = 0; i < groundModel.Subsets; ++i)
{
// Only draw the TRANSPARENT parts of the model now.
if(material[groundModel.SubsetMaterialID].IsTransparent)
{
cbPerObj.difColor = material[groundModel.SubsetMaterialID].Diffuse; // Let shader know which color to draw the model
// (if no diffuse texture we defined)
cbPerObj.hasTexture = material[groundModel.SubsetMaterialID].HasDiffTexture; // Let shader know if we need to use a texture
cbPerObj.hasNormMap = material[groundModel.SubsetMaterialID].HasNormMap; // Let shader know if we need to do normal mapping
d3d11DevCon->UpdateSubresource( cbPerObjectBuffer, 0, NULL, &cbPerObj, 0, 0 );
d3d11DevCon->VSSetConstantBuffers( 0, 1, &cbPerObjectBuffer );
d3d11DevCon->PSSetConstantBuffers( 1, 1, &cbPerObjectBuffer );
// If this subset has a diffuse texture, send it to the pixel shader
if(material[groundModel.SubsetMaterialID].HasDiffTexture)
d3d11DevCon->PSSetShaderResources( 0, 1, &textureMgr.TextureList[material[groundModel.SubsetMaterialID].DiffuseTextureID] );
// If this subset has a normal (bump) map, send it to the pixel shader
if(material[groundModel.SubsetMaterialID].HasNormMap)
d3d11DevCon->PSSetShaderResources( 1, 1, &textureMgr.TextureList[material[groundModel.SubsetMaterialID].NormMapTextureID] );
// The transparent parts are now drawn
int indexStart = groundModel.SubsetIndexStart;
int indexDrawAmount = groundModel.SubsetIndexStart[i+1] - indexStart;
d3d11DevCon->DrawIndexed( indexDrawAmount, indexStart, 0 );
}
}
}
void DrawScene()
{
// Clear our render target and depth/stencil view
float bgColor[4] = { 0.1f, 0.1f, 0.1f, 1.0f };
d3d11DevCon->ClearRenderTargetView(renderTargetView, bgColor);
d3d11DevCon->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
// Update the cbPerFrame
constbuffPerFrame.light = light;
d3d11DevCon->UpdateSubresource( cbPerFrameBuffer, 0, NULL, &constbuffPerFrame, 0, 0 );
d3d11DevCon->PSSetConstantBuffers(0, 1, &cbPerFrameBuffer);
// Set our Render Target
d3d11DevCon->OMSetRenderTargets( 1, &renderTargetView, depthStencilView );
// Set the default blend state (no blending) for opaque objects
d3d11DevCon->OMSetBlendState(0, 0, 0xffffffff);
// Set Vertex and Pixel Shaders
d3d11DevCon->VSSetShader(VS, 0, 0);
d3d11DevCon->PSSetShader(PS, 0, 0);
d3d11DevCon->PSSetSamplers( 0, 1, &LinearSamplerState );
d3d11DevCon->RSSetState(RSCullNone);
/////Draw our model's NON-transparent subsets/////
// Only set the vert and index buffer once per model
// Set the grounds index buffer
d3d11DevCon->IASetIndexBuffer( groundModel1.IndexBuff, DXGI_FORMAT_R32_UINT, 0);
// Set the grounds vertex buffer
d3d11DevCon->IASetVertexBuffers( 0, 1, &groundModel1.VertBuff, &stride, &offset );
// Set the WVP matrix and send it to the constant buffer in effect file
// This also only needs to be set once per model
WVP = groundModel1.World * camView * camProjection;
cbPerObj.WVP = XMMatrixTranspose(WVP);
cbPerObj.World = XMMatrixTranspose(groundModel1.World);
//WVP = groundModel1.World * camView * camProjection;
// cbPerObj.WVP = XMMatrixTranspose(WVP);
// cbPerObj.World = XMMatrixTranspose(groundModel1.World);
DrawObject(groundModel1,material1,textureMgr1);
Translation = XMMatrixTranslation( 0.0f, -5.0f, 0.0f );
Scale = XMMatrixScaling( .1f, .1f, .1f );
WVP = groundModel.World * (Scale * Translation ) * camView * camProjection;
cbPerObj.WVP = XMMatrixTranspose(WVP);
cbPerObj.World = XMMatrixTranspose(groundModel.World);
d3d11DevCon->IASetIndexBuffer( groundModel.IndexBuff, DXGI_FORMAT_R32_UINT, 0);
d3d11DevCon->IASetVertexBuffers( 0, 1, &groundModel.VertBuff, &stride, &offset );
DrawObject(groundModel,material,textureMgr);
DrawTransObject(groundModel,material,textureMgr);
d3d11DevCon->IASetIndexBuffer( groundModel2.IndexBuff, DXGI_FORMAT_R32_UINT, 0);
d3d11DevCon->IASetVertexBuffers( 0, 1, &groundModel2.VertBuff, &stride, &offset );
DrawObject(groundModel2,material2,textureMgr2);
//Present the backbuffer to the screen
SwapChain->Present(0, 0);
}
I have 3 obj files loading into one location and I was trying to figure out how I can load these objects at specific points in a x,y,z location point without using Translation.