/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef _plDX9Pipeline_h
#define _plDX9Pipeline_h

#include "plPipeline.h"
#include "plDXSettings.h"

#include "plSurface/plLayerInterface.h"
#include "hsMatrix44.h"
#include "plFogEnvironment.h"
#include "hsG3DDeviceSelector.h"
#include "hsGeometry3.h"
#include "hsTemplates.h"
#include "hsColorRGBA.h"
#include "hsGDeviceRef.h"
#include "hsPoint2.h"

class plAccessSpan;
class plAuxSpan;
class plVertexSpan;

#include "plPlates.h"   // Used to define plDXPlateManager


//// Defines and Konstants and Other Nifty Stuff //////////////////////////////

class plDXLightRef;
class plDXVertexBufferRef;
class plDXIndexBufferRef;
class plDXTextureRef;
class plDXCubeTextureRef;
class plDXVertexShader;
class plDXPixelShader;

class plShader;

class plVisMgr;

//#define HS_D3D_USE_SPECULAR

class hsGMaterial;
class plMipmap;

class plLightInfo;
class plCullTree;
class plShadowSlave;
class plShadowCaster;

struct D3DXMATRIX;

#ifdef HS_DEBUGGING
#define HS_CHECK_RELEASE
#endif

#ifndef PLASMA_EXTERNAL_RELEASE
#define PROFILE_POOL_MEM(pool, size, add, id)       plDXPipeline::ProfilePoolMem(pool, size, add, id);
#else
#define PROFILE_POOL_MEM(pool, size, add, id)
#endif // PLASMA_EXTERNAL_RELEASE

extern void D3DSURF_MEMNEW(IDirect3DSurface9* surf);
extern void D3DSURF_MEMNEW(IDirect3DTexture9* tex);
extern void D3DSURF_MEMNEW(IDirect3DCubeTexture9* cTex);
extern void D3DSURF_MEMDEL(IDirect3DSurface9* surf);
extern void D3DSURF_MEMDEL(IDirect3DTexture9* tex);
extern void D3DSURF_MEMDEL(IDirect3DCubeTexture9* cTex);


extern void plReleaseObject(IUnknown* x);

#define  ReleaseObject(x)   if(x){ plReleaseObject(x); x=NULL; }

typedef LPDIRECT3D9 (WINAPI * Direct3DCreateProc)( UINT sdkVersion );


//// Helper Classes ///////////////////////////////////////////////////////////

//// The RenderPrimFunc lets you have one function which does a lot of stuff
// around the actual call to render whatever type of primitives you have, instead
// of duplicating everything because the one line to render is different.
class plRenderPrimFunc
{
public:
    virtual hsBool RenderPrims() const = 0; // return true on error
};

//// DX-specific Plate Manager implementation
class plDXPlateManager : public plPlateManager
{
    friend class plDXPipeline;

    public:

        virtual ~plDXPlateManager();

    protected:

        const long  PLD3D_PLATEFVF;

        struct plPlateVertex
        {
            hsPoint3    fPoint;
            UInt32      fColor;
            hsPoint3    fUV;
        };

        IDirect3DDevice9        *fD3DDevice;
        IDirect3DVertexBuffer9  *fVertBuffer;

        plDXPlateManager( plDXPipeline *pipe, IDirect3DDevice9 *device );

        void ICreateGeometry(plDXPipeline* pipe);
        void IReleaseGeometry();

        virtual void    IDrawToDevice( plPipeline *pipe );
};

//// Class Definition /////////////////////////////////////////////////////////

class plDebugTextManager;
struct D3DEnum_DriverInfo;
struct D3DEnum_DeviceInfo;
struct D3DEnum_ModeInfo;
class plGeometrySpan;
class plDrawableSpans;
class plSpan;
class plIcicle;
class hsG3DDeviceModeRecord;
class plDXDeviceRef;
class plParticleSpan;
class plCubicEnvironmap;
class plDXRenderTargetRef;
class plStatusLogDrawer;
class plBinkPlayer;

class plDXPipeline : public plPipeline
{
protected:
    enum {
        kCapsNone               = 0x0,
        kCapsCompressTextures   = 0x1,
        kCapsMipmap             = 0x2,
        kCapsHWTransform        = 0x4,
        kCapsHWLighting         = 0x8,
        kCapsZBias              = 0x10,
        kCapsLinearFog          = 0x20,
        kCapsExpFog             = 0x40,
        kCapsExp2Fog            = 0x80,
        kCapsRangeFog           = 0x100,
        kCapsWBuffer            = 0x200,
        kCapsTexBoundToStage    = 0x400,
        kCapsDither             = 0x800,
        kCapsLODWatch           = 0x1000,
        kCapsFSAntiAlias        = 0x2000,
        kCapsLuminanceTextures  = 0x4000,
        kCapsDoesSmallTextures  = 0x8000,
        kCapsDoesWFog           = 0x10000,
        kCapsPixelFog           = 0x20000,
        kCapsHasBadYonStuff     = 0x40000,
        kCapsNoKindaSmallTexs   = 0x80000,

