Jump to content

  • Log In with Google      Sign In   
  • Create Account


Ubermeowmix

Member Since 30 Jan 2010
Offline Last Active Jul 17 2014 05:44 PM
-----

Topics I've Started

What mesh file format should I be using?

16 February 2014 - 08:09 PM

Hi,

 

Just wondering what the best file format for objects with bones would be to go for.

 

I need something that is going to be Direct 11 and OpenGL 4 compliant as I would really prefer to be coding in OpenGL when I get more understanding of directx programming code.

 

Thanks for reading.


Missing the vertex!

02 January 2014 - 08:46 AM

I'm not from a coding background originally so some of these concepts are hard for me to pick up, I need a little clarity if you can help.

 

When creating different vertex & index buffer objects, how do I load multiple objects into the same IASetVertexBuffers call.

 

How do I seperate say a Quad and a cube into different functions/classes and then draw them to:

 

d3d11DevCon->IASetVertexBuffers( 0, 1, &pVertexBuffers, &stride, &offset );

 

I'm a little lost on how to implement this bit.


DirectX rendering procedure

27 October 2013 - 09:09 AM

I'm having trouble understanding how directX deals with the objects being called and when it renders each one.

 

In a nutshell is it like this?:

 

1. set render states

2. set vertex format

3. load vertex buffers

         3.1. create vertex buffer (lock buffer)

         3.2. fill the buffer with array data

         3.3. Copy array data and then unlock buffer.

4. Draw to scene

5. Present data

 

So do I create classes to load multiple models at step 3 before step 4?

Or does each model have to go through the process up to draw before present is called at step 5?

 

Help would be greatly appreciated!

 

 


DirectX, why can't I do this?

22 October 2013 - 10:58 AM

Looking specifically for why I can't call these two seperate functions:
 
LoadString( );
LoadSprite( );
 
It compiles but the Fon't aren't there!?
 

#include "D3DTextDemo.h"

#include <xnamath.h>



struct VertexPos

{

    XMFLOAT3 pos;

    XMFLOAT2 tex0;

};



D3DTextDemo::D3DTextDemo( ) : solidColorVS_( 0 ),

                              solidColorPS_( 0 ),

                              inputLayout_( 0 ),

                              vertexBuffer_( 0 ),

                              colorMap_( 0 ),

                              colorMapSampler_( 0 ),



                              iCurrMouseButton( 0 ),

                              bMousePressed( false ),



                              mvpCB_( 0 ),

                              alphaBlendState_( 0 ),

                              spriteTooBig( false )

{

}



D3DTextDemo::~D3DTextDemo( )

{



}



bool D3DTextDemo::LoadContent( )

{

    LoadString( );



    LoadSprite( );



    return true;

}



bool D3DTextDemo::LoadString()

