fb.c

Lido PXA270平台开发板的最新BSP,包括源代码

	sCol.fRed = Clampf(FIXED_TO_FLOAT(red), GLES_Zero, GLES_One);
	sCol.fGreen = Clampf(FIXED_TO_FLOAT(green), GLES_Zero, GLES_One);
	sCol.fBlue = Clampf(FIXED_TO_FLOAT(blue), GLES_Zero, GLES_One);
	sCol.fAlpha = Clampf(FIXED_TO_FLOAT(alpha), GLES_Zero, GLES_One);

	gc->sState.sRaster.ui32ClearColor = ColorConvertToHWFormat(&sCol);

	GLES_TIME_STOP(GLES_TIMES_glClearColorx);
}


/***********************************************************************************
 Function Name      : glClearDepth(f/x)
 Inputs             : depth
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Stores depth of clear internally.
					  Used when clear primitives/start of frame clears are sent.
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glClearDepthf(GLclampf depth)
{
    __GL_GET_CONTEXT();
	
	GLES_TIME_START(GLES_TIMES_glClearDepthf);

	gc->sState.sDepth.fClear = Clampf(depth, GLES_Zero, GLES_One);

	GLES_TIME_STOP(GLES_TIMES_glClearDepthf);
}

#endif

GLAPI void APIENTRY glClearDepthx(GLclampx depth)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glClearDepthx);
	
	gc->sState.sDepth.fClear = Clampf(FIXED_TO_FLOAT(depth), GLES_Zero, GLES_One);

	GLES_TIME_STOP(GLES_TIMES_glClearDepthx);
}

/***********************************************************************************
 Function Name      : glClearStencil
 Inputs             : s
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Stores stencil value of clear internally.
					  Not used.
************************************************************************************/
GLAPI void APIENTRY glClearStencil(GLint s)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glClearStencil);

	gc->sState.sStencil.i32Clear = s;

	GLES_TIME_STOP(GLES_TIMES_glClearStencil);
}

/***********************************************************************************
 Function Name      : glSampleCoverage(x)
 Inputs             : value, invert
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Stores value of multisample coverage state internally
					  Not used.
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glSampleCoverage);
	
	gc->sState.sMultisample.fSampleCoverageValue =	Clampf(value, GLES_Zero, GLES_One);
	gc->sState.sMultisample.bSampleCoverageInvert = (IMG_BOOL) invert;

	GLES_TIME_STOP(GLES_TIMES_glSampleCoverage);
}

#endif

GLAPI void APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glSampleCoveragex);

	gc->sState.sMultisample.fSampleCoverageValue =	Clampf(FIXED_TO_FLOAT(value), GLES_Zero, GLES_One);
	gc->sState.sMultisample.bSampleCoverageInvert = (IMG_BOOL) invert;

	GLES_TIME_STOP(GLES_TIMES_glSampleCoveragex);
}

/***********************************************************************************
 Function Name      : glPixelStorei
 Inputs             : pname, param
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Stores pack and unpack alignment internally.
					  Used for converting texture data to internal format and for 
					  converting readpixel data to external format.
************************************************************************************/

GLAPI void APIENTRY glPixelStorei(GLenum pname, GLint param)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glPixelStorei);

	switch(pname)
	{
		case GL_PACK_ALIGNMENT:
		{
			switch (param) 
			{
				case 1: case 2: case 4: case 8:
					gc->sClientPixel.ui32PackAlignment = (IMG_UINT32)param;
					break;
				default:
bad_value:
					SetError(gc, GL_INVALID_VALUE);
					GLES_TIME_STOP(GLES_TIMES_glPixelStorei);
					return;
			}
			break;
		}
		case GL_UNPACK_ALIGNMENT:
		{
			switch (param) 
			{
				case 1: case 2: case 4: case 8:
					gc->sClientPixel.ui32UnpackAlignment = (IMG_UINT32)param;
					break;
				default:
					goto bad_value;
			}
			break;
		}
		default:
			SetError(gc, GL_INVALID_ENUM);
			GLES_TIME_STOP(GLES_TIMES_glPixelStorei);
			return;
	}

	GLES_TIME_STOP(GLES_TIMES_glPixelStorei);

}

/***********************************************************************************
 Function Name      : ValidateMemory
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : UTILITY: It checks if memory has been invalidated by a power event
						by looking at the dummy texture mem_info
************************************************************************************/