        kCapsCubicTextures      = 0x200000,
        kCapsCubicMipmap        = 0x400000
    };
    enum {
        kKNone                  = 0x0,
        kKTNT                   = 0x1
    };

    plDebugTextManager*         fDebugTextMgr;
    plDXPlateManager*           fPlateMgr;

    // The main D3D interfaces
    LPDIRECT3D9             fD3DObject;     // The main D3D object
    LPDIRECT3DDEVICE9       fD3DDevice;     // The D3D rendering device
    IDirect3DSurface9*      fD3DMainSurface;
    IDirect3DSurface9*      fD3DDepthSurface;
    IDirect3DSurface9*      fD3DBackBuff;

    IDirect3DSurface9*      fSharedDepthSurface[2];
    D3DFORMAT               fSharedDepthFormat[2];

    // Dynamic buffers
    UInt32                  fVtxRefTime;
    UInt32                  fNextDynVtx;
    UInt32                  fDynVtxSize;
    IDirect3DVertexBuffer9* fDynVtxBuff;
    hsBool                  fManagedAlloced;
    hsBool                  fAllocUnManaged;


    // States
    plDXGeneralSettings     fSettings;
    plDXTweakSettings       fTweaks;
    plDXStencilSettings     fStencil;
    hsBool                  fDeviceLost;
    hsBool                  fDevWasLost;

    hsTArray<const plCullPoly*> fCullPolys;
    hsTArray<const plCullPoly*> fCullHoles;
    plDrawableSpans*            fCullProxy;
    
    plDXVertexBufferRef*    fVtxBuffRefList;
    plDXIndexBufferRef*     fIdxBuffRefList;
    plDXTextureRef*         fTextureRefList;
    plTextFont*             fTextFontRefList;
    plDXRenderTargetRef*    fRenderTargetRefList;
    plDXVertexShader*       fVShaderRefList;
    plDXPixelShader*        fPShaderRefList;

    hsGMaterial*            fCurrMaterial;
    plLayerInterface*       fCurrLay;
    UInt32                  fCurrLayerIdx, fCurrNumLayers, fCurrRenderLayer;
    UInt32                  fCurrLightingMethod;    // Based on plSpan flags

    D3DCULL                 fCurrCullMode;
    hsGMatState                 fMatOverOn;
    hsGMatState                 fMatOverOff;
    hsTArray<hsGMaterial*>      fOverrideMat;
    hsGMaterial*                fHoldMat;
    hsBool                      fCurrD3DLiteState;

    hsMatrix44                  fBumpDuMatrix;
    hsMatrix44                  fBumpDvMatrix;
    hsMatrix44                  fBumpDwMatrix;

    hsTArray<plLayerInterface*>         fOverLayerStack;
    plLayerInterface*                   fOverBaseLayer;
    plLayerInterface*                   fOverAllLayer;
    hsTArray<plLayerInterface*>         fPiggyBackStack;
    Int32                               fMatPiggyBacks;
    Int32                               fActivePiggyBacks;

    UINT                    fCurrentAdapter;
    D3DEnum_DriverInfo*     fCurrentDriver;
    D3DEnum_DeviceInfo*     fCurrentDevice;
    D3DEnum_ModeInfo*       fCurrentMode;

    hsGDeviceRef*   fLayerRef[ 8 ];
    hsGMatState     fLayerState[ 8 ]; // base stage (0) state is held in base class
    hsGMatState     fOldLayerState[ 8 ];
    hsBool          fLayerTransform[ 8 ];
    float           fLayerLODBias[ 8 ];
    UInt32          fLayerUVWSrcs[ 8 ];
    UInt32          fLayerXformFlags[ 8 ];
    UInt32          fLastEndingStage;
    hsBool          fTexturing;
    hsBool          fForceMatHandle;

    UInt32          fInSceneDepth;
    UInt32          fTextUseTime;       // inc'd every frame - stat gather only
    static UInt32   fTexManaged;
    static UInt32   fTexUsed;
    static UInt32   fVtxManaged;
    static UInt32   fVtxUsed;
    UInt32          fEvictTime;
    UInt32          fManagedSeen;
    UInt32          fManagedCutoff;

    double          fTime;              // World time.
    UInt32          fFrame;             // inc'd every time the camera moves.
    UInt32          fRenderCnt;         // inc'd every begin scene.

    // View stuff
    plDXViewSettings            fView;

    hsBitVector     fDebugFlags;
    UInt32          fDebugSpanGraphY;

    // Fog
    plDXFogSettings fCurrFog;

    // Light
    plDXLightSettings   fLights;

