state.c

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

		{
			ui32RasterEnables &= ~(GLES_RS_TEXTURE0_ENABLE << gc->sState.sTexture.ui32ActiveTexture);
			ui32DirtyBits = GLES_DIRTY_SW_TEXTURE_UNIT | GLES_DIRTY_HW_ISPTSP;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_TEXTURE_2D, Raster);
			goto RASTER_CHECK;
		}
		case GL_DEPTH_TEST:
		{
			if(gc->psMode->bHaveDepthBuffer)
			{
				ui32RasterEnables &= ~GLES_RS_DEPTHTEST_ENABLE;
				ui32DirtyBits = GLES_DIRTY_HW_ISPTSP;
			}
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_DEPTH_TEST, Raster);
			goto RASTER_CHECK;
		}
		case GL_POLYGON_OFFSET_FILL:
		{
			ui32RasterEnables &= ~GLES_RS_POLYOFFSET_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_POLYOFFSET;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_POLYGON_OFFSET_FILL, Raster);
			goto RASTER_CHECK;
		}
		case GL_CULL_FACE:
		{
			ui32TnLEnables &= ~GLES_TL_CULLFACE_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_CULL;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32TnLEnables), ui32TnLEnables, GL_CULL_FACE, TnL);
			goto TNL_CHECK;
		}
		case GL_FOG:
		{
			/* Although fog can be turned on/off per prim, the fog table 
			 * can't be reloaded mid-frame
			 */
			ui32RasterEnables &= ~GLES_RS_FOG_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_FOG | GLES_DIRTY_HW_ISPTSP;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_FOG, Raster);
			goto RASTER_CHECK;
		}
		/*
		 * State which affects vertex processing
		 */
	    case GL_RESCALE_NORMAL:
		{
			ui32TnLEnables &= ~GLES_TL_RESCALE_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LIGHTING;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32TnLEnables), ui32TnLEnables, GL_RESCALE_NORMAL, TnL);
			goto TNL_CHECK;
		}
		case GL_COLOR_MATERIAL:
		{
			ui32TnLEnables &= ~GLES_TL_COLORMAT_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LIGHTING;

			/* 
			 * Need to update material properties with current color when colormaterial is disabled 
			 * (ensures corollary 11 of the spec is enforced - material changes have no effect while colormaterial
			 * is enabled.
			 */
			//Materialfv(gc, GL_FRONT_AND_BACK, gc->sState.sLight.eColorMaterialParam, &gc->sState.sCurrent.asAttrib[AP_COLOR].fX);

			GLES_DIRTY_VGP_CONSTANT(gc, GLES_DIRTY_CONSTANT_COLORMATERIAL);
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32TnLEnables), ui32TnLEnables, GL_COLOR_MATERIAL, TnL);
			goto TNL_CHECK;
		}
		case GL_LIGHTING:
		{
			ui32TnLEnables &= ~GLES_TL_LIGHTING_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LIGHTING;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32TnLEnables), ui32TnLEnables, GL_LIGHTING, TnL);
			goto TNL_CHECK;
		}
		case GL_NORMALIZE:
		{
			ui32TnLEnables &= ~GLES_TL_NORMALIZE_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LIGHTING;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32TnLEnables), ui32TnLEnables, GL_NORMALIZE, TnL);
			goto TNL_CHECK;
		}
		case GL_LIGHT0: case GL_LIGHT1:
		case GL_LIGHT2: case GL_LIGHT3:
		case GL_LIGHT4: case GL_LIGHT5:
		case GL_LIGHT6: case GL_LIGHT7:
		{
			ui32TnLEnables &= ~(GLES_TL_LIGHT0_ENABLE << (cap - GL_LIGHT0));
			ui32DirtyBits = GLES_DIRTY_SW_LIGHT;
			
			/* If our light types change the constants need to be repacked */
			GLES_DIRTY_VGP_CONSTANT(gc,  GLES_DIRTY_CONSTANT_LIGHTS);
			goto TNL_CHECK;
		}
#if defined(SUPPORT_VGP)
		case GL_CLIP_PLANE0:
		case GL_CLIP_PLANE1:
		case GL_CLIP_PLANE2:
		case GL_CLIP_PLANE3:
		case GL_CLIP_PLANE4:
		case GL_CLIP_PLANE5:
		{
			ui32TnLEnables &= ~(GLES_TL_CLIP_PLANE0_ENABLE << (cap - GL_CLIP_PLANE0));
			ui32DirtyBits |= GLES_DIRTY_SW_CLIP_PLANE;
			goto TNL_CHECK;
		}