{

    ID3DBlob* vsBuffer = 0;



    bool compileResult = CompileD3DShader( "TextureMap.fx",

                                           "VS_Main",

                                           "vs_4_0",

                                           &vsBuffer );



    if( compileResult == false )

    {

        MessageBox(0,

                   "Error loading vertex shader!",

                   "Compile Error",

                   MB_OK );

        return false;

    }



    HRESULT d3dResult;



    d3dResult = d3dDevice_->CreateVertexShader( vsBuffer->GetBufferPointer( ),

                                                vsBuffer->GetBufferSize( ),

                                                0,

                                                &solidColorVS_ );



    if( FAILED( d3dResult ) )

    {

        if( vsBuffer )

            vsBuffer->Release( );



        return false;

    }



    D3D11_INPUT_ELEMENT_DESC solidColorLayout[] =

    {

        {

            "POSITION",

            0,

            DXGI_FORMAT_R32G32B32_FLOAT,

            0,

            0,

            D3D11_INPUT_PER_VERTEX_DATA,

            0

        },

        {

            "TEXCOORD",

            0,

            DXGI_FORMAT_R32G32_FLOAT,

            0,

            12,

            D3D11_INPUT_PER_VERTEX_DATA,

            0

        }

    };



    unsigned int totalLayoutElements = ARRAYSIZE( solidColorLayout );



    d3dResult = d3dDevice_->CreateInputLayout( solidColorLayout,

                                               totalLayoutElements,

                                               vsBuffer->GetBufferPointer( ),

                                               vsBuffer->GetBufferSize( ),

                                               &inputLayout_ );



    vsBuffer->Release( );



    if( FAILED( d3dResult ) )

    {

        return false;

    }



    ID3DBlob* psBuffer = 0;



    compileResult = CompileD3DShader( "TextureMap.fx",

                                      "PS_Main",

                                      "ps_4_0",

                                      &psBuffer );



    if( compileResult == false )

    {

        MessageBox(0,

                   "Error loading pixel shader!",

                   "Compile error",

                   MB_OK );

        return false;

    }



    d3dResult = d3dDevice_->CreatePixelShader( psBuffer->GetBufferPointer( ),

                                               psBuffer->GetBufferSize( ),

                                               0,

                                               &solidColorPS_ );



    psBuffer->Release( );



    if( FAILED( d3dResult ) )

    {

        return false;

    }



    d3dResult = D3DX11CreateShaderResourceViewFromFile( d3dDevice_,

                                                        "KKfont.dds",

                                                        0,

                                                        0,

                                                        &colorMap_,

                                                        0 );

    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to load the texture image!" );

        return false;

    }



    D3D11_SAMPLER_DESC colorMapDesc;

    ZeroMemory( &colorMapDesc, sizeof( colorMapDesc ) );

    colorMapDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;

    colorMapDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;

    colorMapDesc.MaxLOD = D3D11_FLOAT32_MAX;



    d3dResult = d3dDevice_->CreateSamplerState( &colorMapDesc,

                                                &colorMapSampler_ );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to create color map sampler state!" );

        return false;

    }



    D3D11_BUFFER_DESC vertexDesc;

    ZeroMemory( &vertexDesc, sizeof( vertexDesc ) );

    vertexDesc.Usage = D3D11_USAGE_DYNAMIC;

    vertexDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

    vertexDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;



    const int sizeOfSprite = sizeof( VertexPos ) * 6;

    //const int maxLetters = 300;



    vertexDesc.ByteWidth = sizeOfSprite * maxLetters;



    d3dResult = d3dDevice_->CreateBuffer( &vertexDesc, 0, &vertexBuffer_ );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to create the vertex buffer!" );

        return false;

    }



    return true;

}



bool D3DTextDemo::LoadSprite()

{

    ID3DBlob* vsBuffer = 0;



    bool compileResult = CompileD3DShader( "TextureMapSprite.fx", "VS_Main", "vs_4_0", &vsBuffer );



    if( compileResult == false )

    {

        DXTRACE_MSG( "Error compiling the vertex shader!" );

        return false;

    }



    HRESULT d3dResult;



    d3dResult = d3dDevice_->CreateVertexShader( vsBuffer->GetBufferPointer( ),

        vsBuffer->GetBufferSize( ), 0, &solidColorVS_ );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Error creating the vertex shader!" );



        if( vsBuffer )

            vsBuffer->Release( );



        return false;

    }



    D3D11_INPUT_ELEMENT_DESC solidColorLayout[] =

    {

        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },

        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }

    };



    unsigned int totalLayoutElements = ARRAYSIZE( solidColorLayout );



    d3dResult = d3dDevice_->CreateInputLayout( solidColorLayout, totalLayoutElements,

        vsBuffer->GetBufferPointer( ), vsBuffer->GetBufferSize( ), &inputLayout_ );



    vsBuffer->Release( );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Error creating the input layout!" );

        return false;

    }



    ID3DBlob* psBuffer = 0;



    compileResult = CompileD3DShader( "TextureMap.fx",

                                      "PS_Main",

                                      "ps_4_0",

                                      &psBuffer );



    if( compileResult == false )

    {

        DXTRACE_MSG( "Error compiling pixel shader!" );

        return false;

    }



    d3dResult = d3dDevice_->CreatePixelShader( psBuffer->GetBufferPointer( ),

                                               psBuffer->GetBufferSize( ),

                                               0,

                                               &solidColorPS_ );



    psBuffer->Release( );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Error creating pixel shader!" );

        return false;

    }



    d3dResult = D3DX11CreateShaderResourceViewFromFile( d3dDevice_,

        "Waiter_001.dds", 0, 0, &colorMap_, 0 );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to load the texture image!" );

        return false;

    }



    D3D11_SAMPLER_DESC colorMapDesc;

    ZeroMemory( &colorMapDesc, sizeof( colorMapDesc ) );

    colorMapDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;

    colorMapDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;

    colorMapDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;

    colorMapDesc.MaxLOD = D3D11_FLOAT32_MAX;



    d3dResult = d3dDevice_->CreateSamplerState( &colorMapDesc, &colorMapSampler_ );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to create color map sampler state!" );

        return false;

    }



    ID3D11Resource* colorTex;

    colorMap_->GetResource( &colorTex);



    D3D11_TEXTURE2D_DESC colorTexDesc;

    ( ( ID3D11Texture2D* )colorTex )->GetDesc( &colorTexDesc );

    colorTex->Release( );



    float halfWidth = ( float )colorTexDesc.Width / 2.0f;

    float halfHeight = ( float )colorTexDesc.Height / 2.0f;



    VertexPos vertices[] =

    {

        { XMFLOAT3(  halfWidth,  halfHeight, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },

        { XMFLOAT3(  halfWidth, -halfHeight, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },

        { XMFLOAT3( -halfWidth, -halfHeight, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },



        { XMFLOAT3( -halfWidth, -halfHeight, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

        { XMFLOAT3( -halfWidth,  halfHeight, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },

        { XMFLOAT3(  halfWidth,  halfHeight, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },

    };



    D3D11_BUFFER_DESC vertexDesc;

    ZeroMemory( &vertexDesc, sizeof( vertexDesc ) );

    vertexDesc.Usage = D3D11_USAGE_DEFAULT;

    vertexDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

    vertexDesc.ByteWidth = sizeof( VertexPos ) * 6;



    D3D11_SUBRESOURCE_DATA resourceData;

    ZeroMemory( &resourceData, sizeof( resourceData ) );

    resourceData.pSysMem = vertices;



    d3dResult = d3dDevice_->CreateBuffer( &vertexDesc,

                                          &resourceData,

                                          &vertexBuffer_ );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to create vertex buffer!" );

        return false;

    }



    D3D11_BUFFER_DESC constDesc;

    ZeroMemory( &constDesc, sizeof( constDesc ) );

    constDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;

    constDesc.ByteWidth = sizeof( XMMATRIX );

    constDesc.Usage = D3D11_USAGE_DEFAULT;



    d3dResult = d3dDevice_->CreateBuffer( &constDesc,

                                          0,

                                          &mvpCB_ );



    if( FAILED( d3dResult ) )

    {

        return false;

    }



    XMFLOAT2 sprite1Pos( 0.0f, 0.0f );

    XMFLOAT2 sprite1ScaleMod( 1.0f, 1.0f );



    sprites_[0].SetPosition( sprite1Pos );

    sprites_[0].SetScale( sprite1ScaleMod );

    sprites_[0].SetDimensions( Dx11DemoBase::GetWindowWidth( ), Dx11DemoBase::GetWindowHeight( ), ( float )colorTexDesc.Width, ( float )colorTexDesc.Height );



    XMFLOAT2 sprite2Pos( 640.0, 480.0f );

    sprites_[1].SetPosition( sprite2Pos );

    sprites_[1].SetScale( sprite1ScaleMod );

    sprites_[1].SetDimensions( Dx11DemoBase::GetWindowWidth( ), Dx11DemoBase::GetWindowHeight( ), ( float )colorTexDesc.Width, ( float )colorTexDesc.Height );



    XMMATRIX view = XMMatrixIdentity( );

    XMMATRIX projection = XMMatrixOrthographicOffCenterLH( 0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f );



    vpMatrix_ = XMMatrixMultiply( view, projection );



    D3D11_BLEND_DESC blendDesc;

    ZeroMemory( &blendDesc, sizeof( blendDesc ) );

    blendDesc.RenderTarget[0].BlendEnable = TRUE;

    blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;

    blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;

    blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;

    blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;

    blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;

    blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;

    blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;



    float blendFactor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };



    d3dDevice_->CreateBlendState( &blendDesc,

                                  &alphaBlendState_ );

    d3dContext_->OMSetBlendState( alphaBlendState_,

                                  blendFactor,

                                  0xFFFFFFFF );



    return true;

}





bool D3DTextDemo::DrawString( const char* message, float startX, float startY )

{

    // size in bytes for a single sprite

    const int sizeOfSrite = sizeof( VertexPos ) * 6;



    // demo's dynamic buffer set up for max letters

    //const int maxLetters = 300;



    int length = strlen( message );



    //clamp for strings too long

    if( length > maxLetters )

        length = maxLetters;



    //chars width on screen

    // this could be pulled in for the height of the loaded font if it's a single line, or even divided by itself if it can be squared.

    float charWidth = 32.0f / 800.0f;

    float charHeight = 32.0f / 600.0f;



    //chars texel width

    // this could be pulled in for the width of the loaded font

    float texelWidth = 32.0f / 1024.0f;

    float texelHeight = 32.0f / 96.0f;



    //verts per-triangle (3) * total triangles (2) = 6

    const int verticesPerLetter = 6;



    D3D11_MAPPED_SUBRESOURCE mapResource;

    HRESULT d3dResult = d3dContext_->Map( vertexBuffer_,

                                          0,

                                          D3D11_MAP_WRITE_DISCARD,

                                          0,

                                          &mapResource );



    if( FAILED( d3dResult ) )

    {

        DXTRACE_MSG( "Failed to map resource!" );

        return false;

    }



    //point to our vertex buffer's internal data.

    VertexPos *spritePtr = ( VertexPos* )mapResource.pData;



    const int indexStart = static_cast<char>( ' ' );

    const int indexEnd = static_cast<char>( '~' );



    int iCurrLetterInc = 0;

    int iLineCount = 0;

    int iLineReset = 0;

    int iCurrCrop = 45;

    

    std::stringstream wss;

    for( int i = 0; i < length; ++i )                                        //FOR LOOP to check each character in message

    {

        //if current char count is over #

            //then increment the line number to X

            //reset the current startX to zero

                //increment the values of startY to incorporate an extra multiple of height

        //set the code going again



        if(iCurrLetterInc >= iCurrCrop)                                    //if i is greater than iCurrCrop, increment the line

        {

            iLineCount++;

            iCurrLetterInc = 0;

        }



        int newX = iLineCount * iCurrCrop;

        

        float thisStartX = startX + ( charWidth * static_cast<float>( i - newX ) );

        float thisEndX = thisStartX + charWidth;



        float thisStartY = startY - ( iLineCount * charHeight );                    //because of multiple lines the thisStartY will be lower everytime we start a new line

        float thisEndY = ( startY + charHeight ) - ( iLineCount * charHeight );        //VERY IMPORTANT... the second brackets mean that they are doubling up the x value in the down direction, otherwise it will turn the polygon away from the camera.



        /*

        wss << "i: ";

        wss << i;

        wss << ", ";

        wss << "newX: ";

        wss << newX;

        wss << ", ";

        */



        spritePtr[0].pos = XMFLOAT3( thisEndX,        thisEndY,        1.0f );

        spritePtr[1].pos = XMFLOAT3( thisEndX,        thisStartY,        1.0f );

        spritePtr[2].pos = XMFLOAT3( thisStartX,    thisStartY,        1.0f );

        spritePtr[3].pos = XMFLOAT3( thisStartX,    thisStartY,        1.0f );

        spritePtr[4].pos = XMFLOAT3( thisStartX,    thisEndY,        1.0f );

        spritePtr[5].pos = XMFLOAT3( thisEndX,        thisEndY,        1.0f );



        int texLookup = 0;

        int letter = static_cast<char>( message[i] );



        if( letter < indexStart || letter > indexEnd )

        {

            texLookup = indexStart;                                    //if it's out of bounds use a space

        } else {

            texLookup = ( letter - indexStart ) ;

        }



        float tuStart    = 0.0f;

        float tuEnd        = 0.0f;

        float tuTop        = 0.0f;

        float tuBottom    = 0.0f;



        if( letter > 63 )                                            //if letter is > ?(1024 pixel width 1st line ends) but less than ~ (third row's start)

        {

            if ( letter > 95 )

            {

                tuStart = 0.0f + ( texelWidth * static_cast<float>( texLookup ) );

                tuEnd = tuStart + texelWidth;



                tuTop = 0.0f + ( texelHeight * 2 );

                tuBottom = tuTop + texelHeight;                        //OutputDebugString( "THIRD LINE LOADED!\n" );

            } else {

                tuStart = 0.0f + ( texelWidth * static_cast<float>( texLookup ) );

                tuEnd = tuStart + texelWidth;



                tuTop = 0.0f + ( texelHeight * 1 );

                tuBottom = tuTop + texelHeight;                        //OutputDebugString( "SECOND LINE LOADED!\n" );

            }

        } else {

            tuStart = 0.0f + ( texelWidth * static_cast<float>( texLookup ) );

            tuEnd = tuStart + texelWidth;



            tuTop = 0.0f;

            tuBottom = tuTop + texelHeight;                            //OutputDebugString( "FIRST LINE LOADED!\n" );

        }



        spritePtr[0].tex0 = XMFLOAT2( tuEnd, tuTop );

        spritePtr[1].tex0 = XMFLOAT2( tuEnd, tuBottom );

        spritePtr[2].tex0 = XMFLOAT2( tuStart, tuBottom );

        spritePtr[3].tex0 = XMFLOAT2( tuStart, tuBottom );

        spritePtr[4].tex0 = XMFLOAT2( tuStart, tuTop );

        spritePtr[5].tex0 = XMFLOAT2( tuEnd, tuTop );



        spritePtr += 6;

        iCurrLetterInc++;

    }

    OutputDebugString( wss.str().c_str()  );

    

    d3dContext_->Unmap( vertexBuffer_, 0 );

    d3dContext_->Draw( 6 * length, 0 );



    return true;

}



void D3DTextDemo::UnloadContent( )

{

    if( colorMapSampler_ ) colorMapSampler_->Release( );

    if( colorMap_ ) colorMap_->Release( );

    if( solidColorVS_ ) solidColorVS_->Release( );

    if( solidColorPS_ ) solidColorPS_->Release( );

    if( inputLayout_ ) inputLayout_->Release( );

    if( vertexBuffer_ ) vertexBuffer_->Release( );



    if( mvpCB_ ) mvpCB_->Release( );

    if( alphaBlendState_ ) alphaBlendState_->Release( );



    colorMapSampler_ = 0;

    colorMap_ = 0;

    solidColorVS_ = 0;

    solidColorPS_ = 0;

    inputLayout_ = 0;

    vertexBuffer_ = 0;



    mvpCB_ = 0;

    alphaBlendState_ = 0;

}



void D3DTextDemo::Update( float dt )

{

    mouseDevice_->GetDeviceState( sizeof ( mouseState_ ),

                                     ( LPVOID )&mouseState_ );



    /*

        MOUSE STATE

    //constants for mouse buttons (NEW)

    #define DIMOUSE_LEFTBUTTON   0

    #define DIMOUSE_RIGHTBUTTON  1

    #define DIMOUSE_MIDDLEBUTTON 2

    #define DIMOUSE_4BUTTON      3

    #define DIMOUSE_5BUTTON      4

    #define DIMOUSE_6BUTTON      5

    #define DIMOUSE_7BUTTON      6

    #define DIMOUSE_8BUTTON      7

    */



    if( BUTTONDOWN( mouseState_, 0 ) )

    {

        iCurrMouseButton = 0;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 1 ) )

    {

        iCurrMouseButton = 1;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 2 ) )

    {

        iCurrMouseButton = 2;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 3 ) )

    {

        iCurrMouseButton = 3;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 4 ) )

    {

        iCurrMouseButton = 4;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 5 ) )

    {

        iCurrMouseButton = 5;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 6 ) )

    {

        iCurrMouseButton = 6;

        bMousePressed = true;

    }

    else if ( BUTTONDOWN( mouseState_, 7 ) )

    {

        iCurrMouseButton = 7;

        bMousePressed = true;

    } else {

        bMousePressed = false;

    }

    

    memcpy( &prevMouseState_,                //take note that this is a reference

            &mouseState_,                    //take note that this is a reference

            sizeof( mouseState_ ) );



}



void D3DTextDemo::Render( )

{

    if( d3dContext_ == 0 )

        return;



    float clearColor[4] = { 0.2f, 0.22f, 0.24f, 1.0f };

    d3dContext_->ClearRenderTargetView( backBufferTarget_,

                                        clearColor );

    unsigned int stride = sizeof( VertexPos );

    unsigned int offset = 0;



    d3dContext_->IASetInputLayout( inputLayout_ );

    d3dContext_->IASetVertexBuffers( 0,

                                     1,

                                     &vertexBuffer_,

                                     &stride,

                                     &offset );



    d3dContext_->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

    d3dContext_->VSSetShader( solidColorVS_,

                              0,

                              0 );



    d3dContext_->PSSetShader( solidColorPS_,

                              0,

                              0 );



    d3dContext_->PSSetShaderResources( 0,

                                       1,

                                       &colorMap_  );



    d3dContext_->PSSetSamplers( 0,

                                1,

                                &colorMapSampler_ );

    



    for( int i = 0; i < 2; i++)

    {

        XMMATRIX world = sprites_[i].GetWorldMatrix( );

        XMMATRIX mvp = XMMatrixMultiply( world, vpMatrix_ );

        mvp = XMMatrixTranspose( mvp );



        d3dContext_->UpdateSubresource( mvpCB_,

                                        0,

                                        0,

                                        &mvp,

                                        0,

                                        0 );

        d3dContext_->VSSetConstantBuffers( 0,

                                           1,

                                           &mvpCB_ );



        d3dContext_->Draw( 6, 0 );

    }



    ObjectInit( );



    swapChain_->Present( 0, 0 );

}



void D3DTextDemo::ObjectInit( )

{

    // mouse pos needs to take into consideration the screen pos

    //int x = GetCursorPos( &mouseState_.lX );//(int)(mousePosX_);

    //int y = GetCursorPos( (int)&mouseState_.lY );//(int)(mousePosY_);



    std::stringstream strNew;



    RECT currSPos;

    if ( GetWindowRect( hwnd_, &currSPos) )

    {

        

        strNew << "Screen coords: Left";

        strNew << currSPos.left;

        strNew << ", Right: ";

        strNew << currSPos.right;

        strNew << ", Top: ";

        strNew << currSPos.top;

        strNew << ", Bottom: ";

        strNew << currSPos.bottom;

    }

    

    POINT currMousePos;

    if ( GetCursorPos(&currMousePos) )

    {

        int newX = 0;

        if( currMousePos.x < currSPos.left )

        {

            newX = 0;

        } else {

            //int newX = currMousePos.x;

            if( currMousePos.x > currSPos.right)

            {

                newX = 800;

            } else {

                newX = currMousePos.x - currSPos.left;

            }

        }



        int newY = 0;

        if( currMousePos.y < currSPos.top )

        {

            newY = 0;

        } else {

            //int newY = currMousePos.y;

            if( currMousePos.y > currSPos.bottom)

            {

                newY = 600;

            } else {

                newY = currMousePos.y - currSPos.top;

            }

        }



        strNew << " mouseCoords: ";

        strNew << newX;

        strNew << " - ";

        strNew << newY;



        std::string str(strNew.str());

        const char* chr = str.c_str();



        DrawString( chr, -0.9f, 0.9f );

    }



    std::string str(strNew.str());

    const char* chr = str.c_str();



    DrawString( chr, -0.9f, 0.9f );



    if(bMousePressed)

    {

        // kick out whether or not the mouse buttons are being pressed

        std::string aButtonArray[] = { "Left mouse button",

                                       "Right mouse button",

                                       "Middle mouse button",

                                       "Left side std button",

                                       "Left side extra button",

                                       "Random button!",

                                       "Right side std button",

                                       "Right side extra button"};

        std::stringstream strMouseButtonPressed;

        strMouseButtonPressed << aButtonArray[iCurrMouseButton];

        strMouseButtonPressed << " currently pressed!";



        std::string otherStr(strMouseButtonPressed.str());

        const char* buttonOut = otherStr.c_str();



        DrawString( buttonOut, -0.9f, 0.75f );

    }



    DrawString( "The Quick Brown Fox Jumps Over The Lazy Dog", -1.0f, 0.9f );

}

Advice on multiple object creation

09 October 2013 - 08:48 AM

Coming at C++ and directx 11 from a newbies point of view I wondered if you guys would lend me a little experience and advise on which outcome would be the best thing to attack.

 

When dealing with large numbers of objects each with their own values updated every frame, what should I use to track them that will give the greatest control without loosing performance through thousand of calls and/or checks.

 

I'd say that there will be around two thousand 'entities' on screen at any one time. Not especially with massive polycounts.

 

Would love to hear your thoughts on the subject.


PARTNERS