📄 context.c
字号:
/******************************************************************************
<module>
* Name : Context.c
* Title : D3DM Context Callbacks
* Author(s) : Imagination Technologies
* Created : 2 March 2004
*
* Copyright : 2004 by Imagination Technologies Limited.
* All rights reserved. No part of this software, either
* material or conceptual may be copied or distributed,
* transmitted, transcribed, stored in a retrieval system
* or translated into any human or computer language in any
* form by any means, electronic, mechanical, manual or
* other-wise, or disclosed to third parties without the
* express written permission of Imagination Technologies
* Limited, Unit 8, HomePark Industrial Estate,
* King's Langley, Hertfordshire, WD4 8LZ, U.K.
*
* Description : Performs D3DMobile context setup and destruction.
*
* Platform : Windows CE
*
</module>
********************************************************************************/
#include "context.h"
/* Array of DrawPrimtives Op handlers to Op Code mappings */
static D3DM_DP_OPCODE_MAPPING psD3DM_DP_OPCodeMappings[] =
{
/* {D3DMOP_CURSORPROPERTIES, D3DM_DP_OP_CursorProperties},
{D3DMOP_CURSORPOSITION, D3DM_DP_OP_CursorPosition},
{D3DMOP_CURSORVISIBILITY, D3DM_DP_OP_CursorVisibility},*/
{D3DMOP_BEGINSCENE, D3DM_DP_OP_BeginScene},
{D3DMOP_ENDSCENE, D3DM_DP_OP_EndScene},
{D3DMOP_PRESENT, D3DM_DP_OP_Present},
{D3DMOP_COPYRECT, D3DM_DP_OP_CopyRect},
{D3DMOP_CLEAR, D3DM_DP_OP_Clear},
{D3DMOP_RENDERTARGET, D3DM_DP_OP_RenderTarget},
{D3DMOP_RENDERSTATE, D3DM_DP_OP_RenderState},
{D3DMOP_TRANSFORM, D3DM_DP_OP_Transform},
{D3DMOP_VIEWPORT, D3DM_DP_OP_ViewPort},
{D3DMOP_MATERIAL, D3DM_DP_OP_Material},
{D3DMOP_CREATELIGHT, D3DM_DP_OP_CreateLight},
{D3DMOP_SETLIGHT, D3DM_DP_OP_SetLight},
{D3DMOP_TEXTURESTAGESTATE, D3DM_DP_OP_TextureStageState},
{D3DMOP_CREATEPALETTE, D3DM_DP_OP_CreatePalette},
{D3DMOP_SETPALETTE, D3DM_DP_OP_SetPalette},
{D3DMOP_PROCESSVERTICES, D3DM_DP_OP_ProcessVertices},
{D3DMOP_DRAWPRIMITIVE, D3DM_DP_OP_DrawPrimitive},
{D3DMOP_DRAWINDEXEDPRIMITIVE, D3DM_DP_OP_DrawIndexedPrimitive},
{D3DMOP_VERTEXBUFFER, D3DM_DP_OP_VertexBuffer},
{D3DMOP_INDEXBUFFER, D3DM_DP_OP_IndexBuffer},
{D3DMOP_COLORFILL, D3DM_DP_OP_ColorFill},
{D3DMOP_STRETCHRECT, D3DM_DP_OP_StretchRect}
};
/* List to hold Op mappings */
D3DM_DP_OPCODE_MAPPINGLIST sD3DM_DP_OPCodeMappingList =
{
sizeof(psD3DM_DP_OPCodeMappings) / sizeof(D3DM_DP_OPCODE_MAPPING),
psD3DM_DP_OPCodeMappings
};
/*----------------------------------------------------------------------------
<function>
FUNCTION : DummyWndProc
DESCRIPTION: Dummy WndProc function used by the shadow window
PARAMETERS : HWND hWnd , UINT Msg, WPARAM wParam, LPARAM lParam)
RETURNS : Result of Applications WndProc
</function>
------------------------------------------------------------------------------*/
LRESULT CALLBACK DummyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_PAINT:
{
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
}
case WM_DESTROY:
break;
default:
{
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
return 0;
}
/*----------------------------------------------------------------------------
<function>
FUNCTION : ForceDesktopRedraw
DESCRIPTION: Forces Desktop to be redrawn
RETURNS : 0
</function>
------------------------------------------------------------------------------*/
VOID ForceDesktopRedraw()
{
HINSTANCE hInstance = GetModuleHandle(NULL);
WNDCLASS wc;
HWND hWnd;
/* Set up window Class */
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC) DummyWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = 0;
wc.hCursor = 0;
wc.lpszMenuName = 0;
// wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.hbrBackground = NULL;
wc.lpszClassName = TEXT("DummyWindow");
/* Now Register the class */
RegisterClass(&wc);
/* Create the fullscreen dummy window */
hWnd = CreateWindowEx(WS_EX_TOPMOST|WS_EX_NOANIMATION,
TEXT("DummyWindow"),
NULL,
WS_VISIBLE,
0,
0,
GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN),
NULL,
NULL,
hInstance,
NULL);
/* Now display then destoy the window */
ShowWindow(hWnd, 1);
UpdateWindow(hWnd);
DestroyWindow(hWnd);
}
/*----------------------------------------------------------------------------
<function>
FUNCTION : EnumWindowsProc
DESCRIPTION: window enumeration
RETURNS : bool
</function>
------------------------------------------------------------------------------*/
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
LPD3DM_CONTEXT psContext = (LPD3DM_CONTEXT)lParam;
IMG_UINT32 ui32Creator;
GetWindowThreadProcessId(hwnd, &ui32Creator);
if(ui32Creator == HostGetCurrentProcessID())
{
psContext->hWnd = hwnd;
return FALSE;
}
return TRUE;
}
/*----------------------------------------------------------------------------
<function>
FUNCTION: D3DM_DP_OPHandlerTableSetUp
PURPOSE: Sets up specified Op handler table.
PARAMETERS: In: ppfnsContextOpTable - table to be filled in
RETURNS:
</function>
------------------------------------------------------------------------------*/
VOID D3DM_DP_OPHandlerTableSetUp(D3DM_DPFUNC *ppfnsContextOpTable)
{
ULONG i;
D3DM_DPF((DPF_ENTRY, "->D3DM_DPHandlerTableSetUp"));
/* Initialise the table with the default 'unhandled' command handler */
for (i = 0; i < D3DM_DP_OPTABLESIZE; i++)
{
ppfnsContextOpTable[i] = D3DM_DP_OP_DefaultHandler;
}
/* Fill in the given command-execution routines */
for (i = 0; i < sD3DM_DP_OPCodeMappingList.ulSize; i++)
{
LPD3DM_DP_OPCODE_MAPPING psEntry;
psEntry = &sD3DM_DP_OPCodeMappingList.psFuncTable[i];
ppfnsContextOpTable[psEntry->eOperation] = psEntry->pfnFunction;
}
D3DM_DPF((DPF_EXIT, "<-D3DM_DPHandlerTableSetUp"));
}
/*----------------------------------------------------------------------------
<function>
FUNCTION: D3DM_RenderStateTableSetUp
PURPOSE: Sets up specified Render State function table.
PARAMETERS: In: ppfnsRStateOpTable - table to be filled in
RETURNS:
</function>
------------------------------------------------------------------------------*/
VOID D3DM_RenderStateTableSetUp(D3DM_RSTATE_FUNC *ppfnsRStateOpTable)
{
ULONG i;
D3DM_DPF((DPF_ENTRY, "->D3DM_RenderStateTableSetUp"));
for(i=0; i<D3DM_MAXRENDERSTATES; i++)
{
switch((D3DMRENDERSTATETYPE) i)
{
case D3DMRS_FILLMODE: {ppfnsRStateOpTable[i] = D3DM_RS_FillMode; break;}
case D3DMRS_SHADEMODE: {ppfnsRStateOpTable[i] = D3DM_RS_ShadeMode; break;}
case D3DMRS_ZWRITEENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_ZWriteEnable; break;}
case D3DMRS_ALPHATESTENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_AlphaTestEnable; break;}
case D3DMRS_LASTPIXEL: {ppfnsRStateOpTable[i] = D3DM_RS_LastPixel; break;}
case D3DMRS_SRCBLEND: {ppfnsRStateOpTable[i] = D3DM_RS_SrcBlend; break;}
case D3DMRS_DESTBLEND: {ppfnsRStateOpTable[i] = D3DM_RS_DestBlend; break;}
case D3DMRS_CULLMODE: {ppfnsRStateOpTable[i] = D3DM_RS_CullMode; break;}
case D3DMRS_ZFUNC: {ppfnsRStateOpTable[i] = D3DM_RS_ZFunc; break;}
case D3DMRS_ALPHAREF: {ppfnsRStateOpTable[i] = D3DM_RS_AlphaRef; break;}
case D3DMRS_ALPHAFUNC: {ppfnsRStateOpTable[i] = D3DM_RS_AlphaFunc; break;}
case D3DMRS_DITHERENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_DitherEnable; break;}
case D3DMRS_ALPHABLENDENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_AlphaBlendEnable; break;}
case D3DMRS_FOGENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_FogEnable; break;}
case D3DMRS_SPECULARENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_SpecularEnable; break;}
case D3DMRS_FOGCOLOR: {ppfnsRStateOpTable[i] = D3DM_RS_FogColour; break;}
case D3DMRS_FOGTABLEMODE: {ppfnsRStateOpTable[i] = D3DM_RS_FogTableMode; break;}
case D3DMRS_FOGSTART: {ppfnsRStateOpTable[i] = D3DM_RS_FogStart; break;}
case D3DMRS_FOGEND: {ppfnsRStateOpTable[i] = D3DM_RS_FogEnd; break;}
case D3DMRS_FOGDENSITY: {ppfnsRStateOpTable[i] = D3DM_RS_FogDensity; break;}
case D3DMRS_DEPTHBIAS: {ppfnsRStateOpTable[i] = D3DM_RS_ZBias; break;}
case D3DMRS_SLOPESCALEDEPTHBIAS: {ppfnsRStateOpTable[i] = D3DM_RS_SlopeScaledDepthBias; break;}
case D3DMRS_RANGEFOGENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_RangeFogEnable; break;}
case D3DMRS_TEXTUREFACTOR: {ppfnsRStateOpTable[i] = D3DM_RS_TextureFactor; break;}
case D3DMRS_TEXTUREPERSPECTIVE: {ppfnsRStateOpTable[i] = D3DM_RS_TexturePerspective; break;}
case D3DMRS_WRAP0: {ppfnsRStateOpTable[i] = D3DM_RS_Wrap; break;}
case D3DMRS_WRAP1: {ppfnsRStateOpTable[i] = D3DM_RS_Wrap; break;}
case D3DMRS_WRAP2: {ppfnsRStateOpTable[i] = D3DM_RS_Wrap; break;}
case D3DMRS_WRAP3: {ppfnsRStateOpTable[i] = D3DM_RS_Wrap; break;}
case D3DMRS_CLIPPING: {ppfnsRStateOpTable[i] = D3DM_RS_Clipping; break;}
case D3DMRS_LIGHTING: {ppfnsRStateOpTable[i] = D3DM_RS_Lighting; break;}
case D3DMRS_AMBIENT: {ppfnsRStateOpTable[i] = D3DM_RS_Ambient; break;}
case D3DMRS_FOGVERTEXMODE: {ppfnsRStateOpTable[i] = D3DM_RS_FogVertexMode; break;}
case D3DMRS_COLORVERTEX: {ppfnsRStateOpTable[i] = D3DM_RS_ColorVertex; break;}
case D3DMRS_LOCALVIEWER: {ppfnsRStateOpTable[i] = D3DM_RS_LocalViewer; break;}
case D3DMRS_NORMALIZENORMALS: {ppfnsRStateOpTable[i] = D3DM_RS_NormalizeNormals; break;}
case D3DMRS_DIFFUSEMATERIALSOURCE: {ppfnsRStateOpTable[i] = D3DM_RS_SetMaterialSource; break;}
case D3DMRS_SPECULARMATERIALSOURCE: {ppfnsRStateOpTable[i] = D3DM_RS_SetMaterialSource; break;}
case D3DMRS_AMBIENTMATERIALSOURCE: {ppfnsRStateOpTable[i] = D3DM_RS_SetMaterialSource; break;}
case D3DMRS_ZENABLE: {ppfnsRStateOpTable[i] = D3DM_RS_ZEnable; break;}
default: {ppfnsRStateOpTable[i] = D3DM_RS_NOP; break;}
}
}
D3DM_DPF((DPF_EXIT, "<-D3DM_RenderStateTableSetUp"));
}
/*----------------------------------------------------------------------------
<function>
FUNCTION: D3DM_TextureStageStateTableSetUp
PURPOSE: Sets up specified texture stage state function table.
PARAMETERS: In: ppfnsTSStateOpTable - table to be filled in
RETURNS:
</function>
------------------------------------------------------------------------------*/
VOID D3DM_TextureStageStateTableSetUp(D3DM_TSSTATEFUNC *ppfnsTSStateOpTable)
{
ULONG i;
D3DM_DPF((DPF_ENTRY, "->D3DM_TextureStageStateTableSetUp"));
for(i=0; i<D3DMTSS_MAXTEXTURESTATES; i++)
{
switch((D3DMTEXTURESTAGESTATETYPE) i)
{
case D3DMTSS_TEXTURE: {ppfnsTSStateOpTable[i] = D3DM_TSS_TextureMap; break;}
case D3DMTSS_COLOROP: {ppfnsTSStateOpTable[i] = D3DM_TSS_ColourOp; break;}
case D3DMTSS_COLORARG1: {ppfnsTSStateOpTable[i] = D3DM_TSS_ColourArg1; break;}
case D3DMTSS_COLORARG2: {ppfnsTSStateOpTable[i] = D3DM_TSS_ColourArg2; break;}
case D3DMTSS_ALPHAOP: {ppfnsTSStateOpTable[i] = D3DM_TSS_AlphaOp; break;}
case D3DMTSS_ALPHAARG1: {ppfnsTSStateOpTable[i] = D3DM_TSS_AlphaArg1; break;}
case D3DMTSS_ALPHAARG2: {ppfnsTSStateOpTable[i] = D3DM_TSS_AlphaArg2; break;}
case D3DMTSS_TEXCOORDINDEX: {ppfnsTSStateOpTable[i] = D3DM_TSS_TexCoordIndex; break;}
case D3DMTSS_ADDRESSU: {ppfnsTSStateOpTable[i] = D3DM_TSS_AddressU; break;}
case D3DMTSS_ADDRESSV: {ppfnsTSStateOpTable[i] = D3DM_TSS_AddressV; break;}
case D3DMTSS_MAGFILTER: {ppfnsTSStateOpTable[i] = D3DM_TSS_MagFilter; break;}
case D3DMTSS_MINFILTER: {ppfnsTSStateOpTable[i] = D3DM_TSS_MinFilter; break;}
case D3DMTSS_MIPFILTER: {ppfnsTSStateOpTable[i] = D3DM_TSS_MipFilter; break;}
case D3DMTSS_MIPMAPLODBIAS: {ppfnsTSStateOpTable[i] = D3DM_TSS_MipMapLODBias; break;}
case D3DMTSS_MAXMIPLEVEL: {ppfnsTSStateOpTable[i] = D3DM_TSS_MaxMipLevel; break;}
case D3DMTSS_MAXANISOTROPY: {ppfnsTSStateOpTable[i] = D3DM_TSS_MaxAnisotropy; break;}
case D3DMTSS_TEXTURETRANSFORMFLAGS: {ppfnsTSStateOpTable[i] = D3DM_TSS_TexTransFlags; break;}
case D3DMTSS_ADDRESSW: {ppfnsTSStateOpTable[i] = D3DM_TSS_NOP; break;}// D3DMTEXTUREADDRESS for W coordinate
case D3DMTSS_COLORARG0: {ppfnsTSStateOpTable[i] = D3DM_TSS_NOP; break;}// D3DMTA_* third arg for triadic ops
case D3DMTSS_ALPHAARG0: {ppfnsTSStateOpTable[i] = D3DM_TSS_NOP; break;}// D3DMTA_* third arg for triadic ops
case D3DMTSS_RESULTARG: {ppfnsTSStateOpTable[i] = D3DM_TSS_NOP; break;}// D3DMTA_* arg for result (CURRENT or TEMP)
default: {ppfnsTSStateOpTable[i] = D3DM_TSS_NOP; break;}
}
}
D3DM_DPF((DPF_EXIT, "<-D3DM_TextureStageStateTableSetUp"));
}
/*----------------------------------------------------------------------------
<function>
FUNCTION: PVRD3DM_CreateContext
PURPOSE: Create a D3DM rendering Context
PARAMETERS: In: pccd - Data for Context creation
RETURNS: D3DM_DRIVER_HANDLED || D3DM_DRIVER_NOTHANDLED
</function>
------------------------------------------------------------------------------*/
DWORD PVRD3DM_CreateContext(D3DM_CREATECONTEXT_DATA *pccd)
{
LPD3DM_CONTEXT psContext;
DWORD dwNumDevices;
DWORD dwCurrentModeIndex;
DWORD dwIndex;
PVRSRV_DEVICE_IDENTIFIER asDevId[PVRSRV_MAX_DEVICES];
PTRANSIENT_STATE psTState;
PSWTNLSTATE psSWTNLState;
PHWSTATE psHWState;
PHWSTATECTL psStateCtl;
float fTmp;
PVR_DEVFORMAT *psDevFormat = NULL;
/* Local Profiling */
PROFILE_INIT();
psContext = NULL;
pccd->rval = D3DM_OK;
dwCurrentModeIndex = 0;/* D3DM 1.0 only has 1 mode */
D3DM_DPF((DPF_ENTRY, "->PVRD3DM_CreateContext"));
/* Allocate context memory */
psContext = (LPD3DM_CONTEXT) D3DMAllocate(sizeof(D3DM_CONTEXT));
if(psContext == NULL)
{
D3DM_DPF((DPF_ERROR,"PVRD3DM_CreateContext: Can't allocate context"));
pccd->rval = D3DM_GENERICFAILURE;
goto error_exit;
}
memset(psContext, 0, sizeof(D3DM_CONTEXT));
/* context is windowed? */
psContext->bWindowed = pccd->bWindowed;
/* swap effect for this context */
psContext->SwapEffect = pccd->SwapEffect;
/* vsync interval for this context */
psContext->nVSyncInterval = pccd->nVSyncInterval;
/* Find creating process's window handle */
EnumWindows(EnumWindowsProc, (LPARAM) psContext);
/* Allocate DP Jump table */
psContext->ppfnsDPOpHandlers = (D3DM_DPFUNC *) D3DMAllocate(D3DM_DP_OPTABLESIZE * sizeof(D3DM_DPFUNC));
if(psContext->ppfnsDPOpHandlers == NULL)
{
D3DM_DPF((DPF_ERROR,"PVRD3DM_CreateContext: Can't allocate DP Op Table"));
pccd->rval = D3DM_GENERICFAILURE;
goto error_exit;
}
/* Set up D3DM DrawPrimitive Operation function pointer table */
D3DM_DP_OPHandlerTableSetUp(psContext->ppfnsDPOpHandlers);
/* Allocate RS Jump table */
psContext->ppfnsRStateFunctions = (D3DM_RSTATE_FUNC *) D3DMAllocate(D3DM_MAXRENDERSTATES * sizeof(D3DM_RSTATE_FUNC));
if(psContext->ppfnsRStateFunctions == NULL)
{
D3DM_DPF((DPF_ERROR,"PVRD3DM_CreateContext: Can't allocate RS function Table"));
pccd->rval = D3DM_GENERICFAILURE;
goto error_exit;
}
/* Set up D3DM Render state function pointer table */
D3DM_RenderStateTableSetUp(psContext->ppfnsRStateFunctions);
/* Allocate TSS Jump table */
psContext->ppfnsTSStateFunctions = (D3DM_TSSTATEFUNC *) D3DMAllocate(D3DMTSS_MAXTEXTURESTATES * sizeof(D3DM_TSSTATEFUNC));
if(psContext->ppfnsTSStateFunctions == NULL)
{
D3DM_DPF((DPF_ERROR,"PVRD3DM_CreateContext: Can't allocate TSS function Table"));
pccd->rval = D3DM_GENERICFAILURE;
goto error_exit;
}
/* Set up D3DM Texture stage state function pointer table */
D3DM_TextureStageStateTableSetUp(psContext->ppfnsTSStateFunctions);
/* Import registry */
GetD3DMRegSettings(0, &psContext->sRegData);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -