state.c

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

		
	switch (dfactor)
	{
		case GL_ZERO:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDZERO;
			break;
		case GL_ONE:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDONE;
			break;
		case GL_SRC_COLOR:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDSRCCOL;
			break;
		case GL_ONE_MINUS_SRC_COLOR:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDINVSRCCOL;
			break;
		case GL_SRC_ALPHA:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDSRCALPHA;
			break;
		case GL_ONE_MINUS_SRC_ALPHA:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDINVSRCALPHA;
			break;
		case GL_DST_ALPHA:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDDESTALPHA;
			break;
		case GL_ONE_MINUS_DST_ALPHA:
			ui32Dst = MBX1_ISPTSPCTL_DESTBLENDINVDESTALPHA;
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
	}

	if(gc->sState.sRaster.ui32BlendSrcDst != (ui32Src | ui32Dst))
	{
		gc->sState.sRaster.ui32BlendSrcDst = ui32Src | ui32Dst;
		gc->ui32DirtyMask |= GLES_DIRTY_HW_ISPTSP;
	}

	GLES_TIME_STOP(GLES_TIMES_glBlendFunc);
}

/***********************************************************************************
 Function Name      : glCullface
 Inputs             : mode
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets culling face state.
					  Stores cull mode in internal state. Needs to be combined with 
					  frontface direction to give actual cull mode.
************************************************************************************/

GLAPI void APIENTRY glCullFace(GLenum mode)
{
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glCullFace);

	switch (mode)
	{
		case GL_FRONT:
		case GL_BACK:
		case GL_FRONT_AND_BACK:
			if(gc->sState.sPolygon.eCullMode != mode)
			{
				gc->sState.sPolygon.eCullMode = mode;
				gc->ui32DirtyMask |= GLES_DIRTY_SW_CULL;
			}
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
    }

	GLES_TIME_STOP(GLES_TIMES_glCullFace);
}

/***********************************************************************************
 Function Name      : glDepthFunc
 Inputs             : cap
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets depth test compare function.
					  Stored in ISPTSP blend word format. Will be overridden by 
					  Depth Func ALWAYS if depth test is disabled.
************************************************************************************/

GLAPI void APIENTRY glDepthFunc(GLenum cap)
{
	IMG_UINT32 ui32TestFunc;
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glDepthFunc);

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

	ui32TestFunc = ((cap - GL_NEVER) << MBX1_ISPTSPCTL_DCMPMODESHIFT) |
					(gc->sState.sDepth.ui32TestFunc & MBX1_ISPTSPCTL_DWDISABLE);

	if(gc->sState.sDepth.ui32TestFunc != ui32TestFunc)
	{
		gc->sState.sDepth.ui32TestFunc = ui32TestFunc;
		gc->ui32DirtyMask |= GLES_DIRTY_HW_ISPTSP;
	}

	GLES_TIME_STOP(GLES_TIMES_glDepthFunc);
}

/***********************************************************************************
 Function Name      : glFrontFace
 Inputs             : mode
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets winding order for front-face determination.
					  Needs to be combined with cullface state to generate HW cull 
					  mode info.
************************************************************************************/

GLAPI void APIENTRY glFrontFace(GLenum mode)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glFrontFace);
    switch (mode) 
	{
		case GL_CW:
		case GL_CCW:
			if(gc->sState.sPolygon.eFrontFaceDirection != mode)
			{
				gc->sState.sPolygon.eFrontFaceDirection = mode;
				gc->ui32DirtyMask |= GLES_DIRTY_SW_CULL;
			}
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
		return;
    }
	GLES_TIME_STOP(GLES_TIMES_glFrontFace);

}

/***********************************************************************************
 Function Name      : glLogicOp
 Inputs             : opcode
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets frame buffer logical operation mode
					  Stores logical op state in ISPTSP word format. This is then 
					  used based on Blend Enable and Color Mask state. (FB Blending
					  has precedence).
			    		!!MBX does not support Logical ops combined with:
							texture blends other than replace.
							fog
************************************************************************************/

GLAPI void APIENTRY glLogicOp(GLenum opcode)
{
	IMG_UINT32 ui32LogicOp;
    __GL_GET_CONTEXT();

    GLES_TIME_START(GLES_TIMES_glLogicOp);

	switch(opcode)
	{
		case GL_CLEAR:
		case GL_AND:
		case GL_AND_REVERSE:
		case GL_COPY:
		case GL_AND_INVERTED:
		case GL_NOOP:
		case GL_XOR:
		case GL_OR:
		case GL_NOR:
		case GL_EQUIV:
		case GL_INVERT:
		case GL_OR_REVERSE:
		case GL_COPY_INVERTED:
		case GL_OR_INVERTED:
		case GL_NAND:
		case GL_SET:
			ui32LogicOp = (opcode - GL_CLEAR) << MBX1_ISPTSPCTL_LO_SHIFT;
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
	}

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

    GLES_TIME_STOP(GLES_TIMES_glLogicOp);
}