    // Shadows
    hsTArray<plShadowSlave*>        fShadows;
    hsTArray<plRenderTarget*>       fRenderTargetPool512;
    hsTArray<plRenderTarget*>       fRenderTargetPool256;
    hsTArray<plRenderTarget*>       fRenderTargetPool128;
    hsTArray<plRenderTarget*>       fRenderTargetPool64;
    hsTArray<plRenderTarget*>       fRenderTargetPool32;
    enum { kMaxRenderTargetNext = 10 };
    UInt32                          fRenderTargetNext[kMaxRenderTargetNext];
    plDXTextureRef*                 fULutTextureRef;
    plRenderTarget*                 fBlurScratchRTs[kMaxRenderTargetNext];
    plRenderTarget*                 fBlurDestRTs[kMaxRenderTargetNext];
    IDirect3DVertexBuffer9*         fBlurVBuffers[kMaxRenderTargetNext];
    UInt32                          fBlurVSHandle;

    hsTArray<plClothingOutfit*>     fClothingOutfits;
    hsTArray<plClothingOutfit*>     fPrevClothingOutfits;

    // Debug stuff
    plDrawableSpans *fBoundsSpans;
    hsGMaterial     *fBoundsMat;
    hsTArray<UInt32>    fBSpansToDelete;

    plStatusLogDrawer   *fLogDrawer;

    hsBool              fVSync;
    hsBool              fForceDeviceReset;

    void            IBeginAllocUnManaged();
    void            IEndAllocUnManaged();
    void            ICheckTextureUsage();
    void            ICheckVtxUsage();
    inline void     ICheckVBUsage(plDXVertexBufferRef* vRef);

    hsBool          IRefreshDynVertices(plGBufferGroup* group, plDXVertexBufferRef* vRef);
    hsBool          ICheckAuxBuffers(const plAuxSpan* span);
    hsBool          ICheckDynBuffers(plDrawableSpans* drawable, plGBufferGroup* group, const plSpan* span);
    void            ICheckStaticVertexBuffer(plDXVertexBufferRef* vRef, plGBufferGroup* owner, UInt32 idx);
    void            ICheckIndexBuffer(plDXIndexBufferRef* iRef);
    void            IFillStaticVertexBufferRef(plDXVertexBufferRef *ref, plGBufferGroup *group, UInt32 idx);
    void            IFillIndexBufferRef(plDXIndexBufferRef* iRef, plGBufferGroup* owner, UInt32 idx);
    void            ISetupVertexBufferRef(plGBufferGroup* owner, UInt32 idx, plDXVertexBufferRef* vRef);
    void            ISetupIndexBufferRef(plGBufferGroup* owner, UInt32 idx, plDXIndexBufferRef* iRef);
    void            ICreateDynamicBuffers();
    void            IReleaseDynamicBuffers();

    void            IAddBoundsSpan( plDrawableSpans *ice, const hsBounds3Ext *bounds, UInt32 bndColor = 0xffff0000 );
    void            IAddNormalsSpan( plDrawableSpans *ice, plIcicle *span, plDXVertexBufferRef *vRef, UInt32 bndColor );

    // Rendering
    hsBool      IFlipSurface();
    long        IGetBufferD3DFormat(UInt8 format) const;
    UInt32      IGetBufferFormatSize(UInt8 format) const;
    void        IGetVisibleSpans( plDrawableSpans* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr );
    void        IRenderSpans( plDrawableSpans *ice, const hsTArray<Int16>& visList );
    hsBool      ILoopOverLayers(const plRenderPrimFunc& render, hsGMaterial* material, const plSpan& span);
    void        IRenderBufferSpan( const plIcicle& span, 
                                    hsGDeviceRef *vb, hsGDeviceRef *ib, 
                                    hsGMaterial *material, 
                                    UInt32 vStart, UInt32 vLength, UInt32 iStart, UInt32 iLength );
    void        IRenderAuxSpan(const plSpan& span, const plAuxSpan* aux);
    void        IRenderAuxSpans(const plSpan& span);

    // Fog
    void        IGetVSFogSet(float* const set) const;
    void        ISetFogParameters(const plSpan* span, const plLayerInterface* baseLay);

    // Lighting
    hsGDeviceRef    *IMakeLightRef( plLightInfo *owner );
    void            IScaleD3DLight( plDXLightRef *ref, hsScalar scale);
    void            ICalcLighting( const plLayerInterface *currLayer, const plSpan *currSpan );
    void            IDisableSpanLights();
    void            IRestoreSpanLights();
    void            ISelectLights( plSpan *span, int numLights, hsBool proj );
    void            IEnableLights( plSpan *span );
    void            IMakeLightLists(plVisMgr* visMgr);
    void            ICheckLighting(plDrawableSpans* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr);
    inline void     inlEnsureLightingOff();
    inline void     inlEnsureLightingOn();
    void            IRenderProjection(const plRenderPrimFunc& render, plLightInfo* li);
    void            IRenderProjections(const plRenderPrimFunc& render);
    void            IRenderProjectionEach(const plRenderPrimFunc& render, hsGMaterial* material, int iPass, const plSpan& span);
    void            IRenderOverWire(const plRenderPrimFunc& render, hsGMaterial* material, const plSpan& span);

