///////////////////////////////////////////////////////////////////////////////
// Copyright (C) Microsoft Corporation, 2000.
//
// rddmon.cpp
//
// Reference Device Debug Monitor
//
///////////////////////////////////////////////////////////////////////////////
#include "pch.cpp"
#pragma hdrstop

// converts correctly for pre-snapped floats only
#define FLOATtoNDOT4( _fVal )  ((INT32)((_fVal)*16.))

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
RDDebugMonitor::RDDebugMonitor( RefDev* pRD, BOOL bDbgMonConnectionEnabled )
{
    m_pRD = pRD;
    UINT i;
    m_bDbgMonConnectionEnabled = bDbgMonConnectionEnabled;

    m_ScreenMask[0] = 0xFFFFFFFF; //0xcccccccc;
    m_ScreenMask[1] = 0xFFFFFFFF; //0xcccccccc;

    memset( (void*)&m_ShMemI, 0, sizeof(m_ShMemI) );
    m_NumShMemI = 0;
}
//-----------------------------------------------------------------------------
RDDebugMonitor::~RDDebugMonitor( void )
{
    for (UINT i=0; i<m_NumShMemI; i++)
    {
        if (m_ShMemI[i].pSM) delete m_ShMemI[i].pSM;
    }
}

//-----------------------------------------------------------------------------
void
RDDebugMonitor::NextEvent( UINT32 EventType )
{
    CheckLostMonitorConnection();

    BOOL bBreakpoint = D3DDebugMonitor::IsEventBreak( EventType );

    // do event-specific stuff (state update; actions; check for breakpoints)
    UINT i;
    switch ( EventType )
    {
    case D3DDM_EVENT_RSTOKEN:
        switch( m_pRD->m_dwRenderState[D3DRS_DEBUGMONITORTOKEN] )
        {
        case D3DDMT_ENABLE:
            m_bDbgMonConnectionEnabled = TRUE;
            break;
        case D3DDMT_DISABLE:
            if( m_pTgtCtx )
            {
                DetachMonitorConnection();
            }
            DPFINFO("D3DDebugTarget - debug monitor connection disabled by target");
            m_bDbgMonConnectionEnabled = FALSE;
            break;
        }
        break;

    case D3DDM_EVENT_BEGINSCENE:
        // try to attach if not attached
        if (!MonitorConnected())  AttachToMonitor(1);
        break;

    case D3DDM_EVENT_ENDSCENE:
        m_pTgtCtx->SceneCount++;
        {
            static DWORD bDoSM = 0;
            if (bDoSM)
                ShMemIRenderTarget( 0x0, 0 );
        }
        break;

    case D3DDM_EVENT_PRIMITIVE:
        m_pTgtCtx->PrimitiveCount++;
        if (m_pMonCtx && m_pMonCtx->PrimitiveCountBP)
        {
            if ( m_pTgtCtx->PrimitiveCount == m_pMonCtx->PrimitiveCountBP )
                bBreakpoint = TRUE;
        }
        break;

    case D3DDM_EVENT_PIXEL:
        m_pTgtCtx->PixelCount++;
        if (m_pMonCtx)
        {
            if (m_pMonCtx->PixelCountBP)
            {
                if ( m_pTgtCtx->PixelCount == m_pMonCtx->PixelCountBP )
                    bBreakpoint = TRUE;
            }
            if (m_pMonCtx->PixelBPEnable)
            {
                for (i=0; i<32; i++)
                {
                    if ( (1<<i) & m_pMonCtx->PixelBPEnable )
                    {
                        if ( ((UINT)m_pMonCtx->PixelBP[i][0] ==
                              (UINT)m_pRD->m_Rast.m_iX[m_pRD->m_Rast.m_iPix] ) &&
                             ((UINT)m_pMonCtx->PixelBP[i][1] ==
                              (UINT)m_pRD->m_Rast.m_iY[m_pRD->m_Rast.m_iPix] ) )
                        {
                            bBreakpoint = TRUE;
                        }
                    }
                }
            }
        }
        break;

    case D3DDM_EVENT_PIXELSHADERINST:
        break;
    }

    // invoke base class to talk to monitor and issue commands
    if (bBreakpoint)
    {
        m_pTgtCtx->EventStatus = EventType;
        D3DDebugMonitor::MonitorBreakpoint();
        m_pTgtCtx->EventStatus = 0x0;
    }
    return;
}

