///////////////////////////////////////////////////////////////////////////////
//
//      ##  ######
//       ######  ###
//  ## ###############        Shark 3D Engine (www.shark3d.com)
//   ########## # # #
//    ########                Copyright (c) 1996-2006 Spinor GmbH.
//   ######### # # #          All rights reserved.
//  ##   ##########
//      ##
//
///////////////////////////////////////////////////////////////////////////////

#include "drv_d3d9_engnull.h"

#ifdef S3D_DRV_D3D9_USE_ENGNULL

///////////////////////////////////////////////////////////////////////////////

s3d_CDrvD3d9GfxEngNull::s3d_CDrvD3d9GfxEngNull(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        s3d_CCompSuppl *CompSuppl, s3d_CUtilAtomMgr *AtomMgr,
        s3d_CUtilMemPool *MemPool, s3d_CCompResMgr *ResMgr, 
        s3d_CUtilStorageMgr *StorageMgr, s3d_CDrvCtx *Ctx, 
        s3d_CCompSuppl *UnivProgSuppl, 
        s3d_CCompSuppl *UnivProgGivenSuppl,
        s3d_CUtilSnkChunk *Param, s3d_CUtilStr_cr Device, int Prop, 
        int Left, int Top, int Width, int Height, 
        int Depth, int Frequency)
{
    bool IsFullscreenWindow = false;
    HMONITOR hMonitor = 0;

    m_CtxWin32 = s3d_UtilRttiCastCheck<s3d_CDrvWin32CtxInterf>(
            MsgHandler, Info, Ctx);
    m_CtxWin32->Win32CreateWindow(
            MsgHandler, Info, 0, IsFullscreenWindow, hMonitor, 
            Top, Left, Width, Height, Depth, Frequency);
    HWND hWnd = m_CtxWin32->Win32GetWndHandle();

    UINT PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
    if(Prop & s3d_CDrvGfxMgr::Prop_Synch)
        PresentationInterval = D3DPRESENT_INTERVAL_ONE;

    s3d_SysMemset(&m_PresentParam, 0, S3D_SYS_SIZEOFS(m_PresentParam));
    m_PresentParam.BackBufferWidth = Width;
    m_PresentParam.BackBufferHeight = Height;
    m_PresentParam.BackBufferFormat = D3DFMT_UNKNOWN;
    m_PresentParam.BackBufferCount = 1;
    m_PresentParam.MultiSampleType = D3DMULTISAMPLE_NONE;
    m_PresentParam.MultiSampleQuality = 0;
    m_PresentParam.SwapEffect = D3DSWAPEFFECT_DISCARD;
    m_PresentParam.hDeviceWindow = hWnd;
    m_PresentParam.Windowed = true;
    m_PresentParam.EnabledAutoDepthStencil = true;
    m_PresentParam.AutoDepthStencilFormat = D3DFMT_D24S8;
    //StretchRects does not support discardable depth/stencil surfaces.
    m_PresentParam.Flags = 0;//D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
    m_PresentParam.FullScreen_RefreshRateInHz = 0;
    m_PresentParam.PresentationInterval = PresentationInterval;

    m_DevFlags = 0;
    m_DevFlags |= D3DCREATE_FPU_PRESERVE;
    m_DevFlags |= D3DCREATE_PUREDEVICE;
    m_DevFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;

    m_D3d.EmptyRef() = Direct3DCreate9(D3D_SDK_VERSION);
    m_D3d->CreateDevice(
            D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, m_DevFlags, 
            &m_PresentParam, &m_D3dDev.EmptyRef());
}

s3d_CDrvD3d9GfxEngNull::~s3d_CDrvD3d9GfxEngNull()
{
}

void s3d_CDrvD3d9GfxEngNull::GetDesc(
        s3d_CUtilStrBuf &Result) const
{
    Result.Reset();
    Result.Append("null");
}

s3d_CDrvGfxOutPtr s3d_CDrvD3d9GfxEngNull::CreateOut(
        s3d_CUtilStr_cr Info, s3d_CDrvCtx *Ctx,
        s3d_CUtilStr_cr Device, int Prop, 
        int Left, int Top, int Width, int Height, 
        int Depth, int Frequency, s3d_CUtilSnkChunk *Param) = 0
{
    return 0;
}

s3d_CDrvGfxOutPtr s3d_CDrvD3d9GfxEngNull::CreateOut(
        s3d_CUtilStr_cr Info, s3d_CDrvCtx *Ctx,
        s3d_CUtilStr_cr Device, int Prop, 
        int Left, int Top, int Width, int Height, 
        int Depth, int Frequency, s3d_CUtilRecogBase *Param)
{
}

s3d_CUtilSnkChunkPtr s3d_CDrvD3d9GfxEngNull::GetDefaultOutParam()
{
    return 0;
}

