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.