HRESULT
RDDebugMonitor::ProcessMonitorCommand( void )
{
    UINT32 Command = m_pMonCtx->Command;
    UINT i;
    RefRast* pRast = &m_pRD->m_Rast;

    // default case - no data
    UINT32 IncomingCommandBufferSize = m_pTgtCtx->CommandBufferSize;
    m_pTgtCtx->CommandBufferSize = 0;

    switch ( Command & D3DDM_CMD_MASK )
    {

    case D3DDM_CMD_GETDEVICESTATE:
        {
            D3DDMDeviceState* pDS = (D3DDMDeviceState*)m_pCmdData;
            memcpy( pDS->RenderState, m_pRD->m_dwRenderState, 4*D3DHAL_MAX_RSTATES );
            for (i=0; i<D3DHAL_TSS_MAXSTAGES; i++)
            {
                memcpy( pDS->TextureStageState[i],
                    m_pRD->m_TextureStageState[i].m_dwVal, 4*D3DTSS_MAX );
            }
            pDS->VertexShaderHandle = m_pRD->m_CurrentVShaderHandle;
            pDS->PixelShaderHandle = m_pRD->m_CurrentPShaderHandle;
            pDS->MaxVShaderHandle = (UINT)m_pRD->m_VShaderHandleArray.GetSize();
            if (pDS->MaxVShaderHandle) pDS->MaxVShaderHandle -= 1;
            while ( ( pDS->MaxVShaderHandle > 0 ) &&
                    ( NULL == m_pRD->m_VShaderHandleArray[pDS->MaxVShaderHandle].m_pShader ) )
            {
                pDS->MaxVShaderHandle--;
            }
            pDS->MaxPShaderHandle = (UINT)m_pRD->m_PShaderHandleArray.GetSize();
            if (pDS->MaxPShaderHandle) pDS->MaxPShaderHandle -= 1;
            while ( ( pDS->MaxPShaderHandle > 0 ) &&
                    ( NULL == m_pRD->m_PShaderHandleArray[pDS->MaxPShaderHandle].m_pShader ) )
            {
                pDS->MaxPShaderHandle--;
            }
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMDeviceState);
        }
        break;

    case D3DDM_CMD_GETVERTEXSHADER:
        {
            DWORD Handle = *(DWORD*)m_pCmdData;
            if ( !(Handle & D3DFVF_RESERVED0) ) break;
            if ( !m_pRD->m_VShaderHandleArray.IsValidIndex(Handle) ) break;
            RDVShader* pRDVS = m_pRD->m_VShaderHandleArray[Handle].m_pShader;
            if ( !pRDVS) break;
            D3DDMVertexShader* pVS = (D3DDMVertexShader*)m_pCmdData;
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMVertexShader);
        }
        break;

    case D3DDM_CMD_GETVERTEXSTATE:
        {
            D3DDMVertexState* pVSS = (D3DDMVertexState*)m_pCmdData;
            m_pRD->GetVM().GetData( D3DSPR_INPUT, 0, D3DDM_MAX_VSINPUTREG, (void*)(pVSS->InputRegs) );
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMVertexState);
        }
        break;
    case D3DDM_CMD_GETVERTEXSHADERCONST:
        {
            D3DDMVertexShaderConst* pVSC = (D3DDMVertexShaderConst*)m_pCmdData;
            m_pRD->GetVM().GetData( D3DSPR_CONST, 0, 96, (void*)(pVSC->ConstRegs) );
            m_pTgtCtx->CommandBufferSize = 96*4*sizeof(FLOAT);
        }
        break;
    case D3DDM_CMD_GETVERTEXSHADERINST:
        {
            DWORD Handle = *(DWORD*)m_pCmdData;
            if ( !(Handle & D3DFVF_RESERVED0) ) break;
            if ( !m_pRD->m_VShaderHandleArray.IsValidIndex(Handle) ) break;
            RDVShader* pRDVS = m_pRD->m_VShaderHandleArray[Handle].m_pShader;
            if ( !pRDVS ) break;
            RDVShaderCode* pShC = pRDVS->m_pCode;
            UINT Inst = (Command & 0xffff);
            if (pShC && (Inst < pShC->GetInstructionCount()))
            {
                D3DDMVertexShaderInst* pVSI = (D3DDMVertexShaderInst*)m_pCmdData;
                memcpy( pVSI->Inst, pShC->m_pInst[Inst].m_Tokens, RD_MAX_SHADERTOKENSPERINST );
                memcpy( pVSI->InstString, pShC->m_pInst[Inst].m_String, RD_MAX_SHADERINSTSTRING );
                m_pTgtCtx->CommandBufferSize = sizeof(D3DDMVertexShaderInst);
                if (pShC->m_pInst[Inst].m_CommentSize)
                {
                    memcpy( (void*)(pVSI+1), pShC->m_pInst[Inst].m_pComment, 4*pShC->m_pInst[Inst].m_CommentSize );
                    m_pTgtCtx->CommandBufferSize += 4*pShC->m_pInst[Inst].m_CommentSize;
                }
            }
        }
        break;
    case D3DDM_CMD_GETVERTEXSHADERSTATE:
        {
            D3DDMVertexShaderState* pVSS = (D3DDMVertexShaderState*)m_pCmdData;
            pVSS->CurrentInst = m_pRD->GetVM().GetCurrentInstIndex();
            m_pRD->GetVM().GetData( D3DSPR_TEMP, 0, D3DDM_MAX_VSTEMPREG, (void*)(pVSS->TempRegs) );
            m_pRD->GetVM().GetData( D3DSPR_RASTOUT, 0, D3DDM_MAX_VSRASTOUTREG, (void*)(pVSS->RastOutRegs) );
            m_pRD->GetVM().GetData( D3DSPR_ATTROUT, 0, D3DDM_MAX_VSATTROUTREG, (void*)(pVSS->AttrOutRegs) );
            m_pRD->GetVM().GetData( D3DSPR_TEXCRDOUT, 0, D3DDM_MAX_VSTEXCRDOUTREG, (void*)(pVSS->TexCrdOutRegs) );
            m_pRD->GetVM().GetData( D3DSPR_ADDR, 0, 1, (void*)(pVSS->AddressReg) );
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMVertexShaderState);
        }
        break;

    case D3DDM_CMD_GETPIXELSTATE:
        {
            D3DDMPixelState* pPS = (D3DDMPixelState*)m_pCmdData;
            UINT iPix = (Command & 0xffff);
            if (pRast->m_bPixelIn[iPix])
            {
                pPS->Location[0] = pRast->m_iX[iPix];
                pPS->Location[1] = pRast->m_iY[iPix];
                pPS->Depth = pRast->m_Depth[iPix];
                pPS->FogIntensity = pRast->m_FogIntensity[iPix];
                memcpy( pPS->InputRegs[0], pRast->m_InputReg[0][iPix], 16 );
                memcpy( pPS->InputRegs[1], pRast->m_InputReg[1][iPix], 16 );
                m_pTgtCtx->CommandBufferSize = sizeof(D3DDMPixelState);
            }
        }
        break;

    case D3DDM_CMD_GETPIXELSHADERCONST:
        {
            D3DDMPixelShaderConst* pPSC = (D3DDMPixelShaderConst*)m_pCmdData;
            memcpy( pPSC->ConstRegs[0], pRast->m_ConstReg[0][0], 16 );
            memcpy( pPSC->ConstRegs[1], pRast->m_ConstReg[1][0], 16 );
            memcpy( pPSC->ConstRegs[2], pRast->m_ConstReg[2][0], 16 );
            memcpy( pPSC->ConstRegs[3], pRast->m_ConstReg[3][0], 16 );
            memcpy( pPSC->ConstRegs[4], pRast->m_ConstReg[4][0], 16 );
            memcpy( pPSC->ConstRegs[5], pRast->m_ConstReg[5][0], 16 );
            memcpy( pPSC->ConstRegs[6], pRast->m_ConstReg[6][0], 16 );
            memcpy( pPSC->ConstRegs[7], pRast->m_ConstReg[7][0], 16 );
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMPixelShaderConst);
        }
        break;

    case D3DDM_CMD_GETPIXELSHADERINST:
        {
            DWORD Handle = *(DWORD*)m_pCmdData;
            if ( !m_pRD->m_PShaderHandleArray.IsValidIndex(Handle) ) break;
            RDPShader* pRDPS = m_pRD->m_PShaderHandleArray[Handle].m_pShader;
            if ( !pRDPS ) break;
            D3DDMPixelShaderInst* pPSI = (D3DDMPixelShaderInst*)m_pCmdData;
            UINT Inst = (Command & 0xffff);
            if ( Inst < pRDPS->m_cInst )
            {
                PixelShaderInstruction* pInst = pRDPS->m_pInst+Inst;
                pPSI->Inst[0] = pInst->Opcode;
                pPSI->Inst[1] = pInst->DstParam;
                pPSI->Inst[2] = pInst->SrcParam[0];
                pPSI->Inst[3] = pInst->SrcParam[1];
                pPSI->Inst[4] = pInst->SrcParam[2];
                memcpy( pPSI->InstString, pInst->Text, RD_MAX_SHADERINSTSTRING );
                m_pTgtCtx->CommandBufferSize = sizeof(D3DDMPixelShaderInst);
                if (pInst->CommentSize)
                {
                    memcpy( (void*)(pPSI+1), pInst->pComment, 4*pInst->CommentSize );
                    m_pTgtCtx->CommandBufferSize += 4*pInst->CommentSize;
                }
            }
            else
            {
                m_pTgtCtx->CommandBufferSize = 0;
            }
        }
        break;

    case D3DDM_CMD_GETPIXELSHADERSTATE:
        {
            D3DDMPixelShaderState* pPSS = (D3DDMPixelShaderState*)m_pCmdData;
            UINT iPix = (Command & 0xffff);
            pPSS->CurrentInst = pRast->m_CurrentPSInst;
            pPSS->Discard = pRast->m_bPixelDiscard[iPix];
            memcpy( pPSS->TempRegs[0], pRast->m_TempReg[0][iPix], 16 );
            memcpy( pPSS->TempRegs[1], pRast->m_TempReg[1][iPix], 16 );
            memcpy( pPSS->TextRegs[0], pRast->m_TextReg[0][iPix], 16 );
            memcpy( pPSS->TextRegs[1], pRast->m_TextReg[1][iPix], 16 );
            memcpy( pPSS->TextRegs[2], pRast->m_TextReg[2][iPix], 16 );
            memcpy( pPSS->TextRegs[3], pRast->m_TextReg[3][iPix], 16 );
            memcpy( pPSS->TextRegs[4], pRast->m_TextReg[4][iPix], 16 );
            memcpy( pPSS->TextRegs[5], pRast->m_TextReg[5][iPix], 16 );
            memcpy( pPSS->TextRegs[6], pRast->m_TextReg[6][iPix], 16 );
            memcpy( pPSS->TextRegs[7], pRast->m_TextReg[7][iPix], 16 );
            m_pTgtCtx->CommandBufferSize = sizeof(D3DDMPixelShaderState);
        }
        break;

    case D3DDM_CMD_DUMPTEXTURE:
        {
            int iSMI = (Command>>0)&0xf;
            int iSTG = (Command>>4)&0x7;
            int iLOD = (Command>>7)&0xf;
            int iIDX = (Command>>11)&0x1f;
            ShMemISurface2D( m_pRD->m_pTexture[iSTG], iLOD, 0x0, iSMI );
        }
        break;

    case D3DDM_CMD_DUMPRENDERTARGET:
        {
            int iSMI = (Command>>0)&0xf;
            ShMemIRenderTarget( 0x0, iSMI );
            break;
        }
        break;
    }
    return S_OK;
}

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void
RDDebugMonitor::GrowShMemArray( UINT ShMemI )
{
    if (ShMemI >= D3DDM_IMAGE_MAX) return;  // too many
    if (ShMemI < m_NumShMemI) return;       // already there
    UINT OldSmMemI = m_NumShMemI ? m_NumShMemI-1 : 0;
    m_NumShMemI = ShMemI+1;
    memset( (void*)&m_ShMemI, 0, sizeof(m_ShMemI) );
    for ( UINT i=OldSmMemI; i<m_NumShMemI; i++)
    {
        m_ShMemI[i].W = 400;
        m_ShMemI[i].H = 400;
        m_ShMemI[i].BPP = 4;
        m_ShMemI[i].SF = RD_SF_B8G8R8A8;
        m_ShMemI[i].pSM = new D3DSharedMem(
            16 + m_ShMemI[i].W*m_ShMemI[i].H*m_ShMemI[i].BPP,
            D3DDM_IMAGE_SM "%d", i );
        m_ShMemI[i].pBits = (void*)((char*)m_ShMemI[i].pSM->GetPtr()+16);
        *((DWORD*)m_ShMemI[i].pSM->GetPtr()+0) = m_ShMemI[i].W;
        *((DWORD*)m_ShMemI[i].pSM->GetPtr()+1) = m_ShMemI[i].H;
        *((DWORD*)m_ShMemI[i].pSM->GetPtr()+2) = m_ShMemI[i].BPP;
        *((DWORD*)m_ShMemI[i].pSM->GetPtr()+3) = m_ShMemI[i].SF;
    }
}

