D3DViewportRenderer.cpp

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

#include <stdio.h>
#include <iostream>

#include <D3DViewportRenderer.h>

#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MRenderingInfo.h>
#include <maya/MRenderTarget.h>
#include <maya/MFnCamera.h>
#include <maya/MAngle.h>
#include <maya/MPoint.h>
#include <maya/MVector.h>
#include <maya/MItDag.h>
#include <maya/MMatrix.h>
#include <maya/MDagPath.h>
#include <maya/MFnDagNode.h>
#include <maya/MFnMesh.h>
#include <maya/MItMeshPolygon.h>
#include <maya/MBoundingBox.h>
#include <maya/MImage.h>
#include <maya/MDrawTraversal.h>
#include <maya/MGeometryManager.h>
#include <maya/MGeometry.h>
#include <maya/MGeometryData.h>
#include <maya/MGeometryPrimitive.h>
#include <maya/MNodeMessage.h> // For monitor geometry list
#include <maya/MPlug.h>
#include <maya/MPlugArray.h>
#include <maya/MFnSet.h>
#include <maya/MFnNumericData.h>
#include <maya/MItDependencyGraph.h>
#include <maya/MMatrix.h>

#include <stdio.h>
#include <maya/MFnLight.h>
#include <maya/MFnSpotLight.h>

#include <maya/MPxHardwareShader.h>
#include <maya/MRenderProfile.h>

#if defined(D3D9_SUPPORTED)

// Screen space quad vertex
struct ScreenSpaceVertex
{
    D3DXVECTOR4 position; // position
    D3DXVECTOR2 texCoord; // texture coordinate

    static const DWORD FVF;
};
const DWORD ScreenSpaceVertex::FVF = D3DFVF_XYZRHW | D3DFVF_TEX1;


//
// Class : D3DViewportRenderer
//
// Very simple renderer using D3D to render to an offscreen render target.
// The contents are read back into system memory to blit into an OpenGL context.
//
// This example has been test compiled against the both the Feb. and April 2006 
// DirectX developer SDKs. Define the D3D9_SUPPORTED preprocessor directive 
// to compile D3D code in.
//
// These code items are work in progress:
//
// - camera is fixed to be perspective. No orthographic cameras yet.
// - offscreen surface is fixed in size.
// - surfaces can either be fixed RGBA8888 or floating point 16. Final output
//   is always fixed, though post-process tone-mapping can be applied before
//       final output.
// - post-process full screen effects are restricted to those which only require
//   color as input.
// - does not handle loss of device.
// - readback is for color only, no depth readback currently.
// - basic Maya material support in a fixed-function pipeline.
// - geometry support for polys for shaded with file texture on color channel.
//
//
#endif

D3DViewportRenderer::D3DViewportRenderer()
:       MViewportRenderer("D3DViewportRenderer")
{
        // Set the ui name
        fUIName.set( "Direct3D Renderer");

        // This renderer overrides all drawing
        fRenderingOverride = MViewportRenderer::kOverrideAllDrawing;

        // Set API and version number
        m_API = MViewportRenderer::kDirect3D;
        m_Version = 9.0f;

        // Default to something reasonable.
        m_renderWidth = 640;
        m_renderHeight = 480;

#if defined(D3D9_SUPPORTED)
        m_hWnd = 0;
        m_pD3D = 0;
        m_pD3DDevice = 0;
        m_pTextureOutput = 0;
        m_pTextureOutputSurface = 0;
        
        m_readBackBuffer.create(m_renderWidth, m_renderHeight, 4/* MPixelType type = kByte */);
        m_readBackBuffer.setRGBA( false );

        m_pBoundsBuffer = 0;
        m_pGeometry = 0;

        m_wantFloatingPointTargets = false;
        m_pTextureInterm = 0;
        m_pTextureIntermSurface = 0;
        m_pTexturePost = 0;

        m_pDepthStencilSurface = 0;
        m_SystemMemorySurface = 0;

        m_requireDepthStencilReadback = false;
#endif
}

/* virtual */
D3DViewportRenderer::~D3DViewportRenderer()
{
        uninitialize();
}

// Dummy window proc.
LRESULT CALLBACK D3DWindowProc( HWND   hWnd, 
                                                         UINT   msg, 
                                                         WPARAM wParam, 
                                                         LPARAM lParam )
{
    switch( msg )
        {
                case WM_CLOSE:
                {
                        //PostQuitMessage(0);   -- can't allow this. Will kill Maya
                }
                break;

        case WM_DESTROY:
                {
            //PostQuitMessage(0);       -- can't allow this. Will kill Maya
                }
        break;
                
                default:
                {
                        return DefWindowProc( hWnd, msg, wParam, lParam );
                }
                break;
        }

        return 0;
}

#if defined(D3D9_SUPPORTED)
bool
D3DViewportRenderer::buildRenderTargets(unsigned int width, unsigned int height)
{
        HRESULT hr = -1;

        // Nothing to do, just return
        if (width == m_renderWidth &&
                height == m_renderHeight &&
                m_pTextureInterm && 
                m_pTextureOutput &&
                m_pTexturePost)
        {
                return true;
        }

        // Set the new width and height
        m_renderWidth = width;
        m_renderHeight = height;

        //printf("New size = %d,%d\n", m_renderWidth, m_renderHeight);

        //
        // Create target for intermediate rendering
        //
        if (m_pTextureInterm)
        {
                m_pTextureInterm->Release();
                m_pTextureInterm = NULL;
        }
        if (m_pTextureIntermSurface)
        {
                m_pTextureIntermSurface->Release();
                m_pTextureIntermSurface = NULL;
        }
        if (!m_pTextureInterm)
        {
                hr = D3DXCreateTexture( m_pD3DDevice, 
                        m_renderWidth, 
                        m_renderHeight, 
                        1, 
                        D3DUSAGE_RENDERTARGET, 
                        m_intermediateTargetFormat, /* Use intermediate target format */
                        D3DPOOL_DEFAULT, 
                        &m_pTextureInterm );

                // Failed to get target with desired intermediate format. Try for
                // fixed as a default
                m_intermediateTargetFormat = m_outputTargetFormat;
                if ( FAILED(hr) )
                {
                        hr = D3DXCreateTexture( m_pD3DDevice, 
                                m_renderWidth, 
                                m_renderHeight, 
                                1, 
                                D3DUSAGE_RENDERTARGET, 
                                m_intermediateTargetFormat, /* Use output target format */
                                D3DPOOL_DEFAULT, 
                                &m_pTextureInterm );
                }
                if ( FAILED(hr) )
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to create intermediate texture for offscreen render target.");
                        return false;
                }
        }
        if (m_pTextureInterm)
        {
                hr = m_pTextureInterm->GetSurfaceLevel( 0, &m_pTextureIntermSurface );
        }
        if ( FAILED(hr) )
        {
                MGlobal::displayWarning("Direct3D renderer : Failed to get surface for off-screen render target.");
                return false;
        }


        //
        // 2. Create output render targets
        //
        // If we don't want floating point, then the intermediate is
        // the final output format, so don't bother creating another one.
        // Just make the output point to the intermediate target.
        if (m_wantFloatingPointTargets)
        {
                if (m_pTextureOutput)
                {
                        m_pTextureOutput->Release();
                        m_pTextureOutput = NULL;
                }
                if (m_pTextureOutputSurface)
                {
                        m_pTextureOutputSurface->Release();
                        m_pTextureOutputSurface = NULL;
                }

                if (!m_pTextureOutput)
                {
                        // Create texture for render target
                        hr = D3DXCreateTexture( m_pD3DDevice, 
                                m_renderWidth, 
                                m_renderHeight, 
                                1, 
                                D3DUSAGE_RENDERTARGET, 
                                m_outputTargetFormat, 
                                D3DPOOL_DEFAULT, 
                                &m_pTextureOutput );

                        if ( FAILED(hr) )
                        {
                                MGlobal::displayWarning("Direct3D renderer : Failed to create texture for offscreen render target.");
                                return false;
                        }
                }

                // Get the surface (0) for the texture. Could probably do this one
                // per refresh and not keep it around...        
                if (m_pTextureOutput)
                {
                        hr = m_pTextureOutput->GetSurfaceLevel( 0, &m_pTextureOutputSurface );
                }
                if ( FAILED(hr) )
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to get surface for off-screen render target.");
                        return false;
                }
        }
        else
        {
                m_pTextureOutput = m_pTextureInterm;
                m_pTextureOutputSurface = m_pTextureIntermSurface;
        }

        //
        // 3. Create post-process render targets
        //
        if (m_pTexturePost)
        {
                m_pTexturePost->Release();
                m_pTexturePost = NULL;
        }
        if (!m_pTexturePost)
        {
                hr = D3DXCreateTexture( m_pD3DDevice, 
                        m_renderWidth, 
                        m_renderHeight, 
                        1, 
                        D3DUSAGE_RENDERTARGET, 
                        m_intermediateTargetFormat, /* Use intermediate target format */
                        D3DPOOL_DEFAULT, 
                        &m_pTexturePost );

                if ( FAILED(hr) )
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to create texture for offscreen post-processing.");
                        return false;
                }
        }

        // 4. Create system memory surface for readback
        if (m_SystemMemorySurface)
        {
                m_SystemMemorySurface->Release();
                m_SystemMemorySurface = 0;
        }
        if (!m_SystemMemorySurface)
        {
                hr = m_pD3DDevice->CreateOffscreenPlainSurface( m_renderWidth,
                        m_renderHeight, m_outputTargetFormat, D3DPOOL_SYSTEMMEM,
                        &m_SystemMemorySurface, NULL );
                if (FAILED(hr))
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to create system memory readback surface.");
                        return false;
                }
        }

        return (m_pTextureOutput && m_pTextureOutputSurface && m_pTextureInterm && 
                        m_pTextureIntermSurface && m_pTexturePost && m_SystemMemorySurface);

#if defined(DEPTH_REQUIRED)
        // 5. Create depth stencil surface for access for readback.
        if (m_pDepthStencilSurface)
        {
                m_pDepthStencilSurface->Release();
                m_pDepthStencilSurface = 0;
        }
        if (m_requireDepthStencilReadback && !m_pDepthStencilSurface)
        {
                hr = m_pD3DDevice->CreateDepthStencilSurface( 
                                                m_renderWidth, m_renderHeight, m_depthStencilFormat, D3DMULTISAMPLE_NONE, 
                                                0, FALSE, 
                                                &m_pDepthStencilSurface, NULL );
                if (FAILED(hr))
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to create depth/stencil surface. Depth read back will not be available.");
                }
        }
#endif
}
#endif

/* virtual */   
MStatus 
D3DViewportRenderer::initialize()
{
        MStatus status = MStatus::kFailure;

#if defined(D3D9_SUPPORTED)

        // Do we want floating point targets
        //
        MString wantFloatingPoint("D3D_RENDERER_FLOAT_TARGETS");
        int value;
        if (!MGlobal::getOptionVarValue(wantFloatingPoint, value))
        {
                m_wantFloatingPointTargets = true;
        }
        else
        {
                m_wantFloatingPointTargets = (value != 0);
        }
        m_wantFloatingPointTargets = false;

        // Create the window to contain our off-screen target.
        //
        if (!m_hWnd)
        {
                // Register the window class
                WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, (WNDPROC) D3DWindowProc, 0L, 0L, 
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                                          "D3D Viewport Renderer", NULL };
                if (RegisterClassEx( &wc ))
                {
                        m_hWnd = CreateWindow( "D3D Viewport Renderer", "D3D Viewport Renderer", 
                                                                        WS_OVERLAPPEDWINDOW, 0, 0, m_renderWidth, m_renderHeight,
                                                                        NULL, NULL, wc.hInstance, NULL );
                }
        }

        // Startup D3D
        if (m_hWnd)
        {
                if (!m_pD3D)
                        m_pD3D = Direct3DCreate9( D3D_SDK_VERSION );
        }

        HRESULT hr;

        // Test for floating point buffer usage for render targets
        if (m_wantFloatingPointTargets)
        {
                m_intermediateTargetFormat = D3DFMT_A16B16G16R16F;
        }
        else
        {
                m_intermediateTargetFormat = D3DFMT_A8R8G8B8;
        }
        // The output target is always fixed8 for now.
        m_outputTargetFormat = D3DFMT_A8R8G8B8;
        if (m_requireDepthStencilReadback)
        {
                m_depthStencilFormat = D3DFMT_D32; // Let's try for 32-bit depth, not stencil
        }
        else
                m_depthStencilFormat = D3DFMT_D24S8; 

        // Create an appropriate device
        if (m_pD3D)
        {
                if (!m_pD3DDevice)
                {
                        D3DPRESENT_PARAMETERS d3dpp; 
                        ZeroMemory( &d3dpp, sizeof(d3dpp) );

                        d3dpp.BackBufferFormat           = m_outputTargetFormat;
                        d3dpp.Windowed                           = TRUE; // Don't want full screen
                        d3dpp.BackBufferWidth        = 1920; // Make it big enough to avoid clipping.
                        d3dpp.BackBufferHeight       = 1680;
                        d3dpp.SwapEffect                         = D3DSWAPEFFECT_DISCARD;
                        d3dpp.PresentationInterval   = D3DPRESENT_INTERVAL_IMMEDIATE;
                        d3dpp.EnableAutoDepthStencil = TRUE;
                        d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; 

                        // Try hardware vertex processing first.
                        //
                        hr = m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd,
                                                                                D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE,
                                                                                &d3dpp, &m_pD3DDevice );
                        
                        // Try software if we can't find hardware.
                        if (FAILED(hr))
                        {
                                hr = m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd,
                                                                                D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE,
                                                                                &d3dpp, &m_pD3DDevice );
                        }
                        if ( FAILED(hr) )
                                m_pD3DDevice = 0;
                }
        }

        // Turn on Z buffer.
        if (m_pD3DDevice)
        {
                m_pD3DDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

                bool builtRenderTargets = buildRenderTargets(640, 480); 
                if (builtRenderTargets)
                {
                        MString shaderLocation(MString(getenv("MAYA_LOCATION")) + MString("\\bin\\HLSL"));

                        // Load in any post effects from a given directory
                        bool loaded = m_resourceManager.initializePostEffects( shaderLocation, m_pD3DDevice );

                        // Load in default surface effect from a given directory
                        const MString defaultSurfaceEffect("Maya_fixedFunction");
                        loaded = m_resourceManager.initializeDefaultSurfaceEffect( shaderLocation, m_pD3DDevice, defaultSurfaceEffect);
                        //printf("Loaded Maya fixed function = %d\n", loaded);

                        // All elements must exist for success
                        if (m_hWnd && m_pD3D && m_pD3DDevice && m_pTextureOutput && m_pTextureOutputSurface && 
                                m_pTextureInterm && m_pTextureIntermSurface )
                        {
                                status = MStatus::kSuccess;
                        }
                }
        }

        // If for any reason we failed. Cleanup what we can.
        if (status != MStatus::kSuccess)
        {
                uninitialize();
        }
#else
        status = MStatus::kSuccess;
#endif

        return status;
}

/* virtual */   
MStatus 
D3DViewportRenderer::uninitialize()
{       
#if defined(D3D9_SUPPORTED)
        // 
        // Cleanup D3D items
        //
        if ( m_pTextureOutput )
        {
                if (m_pTextureOutput != m_pTextureInterm)               
                        m_pTextureOutput->Release();
                m_pTextureOutput = 0;
        }

        if ( m_pTextureOutputSurface )
        {
                if (m_pTextureOutputSurface != m_pTextureIntermSurface)
                        m_pTextureOutputSurface->Release();
                m_pTextureOutputSurface = 0;
        }

        if ( m_pTextureInterm )
        {
        m_pTextureInterm->Release();
                m_pTextureInterm = 0;
        }

        if ( m_pTextureIntermSurface )
        {
        m_pTextureIntermSurface->Release();
                m_pTextureIntermSurface = 0;
        }

        if ( m_pTexturePost )
        {
        m_pTexturePost->Release();
                m_pTexturePost = 0;
        }

        if ( m_SystemMemorySurface )
        {
                m_SystemMemorySurface->Release();
                m_SystemMemorySurface = 0;
        }
        if (m_pDepthStencilSurface)
        {
                m_pDepthStencilSurface->Release();
                m_pDepthStencilSurface = 0;
        }

        if ( m_pBoundsBuffer != NULL )
        {
        m_pBoundsBuffer->Release(); 
                m_pBoundsBuffer = 0;
        }
        if (m_pGeometry)
        {
                m_pGeometry->Release();
                m_pGeometry = 0;
        }
        m_resourceManager.clearResources(false, true); /* wipe out shaders */

    if ( m_pD3DDevice )
        {
        m_pD3DDevice->Release();
                m_pD3DDevice = 0;
        }

    if ( m_pD3D )
        {
        m_pD3D->Release();      
                m_pD3D = 0;
        }

        // Clean up windowing items.
        //
        if (m_hWnd)
        {
                ReleaseDC( m_hWnd, GetDC(m_hWnd ));
                DestroyWindow(m_hWnd);
                UnregisterClass("D3D Viewport Renderer", GetModuleHandle(NULL));
                m_hWnd = 0;
        }

#endif
        return MStatus::kSuccess;
}

/* virtual */ 
MStatus 
D3DViewportRenderer::render(const MRenderingInfo &renderInfo)
{
        MStatus status;

        // Print some diagnostic information.
        //

#if defined(D3D9_SUPPORTED)
        const MRenderTarget & target = renderInfo.renderTarget();
        unsigned int currentWidth = target.width();
        unsigned int currentHeight = target.height();
        
        if (!buildRenderTargets(currentWidth, currentHeight))
                return MStatus::kFailure;
#endif

        //printf("Render using (%s : %s) renderer\n", fName.asChar(), fUIName.asChar());
        //printf("Render region: %d,%d -> %d, %d into target of size %d,%d\n", 
        //      renderInfo.originX(), renderInfo.originY(), renderInfo.width(), renderInfo.height(),
        //      target.width(), target.height() );


#if defined(D3D9_SUPPORTED)
        MViewportRenderer::RenderingAPI targetAPI = renderInfo.renderingAPI();
        //float targetVersion = renderInfo.renderingVersion();
        //printf("Render target API is %s (Version %g)\n", targetAPI == MViewportRenderer::kDirect3D ?
        //              "Direct3D" : "OpenGL", targetVersion);

        // Render if we get a valid camera
        const MDagPath &cameraPath = renderInfo.cameraPath();
        if ( m_resourceManager.translateCamera( cameraPath ) )
        {
                if ( renderToTarget( renderInfo ) )
                {
                        // Read back results and set into an intermediate buffer,
                        // if the target is not Direct3D. Also readback if we
                        // want to debug the buffer.
                        //
                        bool requireReadBack = (targetAPI != MViewportRenderer::kDirect3D);
                        if ( requireReadBack )
                        {
                                if (readFromTargetToSystemMemory())
                                {
                                        // Blit image back to OpenGL 
                                        if (targetAPI == MViewportRenderer::kOpenGL)
                                        {
                                                // Center the image for now.
                                                //
                                                unsigned int targetW = target.width();
                                                unsigned int targetH = target.height();                                                 
                                                unsigned int m_readBackBufferWidth, m_readBackBufferHeight;
                                                m_readBackBuffer.getSize(m_readBackBufferWidth, m_readBackBufferHeight);

                                                if (m_readBackBufferWidth && m_readBackBufferHeight)
                                                {
                                                        if (m_readBackBufferWidth > targetW ||
                                                                m_readBackBufferHeight > targetH)
                                                        {
                                                                m_readBackBuffer.resize(targetW, targetH);
                                                                target.writeColorBuffer( m_readBackBuffer, 0, 0 );
                                                        }
                                                        else
                                                        {
                                                                target.writeColorBuffer( m_readBackBuffer, 
                                                                        (short)(targetW/2 - m_readBackBufferWidth/2),
                                                                        (short)(targetH/2 - m_readBackBufferHeight/2));
                                                        }
                                                        status = MStatus::kSuccess;
                                                }
                                        }

                                        // Blit image back to a software raster
                                        else
                                        {
                                                // To ADD
                                                status = MStatus::kFailure;
                                        }
                                }
                                else
                                        status = MStatus::kFailure;                             
                        }

                        // Do nothing here. Direct rendering to D3D target
                        // should be handled in renderToTarget().
                        else 
                        {
                                status = MStatus::kSuccess;
                        }
                }
                else
                        status = MStatus::kFailure;
        }
        else
        {
                MGlobal::displayWarning("Direct3D renderer : No valid render camera to use. Nothing rendered\n");
                status = MStatus::kFailure;
        }
#else
                status = MStatus::kSuccess;
#endif
        return status;
}