    hsBool                  ISkipBumpMap(hsGMaterial* newMat, UInt32& layer, const plSpan* currSpan) const;
    void                    ISetBumpMatrices(const plLayerInterface* layer, const plSpan* span);
    const hsMatrix44&       IGetBumpMatrix(UInt32 miscFlags) const;

    // Materials
    const hsGMatState&  ICompositeLayerState(int which, plLayerInterface* layer);
    Int32       IHandleMaterial(hsGMaterial* newMat, UInt32 which, const plSpan* currSpan);
    void        IHandleFirstTextureStage( plLayerInterface* layer );
    void        IHandleShadeMode();
    void        IHandleZMode();
    void        IHandleMiscMode();
    void        IHandleTextureStage(UInt32 stage, plLayerInterface* layer);
    void        IHandleFirstStageBlend();
    void        IHandleBumpEnv(int stage, UInt32 blendFlags);
    void        IHandleStageBlend(int stage);
    void        IHandleStageClamp(int stage);
    void        IHandleStageTransform(int stage, plLayerInterface* layer);
    void        IHandleTextureMode(plLayerInterface* layer);
    void        IUseTextureRef(int stage, hsGDeviceRef* dRef, plLayerInterface* layer);
    void        IStageStop(UInt32 stage);
    UInt32      ILayersAtOnce(hsGMaterial* mat, UInt32 which);
    hsBool      ICanEatLayer(plLayerInterface* lay);
    void        ISetLayer(UInt32 lay);
    void        IBottomLayer();

    // Push special effects
    plLayerInterface*   IPushOverBaseLayer(plLayerInterface* li);
    plLayerInterface*   IPopOverBaseLayer(plLayerInterface* li);
    plLayerInterface*   IPushOverAllLayer(plLayerInterface* li);
    plLayerInterface*   IPopOverAllLayer(plLayerInterface* li);

    int                 ISetNumActivePiggyBacks();
    void                IPushPiggyBacks(hsGMaterial* mat);
    void                IPopPiggyBacks();
    void                IPushProjPiggyBack(plLayerInterface* li);
    void                IPopProjPiggyBacks();

    void                ISetPipeConsts(plShader* shader);
    HRESULT             ISetShaders(plShader* vShader, plShader* pShader);

    // Stenciling
    virtual hsBool          StencilEnable( hsBool enable );
    virtual void            StencilSetCompareFunc( UInt8 func, UInt32 refValue );
    virtual void            StencilSetMask( UInt32 mask, UInt32 writeMask );
    virtual void            StencilSetOps( UInt8 passOp, UInt8 failOp, UInt8 passButZFailOp );
    virtual hsBool          StencilGetCaps( plStencilCaps *caps );

    hsGDeviceRef    *MakeTextureRef( plLayerInterface* layer, plMipmap *b );
    void            IReloadTexture( plDXTextureRef *ref );
    void            IFillD3DTexture( plDXTextureRef *ref );
    void            IFillD3DCubeTexture( plDXCubeTextureRef *ref );
    void            IGetD3DTextureFormat( plBitmap *b, D3DFORMAT &formatType, UInt32& texSize );
    void            IFormatTextureData( UInt32 formatType, UInt32 numPix, hsRGBAColor32* const src, void *dst );
    void            *IGetPixelScratch( UInt32 size );
    hsGDeviceRef    *IMakeCubicTextureRef( plLayerInterface* layer, plCubicEnvironmap *cubic );
    hsBool          IProcessMipmapLevels( plMipmap *mipmap, UInt32 &numLevels,
                                                UInt32 *&levelSizes, UInt32 &totalSize, 
                                                UInt32 &numPixels, void *&textureData, hsBool noMip );
    IDirect3DTexture9       *IMakeD3DTexture( plDXTextureRef *ref, D3DFORMAT formatType );
    IDirect3DCubeTexture9   *IMakeD3DCubeTexture( plDXTextureRef *ref, D3DFORMAT formatType );

    // Visualization of active occluders
    void            IMakeOcclusionSnap();

    hsBool          IAvatarSort(plDrawableSpans* d, const hsTArray<Int16>& visList);
    void            IBlendVertsIntoBuffer( plSpan* span, 
                                            hsMatrix44* matrixPalette, int numMatrices,
                                            const UInt8 *src, UInt8 format, UInt32 srcStride, 
                                            UInt8 *dest, UInt32 destStride, UInt32 count, UInt16 localUVWChans );
    hsBool          ISoftwareVertexBlend( plDrawableSpans* drawable, const hsTArray<Int16>& visList );


    void            ILinkDevRef( plDXDeviceRef *ref, plDXDeviceRef **refList );
    void            IUnlinkDevRef( plDXDeviceRef *ref );