/***********************************************************************************
 Function Name      : glPolygonOffset[x]
 Inputs             : factor, units
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets state for calculating z offset for polygons.
					  Sets z bias in primitive block header. Not fully supported in HW,
					  so use values that "look right". Halflife uses glPolygonOffset 
					  of (1.0,4.0) and (-1.0,-4.0), while Quake 3 uses (-1.0,-2.0).
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
{
	IMG_UINT32 ui32Mode = (units < GLES_Zero) ? MBX1_TAPRIM_ZBIAS_MODEDECREASING : MBX1_TAPRIM_ZBIAS_MODEINCREASING;
	IMG_UINT32 ui32DepthBias = (IMG_UINT32) GLES_ABSF(units * GLES_DEPTHBIAS_STEP);
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glPolygonOffset);

	UNREFERENCED_PARAMETER(factor);

	ui32DepthBias = Clampi((IMG_INT32)ui32DepthBias, 0, MBX1_TAPRIM_ZBIAS_AMOUNTMASK);

	ui32DepthBias = ui32Mode | ((ui32DepthBias & MBX1_TAPRIM_ZBIAS_AMOUNTMASK) << MBX1_TAPRIM_ZBIAS_SHIFT);

	if(gc->sState.sPolygon.ui32DepthBias != ui32DepthBias)
	{
		gc->sState.sPolygon.ui32DepthBias = ui32DepthBias;
		gc->ui32DirtyMask |= GLES_DIRTY_SW_POLYOFFSET;
	}

	GLES_TIME_STOP(GLES_TIMES_glPolygonOffset);
}
#endif

GLAPI void APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units)
{
	IMG_INT32 i32Units = FIXED_TO_LONG(units);
	IMG_UINT32 ui32Mode = (i32Units < 0) ? MBX1_TAPRIM_ZBIAS_MODEDECREASING : MBX1_TAPRIM_ZBIAS_MODEINCREASING;
	IMG_UINT32 ui32DepthBias = GLES_ABS(i32Units * GLES_DEPTHBIAS_STEP);
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glPolygonOffsetx);

	UNREFERENCED_PARAMETER(factor);

	ui32DepthBias = Clampi((IMG_INT32)ui32DepthBias, 0, MBX1_TAPRIM_ZBIAS_AMOUNTMASK);

	ui32DepthBias = ui32Mode | ((ui32DepthBias & MBX1_TAPRIM_ZBIAS_AMOUNTMASK) << MBX1_TAPRIM_ZBIAS_SHIFT);

	if(gc->sState.sPolygon.ui32DepthBias != ui32DepthBias)
	{
		gc->sState.sPolygon.ui32DepthBias = ui32DepthBias;
		gc->ui32DirtyMask |= GLES_DIRTY_SW_POLYOFFSET;
	}

	GLES_TIME_STOP(GLES_TIMES_glPolygonOffsetx);
}

/***********************************************************************************
 Function Name      : glShadeModel
 Inputs             : mode
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets flat shading state for primitives.
					  Controls gouraud shading - sets up ISPTSP word directly.
************************************************************************************/

GLAPI void APIENTRY glShadeModel(GLenum mode)
{
	GLenum eOldMode;
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glShadeModel);

	if ((mode < GL_FLAT) || (mode > GL_SMOOTH)) 
	{
		SetError(gc, GL_INVALID_ENUM);
		return;
    }

	eOldMode = (gc->sHWContext.ui32ISPTSPWord & MBX1_ISPTSPCTL_GOURAUD) ? GL_SMOOTH : GL_FLAT;

	if(eOldMode != mode)
	{
		if(mode == GL_FLAT)
		{
			gc->sHWContext.ui32ISPTSPWord &= ~MBX1_ISPTSPCTL_GOURAUD;
		}
		else
		{
			gc->sHWContext.ui32ISPTSPWord |= MBX1_ISPTSPCTL_GOURAUD;
		}
		gc->ui32DirtyMask |= GLES_DIRTY_HW_ISPTSP;
	}
	GLES_TIME_STOP(GLES_TIMES_glShadeModel);
}

/***********************************************************************************
 Function Name      : glStencilFunc
 Inputs             : func, ref, mask
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets stencil test state.
					  Ignored.
************************************************************************************/

GLAPI void APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
	__GL_GET_CONTEXT();
    
	GLES_TIME_START(GLES_TIMES_glStencilFunc);

	if ((func < GL_NEVER) || (func > GL_ALWAYS)) 
	{
		SetError(gc, GL_INVALID_ENUM);
		return;
    }
	gc->sState.sStencil.eTestFunc = func;
	gc->sState.sStencil.i32Reference = ref;
	gc->sState.sStencil.ui32Mask = mask;
    
	GLES_TIME_STOP(GLES_TIMES_glStencilFunc);
}  

/***********************************************************************************
 Function Name      : glStencilop
 Inputs             : fail, zfail, zpass
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets stencil op state.
					  Ignored.
************************************************************************************/

GLAPI void APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glStencilOp);

    switch (fail) 
	{
		case GL_KEEP: case GL_ZERO: case GL_REPLACE:
		case GL_INCR: case GL_DECR: case GL_INVERT:
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
    }

    switch (zfail) 
	{
		case GL_KEEP: case GL_ZERO: case GL_REPLACE:
		case GL_INCR: case GL_DECR: case GL_INVERT:
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
    }

    switch (zpass) 
	{
		case GL_KEEP: case GL_ZERO: case GL_REPLACE:
		case GL_INCR: case GL_DECR: case GL_INVERT:
			break;
		default:
			SetError(gc, GL_INVALID_ENUM);
			return;
    }

	gc->sState.sStencil.eFail = fail;
	gc->sState.sStencil.eDepthFail = zfail;
	gc->sState.sStencil.eDepthPass = zpass;

	GLES_TIME_STOP(GLES_TIMES_glStencilOp);
}