/* virtual */ 
bool    
D3DViewportRenderer::nativelySupports( MViewportRenderer::RenderingAPI api, 
                                                                           float version )
{
        // Do API and version check
        return ((api == m_API) && (version == m_Version) );
}

/* virtual */ bool      
D3DViewportRenderer::override( MViewportRenderer::RenderingOverride override )
{
        // Check override
        return (override == fRenderingOverride);
}

// Rendering methods
#if defined(D3D9_SUPPORTED)

bool                                    
D3DViewportRenderer::translateCamera( const MRenderingInfo &renderInfo )
//
// Description:
//              Translate Maya's camera 
//
{
        const MDagPath &cameraPath = renderInfo.cameraPath();
        if (cameraPath.isValid())
                return m_resourceManager.translateCamera( cameraPath );
        else
                return false;
}

bool D3DViewportRenderer::drawCube(float minVal[3], float maxVal[3], bool filled, bool useDummyGeometry,
                                                                   float color[3], LPDIRECT3DVERTEXBUFFER9 buffer /* = NULL */)
//
// Description:
//              Draw a rectangular bounds of min->max size.
//
{
        if (!m_pD3DDevice)
                return false;

        D3DMATERIAL9 Material;
        Material.Emissive.r = color[0]; 
        Material.Emissive.g = color[1]; 
        Material.Emissive.b = color[2]; 
        Material.Emissive.a = 1.0f; 
        Material.Ambient.r = color[0]; 
        Material.Ambient.g = color[1]; 
        Material.Ambient.b = color[2]; 
        Material.Ambient.a = 1.0f; 
        m_pD3DDevice->SetMaterial( &Material);
        m_pD3DDevice->LightEnable( 0, false);
        m_pD3DDevice->LightEnable( 1, false);
        m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);

        // Set up render state
        //
        if (!filled)
        {
                m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
        }
        else
        {
                m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );          
        }
        m_pD3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
        m_pD3DDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_FLAT );

        // 
        if (!m_pGeometry)
        {
                if (useDummyGeometry)
                {
                        //D3DXCreateSphere(m_pD3DDevice, 1.0f, 20, 20, &m_pGeometry, NULL);
                        //D3DXCreateTeapot(m_pD3DDevice, &m_pGeometry, NULL);
                        //D3DXCreateBox(m_pD3DDevice, 1.0, 1.0, 1.0, &m_pGeometry, NULL);
                }
        }
        if (useDummyGeometry && m_pGeometry)
        {
                m_pGeometry->DrawSubset(0);
                return true;
        }

        // Build a vertex buffer to hold a cube once.
        //
        LPDIRECT3DVERTEXBUFFER9 bufferToFill = m_pBoundsBuffer;
        if (!bufferToFill)
        {
                m_pD3DDevice->CreateVertexBuffer( 24*sizeof(PlainVertex),0, PlainVertex::FVF_Flags,
                                                                                        D3DPOOL_DEFAULT, &bufferToFill, NULL );
        }
        if (!bufferToFill)
        {
                return false;
        }
        
        PlainVertex cube[] =
        {
                { minVal[0], maxVal[1], minVal[2]},
                { maxVal[0], maxVal[1], minVal[2]},
                { minVal[0], minVal[1], minVal[2] },
                { maxVal[0], minVal[1], minVal[2] },

                {minVal[0], maxVal[1], maxVal[2] },
                {minVal[0],minVal[1], maxVal[2] },
                { maxVal[0], maxVal[1], maxVal[2] },
                { maxVal[0],minVal[1], maxVal[2] },

                {minVal[0], maxVal[1], maxVal[2] },
                { maxVal[0], maxVal[1], maxVal[2] },
                {minVal[0], maxVal[1],minVal[2] },
                { maxVal[0], maxVal[1],minVal[2] },

                {minVal[0],minVal[1], maxVal[2] },
                {minVal[0],minVal[1],minVal[2] },
                { maxVal[0],minVal[1], maxVal[2] },
                { maxVal[0],minVal[1],minVal[2] },

                { maxVal[0], maxVal[1],minVal[2] },
                { maxVal[0], maxVal[1], maxVal[2] },
                { maxVal[0],minVal[1],minVal[2] },
                { maxVal[0],minVal[1], maxVal[2] },

                {minVal[0], maxVal[1],minVal[2] },
                {minVal[0],minVal[1],minVal[2] },
                {minVal[0], maxVal[1], maxVal[2] },
                {minVal[0],minVal[1], maxVal[2] }
        };

        void *pVertices = NULL;

        // Do this everytime as we don't store more than one box,
        // and we don't check for changes in bounds sizes.
        //
        bufferToFill->Lock( 0, sizeof(cube), (void**)&pVertices, 0 );
        memcpy( pVertices, cube, sizeof(cube) );
        bufferToFill->Unlock();

    m_pD3DDevice->SetStreamSource( 0, bufferToFill, 0, sizeof(PlainVertex) );
    m_pD3DDevice->SetFVF( PlainVertex::FVF_Flags );


        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP,  0, 2 );
        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP,  4, 2 );
        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP,  8, 2 );
        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 12, 2 );
        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 16, 2 );
        m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 20, 2 );

        m_pD3DDevice->LightEnable( 0, true);
        m_pD3DDevice->LightEnable( 1, true);

        return true;
}

void                                    
D3DViewportRenderer::clearResources(bool onlyInvalidItems, bool clearShaders)
{
        m_resourceManager.clearResources( onlyInvalidItems, clearShaders );
}

MObject findShader( MObject& setNode )
//
//  Description:
//      Find the shading node for the given shading group set node.
//
{
        MFnDependencyNode fnNode(setNode);
        MPlug shaderPlug = fnNode.findPlug("surfaceShader");
                        
        if (!shaderPlug.isNull()) {                     
                MPlugArray connectedPlugs;
                bool asSrc = false;
                bool asDst = true;
                shaderPlug.connectedTo( connectedPlugs, asDst, asSrc );

                if (connectedPlugs.length() != 1)
                        MGlobal::displayError("Error getting shader");
                else 
                        return connectedPlugs[0].node();
        }                       
        
        return MObject::kNullObj;
}