    // Properties
    inline DWORD            inlGetD3DColor( const hsColorRGBA &c ) const;
    inline D3DCOLORVALUE    inlPlToD3DColor(const hsColorRGBA& c, float a) const;

    // Error handling
    void    IAddErrorMessage( char *errStr );
    void    ISetErrorMessage( char *errStr = nil );
    void    IGetD3DError();
    void    IShowErrorMessage( char *errStr = nil );
    hsBool  ICreateFail( char *errStr );

    // FPU mode check
    void    IFPUCheck();

    // Device initialization
    void    IInvalidateState();
    void    IInitDeviceState();
    void    IClearMembers();
    void    ISetCaps();
    void    IRestrictCaps( const hsG3DDeviceRecord& devRec );
    void    ISetGraphicsCapability(UInt32 v);

    hsBool  IFindDepthFormat(D3DPRESENT_PARAMETERS& params);
    hsBool  IFindCompressedFormats();
    hsBool  IFindLuminanceFormats();
    hsBool  ITextureFormatAllowed( D3DFORMAT format );

    void    ISetCurrentDriver( D3DEnum_DriverInfo *driv );
    void    ISetCurrentDevice( D3DEnum_DeviceInfo *dev );
    void    ISetCurrentMode( D3DEnum_ModeInfo *mode );

    hsBool      ICreateMaster();
    hsBool      ICreateDevice(hsBool windowed);
    hsBool      ICreateNormalSurfaces();

    hsBool      ICreateDeviceObjects();
    void        IReleaseDeviceObjects();

    hsBool      ICreateDynDeviceObjects();
    void        IReleaseDynDeviceObjects();
    void        IReleaseShaders();

    hsBool      IResetDevice();

    // View and clipping
    void        ISetViewport();
    void        IUpdateViewVectors() const;
    void        IRefreshCullTree();
    void        ISetAnisotropy(hsBool on);

    // Transforms
    D3DXMATRIX&     IMatrix44ToD3DMatrix( D3DXMATRIX& dst, const hsMatrix44& src );
    void            ITransformsToD3D();
    hsMatrix44      IGetCameraToNDC();
    void            IProjectionMatrixToD3D();
    void            IWorldToCameraToD3D();
    void            ILocalToWorldToD3D();
    void            ISavageYonHack();
    void            ISetLocalToWorld( const hsMatrix44& l2w, const hsMatrix44& w2l );
    void            ISetCullMode(hsBool flip=false);
    hsBool inline   IIsViewLeftHanded();
    hsBool          IGetClearViewPort(D3DRECT& r);
    plViewTransform& IGetViewTransform() { return fView.fTransform; }
    void            IUpdateViewFlags();
    void            ISetupTransforms(plDrawableSpans* drawable, const plSpan& span, hsMatrix44& lastL2W);

    // Plate management
    friend plDXPlateManager;
    friend plBinkPlayer;

    void        IDrawPlate( plPlate *plate );

    void    ISetRenderTarget( plRenderTarget *target );

    hsBool  IPrepRenderTargetInfo( plRenderTarget *owner, D3DFORMAT &surfFormat,
                                    D3DFORMAT &depthFormat, D3DRESOURCETYPE &resType );
    hsBool  IFindRenderTargetInfo( plRenderTarget *owner, D3DFORMAT &surfFormat, D3DRESOURCETYPE &resType );

    // From a D3DFORMAT enumeration, return the string literal for it
    static const char   *IGetDXFormatName( D3DFORMAT format );

    /////// Shadow internals
    // Generation
    void    IClearShadowSlaves();
    void    IPreprocessShadows();
    hsBool  IPrepShadowCaster(const plShadowCaster* caster);
    void    IRenderShadowCasterSpan(plShadowSlave* slave, plDrawableSpans* drawable, const plIcicle& span);
    void    ISetupShadowCastTextureStages(plShadowSlave* slave);
    hsBool  IRenderShadowCaster(plShadowSlave* slave);
    void    ISetupShadowLight(plShadowSlave* slave);
    plDXLightRef*   INextShadowLight(plShadowSlave* slave);

    hsBool  IPushShadowCastState(plShadowSlave* slave);
    hsBool  IPopShadowCastState(plShadowSlave* slave);

    plDXTextureRef* IGetULutTextureRef();
    hsBool              ICreateBlurVBuffers();
    void                IReleaseBlurVBuffers();
    void                IMakeRenderTargetPools();
    void                IResetRenderTargetPools();
    plRenderTarget*     IFindRenderTarget(UInt32& w, UInt32& h, hsBool ortho);
    void                IReleaseRenderTargetPools();

    // Selection
    void    IAttachSlaveToReceivers(int iSlave, plDrawableSpans* drawable, const hsTArray<Int16>& visList);
    void    IAttachShadowsToReceivers(plDrawableSpans* drawable, const hsTArray<Int16>& visList);
    hsBool  IAcceptsShadow(const plSpan* span, plShadowSlave* slave);
    hsBool  IReceivesShadows(const plSpan* span, hsGMaterial* mat);
    void    ISetShadowFromGroup(plDrawableSpans* drawable, const plSpan* span, plLightInfo* liInfo);

    // Application  
    void    IRenderShadowsOntoSpan(const plRenderPrimFunc& render, const plSpan* span, hsGMaterial* mat);
    void    ISetupShadowRcvTextureStages(hsGMaterial* mat);
    void    ISetShadowLightState(hsGMaterial* mat);
    void    IDisableLightsForShadow();
    void    IEnableShadowLight(plShadowSlave* slave);
    void    ISetupShadowSlaveTextures(plShadowSlave* slave);

    // Postprocess (blurring)
    hsBool              ISetBlurQuadToRender(plRenderTarget* smap);
    void                IRenderBlurBackToShadowMap(plRenderTarget* smap, plRenderTarget* scratch, plRenderTarget* dst);
    void                IRenderBlurFromShadowMap(plRenderTarget* scratchRT, plRenderTarget* smap, hsScalar scale);
    void                IBlurSetRenderTarget(plRenderTarget* rt);
    int                 IGetScratchRenderTarget(plRenderTarget* smap);
    void                IBlurShadowMap(plShadowSlave* slave);

    // Avatar Texture Rendering
    double                      fAvRTShrinkValidSince;
    hsTArray<plRenderTarget*>   fAvRTPool;
    UInt16                      fAvRTWidth;
    UInt32                      fAvNextFreeRT;
    void                    IFillAvRTPool();
    hsBool                  IFillAvRTPool(UInt16 numRTs, UInt16 width); // Returns true if we successfully filled the pool. Otherwise cleans up.
    void                    IReleaseAvRTPool();
    plRenderTarget*         IGetNextAvRT();
    void                    IFreeAvRT(plRenderTarget* tex);
    void                    IPreprocessAvatarTextures();
    void                    IDrawClothingQuad(hsScalar x, hsScalar y, hsScalar w, hsScalar h, hsScalar uOff, hsScalar vOff, plMipmap *tex);
    void                    IClearClothingOutfits(hsTArray<plClothingOutfit*>* outfits);

    void IPrintDeviceInitError();

    void IResetToDefaults(D3DPRESENT_PARAMETERS *params);

public:
    plDXPipeline( hsWinRef hWnd, const hsG3DDeviceModeRecord *devMode );
    virtual ~plDXPipeline();

    CLASSNAME_REGISTER( plDXPipeline );
    GETINTERFACE_ANY( plDXPipeline, plPipeline );

    virtual IDirect3DDevice9*           GetD3DDevice() const { return fD3DDevice; }

    // Typical 3D device
    virtual hsBool                      PreRender(plDrawable* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr=nil);
    virtual hsBool                      PrepForRender(plDrawable* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr=nil);
    virtual void                        Render(plDrawable* d, const hsTArray<Int16>& visList);
    virtual void                        Draw(plDrawable* d);
    
    virtual void                        PushRenderRequest(plRenderRequest* req);
    virtual void                        PopRenderRequest(plRenderRequest* req);

    void ResetDisplayDevice(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync = false );

    virtual void                        ClearRenderTarget( plDrawable* d );
    virtual void                        ClearRenderTarget( const hsColorRGBA* col = nil, const hsScalar* depth = nil );
    virtual void                        SetClear(const hsColorRGBA* col=nil, const hsScalar* depth=nil);
    virtual hsColorRGBA                 GetClearColor() const;
    virtual hsScalar                    GetClearDepth() const;
    virtual hsGDeviceRef*               MakeRenderTargetRef( plRenderTarget *owner );
    virtual hsGDeviceRef*               SharedRenderTargetRef(plRenderTarget* sharer, plRenderTarget *owner);
    virtual void                        PushRenderTarget( plRenderTarget *target );
    virtual plRenderTarget*             PopRenderTarget();

    virtual hsBool                      BeginRender();
    virtual hsBool                      EndRender();
    virtual void                        RenderScreenElements();

    virtual hsBool                      BeginDrawable(plDrawable* d);
    virtual hsBool                      EndDrawable(plDrawable* d);

    virtual void                        BeginVisMgr(plVisMgr* visMgr);
    virtual void                        EndVisMgr(plVisMgr* visMgr);

    virtual hsBool                      IsFullScreen() const { return fSettings.fFullscreen; }
    virtual UInt32                      Width() const { return fView.fTransform.GetViewPortWidth(); }
    virtual UInt32                      Height() const { return fView.fTransform.GetViewPortHeight(); }
    virtual UInt32                      ColorDepth() const { return fSettings.fColorDepth; }
    virtual void                        Resize( UInt32 width, UInt32 height );