IMG_BOOL ValidateMemory(GLESContext *gc)
{
	GLEStextureManager *psTexMgr = gc->sTexture.psTextureManager;

	if(*psTexMgr->psDummyTexture->pui32Flags & PVRSRV_MEMFLG_MEMORY_NOT_AVAILABLE)
		return IMG_FALSE;
	else
		return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : StartFrame
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Starts a new frame. Initialises registers
************************************************************************************/

static IMG_VOID StartFrame(GLESContext *gc)
{
	PVR3DIF_SHAREDDATA *psSharedData = gc->psRenderSurface->psTARenderInfo->psSharedData;
	GLESDrawableParams *psDrawParams = &gc->sDrawableParams;
	IMG_UINT32 ui32FogColor = gc->sState.sFog.ui32Color;
	IMG_BOOL bPreviousDrawmaskFullScreen = IMG_FALSE;
	PVRSRV_HWREG *psTARegs = gc->sHWContext.sRegisters.psTARegs;
	PVRSRV_HWREG *ps3DRegs = gc->sHWContext.sRegisters.ps3DRegs;
#if defined(OLDPDUMP)
	IMG_UINT32 i=0;
#endif
#if defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)
	IMG_UINT32 ui32RedTemp, ui32BlueTemp;

	/* VGP swizzles colours on output - need to pre-swizzle fog colour first */
	ui32RedTemp = (ui32FogColor & 0x00FF0000) >> 16;
	ui32BlueTemp = (ui32FogColor & 0x000000FF) << 16;
	ui32FogColor = (ui32FogColor & 0xFF00FF00) | ui32RedTemp | ui32BlueTemp;
#endif

	if(gc->ui32FrameEnables & GLES_FS_DITHER_ENABLE)
		ps3DRegs[GLES_SW3DREG_FBCTL].ui32RegVal |= MBX1_FBCTL_DITHER;
	else
		ps3DRegs[GLES_SW3DREG_FBCTL].ui32RegVal &= ~MBX1_FBCTL_DITHER;

	if(gc->psMode->ui32AntiAliasMode)
	{
		IMG_UINT32 ui32XClip, ui32YClip;

		ui32XClip = (psDrawParams->ui32Width << MBX1_TA_XCLIPMAXSHIFT) | (0 << MBX1_TA_XCLIPMINSHIFT);
		ui32YClip = (psDrawParams->ui32Height << MBX1_TA_YCLIPMAXSHIFT) | (0 << MBX1_TA_YCLIPMINSHIFT);

		if((gc->ui32FrameEnables & GLES_FS_MULTISAMPLE_ENABLE) || (gc->sAppHints.i32SceneAntiAlias > 0))
		{
#if defined(SUPPORT_MBX1_LITE)
			if(gc->psMode->ui32AntiAliasMode & (GLES_ANTIALIAS_2x1|GLES_ANTIALIAS_2x2))
			{

				ps3DRegs[GLES_SW3DREG_SCALERCTL].ui32RegVal |= MBX1_SCALERCTL_HSCALE;
				psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal |= MBX1_TACONFIG_SUPERSAMPLEX;
	
				ui32XClip &= MBX1_TA_XCLIPMAXCLR;
				ui32XClip |= (psDrawParams->ui32Width << (MBX1_TA_XCLIPMAXSHIFT + 1));

			}
#else
			if(gc->psMode->ui32AntiAliasMode & (GLES_ANTIALIAS_2x1|GLES_ANTIALIAS_2x2))
			{
				ps3DRegs[GLES_SW3DREG_3DPIXSAMP].ui32RegVal |= MBX1_PIXSAMP_FASTAA;
			}
#endif		
			if(gc->psMode->ui32AntiAliasMode & GLES_ANTIALIAS_2x2)
			{
				ps3DRegs[GLES_SW3DREG_SCALERCTL].ui32RegVal |= MBX1_SCALERCTL_VSCALE;
				psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal |= MBX1_TACONFIG_SUPERSAMPLEY;

				ui32YClip &= MBX1_TA_YCLIPMAXCLR;
				ui32YClip |= (psDrawParams->ui32Height << (MBX1_TA_YCLIPMAXSHIFT + 1));
			}
		}
		else
		{
			ps3DRegs[GLES_SW3DREG_3DPIXSAMP].ui32RegVal &= ~MBX1_PIXSAMP_FASTAA;
			ps3DRegs[GLES_SW3DREG_SCALERCTL].ui32RegVal &= ~(MBX1_SCALERCTL_HSCALE | MBX1_SCALERCTL_VSCALE);
			psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal &= ~(MBX1_TACONFIG_SUPERSAMPLEX | MBX1_TACONFIG_SUPERSAMPLEY);
		}

		GLES_SET_TAREG(psTARegs, XCLIP, ui32XClip);
		GLES_SET_TAREG(psTARegs, YCLIP, ui32YClip);
	}

	if(gc->psRenderSurface->psZBufferMemInfo)
	{
		/* Always Z store if we have an external depth buffer */
		psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal |= MBX1_TACONFIG_ZSTORE;
		ps3DRegs[GLES_SW3DREG_ZLOADSTORE].ui32RegVal |= MBX1_ZLOADSTORE_ZSTORE;

		/* Only Z load if we have no depth clear, or the clear is scissored */
		if(gc->sClear.ui32ClearFlags & GLES_CLEARFLAG_DEPTH && 
			(!(gc->ui32FrameEnables & GLES_FS_SCISSOR_ENABLE) || gc->bFullScreenScissor))
		{
			psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal &= ~MBX1_TACONFIG_ZLOAD;
			ps3DRegs[GLES_SW3DREG_ZLOADSTORE].ui32RegVal &= ~MBX1_ZLOADSTORE_ZLOAD;
		}
		else
		{
			psTARegs[GLES_SWTAREG_CONFIG].ui32RegVal |= MBX1_TACONFIG_ZLOAD;
			ps3DRegs[GLES_SW3DREG_ZLOADSTORE].ui32RegVal |= MBX1_ZLOADSTORE_ZLOAD;
		}
	}
	else
	{
	   /* 
		* The HW does the equivalent of setting a fullscreem drawmask at SOF.
		* Ensure that a valid drawmask is sent at beginning of frame if previous drawmask was not fullscreen.
		*/
		if(!gc->bLastDrawMaskFullScreenEnable)
		{
			gc->sLastDrawMask.ui32Width = 0xFFFFFFFF;
		}

	}

	GLES_SET_3DREG(ps3DRegs, FBSTART, psDrawParams->ui32HWSurfaceAddress);
	GLES_SET_3DREG(ps3DRegs, FOGCOLVERT, ui32FogColor);
	GLES_SET_TAREG(psTARegs, REGION_BASE, psSharedData->asRgnHeaderDevVAddr[psSharedData->ui32CurrentRenderData].uiAddr);
	GLES_SET_3DREG(ps3DRegs, RGNBASE, psSharedData->asRgnHeaderDevVAddr[psSharedData->ui32CurrentRenderData].uiAddr);
	GLES_SET_3DREG(ps3DRegs, 3D_ZL_BACKGROUND_DEPTH, FLOAT_TO_LONG(gc->sClear.fClearDepth) | 0x00000001);

	/* disable render to investigate performance */
	#if !defined(DISABLE_HARDWARE_RENDER)
	/* queue render now in case of TA overflows */
	if(PVRSRVQueueRender(	psDrawParams->psQueueInfo, 
							gc->psRenderSurface->psTARenderInfo,
							&gc->sHWContext.sBGObjInfo,
							(gc->psRenderSurface->psZBufferMemInfo == NULL)
								? IMG_FALSE
								: IMG_TRUE,
							psDrawParams->psSyncInfo,
							0,
							IMG_NULL,
							GLES_COUNT_SW3DREG,
							ps3DRegs) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Schedule render failed"));
	}
	#endif

	/* DumpTARegs */
	WriteHWRegs(gc->sHWContext.psHWInfo->pvRegsBase, GLES_COUNT_SWTAREG, psTARegs);
#ifdef OLDPDUMP

	for(i=0; i< GLES_COUNT_SWTAREG; i++)
	{
		PDUMP_WRITEREG(gc, psTARegs[i].ui32RegAddr, psTARegs[i].ui32RegVal);
	}
#endif


#ifdef FIX_HW_PRN_296
	/* this HW bug results in stream error interrupts persisting after they are handled */
	if(gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D.bLastContextStreamError)
	{
		HostWaitus(1000);
		gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D.bTAStreamErrorInterrupt = IMG_FALSE;
		gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D.bLastContextStreamError = IMG_FALSE;
	}
#endif

	TexMgrAdvanceOneFrame(gc);

	PDUMPREGARRAY(gc->psPDContext, PDUMPTAGS_REG_MBX, psTARegs, GLES_COUNT_SWTAREG);

	gc->psRenderSurface->bInFrame = IMG_TRUE;
	
	/* 
	 * The Z format we have picked contains a viewport bit as well, but the SW BG object must ignore it, 
	 * so we are going to send a fullscreen viewport object, for the SW BG object, then the valid drawmask 
	 * object after that. This is irrespective of whether we did a Zload or not, but contingent only on if we are not
	 * loading z from register as we do with no external zbuffer. 
	 */

	if(gc->psRenderSurface->psZBufferMemInfo)
	{
		bPreviousDrawmaskFullScreen = gc->bLastDrawMaskFullScreenEnable;
		gc->bLastDrawMaskFullScreenEnable = IMG_FALSE;
		SendDrawMaskRect(gc, NULL, IMG_TRUE);
	}

	SendSWBackgroundObject(gc);

	if(gc->psRenderSurface->psZBufferMemInfo)
	{
		if(!bPreviousDrawmaskFullScreen)
		{
			gc->bDrawMaskInvalid = IMG_TRUE;
		}
	}

	gc->sDrawableParams.ui32Stride = psDrawParams->ui32Stride;
	gc->sDrawableParams.pvLinSurfaceAddress = psDrawParams->pvLinSurfaceAddress;
	gc->sDrawableParams.ui32HWSurfaceAddress = psDrawParams->ui32HWSurfaceAddress;
	gc->sDrawableParams.psSyncInfo = psDrawParams->psSyncInfo;

}


/***********************************************************************************
 Function Name      : PrepareToDraw
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Called prior to primitive drawing. Sends required 
					  clears/drawmasks. Starts a frame if appropriate.
************************************************************************************/

IMG_BOOL PrepareToDraw(GLESContext *gc)
{
	GLESDrawableParams *psDrawParams = &gc->sDrawableParams;
	GLESDrawableParams sParams;
	
	GLES_TIME_START(GLES_TIMER_PREPARE_TO_DRAW_TIME);

	if(gc->psRenderSurface->bInFrame)
	{
		/* Placeholder: Acquire the TA/Slaveport */
		if(!GLESAcquireTA(gc, gc->psRenderSurface))