bool D3DViewportRenderer::setSurfaceMaterialShader( const MDagPath &dagPath, D3DGeometry* Geometry,
                                                                                                        const D3DXMATRIXA16 &objectToWorld, 
                                                                                                        const D3DXMATRIXA16 &objectToWorldInvTranspose, 
                                                                                                        const D3DXMATRIXA16 &worldViewProjection,
                                                                                                        const D3DXVECTOR4 &worldEyePosition)
{
        if (!Geometry)
                return false;

        const SurfaceEffectItemList & surfaceEffects = m_resourceManager.getSurfaceEffectItemList();
        bool havePixelShader = (surfaceEffects.size() > 0);
        if (havePixelShader)
        {
                // Default is always the first shader !
                SurfaceEffectItem *defaultItem = surfaceEffects.front();
                if (defaultItem)
                {
                        ID3DXEffect* effect = defaultItem->fEffect;
                        if (effect)
                        {
                                //printf("Setup effects technique...\n");
                                HRESULT hres = effect->SetTechnique("MayaPhong");
                                if (hres != D3D_OK)
                                        havePixelShader = false;
                                else
                                {
                                        //printf("Set up effect parameters\n");
                                        D3DXHANDLE handle;
                                        handle = effect->GetParameterBySemantic( NULL, "WorldView" );
                                        effect->SetMatrix( handle, &objectToWorld );
                                        handle = effect->GetParameterBySemantic( NULL, "WorldViewInverseTranspose" );
                                        effect->SetMatrix( handle, &objectToWorldInvTranspose );
                                        handle = effect->GetParameterBySemantic( NULL, "WorldViewProjection" );
                                        effect->SetMatrix( handle, &worldViewProjection );

                                        // Required for specular lighting.
                                        //effect->SetVector( "worldEyePosition", &worldEyePosition );

                                        // Setup lighting parameters
                                        MItDag dagIterator( MItDag::kDepthFirst, MFn::kLight );
                                        MDagPath lightPath;
                                        for (; !dagIterator.isDone(); dagIterator.next())
                                        {
                                                if ( !dagIterator.getPath(lightPath) )
                                                        continue;
                                                MFnLight    fnLight( lightPath );
                                                MTransformationMatrix worldMatrix = lightPath.inclusiveMatrix();

                                                MVector translation = worldMatrix.translation( MSpace::kWorld );
                                                MVector direction( 0.0, 0.0, 1.0 ); 
                                                direction *= worldMatrix.asMatrix();
                                                direction.normalize();

                                                // Hard coded for directional only currently
                                                D3DXVECTOR4 e_val((float)direction.x, (float)direction.y, (float)direction.z, 1.0f );
                                                hres = effect->SetVector( "lightDir", &e_val );

                                                MColor      colorVal = fnLight.color();
                                                float intensity = fnLight.intensity();

                                                D3DXVECTOR4 c_val( colorVal.r * intensity, colorVal.g * intensity, colorVal.b * intensity, 1.0f );
                                                hres = effect->SetVector( "lightColor", &c_val );
                                        }
        
                                        // Setup material parameters
                                        //
                                        bool isTransparent = false;
                                        MFnMesh fnMesh(dagPath);
                                        MObjectArray sets;
                                        MObjectArray comps;
                                        unsigned int instanceNum = dagPath.instanceNumber();
                                        if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true))
                                                MGlobal::displayError("ERROR: MFnMesh::getConnectedSetsAndMembers");
                                        if (sets.length())
                                        {
                                                MObject set = sets[0];
                                                MObject comp = comps[0];

                                                MStatus status;
                                                MObject shaderNode = findShader(set);
                                                if (shaderNode != MObject::kNullObj)
                                                {                                                               
                                                        float rgb[3];

                                                        MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status);
                                                        D3DTexture* Texture = NULL;
                                                        if (status != MS::kFailure)
                                                        {
                                                                MItDependencyGraph It( colorPlug, MFn::kFileTexture, MItDependencyGraph::kUpstream);
                                                                if( !It.isDone())
                                                                {
                                                                        Texture = m_resourceManager.getTexture( It.thisNode());
                                                                        hres = effect->SetTexture( "diffuseTexture", Texture->Texture( m_pD3DDevice ));
                                                                        D3DXVECTOR4 e_val(1.0f, 1.0f, 1.0f, 1.0f );
                                                                        hres = effect->SetVector( "diffuseMaterial", &e_val);

                                                                        // Change the technique to a textured one
                                                                        hres = effect->SetTechnique("MayaPhongTextured");
                                                                }
                                                                else
                                                                {
                                                                        MObject data;
                                                                        colorPlug.getValue( data);
                                                                        MFnNumericData val(data);
                                                                        val.getData( rgb[0], rgb[1], rgb[2]);
                                                                        
                                                                        D3DXVECTOR4 e_val(rgb[0], rgb[1], rgb[2], 1.0f );
                                                                        hres = effect->SetVector( "diffuseMaterial", &e_val);
                                                                }
                                                        }

                                                        MPlug diffusePlug = MFnDependencyNode(shaderNode).findPlug("diffuse", &status);
                                                        if (status != MS::kFailure)
                                                        {
                                                                MObject data;
                                                                float diff;
                                                                diffusePlug.getValue( diff );
                                                                //Material.Diffuse.r *= (float)diff;
                                                                //Material.Diffuse.g *= (float)diff; 
                                                                //Material.Diffuse.b *= (float)diff;
                                                        }
                                                        MPlug ambientColorPlug = MFnDependencyNode(shaderNode).findPlug("ambientColor", &status);
                                                        if (status != MS::kFailure)
                                                        {
                                                                MObject data;
                                                                ambientColorPlug .getValue( data);
                                                                MFnNumericData val(data);
                                                                val.getData( rgb[0], rgb[1], rgb[2]);

                                                                D3DXVECTOR4 e_val( rgb[0], rgb[1], rgb[2], 1.0f );
                                                                effect->SetVector( "ambientMaterial", &e_val );
                                                        }
                                                        MPlug transparencyPlug = MFnDependencyNode(shaderNode).findPlug("transparency", &status);
                                                        if (status != MS::kFailure)
                                                        {
                                                                MObject data;
                                                                transparencyPlug.getValue( data);
                                                                MFnNumericData val(data);
                                                                val.getData( rgb[0], rgb[1], rgb[2]);

                                                                D3DXVECTOR4 e_val( 1.0f - rgb[0], 1.0f - rgb[1], 1.0f - rgb[2], 1.0f );
                                                                effect->SetVector( "transparency", &e_val );
                                                                if (rgb[0] < 1.0f || rgb[1] < 1.0f || rgb[2] < 1.0f)
                                                                        isTransparent = true;
                                                        }
                                                        MPlug incandescencePlug = MFnDependencyNode(shaderNode).findPlug("incandescence", &status);
                                                        if (status != MS::kFailure)
                                                        {
                                                                MObject data;
                                                                incandescencePlug.getValue( data);
                                                                MFnNumericData val(data);
                                                                val.getData( rgb[0], rgb[1], rgb[2]);
                                                                //Material.Emissive.r = (float)rgb[0]; 
                                                                //Material.Emissive.g = (float)rgb[1]; 
                                                                //Material.Emissive.b = (float)rgb[2]; Material.Emissive.a = 1.0f; 
                                                        }
                                                        MPlug specularColorPlug = MFnDependencyNode(shaderNode).findPlug("specularColor", &status);
                                                        if (status != MS::kFailure)
                                                        {
                                                                MObject data;
                                                                specularColorPlug.getValue( data);
                                                                MFnNumericData val(data);
                                                                val.getData( rgb[0], rgb[1], rgb[2]);

                                                                D3DXVECTOR4 e_val( rgb[0], rgb[1], rgb[2], 1.0f );
                                                                effect->SetVector( "specularMaterial", &e_val );
                                                        }                                               
                                                        // Rough approximations for Phong, PhongE, and Blinn.
                                                        //
                                                        if (shaderNode.hasFn(MFn::kLambert))
                                                        {
                                                                effect->SetFloat( "specularPower", 0.0f );
                                                        }
                                                        if (shaderNode.hasFn(MFn::kPhong))
                                                        {
                                                                MPlug cosinePowerPlug = MFnDependencyNode(shaderNode).findPlug("cosinePower", &status);
                                                                if (status != MS::kFailure)
                                                                {
                                                                        MObject data;
                                                                        float cosPower = 0.0f;
                                                                        cosinePowerPlug.getValue( cosPower );
                                                                        hres = effect->SetFloat( "specularPower", cosPower * 4.0f );
                                                                }                                               
                                                        }
                                                        else if (MFn::kBlinn)
                                                        {
                                                                MPlug eccentricityPlug = MFnDependencyNode(shaderNode).findPlug("eccentricity", &status);
                                                                if (status != MS::kFailure)
                                                                {
                                                                        // Maya's funky remapping of eccentricity into cosinePower.
                                                                        //
                                                                        MObject data;
                                                                        float eccentricity = 0.0f;
                                                                        eccentricityPlug.getValue( eccentricity );
                                                                        hres = effect->SetFloat( "specularPower", (eccentricity < 0.03125f) ? 128.0f : 4.0f / eccentricity );
                                                                }
                                                        }
                                                        else // if (shaderNode.hasFn(MFn::kPhongE))
                                                        {
                                                                MPlug roughnessPlug = MFnDependencyNode(shaderNode).findPlug("roughness", &status);
                                                                if (status != MS::kFailure)
                                                                {
                                                                        MObject data;
                                                                        float roughness = 0.0f;
                                                                        roughnessPlug.getValue( roughness );
                                                                        hres = effect->SetFloat( "specularPower", roughness * 4.0f );
                                                                }
                                                        }
                                                }
                                        }

                                        unsigned int numPasses;
                                        effect->Begin( &numPasses, 0 );
                                        if (hres != D3D_OK)
                                                havePixelShader = false;
                                        else
                                        {
                                                //printf("Draw %d passes\n", numPasses);
                                                for (unsigned int p=0; p<numPasses; ++p)
                                                {
                                                        hres = effect->BeginPass( p );
                                                        if (hres == D3D_OK) 
                                                        {
                                                                // Enable transparency if required by material.
                                                                //
                                                                //m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, isTransparent);
                                                                //m_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
                                                                //m_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

                                                                //printf("Draw surface shader pass\n");
                                                                Geometry->Render( m_pD3DDevice);
                                                        }
                                                        hres = effect->EndPass();
                                                }
                                        }
                                        hres = effect->End();
                                        if (hres != D3D_OK) 
                                                havePixelShader = false;
                                }
                        }
                }
        }

        return havePixelShader;
}


