Jump to content

  • Log In with Google      Sign In   
  • Create Account

Loading models at specific locations in World view


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
2 replies to this topic

#1 VoidAccess   Members   -  Reputation: 109

Like
0Likes
Like

Posted 20 March 2013 - 04:12 PM

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[i]].IsTransparent)            
        {
            cbPerObj.difColor = material[groundModels.SubsetMaterialID[i]].Diffuse;      // Let shader know which color to draw the model
                                                                                        // (if no diffuse texture we defined)
            cbPerObj.hasTexture = material[groundModels.SubsetMaterialID[i]].HasDiffTexture; // Let shader know if we need to use a texture
            cbPerObj.hasNormMap = material[groundModels.SubsetMaterialID[i]].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[i]].HasDiffTexture)    
                d3d11DevCon->PSSetShaderResources( 0, 1, &textureMgr.TextureList[material[groundModels.SubsetMaterialID[i]].DiffuseTextureID] );

            // If this subset has a normal (bump) map, send it to the pixel shader
            if(material[groundModels.SubsetMaterialID[i]].HasNormMap)    
                d3d11DevCon->PSSetShaderResources( 1, 1, &textureMgr.TextureList[material[groundModels.SubsetMaterialID[i]].NormMapTextureID] );     

            // Draw the NON-transparent stuff
            int indexStart = groundModels.SubsetIndexStart[i];
            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[i]].IsTransparent)                     
        {
            cbPerObj.difColor = material[groundModel.SubsetMaterialID[i]].Diffuse;      // Let shader know which color to draw the model
                                                                                        // (if no diffuse texture we defined)
            cbPerObj.hasTexture = material[groundModel.SubsetMaterialID[i]].HasDiffTexture; // Let shader know if we need to use a texture
            cbPerObj.hasNormMap = material[groundModel.SubsetMaterialID[i]].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[i]].HasDiffTexture)                    
                d3d11DevCon->PSSetShaderResources( 0, 1, &textureMgr.TextureList[material[groundModel.SubsetMaterialID[i]].DiffuseTextureID] );

            // If this subset has a normal (bump) map, send it to the pixel shader
            if(material[groundModel.SubsetMaterialID[i]].HasNormMap)                    
                d3d11DevCon->PSSetShaderResources( 1, 1, &textureMgr.TextureList[material[groundModel.SubsetMaterialID[i]].NormMapTextureID] );     

            // The transparent parts are now drawn
            int indexStart = groundModel.SubsetIndexStart[i];
            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.

 

 



Sponsor:

#2 FLeBlanc   Crossbones+   -  Reputation: 3101

Like
0Likes
Like

Posted 20 March 2013 - 04:24 PM

Why the arbitrary and ridiculous prohibition against using translation?

#3 Postie   Members   -  Reputation: 964

Like
0Likes
Like

Posted 20 March 2013 - 08:04 PM

If you don't want to use a translation matrix, then simply add the world offset to the x,y,z coordinates of every vertex of the model when you load it in. That said, I wouldn't recommend it, as you've complicated things like rotating the objects about their local axes.


Currently working on an open world survival RPG - For info check out my Development blog: ByteWrangler




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS