MercuryDisplay_D3D.cpp

Go to the documentation of this file.

#if defined( USE_D3D )

#define MCOLOR_TO_DX_COLOR( mc )  (*((D3DCOLORVALUE*)(void*)&mc))
#define MPOINT_TO_DX_VECTOR( mc ) (*((D3DVECTOR*)(void*)&mc))
#include <D3D9.h>
#include <D3dx9math.h>
#include <D3DX9Core.h>

#include "MercuryDisplay_D3D.h"
#include "MercuryObject.h"
#include "MercuryLog.h"

#if defined(_MSC_VER)
    #pragma comment(lib, "D3dx9.lib")
    #pragma comment(lib, "D3d9.lib")
    #pragma comment(lib, "Dxerr9.lib")
#endif

MercuryDisplay_D3D::~MercuryDisplay_D3D()
{
    if(m_pDirect3DDevice != NULL)
    {
        m_pDirect3DDevice->Release();
        m_pDirect3DDevice = NULL;
    }

    if(m_d3d != NULL)
    {
        m_d3d->Release();
        m_d3d = NULL;
    }
}

MercuryDisplay_D3D::MercuryDisplay_D3D()
{
    MercuryDisplay::MercuryDisplay();
}

bool MercuryDisplay_D3D::MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
    m_pDirect3DDevice = NULL;

    if (m_window == NULL)
        return false;

    
    if (!m_window->MakeRender(title, width, height, bits, fullscreenflag, RT_D3D))
    {
        LOG.Warn( "Failed to make Renderer" );
        m_window->DestroyWindowAndRender();
        return false;
    }

    m_d3d = Direct3DCreate9( D3D_SDK_VERSION );
    
    if( m_d3d == NULL )
    {
        LOG.Warn( "Could not create Direct3D Object" );
        return false;
    }

    ZeroMemory(&m_PresentParameters,sizeof(m_PresentParameters));

    m_PresentParameters.Windowed = !fullscreenflag;
    m_PresentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    m_PresentParameters.EnableAutoDepthStencil = true;
    m_PresentParameters.AutoDepthStencilFormat = D3DFMT_D16;
    m_PresentParameters.hDeviceWindow = (HWND)m_window->m_hWnd;

    m_PresentParameters.BackBufferWidth = width;       //screen width
    m_PresentParameters.BackBufferHeight = height;     //screen height
    m_PresentParameters.BackBufferFormat = (bits==16)?D3DFMT_R5G6B5:D3DFMT_X8R8G8B8;
                    // D3DFMT_A8R8G8B8 and D3DFMT_X8R8G8B8 are the other options
    m_PresentParameters.MultiSampleType = D3DMULTISAMPLE_NONE; //anti-aliasing

    if( FAILED( m_d3d->CreateDevice(
                    D3DADAPTER_DEFAULT,
                    D3DDEVTYPE_HAL,
                    (HWND)m_window->m_hWnd,
                    D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                    &m_PresentParameters,
                    &m_pDirect3DDevice)))
    {
        LOG.Warn( "Could not create Direct3D Device" );
        return false;
    }

    Viewport( 0,0, m_window->GetWidth(), m_window->GetHeight() );

    return MercuryDisplay::MakeWindow( title, width, height, bits, fullscreenflag );
}

void MercuryDisplay_D3D::Init()
{
    MercuryDisplay::Init();
}

bool MercuryDisplay_D3D::BeginFrame()
{
    m_pDirect3DDevice->Clear(
        0,
        NULL,
        D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
        D3DCOLOR_XRGB(0,0,255),
        1.0f,
        0);
    if( !m_pDirect3DDevice->BeginScene() )
        return false;

    return true;
}

bool MercuryDisplay_D3D::EndFrame()
{
    m_pDirect3DDevice->EndScene();
    m_pDirect3DDevice->Present( NULL, NULL, NULL, NULL );
    m_window->SwapBuffers();
    return true;
}

void MercuryDisplay_D3D::DrawParticleField(const MercuryParticleField* field)
{
    MDequeIterator<MercuryObject::ParentHoldPair> i = field->m_objects.begin();
    //
    // to do, here, use GetBackBuffer and UpdateSurface (to blit the image)
    //
}
/*
void MercuryDisplay_D3D::DrawGeometry(const MercuryGeometry& g, const MercuryMesh& mesh)
{
    IDirect3DVertexBuffer9 *ID3VB;
    HRESULT T;
    T = m_pDirect3DDevice->CreateVertexBuffer(
        mesh.NumVertices() * sizeof( MercuryVertex ),
        0,
        D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1,
        D3DPOOL_SYSTEMMEM,
        &ID3VB,
        NULL );

    VOID* pVertices;

    if(FAILED(ID3VB->Lock(0, sizeof(MercuryVertex) * mesh.NumVertices( ), 
        (void**)&pVertices, 0 ) ) ) 
            return; //??go figure
    memcpy( pVertices, mesh.GetVerticePtr(), mesh.NumVertices() );
    ID3VB->Unlock();
    int i = m_pDirect3DDevice->SetStreamSource( 0, ID3VB, 0, sizeof( MercuryVertex ) );
    i = m_pDirect3DDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, mesh.NumVertices() );
    m_verticesDrawn += mesh.NumVertices();
}
*/
void MercuryDisplay_D3D::SetMaterial(const MercuryMaterial* material)
{
}

void MercuryDisplay_D3D::RendererInfo()
{
}

void MercuryDisplay_D3D::ClearZBuffer()
{
    m_pDirect3DDevice->Clear(
        0,
        NULL,
        D3DCLEAR_ZBUFFER,
        D3DCOLOR_XRGB(0,0,0),
        1.0f,
        0);
}

void MercuryDisplay_D3D::DeleteTextures(int n, unsigned int* textureNames)
{
    for( unsigned i = 0; i < n; ++i )
    {
        m_vSurfaces[textureNames[i]]->Release();;
        m_vFreeSurfaces.push_back(textureNames[i]);
    }
}

void MercuryDisplay_D3D::UpdateTextureData(MercuryTexture* texture, unsigned int& ID)
{
    UpdateTextureData( texture->GetRaw(), texture->GetWidth(), texture->GetHeight(), texture->GetColorByteType(), ID );
}

void MercuryDisplay_D3D::UpdateTextureData(unsigned char*ib, int w, int h, ColorBytes cb, unsigned int& ID)
{
    unsigned char * buf;
    unsigned p;
    RECT c;
    c.top = 0;
    c.left = 0;
    c.right = w;
    c.bottom = h;

    //Notice that we set levels to 1 here. This is because we don't yet support mipmaps for DirectX
    IDirect3DTexture9 * s = NULL;
    //int i = m_pDirect3DDevice->CreateTexture
    
    int i =  D3DXCreateTexture( m_pDirect3DDevice, 
        w, h, 1, D3DUSAGE_DYNAMIC,
        (cb==RGB)?D3DFMT_R8G8B8:D3DFMT_A8R8G8B8,
        D3DPOOL_SYSTEMMEM, &s );

    if( FAILED( i ) )
        return;

    m_vSurfaces[ID] = s;

    D3DLOCKED_RECT lri;
    i = s->LockRect( 0, &lri, &c, D3DLOCK_NOSYSLOCK );

    if( FAILED( i ) )
        return;

    IDirect3DSurface9 * surf;

    s->GetSurfaceLevel( 0, &surf );

    switch( cb )
    {
    case BLANK:
    case BLANK1:
        break;
    case LUMINANCE_ALPHA:
        //How annoying! DirectX doesn't support Luminance Alpha.
        buf = new unsigned char[c.right*c.bottom*2];
        
        for( p = 0; p < c.right*c.bottom; ++p )
        {
            buf[p*4+0] = ib[p*2+1];
            buf[p*4+1] = ib[p*2+0];
            buf[p*4+2] = ib[p*2+0];
            buf[p*4+3] = ib[p*2+0];
        }

        D3DXLoadSurfaceFromMemory( surf, 0, 0, buf, 
            D3DFMT_R8G8B8, w * 3, NULL, &c, D3DX_DEFAULT, 0 );
        break;

        delete buf;
        break;
    case RGB:
        D3DXLoadSurfaceFromMemory( surf, 0, 0, ib, 
            D3DFMT_R8G8B8, w * 3, NULL, &c, D3DX_DEFAULT, 0 );
        break;
    case RGBA:
        //DirectX doesn't allow alpha at end, unlike everything else, so we have to flip it.

        buf = new unsigned char[c.right*c.bottom*4];

        for( p = 0; p < c.right*c.bottom; ++p )
        {
            buf[p*4+0] = ib[p*4+3];
            buf[p*4+1] = ib[p*4+0];
            buf[p*4+2] = ib[p*4+1];
            buf[p*4+3] = ib[p*4+2];
        }

        D3DXLoadSurfaceFromMemory( surf, 0, 0, buf, 
            D3DFMT_R8G8B8, w * 3, NULL, &c, D3DX_DEFAULT, 0 );
        delete buf;

        break;
    }

    s->UnlockRect( 0 );
}

void MercuryDisplay_D3D::CreateCache(MercuryTexture* texture, unsigned int& ID)
{
    ID = AllocTex();
    UpdateTextureData( texture->GetRaw(), texture->GetWidth(), texture->GetHeight(), texture->GetColorByteType(), ID );
}

void MercuryDisplay_D3D::CreateCache(RawImageData* data, unsigned int& ID)
{
    ID = AllocTex();
    UpdateTextureData( data->data, data->attrs.m_width, data->attrs.m_height, data->attrs.m_ColorByteType, ID );
}

int MercuryDisplay_D3D::AllocTex()
{
    if( !m_vFreeSurfaces.empty() )
    {
        int c = m_vFreeSurfaces.front();
        m_vFreeSurfaces.pop_back();
        return c;
    }

    m_vSurfaces.resize( m_vSurfaces.size() + 1 );
    return m_vSurfaces.size()-1;
}

void MercuryDisplay_D3D::EnablePixelshader()
{
}

void MercuryDisplay_D3D::DisablePixelshader()
{
}

void MercuryDisplay_D3D::EnableAllLighting()
{
    m_pDirect3DDevice->SetRenderState( D3DRS_LIGHTING, true );
}

void MercuryDisplay_D3D::DisableAllLighting()
{
    m_pDirect3DDevice->SetRenderState( D3DRS_LIGHTING, false );
}


void MercuryDisplay_D3D::EnableDepthTest()
{
    m_pDirect3DDevice->SetRenderState( D3DRS_ZENABLE, true );
}

void MercuryDisplay_D3D::DisableDepthTest()
{
    m_pDirect3DDevice->SetRenderState( D3DRS_ZENABLE, false );
}

void MercuryDisplay_D3D::Viewport(int x, int y, int width, int height)
{
    if( !m_pDirect3DDevice )
        return;
    D3DVIEWPORT9 vp;

    vp.X = x; vp.Y = y; vp.Width = width; vp.Height = height; 
    
    vp.MinZ = 0; vp.MaxZ = 1;
    
    m_pDirect3DDevice->SetViewport( &vp );
}

void MercuryDisplay_D3D::ErrorCheck()
{
}

void MercuryDisplay_D3D::ReadFrameBuffer(RawImageData& image)
{
}

void MercuryDisplay_D3D::ProcessLightsInternal( const MercuryLight * light[], unsigned int count )
{
    for (unsigned int i = 0; i < count; ++i)
    {
        if (!light[i])
            continue;

        D3DLIGHT9 l;
        l.Type = ( light[i]->GetLightType() ==  LT_DIRECTIONAL )?D3DLIGHT_DIRECTIONAL:D3DLIGHT_POINT;

        const MercuryMaterial& m = light[i]->GetFinalMaterial();
        l.Diffuse = MCOLOR_TO_DX_COLOR(m.m_diffuse);
        l.Specular = MCOLOR_TO_DX_COLOR(m.m_ambient);
        l.Ambient = MCOLOR_TO_DX_COLOR(m.m_specular);
        l.Position = MPOINT_TO_DX_VECTOR(light[i]->GetPosition());
        l.Direction = MPOINT_TO_DX_VECTOR(light[i]->GetPosition());
        l.Range = 1000; //????
        l.Falloff = 0;
        l.Attenuation0 = light[i]->GetAttenuation( Attenuation::CONSTANT ).value;
        l.Attenuation1 = light[i]->GetAttenuation( Attenuation::LINEAR ).value;
        l.Attenuation2 = light[i]->GetAttenuation( Attenuation::QUADRATIC ).value;
        l.Theta = 0;
        l.Phi = 0;

    }
}

void MercuryDisplay_D3D::DisableOldLights()
{
}

void MercuryDisplay_D3D::RenderTranslucentObject()
{
    //Not yet implemented
}

void MercuryDisplay_D3D::DefineClippingPlanes( const MVector<MQuaternion> & planes )
{
    //Not yet implemented
}

int MercuryDisplay_D3D::CompileShader( MString vertStr, MString fragStr )
{
    return -1;
}

void MercuryDisplay_D3D::StencilFunc( TFUNCT func, int ref, unsigned int zref )
{
    //XXX Not yet implemented
}

void MercuryDisplay_D3D::CullBackface( bool toggle )
{
    m_pDirect3DDevice->SetRenderState( D3DRS_CULLMODE, toggle );
}

void MercuryDisplay_D3D::StencilOp( STENCILOPS fail, STENCILOPS zfail, STENCILOPS zpass )
{
}

void MercuryDisplay_D3D::ToggleStencilBufferWrite( bool toggle )
{
}

void MercuryDisplay_D3D::ToggleColorMask( bool toggle )
{
}

void MercuryDisplay_D3D::ToggleZBufferWrite( bool toggle )
{
    m_pDirect3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, toggle );
}


void MercuryDisplay_D3D::SendProjectionMatrixData()
{
    m_pDirect3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)&GetProjection() );
}

void MercuryDisplay_D3D::SendMatrixData( const MercuryMatrix & m )
{
    m_pDirect3DDevice->SetTransform( D3DTS_VIEW, (D3DMATRIX*)&ViewStack.GetTop() );
    m_pDirect3DDevice->SetTransform( D3DTS_WORLDMATRIX(0), (D3DMATRIX*)&m );
}

void MercuryDisplay_D3D::EnableTextures(MercuryMaterial* material)
{
    m_pDirect3DDevice->SetMaterial( (D3DMATERIAL9*)(&material->m_diffuse) );
    for( unsigned i = 0; i < material->NumTextures(); ++i )
        m_pDirect3DDevice->SetTexture( i, m_vSurfaces[material->GetTexture( i )->GetID()] );
}

void MercuryDisplay_D3D::DrawNoGeometry( const MercuryMesh & mesh, DRAWTYPES drawtype )
{
    IDirect3DVertexBuffer9 *ID3VB;
    HRESULT T;
    T = m_pDirect3DDevice->CreateVertexBuffer(
        mesh.NumVertices() * sizeof( MercuryVertex ),
        0,
        D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1,
        D3DPOOL_SYSTEMMEM,
        &ID3VB,
        NULL );

    VOID* pVertices;

    if(FAILED(ID3VB->Lock(0, sizeof(MercuryVertex) * mesh.NumVertices( ), 
        (void**)&pVertices, 0 ) ) ) 
            return; //??go figure
    memcpy( pVertices, mesh.GetVerticePtr(), mesh.NumVertices() );
    ID3VB->Unlock();
    int i = m_pDirect3DDevice->SetStreamSource( 0, ID3VB, 0, sizeof( MercuryVertex ) );
    i = m_pDirect3DDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, mesh.NumVertices() );
    m_verticesDrawn += mesh.NumVertices();
}

void MercuryDisplay_D3D::RenderText(const MercuryText& text)
{
}

void MercuryDisplay_D3D::DrawSprite(const MercuryMesh& sprite)
{
}



#endif //END: USE_D3D

//Used guide from http://www.two-kings.de/tutorials/dxgraphics/dxgraphics02.html
//  for help.

/* 
 * Copyright (c) 2006 Joshua Allen, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by