    // Culling. Might be used in Update before bothering to do any serious computation.
    virtual hsBool                      TestVisibleWorld(const hsBounds3Ext& wBnd);
    virtual hsBool                      TestVisibleWorld(const plSceneObject* sObj);
    virtual hsBool                      HarvestVisible(plSpaceTree* space, hsTArray<Int16>& visList);
    virtual hsBool                      SubmitOccluders(const hsTArray<const plCullPoly*>& polyList);

    // Debug flags
    virtual void                        SetDebugFlag( UInt32 flag, hsBool on );
    virtual hsBool                      IsDebugFlagSet( UInt32 flag ) const;

    // These are also only for debugging.
    virtual void                        SetMaxCullNodes(UInt16 n) { fView.fCullMaxNodes = n; }
    virtual UInt16                      GetMaxCullNodes() const { return fView.fCullMaxNodes; }

    virtual hsBool                      CheckResources();
    virtual void                        LoadResources();    // Tells us where it's a good time to load in unmanaged resources.

    // Properties
    virtual void                        SetProperty( UInt32 prop, hsBool on ) { on ? fSettings.fProperties |= prop : fSettings.fProperties &= ~prop; }
    virtual hsBool                      GetProperty( UInt32 prop ) const { return ( fSettings.fProperties & prop ) ? true : false; }

    virtual UInt32                      GetMaxLayersAtOnce() const { return fSettings.fMaxLayersAtOnce; }

    // Drawable type mask
    virtual void                        SetDrawableTypeMask( UInt32 mask ) { fView.fDrawableTypeMask = mask; }
    virtual UInt32                      GetDrawableTypeMask() const { return fView.fDrawableTypeMask; }
    virtual void                        SetSubDrawableTypeMask( UInt32 mask ) { fView.fSubDrawableTypeMask = mask; }
    virtual UInt32                      GetSubDrawableTypeMask() const { return fView.fSubDrawableTypeMask; }

    // Create a debug text font object
    virtual plTextFont      *MakeTextFont( char *face, UInt16 size );

    // Create and/or Refresh geometry buffers
    virtual void            CheckVertexBufferRef(plGBufferGroup* owner, UInt32 idx);
    virtual void            CheckIndexBufferRef(plGBufferGroup* owner, UInt32 idx);

    virtual hsBool          OpenAccess(plAccessSpan& dst, plDrawableSpans* d, const plVertexSpan* span, hsBool readOnly);
    virtual hsBool          CloseAccess(plAccessSpan& acc);

    virtual void            CheckTextureRef(plLayerInterface* lay);     
    static void             FreeManagedTexture(UInt32 sz) { hsAssert(fTexManaged >= sz, "Freeing mem we don't have"); fTexManaged -= sz; }
    static void             AllocManagedTexture(UInt32 sz) { fTexManaged += sz; }
    static void             FreeManagedVertex(UInt32 sz) { hsAssert(fVtxManaged >= sz, "Freeing mem we don't have"); fVtxManaged -= sz; }
    static void             AllocManagedVertex(UInt32 sz) { fVtxManaged += sz; }

#ifndef PLASMA_EXTERNAL_RELEASE
    static void ProfilePoolMem(D3DPOOL poolType, UInt32 size, hsBool add, char *id);
#endif // PLASMA_EXTERNAL_RELEASE

    //  From a D3DFORMAT enumeration, return the bit depth associated with it.
    static short    GetDXBitDepth( D3DFORMAT format );

    // Default fog settings
    virtual void                        SetDefaultFogEnviron( plFogEnvironment *fog ) { fView.fDefaultFog = *fog; fCurrFog.fEnvPtr = nil; }
    virtual const plFogEnvironment      &GetDefaultFogEnviron() const { return fView.fDefaultFog; }

    // View state
    virtual hsPoint3                    GetViewPositionWorld() const { return GetViewTransform().GetPosition(); }
    virtual hsVector3                   GetViewAcrossWorld() const { return GetViewTransform().GetAcross(); }
    virtual hsVector3                   GetViewUpWorld() const { return GetViewTransform().GetUp(); }
    virtual hsVector3                   GetViewDirWorld() const { return GetViewTransform().GetDirection(); }
    virtual void                        GetViewAxesWorld(hsVector3 axes[3] /* ac,up,at */ ) const;

    virtual void                        GetFOV(hsScalar& fovX, hsScalar& fovY) const;
    virtual void                        SetFOV(hsScalar fovX, hsScalar fovY);

    virtual void                        GetSize(hsScalar& width, hsScalar& height) const;
    virtual void                        SetSize(hsScalar width, hsScalar height);

    virtual void                        GetDepth(hsScalar& hither, hsScalar& yon) const;
    virtual void                        SetDepth(hsScalar hither, hsScalar yon);

    virtual hsScalar                    GetZBiasScale() const;
    virtual void                        SetZBiasScale(hsScalar scale);