void s3d_CDrvD3d9GfxEngNull::RegisterNotifCtxChanged(
        s3d_CUtilNotifRecip *Recip)
{
}

void s3d_CDrvD3d9GfxEngNull::UserFunc(
        s3d_CUtilCoStr Func)
{
}

bool s3d_CDrvD3d9GfxEngNull::HasCap(
        s3d_CSysIntps CapLen, const s3d_CSysChar *CapStart) const
{
    return true;
}

s3d_CDrvGfxStat *s3d_CDrvD3d9GfxEngNull::GetStat()
{
    return 0;
}

int s3d_CDrvD3d9GfxEngNull::GetSampCnt() const
{
    return 32;
}

void s3d_CDrvD3d9GfxEngNull::SnapTexSize(
        int &Width, int &Height, int &Depth, 
        int TexProp, int SnapProp)
{
}

s3d_CDrvGfxTexPtr s3d_CDrvD3d9GfxEngNull::CreateTexDirect(
        s3d_CUtilStr_cr Info, int TexProp,
        int Width, int Height, int Depth)
{
    return 0;
}

s3d_CDrvGfxTexPtr s3d_CDrvD3d9GfxEngNull::CreateTexStream(
        s3d_CUtilStr_cr Info, int TexProp,
        s3d_CUtilStream *Stream)
{
    return 0;
}

s3d_CDrvGfxTexPtr s3d_CDrvD3d9GfxEngNull::CreateTexVideo(
        s3d_CUtilStr_cr Info, int TexProp,
        s3d_CDrvVideoPlayer *VideoPlayer)
{
    return 0;
}

s3d_CDrvGfxTexPtr s3d_CDrvD3d9GfxEngNull::CreateTexIdent(
        s3d_CUtilStr_cr Info, int TexProp,
        s3d_CUtilStr_cr Ident)
{
    return 0;
}

s3d_CDrvGfxTexPtr s3d_CDrvD3d9GfxEngNull::CreateTexUser(
        s3d_CUtilStr_cr Info, int TexProp,
        s3d_CCompObj *UserObj)
{
    return 0;
}

void s3d_CDrvD3d9GfxEngNull::SetSampTex(
        int Samp, s3d_CDrvGfxTex *Tex)
{
}

void s3d_CDrvD3d9GfxEngNull::SetSampTexElseNone(
        int SampStart)
{
}

void s3d_CDrvD3d9GfxEngNull::SetSampMode(
        int Samp, int SampMode)
{
}

s3d_CDrvGfxProgPtr s3d_CDrvD3d9GfxEngNull::CreateProg(
        s3d_CUtilNotifGather *NotifGather, 
        s3d_CUtilSnkChunk *Desc)
{
    return 0;
}

void s3d_CDrvD3d9GfxEngNull::GetSize(
        int &Width, int &Height) const
{
    Width = m_PresentParam.BackBufferWidth;
    Height = m_PresentParam.BackBufferHeight;
}

int s3d_CDrvD3d9GfxEngNull::GetColorBits() const
{
    return 32;
}

void s3d_CDrvD3d9GfxEngNull::SetGamma(
        s3d_CUtilVec3f_cr Gamma)
{
}

void s3d_CDrvD3d9GfxEngNull::Present()
{
    EndRender();

    m_D3dDev->Present(0,0,0,0);
}

void s3d_CDrvD3d9GfxEngNull::GetCurTargetSize(
        int &Width, int &Height) const
{
    Width = m_Width;
    Height = m_Height;
}

void s3d_CDrvD3d9GfxEngNull::EndRender()
{
    m_Width = -1;
    m_Height = -1;
}

void s3d_CDrvD3d9GfxEngNull::BeginRenderMain(
        int DestProp,
        s3d_CDrvGfxOut *GfxOut)
{
    m_Width = m_PresentParam.BackBufferWidth;
    m_Height = m_PresentParam.BackBufferHeight;
}

void s3d_CDrvD3d9GfxEngNull::BeginRenderTex(
        int DestProp,
        int Width, int Height,
        s3d_CSysIntps DestCnt, const s3d_CDrvGfxDest *DestArray)
{
    m_Width = Width;
    m_Height = Height;
}

void s3d_CDrvD3d9GfxEngNull::CopyIntoTex(
        int Width, int Height, int SrcX, int SrcY,
        s3d_CSysIntps DestCnt, const s3d_CDrvGfxDest *DestArray)
{
}

void s3d_CDrvD3d9GfxEngNull::StoreScreenshot()
{
}

void s3d_CDrvD3d9GfxEngNull::SetViewRect(
        s3d_CUtilTranslScale2f_cr ViewRect)
{
}

void s3d_CDrvD3d9GfxEngNull::SetViewDepthRange(
        float NegZ, float PosZ)
{
}