#endif
#if (defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)) && !defined(PASSTHROUGH_BUILD)
		case GL_VERTEX_PROGRAM_ARB:
		{
			ui32TnLEnables &= ~GLES_TL_VERTEX_PROGRAM_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_VGPPROGRAM | GLES_DIRTY_SW_VGPSECTION;
			goto TNL_CHECK;
		}
#endif
		/*
		 * Whole frame/framebuffer state
		 * Although this state can be turned on/off per prim, 
		 * either we need to special handling or we can only do on a
		 * per frame basis
		 */
		case GL_SCISSOR_TEST:
		{
			if (gc->ui32FrameEnables & GLES_FS_SCISSOR_ENABLE)
			{
				if (gc->sClear.ui32ClearFlags)
				{
					/* If we can't flush clears - just continue to record state. */
					if(PrepareToDraw(gc))
					{
						GLESReleaseTA(gc, IMG_FALSE);
					}
					else
					{
						DPF((DBG_ERROR,"Can't flush clears"));
					}
				}

				gc->bDrawMaskInvalid = IMG_TRUE;				
				ui32FrameEnables &= ~GLES_FS_SCISSOR_ENABLE;
			}
			goto FS_CHECK;
		}
		case GL_DITHER:
		{
			ui32FrameEnables &= ~GLES_FS_DITHER_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32FrameEnables), ui32FrameEnables, GL_DITHER, Frame);
			goto FS_CHECK;
		}
		case GL_MULTISAMPLE:
		{
			ui32FrameEnables &= ~GLES_FS_MULTISAMPLE_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32FrameEnables), ui32FrameEnables, GL_MULTISAMPLE, Frame);
			goto FS_CHECK;
		}
		/*
		 * Unsupported multisample state - not do-able in HW
		 */
		case GL_SAMPLE_ALPHA_TO_COVERAGE:
		{
			ui32IgnoreEnables &= ~GLES_IG_MSALPHACOV_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32IgnoredEnables), ui32IgnoreEnables, GL_SAMPLE_ALPHA_TO_COVERAGE, Ignore);
			goto IGNORE_CHECK;
		}
		case GL_SAMPLE_ALPHA_TO_ONE:
		{
			ui32IgnoreEnables &= ~GLES_IG_MSSAMPALPHA_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32IgnoredEnables), ui32IgnoreEnables, GL_SAMPLE_ALPHA_TO_ONE, Ignore);
			goto IGNORE_CHECK;
		}
		case GL_SAMPLE_COVERAGE:
		{
			ui32IgnoreEnables &= ~GLES_IG_MSSAMPCOV_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32IgnoredEnables), ui32IgnoreEnables, GL_SAMPLE_COVERAGE, Ignore);
			goto IGNORE_CHECK;
		}
		/*
		 * Unsupported, but not exported
		 */ 
		case GL_STENCIL_TEST:
		{
			ui32IgnoreEnables &= ~GLES_IG_STENCILTEST_ENABLE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32IgnoredEnables), ui32IgnoreEnables, GL_STENCIL_TEST, Ignore);
			goto IGNORE_CHECK;
		}
		/*
		 * Unsupported per-primitive state, and not do-able in HW
		 */ 
		case GL_LINE_SMOOTH:
		{
			ui32RasterEnables &= ~GLES_RS_LINESMOOTH_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LINEPOINTSIZE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_LINE_SMOOTH, Raster);
			goto RASTER_CHECK;
		}
		case GL_POINT_SMOOTH:
		{
			ui32RasterEnables &= ~GLES_RS_POINTSMOOTH_ENABLE;
			ui32DirtyBits = GLES_DIRTY_SW_LINEPOINTSIZE;
			GLES_PROFILE_ADD_REDUNTANT_STATE(__GC(ui32RasterEnables), ui32RasterEnables, GL_POINT_SMOOTH, Raster);
			goto RASTER_CHECK;
		}
		/*
		 * Set error value, not an OGL-ES state
		 */
		default:
		{
			SetError(gc, GL_INVALID_ENUM);

			GLES_TIME_STOP(GLES_TIMES_glDisable);

			return;
		}
    }

 RASTER_CHECK:
	if(gc->ui32RasterEnables != ui32RasterEnables)
	{
		gc->ui32RasterEnables = ui32RasterEnables;
		gc->ui32DirtyMask |= ui32DirtyBits;
	}

	GLES_TIME_STOP(GLES_TIMES_glDisable);

	return;

 TNL_CHECK:
	if(gc->ui32TnLEnables != ui32TnLEnables)
	{
		gc->ui32TnLEnables = ui32TnLEnables;
		gc->ui32DirtyMask |= ui32DirtyBits;
	}

	GLES_TIME_STOP(GLES_TIMES_glDisable);

	return;

 FS_CHECK:
	__GC(ui32FrameEnables) = ui32FrameEnables;

	GLES_TIME_STOP(GLES_TIMES_glDisable);

	return;

 IGNORE_CHECK:
	__GC(ui32IgnoredEnables) = ui32IgnoreEnables;

	GLES_TIME_STOP(GLES_TIMES_glDisable);

	return;
}