bool D3DViewportRenderer::setSurfaceMaterial( const MDagPath &dagPath )
{
        D3DMATERIAL9 Material;
        bool isTransparent = false;

        MFnMesh fnMesh(dagPath);
        MObjectArray sets;
        MObjectArray comps;
        unsigned int instanceNum = dagPath.instanceNumber();
        if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true))
                MGlobal::displayError("ERROR : MFnMesh::getConnectedSetsAndMembers");
        for ( unsigned i=0; i<sets.length(); i++ ) 
        {
                MObject set = sets[i];
                MObject comp = comps[i];

                MStatus status;
                MFnSet fnSet( set, &status );
                if (status == MS::kFailure) {
                        MGlobal::displayError("ERROR: MFnSet::MFnSet");
                        continue;
                }

                MObject shaderNode = findShader(set);
                if (shaderNode != MObject::kNullObj)
                {                                                               
                        float rgb[3];

                        MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status);
                        D3DTexture* Texture = NULL;
                        if (status != MS::kFailure)
                        {
                                MItDependencyGraph It( colorPlug, MFn::kFileTexture, MItDependencyGraph::kUpstream);
                                if( !It.isDone())
                                {
                                        Texture = m_resourceManager.getTexture( It.thisNode());
                                        m_pD3DDevice->SetTexture( 0, Texture->Texture( m_pD3DDevice));
                                        m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
                                        m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
                                        m_pD3DDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
                                        m_pD3DDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
                                        m_pD3DDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
                                        m_pD3DDevice->SetRenderState(D3DRS_WRAP0, D3DWRAPCOORD_0);
                                        m_pD3DDevice->SetRenderState(D3DRS_WRAP1, D3DWRAPCOORD_1);
                                        Material.Diffuse.r = Material.Diffuse.g = Material.Diffuse.b = Material.Diffuse.a = 1.0f; 
                                }
                                else
                                {
                                        m_pD3DDevice->SetTexture( 0, NULL);
                                        MObject data;
                                        colorPlug.getValue( data);
                                        MFnNumericData val(data);
                                        val.getData( rgb[0], rgb[1], rgb[2]);
                                        Material.Diffuse.r = (float)rgb[0]; 
                                        Material.Diffuse.g = (float)rgb[1]; 
                                        Material.Diffuse.b = (float)rgb[2]; Material.Diffuse.a = 1.0f; 
                                }
                        }

                        MPlug diffusePlug = MFnDependencyNode(shaderNode).findPlug("diffuse", &status);
                        if (status != MS::kFailure)
                        {
                                MObject data;
                                float diff;
                                diffusePlug.getValue( diff );
                                Material.Diffuse.r *= (float)diff;
                                Material.Diffuse.g *= (float)diff; 
                                Material.Diffuse.b *= (float)diff;
                        }
                        MPlug ambientColorPlug = MFnDependencyNode(shaderNode).findPlug("ambientColor", &status);
                        if (status != MS::kFailure)
                        {
                                MObject data;
                                ambientColorPlug .getValue( data);
                                MFnNumericData val(data);
                                val.getData( rgb[0], rgb[1], rgb[2]);
                                Material.Ambient.r = (float)rgb[0]; 
                                Material.Ambient.g = (float)rgb[1]; 
                                Material.Ambient.b = (float)rgb[2]; Material.Ambient.a = 1.0f; 
                        }
                        MPlug transparencyPlug = MFnDependencyNode(shaderNode).findPlug("transparency", &status);
                        if (status != MS::kFailure)
                        {
                                MObject data;
                                transparencyPlug.getValue( data);
                                MFnNumericData val(data);
                                val.getData( rgb[0], rgb[1], rgb[2]);
                                Material.Diffuse.a = 1.0f - (rgb[0] + rgb[1] + rgb[2]) / 3.0f;
                                if (Material.Diffuse.a < 1.0f)
                                        isTransparent = true;
                        }
                        MPlug incandescencePlug = MFnDependencyNode(shaderNode).findPlug("incandescence", &status);
                        if (status != MS::kFailure)
                        {
                                MObject data;
                                incandescencePlug.getValue( data);
                                MFnNumericData val(data);
                                val.getData( rgb[0], rgb[1], rgb[2]);
                                Material.Emissive.r = (float)rgb[0]; 
                                Material.Emissive.g = (float)rgb[1]; 
                                Material.Emissive.b = (float)rgb[2]; Material.Emissive.a = 1.0f; 
                        }
                        MPlug specularColorPlug = MFnDependencyNode(shaderNode).findPlug("specularColor", &status);
                        if (status != MS::kFailure)
                        {
                                MObject data;
                                specularColorPlug.getValue( data);
                                MFnNumericData val(data);
                                val.getData( rgb[0], rgb[1], rgb[2]);
                                Material.Specular.r = (float)rgb[0]; 
                                Material.Specular.g = (float)rgb[1]; 
                                Material.Specular.b = (float)rgb[2]; Material.Specular.a = 1.0f; 
                        }                                               
                        // Rough approximations for Phong, PhongE, and Blinn.
                        //
                        Material.Power = 20.0f;
                        if (shaderNode.hasFn(MFn::kLambert))
                        {
                                Material.Power = 0.0f;
                        }
                        if (shaderNode.hasFn(MFn::kPhong))
                        {
                                MPlug cosinePowerPlug = MFnDependencyNode(shaderNode).findPlug("cosinePower", &status);
                                if (status != MS::kFailure)
                                {
                                        MObject data;
                                        float cosPower = 0.0f;
                                        cosinePowerPlug.getValue( cosPower );
                                        Material.Power = cosPower * 4.0f;
                                }                                               
                        }
                        else if (MFn::kBlinn)
                        {
                                MPlug eccentricityPlug = MFnDependencyNode(shaderNode).findPlug("eccentricity", &status);
                                if (status != MS::kFailure)
                                {
                                        // Maya's funky remapping of eccentricity into cosinePower.
                                        //
                                        MObject data;
                                        float eccentricity = 0.0f;
                                        eccentricityPlug.getValue( eccentricity );
                                        Material.Power = (eccentricity < 0.03125f) ? 128.0f : 4.0f / eccentricity;
                                }
                        }
                        else // if (shaderNode.hasFn(MFn::kPhongE))
                        {
                                MPlug roughnessPlug = MFnDependencyNode(shaderNode).findPlug("roughness", &status);
                                if (status != MS::kFailure)
                                {
                                        MObject data;
                                        float roughness = 0.0f;
                                        roughnessPlug.getValue( roughness );
                                        Material.Power = roughness * 4.0f;
                                }
                        }
                        break;
                }
        }

        // Enable transparency if required by material.
        //
        m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, isTransparent);
        m_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        m_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

        m_pD3DDevice->SetMaterial( &Material);

        return true;
}