void s3d_CDrvD3d9GfxEngNull::Clear(
        s3d_CDrvGfxClearParam_cr ClearParam)
{
/*
    DWORD D3dFlags = D3DCLEAR_TARGET;
    if(ClearParam.m_MustDepth)
        D3dFlags |= D3DCLEAR_ZBUFFER;
    if(ClearParam.m_MustStencil)
        D3dFlags |= D3DCLEAR_STENCIL;
    D3DCOLOR D3dColor = D3DCOLOR_COLORVALUE(
            ClearParam.m_Color.m_x, 
            ClearParam.m_Color.m_y, 
            ClearParam.m_Color.m_z, 1);
    m_D3dDev->Clear(
                0, 0, D3dFlags, D3dColor, 
                ClearParam.m_Depth, ClearParam.m_Stencil);
*/
}

void s3d_CDrvD3d9GfxEngNull::SetCullMode(
        int Mode)
{
}

void s3d_CDrvD3d9GfxEngNull::SetDepthTest(
        int Mode)
{
}

void s3d_CDrvD3d9GfxEngNull::SetDepthWrite(
        bool Enabled)
{
}

int s3d_CDrvD3d9GfxEngNull::GetStencilBits() const
{
    return 8;
}

void s3d_CDrvD3d9GfxEngNull::SetStencilMode(
        int TestMask, int TestRef, int TestModeFront, int TestModeBack, 
        int WriteMask,
        int OpFailFront, int OpDepthFailFront, int OpDepthPassFront,
        int OpFailBack, int OpDepthFailBack, int OpDepthPassBack)
{
}

void s3d_CDrvD3d9GfxEngNull::SetAlphaTest(
        int Mode, float Ref)
{
}

void s3d_CDrvD3d9GfxEngNull::SetBlendMode(
        int ColSrcFac, int ColDestFac, int ColOp,
        int AlphaSrcFac, int AlphaDestFac, int AlphaOp)
{
}

void s3d_CDrvD3d9GfxEngNull::SetPaintMode(
        int Mode)
{
}

void s3d_CDrvD3d9GfxEngNull::SetPaintExt(
        float Ext)
{
}

void s3d_CDrvD3d9GfxEngNull::BeginVisib()
{
}

s3d_CDrvGfxVisibPtr s3d_CDrvD3d9GfxEngNull::EndVisib()
{
    return 0;
}

void s3d_CDrvD3d9GfxEngNull::SetFogNone()
{
}

void s3d_CDrvD3d9GfxEngNull::SetFogExp(
        float Density, s3d_CUtilVec3f_cr Color)
{
}

bool s3d_CDrvD3d9GfxEngNull::IsStereo() const
{
    return false;
}

void s3d_CDrvD3d9GfxEngNull::SetStereoEyeOffset(
        s3d_CUtilVec3f_cr EyeOffset)
{
}

void s3d_CDrvD3d9GfxEngNull::SetTransf(
        int Chan, int Slot, s3d_CUtilMat4x4f_cr Mat)
{
}

void s3d_CDrvD3d9GfxEngNull::SetTransfIdentity(
        int Chan, int Slot)
{
}

void s3d_CDrvD3d9GfxEngNull::SetClipPlane(
        s3d_CUtilVec4f_cr Plane)
{
}

void s3d_CDrvD3d9GfxEngNull::SetDepthBias(
        float BiasOverlay, float BiasOffs)
{
}

void s3d_CDrvD3d9GfxEngNull::DisableLighting()
{
}

void s3d_CDrvD3d9GfxEngNull::SetLightArray(
        s3d_CSysIntps LightCnt, 
        s3d_CDrvGfxLight **LightArray)
{
}

void s3d_CDrvD3d9GfxEngNull::SetMtl(
        s3d_CUtilVec3f_cr Ambient, s3d_CUtilVec3f_cr Diffuse,
        s3d_CUtilVec3f_cr Specular, s3d_CUtilVec3f_cr Emissive,
        float SpecExp, float Alpha)
{
}

void s3d_CDrvD3d9GfxEngNull::SetColorAlpha(
        s3d_CUtilVec4f_cr ColorAlpha)
{
}

void s3d_CDrvD3d9GfxEngNull::GetPacketLimits(
        s3d_CSysIntps &MaxVertCnt, s3d_CSysIntps &MaxPrimCnt,
        int Prim)
{
    MaxVertCnt = -1;
    MaxPrimCnt = -1;
}

s3d_CDrvGfxBatchPtr s3d_CDrvD3d9GfxEngNull::CreateBatch(
        const s3d_CDrvGfxCharge *Charge)
{
    return 0;
}

void s3d_CDrvD3d9GfxEngNull::ExecuteCharge(
        const s3d_CDrvGfxCharge *Charge, s3d_CDrvGfxBatch *Batch,
        s3d_CDrvGfxParam_cr GfxParam)
{
}

///////////////////////////////////////////////////////////////////////////////

#endif // S3D_DRV_D3D9_USE_ENGNULL