//-----------------------------------------------------------------------------
//
// Dumps render target image to specified shared memory segment.  Viewable by
// rddm_iview image viewer tool.
//
//-----------------------------------------------------------------------------
void
RDDebugMonitor::ShMemIRenderTarget( DWORD Flags, UINT iSM )
{
    GrowShMemArray( iSM );

    // copy to debug monitor shared memory
    int height = (int)min(
        (int)m_pRD->m_pRenderTarget->m_pColor->GetHeight(),
        (int)m_ShMemI[iSM].H);
    int width =  (int)min(
        (int)m_pRD->m_pRenderTarget->m_pColor->GetWidth(),
        (int)m_ShMemI[iSM].W);
    for (int iY = 0; iY < height; iY++)
    {
        for (int iX = 0; iX < width; iX++)
        {
            RDColor Color((UINT32)0);
            if( m_pRD->m_pRenderTarget->m_pColor->m_iSamples == 0 )
            {
                m_pRD->m_pRenderTarget->ReadPixelColor( iX, iY, 0, Color );
            }
            else
            {
                FLOAT fSampleScale = 1.F/((FLOAT)m_pRD->m_pRenderTarget->m_pColor->m_iSamples);
                for (UINT iS=0; iS<m_pRD->m_pRenderTarget->m_pColor->m_iSamples; iS++)
                {
                    RDColor SampleColor;
                    m_pRD->m_pRenderTarget->ReadPixelColor( iX, iY, iS, SampleColor );
                    Color.R += (SampleColor.R * fSampleScale);
                    Color.G += (SampleColor.G * fSampleScale);
                    Color.B += (SampleColor.B * fSampleScale);
                    Color.A += (SampleColor.A * fSampleScale);
                }
            }
            Color.ConvertTo( m_ShMemI[iSM].SF, 0.,
                (char*)m_ShMemI[iSM].pBits +
                 (m_ShMemI[iSM].W*m_ShMemI[iSM].BPP*iY) + (m_ShMemI[iSM].BPP*iX) );
        }
    }
    {
        char winstr[128]; _snprintf( winstr, 128, "D3DDM_I_%d", iSM );
        HWND hWnd = FindWindow( winstr, winstr );
        if (NULL != hWnd) SendMessage(hWnd, WM_USER, 0, 0);
    }
}

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void
RDDebugMonitor::ShMemISurface2D( RDSurface2D* pRS, INT32 iLOD, DWORD Flags, UINT iSM )
{
    GrowShMemArray( iSM );
    if (!pRS) return;

    // copy to debug monitor shared memory
    int height = (int)min(pRS->m_iHeight,(int)m_ShMemI[iSM].H);
    int width =  (int)min(pRS->m_iWidth,(int)m_ShMemI[iSM].W);
    for (int iY = 0; iY < height; iY++)
    {
        for (int iX = 0; iX < width; iX++)
        {
            RDColor Color; BOOL bDummy; pRS->ReadColor( iX, iY, 0, iLOD, Color, bDummy );
            Color.ConvertTo( m_ShMemI[iSM].SF, 0.,
                (char*)m_ShMemI[iSM].pBits +
                 (m_ShMemI[iSM].W*m_ShMemI[iSM].BPP*iY) + (m_ShMemI[iSM].BPP*iX) );
        }
    }
    {
        char winstr[128]; _snprintf( winstr, 128, "D3DDM_I_%d", iSM );
        HWND hWnd = FindWindow( winstr, winstr );
        if (NULL != hWnd) SendMessage(hWnd, WM_USER, 0, 0);
    }
}

///////////////////////////////////////////////////////////////////////////////
// end