bool D3DViewportRenderer::drawSurface( const MDagPath &dagPath, bool active, bool templated)
{
        bool drewSurface = false;

        if ( !dagPath.hasFn( MFn::kMesh ))
        {
                MMatrix  matrix = dagPath.inclusiveMatrix();
                MFnDagNode dagNode(dagPath);
                MBoundingBox box = dagNode.boundingBox();
                float color[3] = {0.6f, 0.3f, 0.0f};
                if (active)
                {
                        color[0] = 1.0f;
                        color[1] = 1.0f;
                        color[2] = 1.0f;
                }
                else if (templated)
                {
                        color[0] = 1.0f;
                        color[1] = 0.686f;
                        color[2] = 0.686f;
                }
                drawBounds( matrix, box, false, true, color);
                return true;
        }

        if ( dagPath.hasFn( MFn::kMesh ))
        {
                MMatrix  matrix = dagPath.inclusiveMatrix();
                MFnDagNode dagNode(dagPath);

                // Look for any hardware shaders which can draw D3D first.
                //
                bool drewWithHwShader = false;
                {
                        MFnMesh fnMesh(dagPath);
                        MObjectArray sets;
                        MObjectArray comps;
                        unsigned int instanceNum = dagPath.instanceNumber();
                        if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true))
                                MGlobal::displayError("ERROR : MFnMesh::getConnectedSetsAndMembers");
                        for ( unsigned i=0; i<sets.length(); i++ ) 
                        {
                                MObject set = sets[i];
                                MObject comp = comps[i];

                                MStatus status;
                                MFnSet fnSet( set, &status );
                                if (status == MS::kFailure) {
                                        MGlobal::displayError("ERROR: MFnSet::MFnSet");
                                        continue;
                                }

                                MObject shaderNode = findShader(set);
                                if (shaderNode != MObject::kNullObj)
                                {
                                        MPxHardwareShader * hwShader = 
                                                MPxHardwareShader::getHardwareShaderPtr( shaderNode );

                                        if (hwShader)
                                        {
                                                const MRenderProfile & profile = hwShader->profile();
                                                if (profile.hasRenderer( MRenderProfile::kMayaD3D))
                                                {
                                                        // Render a Maya D3D hw shader here....
                                                        //printf("Found a D3D hw shader\n");
                                                        //drewWithHwShader = true;
                                                }
                                        }
                                }
                        }
                }

                // Get the geometry buffers for this bad boy and render them
                D3DGeometry* Geometry = m_resourceManager.getGeometry( dagPath, m_pD3DDevice);
                if( Geometry)
                {
                        // Transform from object to world space
                        //
                        D3DXMATRIXA16 objectToWorld = D3DXMATRIXA16
                                (
                                (float)matrix.matrix[0][0], (float)matrix.matrix[0][1], (float)matrix.matrix[0][2], (float)matrix.matrix[0][3],
                                (float)matrix.matrix[1][0], (float)matrix.matrix[1][1], (float)matrix.matrix[1][2], (float)matrix.matrix[1][3],
                                (float)matrix.matrix[2][0], (float)matrix.matrix[2][1], (float)matrix.matrix[2][2], (float)matrix.matrix[2][3],
                                (float)matrix.matrix[3][0], (float)matrix.matrix[3][1], (float)matrix.matrix[3][2], (float)matrix.matrix[3][3]
                        );

                        m_pD3DDevice->SetTransform( D3DTS_WORLD, &objectToWorld );
                        m_pD3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
                        m_pD3DDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
                        m_pD3DDevice->SetRenderState( D3DRS_AMBIENT, 0xFFFFFFFF );
                        m_pD3DDevice->SetRenderState( D3DRS_VERTEXBLEND, FALSE );
                        m_pD3DDevice->SetRenderState( D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE );
                        m_pD3DDevice->SetRenderState( D3DRS_COLORWRITEENABLE, 0xFFFFFFFF );

                        if (!drewWithHwShader)
                        {
                                // Get material properties for shader associated with mesh
                                //
                                // 1. Try to draw with the sample internal programmable shader
                                bool drewGeometryWithShader = false;
                                // optionVar -iv "D3D_USE_PIXEL_SHADER" 1; // Set it
                                // optionVar -remove "D3D_USE_PIXEL_SHADER"; // Remove it
                                MString usePixelShader("D3D_USE_PIXEL_SHADER");
                                int val = 0;
                                if (MGlobal::getOptionVarValue(usePixelShader, val))
                                {
                                        MMatrix  itmatrix = matrix.inverse().transpose();
                                        D3DXMATRIXA16 objectToWorldInvTransp = D3DXMATRIXA16
                                                (
                                                (float)itmatrix.matrix[0][0], (float)itmatrix.matrix[0][1], (float)itmatrix.matrix[0][2], (float)itmatrix.matrix[0][3],
                                                (float)itmatrix.matrix[1][0], (float)itmatrix.matrix[1][1], (float)itmatrix.matrix[1][2], (float)itmatrix.matrix[1][3],
                                                (float)itmatrix.matrix[2][0], (float)itmatrix.matrix[2][1], (float)itmatrix.matrix[2][2], (float)itmatrix.matrix[2][3],
                                                (float)itmatrix.matrix[3][0], (float)itmatrix.matrix[3][1], (float)itmatrix.matrix[3][2], (float)itmatrix.matrix[3][3]
                                        );

                                        MVector eyePos( 0.0, 0.0, 0.0 );
                                        eyePos *= mm_currentViewMatrix;
                                        D3DXVECTOR4 worldEye( (float)eyePos[0], (float)eyePos[1], (float)eyePos[2], (float)eyePos[3]);

                                        drewGeometryWithShader = setSurfaceMaterialShader( dagPath, Geometry, objectToWorld, objectToWorldInvTransp,
                                                objectToWorld * m_currentViewMatrix * m_currentProjectionMatrix,
                                                worldEye );
                                }

                                // 2. Draw with fixed function shader
                                if (!drewGeometryWithShader)
                                {
                                        // Set up a default material, just in case there is none.
                                        //
                                        D3DMATERIAL9 Material;
                                        if (active)
                                        {
                                                m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
                                                Material.Diffuse.r = 1.0f; Material.Diffuse.g = 1.0f; Material.Diffuse.b = 1.0f; Material.Diffuse.a = 1.0f; 
                                        }
                                        else if (templated)
                                        {
                                                m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
                                                Material.Diffuse.r = 1.0f; Material.Diffuse.g = 0.686f; Material.Diffuse.b = 0.686f; Material.Diffuse.a = 1.0f; 
                                        }
                                        else
                                        {
                                                m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
                                                Material.Diffuse.r = 0.5f; Material.Diffuse.g = 0.5f; Material.Diffuse.b = 0.5f; Material.Diffuse.a = 1.0f; 
                                        }
                                        Material.Ambient.r = 0.0f; Material.Ambient.g = 0.0f; Material.Ambient.b = 0.0f; Material.Ambient.a = 0.0f; 
                                        Material.Specular.r = 1.0f; Material.Specular.g = 1.0f; Material.Specular.b = 1.0f; Material.Specular.a = 1.0f; 
                                        Material.Emissive.r = 0.0f; Material.Emissive.g = 0.0f; Material.Emissive.b = 0.0f; Material.Emissive.a = 0.0f; 
                                        Material.Power = 50.0f;

                                        bool scanForMayaMaterial = true;
                                        if (!templated && scanForMayaMaterial)
                                        {
                                                if (!setSurfaceMaterial( dagPath ))
                                                {
                                                        m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
                                                        m_pD3DDevice->SetMaterial( &Material);
                                                }
                                        }

                                        Geometry->Render( m_pD3DDevice);
                                }
                        }

                        // Draw wireframe on top
                        //
                        m_pD3DDevice->SetTexture( 0, NULL);
                        m_pD3DDevice->SetRenderState(D3DRS_WRAP0, 0);
                        m_pD3DDevice->SetRenderState(D3DRS_WRAP1, 0);

                        if (active)
                        {
                                bool drawActiveWithBounds = false;
                                if (drawActiveWithBounds)
                                {
                                        MBoundingBox box = dagNode.boundingBox();
                                        float color[3] = {1.0f, 1.0f, 1.0f};
                                        drawBounds( matrix, box, false, false, color );
                                }
                                else
                                {
                                        D3DMATERIAL9 Material;
                                        Material.Emissive.r = 1.0; 
                                        Material.Emissive.g = 1.0; 
                                        Material.Emissive.b = 1.0; 
                                        Material.Emissive.a = 1.0f; 
                                        Material.Ambient.r = 1.0; 
                                        Material.Ambient.g = 1.0; 
                                        Material.Ambient.b = 1.0; 
                                        Material.Ambient.a = 1.0f; 
                                        m_pD3DDevice->SetMaterial( &Material);
                                        m_resourceManager.enableLights( FALSE, m_pD3DDevice );
                                        m_pD3DDevice->SetRenderState( D3DRS_ANTIALIASEDLINEENABLE, TRUE );
                                        m_pD3DDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_FLAT );
                                        m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
                                        m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
                                        m_pD3DDevice->SetRenderState( D3DRS_SLOPESCALEDEPTHBIAS, 100 );
                                        m_pD3DDevice->SetRenderState( D3DRS_DEPTHBIAS, 10 );

                                        Geometry->Render( m_pD3DDevice);                                

                                        m_pD3DDevice->SetRenderState( D3DRS_DEPTHBIAS, 0 );
                                        m_pD3DDevice->SetRenderState( D3DRS_SLOPESCALEDEPTHBIAS, 0 );
                                        m_pD3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );          
                                        m_resourceManager.enableLights( TRUE, m_pD3DDevice );
                                }
                        }
                } // If Geometry
        }
        return drewSurface;
}

bool D3DViewportRenderer::drawScene(const MRenderingInfo &renderInfo)
//
// Description:
//              Draw the Maya scene, using a custom traverser.
//
{
        bool useDrawTraversal = true;
        float groundPlaneColor[3] = { 0.8f, 0.8f, 0.8f };

        if (useDrawTraversal)
        {
                const MDagPath &cameraPath = renderInfo.cameraPath();
                if (cameraPath.isValid())
                {
                        // You can actually keep the traverser classes around
                        // if desired. Here we just create temporary traversers
                        // on the fly.
                        //
                        MDrawTraversal *trav = new MDrawTraversal;
                        trav->enableFiltering( false );
                        if (!trav)
                        {
                                MGlobal::displayWarning("Direct3D renderer : failed to create a traversal class !\n");
                                return true;
                        }

                        const MRenderTarget &renderTarget = renderInfo.renderTarget();
                        trav->setFrustum( cameraPath, renderTarget.width(), 
                                                          renderTarget.height() );

                        if (!trav->frustumValid())
                        {
                                MGlobal::displayWarning("Direct3D renderer : Frustum is invalid !\n");
                                return true;
                        }

                        trav->traverse();

                        unsigned int numItems = trav->numberOfItems();
                        unsigned int i;
                        for (i=0; i<numItems; i++)
                        {
                                MDagPath path;
                                trav->itemPath(i, path);

                                if (path.isValid())
                                {
                                        bool drawIt = false;

                                        // Default traverer may have view manips showing up.
                                        // This is currently a known Maya bug.
                                        if ( path.hasFn( MFn::kViewManip ))
                                                continue;

                                        //
                                        // Draw surfaces (polys, nurbs, subdivs)
                                        //
                                        bool active = false;
                                        bool templated = false;
                                        if ( path.hasFn( MFn::kMesh) || 
                                                 path.hasFn( MFn::kNurbsSurface) || 
                                                 path.hasFn( MFn::kSubdiv) )
                                        {
                                                drawIt = true;
                                                if (trav->itemHasStatus( i, MDrawTraversal::kActiveItem ))
                                                {
                                                        active = true;
                                                }
                                                else if (trav->itemHasStatus( i, MDrawTraversal::kTemplateItem ))
                                                {
                                                        templated = true;
                                                }
                                                else
                                                {
                                                        if (path.hasFn( MFn::kMesh ))
                                                                ;
                                                        else if (path.hasFn( MFn::kNurbsSurface))
                                                                ;
                                                        else
                                                                ;
                                                }
                                        }

                                        //
                                        // Draw the ground plane
                                        //
                                        else if (path.hasFn( MFn::kSketchPlane ) ||
                                                         path.hasFn( MFn::kGroundPlane ))
                                        {
                                                MMatrix  matrix = path.inclusiveMatrix();
                                                MFnDagNode dagNode(path);
                                                MBoundingBox box = dagNode.boundingBox();
                                                drawBounds( matrix, box, false, false, groundPlaneColor );
                                        }

                                        if (drawIt)
                                        {
                                                drawSurface( path, active, templated );
                                        }
                                }
                        }

                        if (trav)
                                delete trav;

                        // Cleanup any unused resource items
                        bool onlyInvalidItems = true;
                        clearResources( onlyInvalidItems, false );
                }
        }
        else
        {
                // Draw some poly bounding boxes 
                //
                MItDag::TraversalType traversalType = MItDag::kDepthFirst;
                MFn::Type filter = MFn::kMesh;
                MStatus status;

                MItDag dagIterator( traversalType, filter, &status);

                for ( ; !dagIterator.isDone(); dagIterator.next() ) 
                {

                        MDagPath dagPath;

                        status = dagIterator.getPath(dagPath);
                        if ( !status ) {
                                status.perror("MItDag::getPath");
                                continue;
                        }

                        MFnDagNode dagNode(dagPath, &status);
                        if ( !status ) {
                                status.perror("MFnDagNode constructor");
                                continue;
                        }

                        MMatrix  matrix = dagPath.inclusiveMatrix();
                        MBoundingBox box = dagNode.boundingBox();
                        drawBounds( matrix, box, false, false, NULL );
                }
        }
        return true;
}

bool D3DViewportRenderer::drawBounds(const MMatrix &matrix, const MBoundingBox &box, bool filled, bool useDummyGeometry,
                                                                         float color[3],
                                                                         LPDIRECT3DVERTEXBUFFER9 buffer /* = NULL */)
{
        // Transform from object to world space
        //
        D3DXMATRIXA16 mat = D3DXMATRIXA16
                (
                (float)matrix.matrix[0][0], (float)matrix.matrix[0][1], (float)matrix.matrix[0][2], (float)matrix.matrix[0][3],
                (float)matrix.matrix[1][0], (float)matrix.matrix[1][1], (float)matrix.matrix[1][2], (float)matrix.matrix[1][3],
                (float)matrix.matrix[2][0], (float)matrix.matrix[2][1], (float)matrix.matrix[2][2], (float)matrix.matrix[2][3],
                (float)matrix.matrix[3][0], (float)matrix.matrix[3][1], (float)matrix.matrix[3][2], (float)matrix.matrix[3][3]
                );
        m_pD3DDevice->SetTransform( D3DTS_WORLD, &mat );

        // Draw the bounding scaled and offset bounds. Handles component transforms
        //
        MPoint  minPt = box.min();
        MPoint  maxPt = box.max();
        float minVal[3] = { (float)minPt.x, (float)minPt.y, (float)minPt.z };
        float maxVal[3] = { (float)maxPt.x, (float)maxPt.y, (float)maxPt.z };
        drawCube( minVal, maxVal, filled, useDummyGeometry, color, buffer );

        return true;
}

bool D3DViewportRenderer::renderToTarget( const MRenderingInfo &renderInfo )
//
// Description:
//              Rener to off-screen render target and read back into system memory 
//              output buffer.
//
//
{
        // Direct rendering to a D3D surface
        //
        if (renderInfo.renderingAPI() == MViewportRenderer::kDirect3D)
        {
                // Maya does not support D3D currently. Would need
                // to have access to the device, and surface here
                // from an MRenderTarget. API doesn't exist, so
                // do nothing.
                return false;
        }

        //
        // Offscreen rendering
        //
        if (!m_pD3DDevice || !m_pTextureOutput || !m_pTextureInterm)
                return false;

        // START RENDER
        HRESULT hres;

        // Set colour and depth surfaces.
        //
        hres = m_pD3DDevice->SetRenderTarget( 0, m_pTextureIntermSurface );
        if (m_requireDepthStencilReadback && m_pDepthStencilSurface)
                hres = m_pD3DDevice->SetDepthStencilSurface( m_pDepthStencilSurface );

        hres = m_pD3DDevice->BeginScene();
        if (hres == D3D_OK)
        {
                // Setup projection and view matrices
                setupMatrices( renderInfo );

                // Clear the entire buffer (RGB, Depth). Leave stencil for now.
                //
                hres = m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 
                                                                        D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,1.0f), 1.0f, 0 );

                // Setup lighting
                //
                m_resourceManager.setupLighting(m_pD3DDevice);

                if (hres == D3D_OK)
                {
                        // Render the scene
                        drawScene(renderInfo);
                }

                m_resourceManager.cleanupLighting(m_pD3DDevice);
        }
        // END SCENE RENDER

        hres = m_pD3DDevice->EndScene();
        if (hres != D3D_OK)
                return false;

        // Do post-rendering
        postRenderToTarget();

        return true;
}

bool D3DViewportRenderer::setupMatrices( const MRenderingInfo &info )
//
// Description:
//
//              Set up camera matrices. Mechanism to check for changes in camera
//              parameters should be done before matrix setup.
//
//              Note that we *must* use a "right-handed" system (RH method 
//              versions) for computations to match what is coming from Maya.
//
{
        if (!m_pD3DDevice)
                return false;

        const MMatrix & view = info.viewMatrix(); 
        const MMatrix & projection = info.projectionMatrix();

        // Double to float conversion
        D3DXMATRIXA16 vm( (float)view.matrix[0][0], (float)view.matrix[0][1], (float)view.matrix[0][2], (float)view.matrix[0][3], 
                (float)view.matrix[1][0], (float)view.matrix[1][1], (float)view.matrix[1][2], (float)view.matrix[1][3], 
                (float)view.matrix[2][0], (float)view.matrix[2][1], (float)view.matrix[2][2], (float)view.matrix[2][3], 
                (float)view.matrix[3][0], (float)view.matrix[3][1], (float)view.matrix[3][2], (float)view.matrix[3][3]);

        D3DXMATRIXA16 pm( (float)projection.matrix[0][0], (float)projection.matrix[0][1], (float)projection.matrix[0][2], (float)projection.matrix[0][3], 
                (float)projection.matrix[1][0], (float)projection.matrix[1][1], (float)projection.matrix[1][2], (float)projection.matrix[1][3], 
                (float)projection.matrix[2][0], (float)projection.matrix[2][1], (float)projection.matrix[2][2], (float)projection.matrix[2][3], 
                (float)projection.matrix[3][0], (float)projection.matrix[3][1], (float)projection.matrix[3][2], (float)projection.matrix[3][3]);


        m_pD3DDevice->SetTransform( D3DTS_PROJECTION, &pm );
        m_pD3DDevice->SetTransform( D3DTS_VIEW, &vm  );

        return true;
}

void D3DViewportRenderer::drawFullScreenQuad(float leftU, float topV, 
                                                                                         float rightU, float bottomV,
                                                                                         float targetWidth, float targetHeight,
                                                                                         LPDIRECT3DDEVICE9 D3D)
//
// Description:
//              Draw a screen space quad.
//
{
    float width = targetWidth - 0.5f;
    float height = targetHeight - 0.5f;

    // Draw the quad
    ScreenSpaceVertex screenQuad[4];

    screenQuad[0].position = D3DXVECTOR4(-0.5f, -0.5f, 0.5f, 1.0f);
    screenQuad[0].texCoord = D3DXVECTOR2(leftU, topV);

    screenQuad[1].position = D3DXVECTOR4(width, -0.5f, 0.5f, 1.0f);
    screenQuad[1].texCoord = D3DXVECTOR2(rightU, topV);

    screenQuad[2].position = D3DXVECTOR4(-0.5f, height, 0.5f, 1.0f);
    screenQuad[2].texCoord = D3DXVECTOR2(leftU, bottomV);

    screenQuad[3].position = D3DXVECTOR4(width, height, 0.5f, 1.0f);
    screenQuad[3].texCoord = D3DXVECTOR2(rightU, bottomV);

    D3D->SetRenderState(D3DRS_ZENABLE, FALSE);
    D3D->SetFVF(ScreenSpaceVertex::FVF);
    D3D->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, screenQuad, sizeof(ScreenSpaceVertex));
    D3D->SetRenderState(D3DRS_ZENABLE, TRUE);
}