/***********************************************************************************
 Function Name      : glAlphaFunc[x]
 Inputs             : func, ref
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets alpha test reference value and compare function.
					  Stored directly in TSP object word.
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glAlphaFunc(GLenum func, GLclampf ref)
{
	IMG_UINT32 ui32AlphaRef;
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glAlphaFunc);

    if ((func < GL_NEVER) || (func > GL_ALWAYS)) 
	{
		SetError(gc, GL_INVALID_ENUM);
		return;
    }

	/* Need to multiply by 256 to pass conformance test (apfunc.c),
	 * this is because colourconvert is now more sensitive and has the same conversion
	 * This implies that a post-clamp is necessary
	 */
	ui32AlphaRef = (IMG_UINT32)(Clampf(ref, GLES_Zero, GLES_One) * 256.0f);
	
	ui32AlphaRef = ui32AlphaRef & 0x100 ? 0xFF : ui32AlphaRef;

	ui32AlphaRef = (ui32AlphaRef << MBX1_TSPOBJ_ALPHAREFSHIFT) | 
					((func - GL_NEVER) << MBX1_TSPOBJ_ALPHACMPSHIFT);

	if(gc->sState.sRaster.ui32AlphaFuncRef != ui32AlphaRef)
	{
		gc->sState.sRaster.ui32AlphaFuncRef = ui32AlphaRef;
		gc->ui32DirtyMask |= (GLES_DIRTY_HW_ISPTSP|GLES_DIRTY_HW_TSPOBJECT);
	}

	GLES_TIME_STOP(GLES_TIMES_glAlphaFunc);
}
#endif

GLAPI void APIENTRY glAlphaFuncx(GLenum func, GLclampx ref)
{
	IMG_UINT32 ui32AlphaRef;
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glAlphaFuncx);

    if ((func < GL_NEVER) || (func > GL_ALWAYS)) 
	{
		SetError(gc, GL_INVALID_ENUM);
		return;
    }

	/* Need to multiply by 256 to pass conformance test (apfunc.c),
	 * this is because colourconvert is now more sensitive and has the same conversion
	 * This implies that a post-clamp is necessary
	 */
	ui32AlphaRef = (IMG_UINT32)(Clampf(FIXED_TO_FLOAT(ref), GLES_Zero, GLES_One) * 256.0f);
	
	ui32AlphaRef = ui32AlphaRef & 0x100 ? 0xFF : ui32AlphaRef;

	ui32AlphaRef = (ui32AlphaRef << MBX1_TSPOBJ_ALPHAREFSHIFT) | 
					((func - GL_NEVER) << MBX1_TSPOBJ_ALPHACMPSHIFT);

	if(gc->sState.sRaster.ui32AlphaFuncRef != ui32AlphaRef)
	{
		gc->sState.sRaster.ui32AlphaFuncRef = ui32AlphaRef;
		gc->ui32DirtyMask |= (GLES_DIRTY_HW_ISPTSP|GLES_DIRTY_HW_TSPOBJECT);
	}

	GLES_TIME_STOP(GLES_TIMES_glAlphaFuncx);
}

/***********************************************************************************
 Function Name      : glBlendFunc
 Inputs             : sfactor, dfactor
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets blend function source and dest factors.
					  Stores blend state in ISPTSP blend word format. This is then 
					  used based on Blend Enable and Color Mask state. 
					  MBX does not support GL_SRC_ALPHA_SATURATE.
************************************************************************************/

GLAPI void APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
{
	IMG_UINT32 ui32Src, ui32Dst;
    __GL_GET_CONTEXT();
	
	GLES_TIME_START(GLES_TIMES_glBlendFunc);

	switch (sfactor) 
	{
		case GL_ZERO:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDZERO;
			break;
		case GL_ONE:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDONE;
			break;
		case GL_DST_COLOR:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDDESTCOL;
			break;
		case GL_ONE_MINUS_DST_COLOR:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDINVDESTCOL;
			break;
		case GL_SRC_ALPHA:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDSRCALPHA;
			break;
		case GL_ONE_MINUS_SRC_ALPHA:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDINVSRCALPHA;
			break;
		case GL_DST_ALPHA:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDDESTALPHA;
			break;
		case GL_ONE_MINUS_DST_ALPHA:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDINVDESTALPHA;
			break;
		/* Not correctly supported */
		case GL_SRC_ALPHA_SATURATE:
			ui32Src = MBX1_ISPTSPCTL_SRCBLENDSRCALPHA;
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
	}