    virtual const hsMatrix44&           GetWorldToCamera() const;
    virtual const hsMatrix44&           GetCameraToWorld() const;
    virtual void                        SetWorldToCamera(const hsMatrix44& w2c, const hsMatrix44& c2w);

    virtual void                        SetViewTransform(const plViewTransform& trans);
    virtual const plViewTransform&      GetViewTransform() const { return fView.fTransform; }

    virtual const hsMatrix44&           GetWorldToLocal() const;
    virtual const hsMatrix44&           GetLocalToWorld() const;

    virtual void                        ScreenToWorldPoint( int n, UInt32 stride, Int32 *scrX, Int32 *scrY, 
                                                    hsScalar dist, UInt32 strideOut, hsPoint3 *worldOut );
    
    virtual void                        RefreshMatrices();
    virtual void                        RefreshScreenMatrices();

    virtual void                        RegisterLight(plLightInfo* light);
    virtual void                        UnRegisterLight(plLightInfo* light);

    // Overrides, always push returns whatever is necessary to restore on pop.
    virtual hsGMaterial*                PushOverrideMaterial(hsGMaterial* mat);
    virtual void                        PopOverrideMaterial(hsGMaterial* restore);
    virtual hsGMaterial*                GetOverrideMaterial() const;

    virtual plLayerInterface*           AppendLayerInterface(plLayerInterface* li, hsBool onAllLayers = false);
    virtual plLayerInterface*           RemoveLayerInterface(plLayerInterface* li, hsBool onAllLayers = false);

    virtual plLayerInterface*           PushPiggyBackLayer(plLayerInterface* li);
    virtual plLayerInterface*           PopPiggyBackLayer(plLayerInterface* li);

    virtual UInt32                      GetMaterialOverrideOn(hsGMatState::StateIdx category) const;
    virtual UInt32                      GetMaterialOverrideOff(hsGMatState::StateIdx category) const;

    virtual hsGMatState                 PushMaterialOverride(const hsGMatState& state, hsBool on);
    virtual hsGMatState                 PushMaterialOverride(hsGMatState::StateIdx cat, UInt32 which, hsBool on);
    virtual void                        PopMaterialOverride(const hsGMatState& restore, hsBool on);
    virtual const hsGMatState&          GetMaterialOverride(hsBool on) const;

    virtual hsColorOverride             PushColorOverride(const hsColorOverride& over);
    virtual void                        PopColorOverride(const hsColorOverride& restore);
    virtual const hsColorOverride&      GetColorOverride() const;

    virtual void                        SubmitShadowSlave(plShadowSlave* slave);
    virtual void                        SubmitClothingOutfit(plClothingOutfit* co);

    virtual hsBool                      SetGamma(hsScalar eR, hsScalar eG, hsScalar eB);
    virtual hsBool                      SetGamma(const UInt16* const tabR, const UInt16* const tabG, const UInt16* const tabB);

    virtual hsBool                      CaptureScreen( plMipmap *dest, bool flipVertical = false, UInt16 desiredWidth = 0, UInt16 desiredHeight = 0 );
    virtual plMipmap*                   ExtractMipMap(plRenderTarget* targ);

    /// Error handling
    virtual const char                  *GetErrorString();

    hsBool                              ManagedAlloced() const { return fManagedAlloced; }

    virtual void                        GetSupportedColorDepths(hsTArray<int> &ColorDepths);
    virtual void                        GetSupportedDisplayModes(std::vector<plDisplayMode> *res, int ColorDepth = 32 );
    virtual int                         GetMaxAnisotropicSamples();
    virtual int                         GetMaxAntiAlias(int Width, int Height, int ColorDepth);

};


//// Direct3D Inlines //////////////////////////////////////////////////////
//  ??.?? - Some mild optimizations PBG
//  MMW - take advantage of the 32 bit float representation on a PC

#define CONVERT_FLOAT_TO_BYTE_COLOR( f, dest ) \
    { \
        LONG const floatBitsOne = 0x3f800000; \
        LONG const floatBits = *( (LONG const *)( &f ) ); \
        if( floatBits <= 0 ) dest = 0; \
        else if( floatBits >= floatBitsOne ) dest = 255; \
        else \
        { \
            LONG const times256 = floatBits + ( 8 << 23 ); \
            dest = (DWORD)( *( (float const *)( &times256 ) ) ); \
        } \
    }

inline DWORD    plDXPipeline::inlGetD3DColor( const hsColorRGBA &col ) const
{
    DWORD   dr, dg, db, da;
    
    CONVERT_FLOAT_TO_BYTE_COLOR( col.r, dr );   
    CONVERT_FLOAT_TO_BYTE_COLOR( col.g, dg );
    CONVERT_FLOAT_TO_BYTE_COLOR( col.b, db );
    CONVERT_FLOAT_TO_BYTE_COLOR( col.a, da );
  
    return( ( da << 24 ) | ( dr << 16 ) | ( dg << 8 ) | db );
}


#endif // _plDX9Pipeline_h