bool D3DViewportRenderer::postRenderToTarget()
//
// Description:
//      Render using post-process screen effects. Uses a 2 target buffering
//      scheme to ping-pong results back and forth for each effect change.
//
{
        if (!m_pTexturePost)
                return false;

        IDirect3DSurface9 *postSurface = NULL;
        HRESULT hres = m_pTexturePost->GetSurfaceLevel( 0, &postSurface );
        if (hres != D3D_OK)
                return false;   

        IDirect3DSurface9 *currentSurface[2] = { m_pTextureIntermSurface, postSurface };
        LPDIRECT3DTEXTURE9  currentTexture[2] = { m_pTextureInterm, m_pTexturePost };

        // Render source texture into destination, and then flip back
        // and forth as required until we finish all effects
        //
        unsigned int currentTarget = 0;
        unsigned int newTarget = 0;

        // Determine the quad render size once
        //
        D3DSURFACE_DESC surfaceDesc;
        m_pTextureOutputSurface->GetDesc( &surfaceDesc );
        float quad_renderWidth = (float)surfaceDesc.Width;
        float quad_renderHeight = (float)surfaceDesc.Height;

        unsigned int numEffectsApplied = 0;

        const MStringArray &enabledEffects = m_resourceManager.getListOfEnabledPostEffects();
        const PostEffectItemList &postEffectList = m_resourceManager.getPostEffectItemList();

        unsigned int numOfEnabledEffects = enabledEffects.length();
        unsigned int numEffects = (unsigned int) postEffectList.size();

        // We don't want floating point, and we don't have any effects.
        // So there's nothing to do.
        if (!m_wantFloatingPointTargets && !numOfEnabledEffects || !numEffects)
                return false;

        // Don't need depth anymore
        m_pD3DDevice->SetRenderState( D3DRS_ZENABLE, FALSE );

        for (unsigned int m=0; m<numOfEnabledEffects ; m++)
        {
                ID3DXEffect* effect = NULL;
                PostEffectItem *effectItem = NULL;

                // Scan all existing effects item to see if the name matches
                // the enabled effect name.
                PostEffectItemList::const_iterator eit, end_eit;
                end_eit = postEffectList.end();
                for (eit = postEffectList.begin(); eit != end_eit;  eit++)
                {
                        PostEffectItem *item = *eit;
                        if (item)
                        {
                                // Enable item hase been found in the global effects list.
                                if (enabledEffects[m] == item->fName)
                                {
                                        effectItem = item;
                                        effect = item->fEffect;
                                        break;
                                }
                        }
                }
                if (effect != NULL)
                {
                        // Flip the current render target
                        newTarget = ( currentTarget + 1 ) % 2;
                        m_pD3DDevice->SetRenderTarget( 0, currentSurface[newTarget] );

                        // Start scene rendering
                        m_pD3DDevice->BeginScene();
                        {
                                /* WARNING Magic word lookup */
                                hres = effect->SetTechnique( "PostProcess" ); 
                                if (hres != D3D_OK)
                                        continue;

                                // Set the deltas for the kernel, if required
                                /* WARNING Magic word lookup */
                                effect->SetFloat( "duKernel", 1.0f / (float)quad_renderWidth );                         
                                effect->SetFloat( "dvKernel", 1.0f / (float)quad_renderHeight);

                                // Hacks set the value for effects via Maya option variables.
                                if (effectItem->fName == MString("PostProcess_ToneMapFilter"))
                                {
                                        double value = 1.0;
                                        MString toneMapExp("PostProcess_ToneMapFilter_Exposure");
                                        if (!MGlobal::getOptionVarValue(toneMapExp, value))
                                                MGlobal::setOptionVarValue(toneMapExp, value);
                                        effect->SetFloat( "exposure", (float)value );                           
                                }
                                else if (effectItem->fName == MString("PostProcess_SobelFilter"))
                                {
                                        double value = 20;
                                        MString thickness("PostProcess_SobelFilter_edgeThickness");
                                        if (!MGlobal::getOptionVarValue(thickness, value))
                                                MGlobal::setOptionVarValue(thickness, value);
                                        effect->SetFloat( "edgeThickness", (float)value);       
                                }

                                // Start effect rendering
                                unsigned int numPasses;
                                hres = effect->Begin( &numPasses, 0 );
                                if (hres != D3D_OK)
                                        continue;
                                else
                                {
                                        // Flip the current input texture
                                        /* WARNING Magic word lookup */
                                        hres = effect->SetTexture( "textureSourceColor", currentTexture[currentTarget] );
                                        if (hres != D3D_OK)
                                        {
                                                m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET /* | D3DCLEAR_ZBUFFER */, 
                                                        D3DCOLOR_COLORVALUE(1.0f,0.0f,0.0f,1.0f), 1.0f, 0 );

                                                continue;
                                        }

                                        // Loop through all passes                              
                                        for (unsigned int p=0; p<numPasses; ++p)
                                        {
                                                hres = effect->BeginPass( p );
                                                if (hres != D3D_OK) 
                                                {
                                                        m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET /* | D3DCLEAR_ZBUFFER */, 
                                                                D3DCOLOR_COLORVALUE(1.0f,0.0f,0.0f,1.0f), 1.0f, 0 );
                                                        continue;
                                                }
                                                // Draw quad for the effect
                                                drawFullScreenQuad( 0.0f, 0.0f, 1.0f, 1.0f, 
                                                        quad_renderWidth, quad_renderHeight, m_pD3DDevice );

                                                hres = effect->EndPass();
                                                if (hres != D3D_OK) 
                                                {
                                                        m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET /* | D3DCLEAR_ZBUFFER */, 
                                                                D3DCOLOR_COLORVALUE(1.0f,0.0f,0.0f,1.0f), 1.0f, 0 );

                                                        continue;
                                                }
                                        }
                                }
                                hres = effect->End();

                                numEffectsApplied++;
                        }
                        m_pD3DDevice->SetTexture( 0, NULL);
                        m_pD3DDevice->EndScene();

#if defined(_DEBUG_POST_BUFFERS_)
                        bool dumpToFile= false;
                        if (dumpToFile)
                        {
                                const char fileName[] = "c:\\temp\\d3dDump_newTarget.jpg";
                                HRESULT hres = D3DXSaveSurfaceToFile( fileName, D3DXIFF_JPG,
                                        currentSurface[newTarget], NULL /*palette*/, NULL /*rect*/ );

                                const char fileName2[] = "c:\\temp\\d3dDump_oldTarget.jpg";
                                hres = D3DXSaveSurfaceToFile( fileName2, D3DXIFF_JPG,
                                        currentSurface[currentTarget], NULL /*palette*/, NULL /*rect*/ );

                        }
#endif

                        // Flip to the next render target
                        //
                        currentTarget = newTarget;
                }
        }

        // 
        // Copy the intermediate target to our final output target,
        // if they are not the same. If we aren't using floating point
        // then there's nothing to do.
        //
        if ((currentSurface[currentTarget] != m_pTextureIntermSurface) || 
                (m_pTextureOutputSurface != m_pTextureIntermSurface))
        {
                m_pD3DDevice->SetRenderTarget( 0, m_pTextureOutputSurface );
                m_pD3DDevice->BeginScene();
                {
                        m_pD3DDevice->SetTexture( 0, currentTexture[currentTarget] );
                        drawFullScreenQuad( 0.0f, 0.0f, 1.0f, 1.0f, 
                                quad_renderWidth, quad_renderHeight, m_pD3DDevice );
                }
                m_pD3DDevice->EndScene();
        }

        // Release temporary surface
        if (postSurface)
                postSurface->Release();

        // Turn depth back on
        m_pD3DDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

        return true;
}

bool D3DViewportRenderer::readFromTargetToSystemMemory()
//
// Description:
//              Read back render target memory into system memory to 
//              transfer back to calling code.
// 
{
        if (!m_pD3DDevice || !m_pTextureOutputSurface || m_renderWidth==0 || m_renderHeight == 0 ||
                !m_SystemMemorySurface)
                return false;

        bool readBuffer = false;

        // Dump to file option for debugging purposes.
        //
#if defined(_DUMP_SURFACE_READBACK_CONTENTS_)
        bool dumpToFile= false;
        if (dumpToFile)
        {
                const char fileName[] = "c:\\temp\\d3dDump.jpg";
                HRESULT hres = D3DXSaveSurfaceToFile( fileName, D3DXIFF_JPG,
                                                        m_pTextureOutputSurface, NULL /*palette*/, NULL /*rect*/ );
                if (hres != D3D_OK)
                {
                        MGlobal::displayWarning("Direct3D renderer : Failed to dump surface contents to file !\n");
                }
        }
#endif

        D3DSURFACE_DESC surfaceDesc;
        m_pTextureOutputSurface->GetDesc( &surfaceDesc );
        //m_renderWidth = surfaceDesc.Width;
        //m_renderHeight = surfaceDesc.Height;

        D3DLOCKED_RECT rectInfo;
        // RECTs use upper-left to lower-right scheme.
        RECT rectToRead;
        rectToRead.top = 0;
        rectToRead.left = 0;
        rectToRead.bottom = m_renderHeight;
        rectToRead.right = m_renderWidth;
        DWORD readFlags = D3DLOCK_READONLY;

        // Since the texture is in D3DPOOL_DEFAULT, need to call
        // GetRenderTargetData to get the contents back into system
        // system. Pretty gruesome code for now....
        //
        HRESULT hres = m_pD3DDevice->GetRenderTargetData( m_pTextureOutputSurface,
                m_SystemMemorySurface );

        if (hres == D3D_OK)
        {
                // Lock the system memory surface, and read back based on lock info
                // returned.
                //
                hres = m_SystemMemorySurface->LockRect( &rectInfo, &rectToRead, readFlags );
                if (hres == D3D_OK)
                {                                       
                        INT pitch = rectInfo.Pitch;
                        BYTE *data = (BYTE *)rectInfo.pBits;

                        // ** Magic number warning ***
                        // We use D3DFMT_A8R8G8B8 as the buffer format for now as we
                        // assume 32 bits per pixel = 4 bytes per pixel. Will need to
                        // change when buffer format changes possibly be float.
                        //
                        const unsigned int bytesPerPixel = 4;

                        // Reallocate buffer block as required.
                        unsigned int m_readBackBufferWidth = 0;
                        unsigned int m_readBackBufferHeight = 0;
                        m_readBackBuffer.getSize(m_readBackBufferWidth, m_readBackBufferHeight);

                        BYTE *m_readBackBufferPtr = NULL;
                        bool replaceReadBackBuffer = false;

                        if (!m_readBackBufferWidth || !m_readBackBufferHeight ||
                                m_readBackBufferWidth != m_renderWidth ||
                                m_readBackBufferHeight != m_renderHeight)
                        {
                                // This crashes Maya. Need to figure out why ?????
                                m_readBackBuffer.resize(m_renderWidth, m_renderHeight, false);
                                m_readBackBuffer.getSize(m_readBackBufferWidth, m_readBackBufferHeight);
                                if (m_readBackBufferWidth != m_renderWidth ||
                                        m_readBackBufferHeight != m_renderHeight)
                                {
                                        MGlobal::displayError("D3D Renderer : Could not resize MImage buffer for readback !\n");
                                        return false;
                                }
                                m_readBackBufferPtr = (BYTE *)(m_readBackBuffer.pixels());
                        }
                        else
                                m_readBackBufferPtr = (BYTE *)(m_readBackBuffer.pixels());

                        if (m_readBackBufferPtr)
                        {
                                // Copy a row at a time.
                                // The jump by pitch, may differ if pitch is not the same as width.
                                //
                                unsigned int myLineSize = m_renderWidth * bytesPerPixel;
                                unsigned int offsetMyData = (m_renderHeight-1) * myLineSize;
                                unsigned int offsetData = 0;

                                unsigned int i;
                                for ( i=0 ; i < m_renderHeight; i++ )
                                {
                                        memcpy( m_readBackBufferPtr + offsetMyData, 
                                                data + offsetData, 
                                                myLineSize );
                                        offsetMyData -= myLineSize;
                                        offsetData += pitch;
                                }

                                readBuffer = true;
                        }

                        if (replaceReadBackBuffer)
                        {
                                m_readBackBuffer.setPixels( m_readBackBufferPtr, m_renderWidth,
                                        m_renderHeight );
                                delete[] m_readBackBufferPtr;                                   
                        }
                        m_readBackBufferPtr = 0;

                        // Unlock 
                        hres = m_SystemMemorySurface->UnlockRect();
                }
        }
        return readBuffer;
}

#endif