misc.c

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

			}
			else
			{
				gc->sState.sHints.ui32FastPath &= ~GLES_HINT_NO_CLIPVOLUME;
			}
			break;
		case GL_VERTICES_IN_DEVICE_COORDS_IMG:
			if(mode == GL_FASTEST)
			{
				gc->sState.sHints.ui32FastPath |= GLES_HINT_NO_VPTRANSFORM;
			}
			else
			{
				gc->sState.sHints.ui32FastPath &= ~GLES_HINT_NO_VPTRANSFORM;
			}
			break;
#endif
		default:
			SetError(gc, GL_INVALID_ENUM);
			GLES_TIME_STOP(GLES_TIMES_glHint);
			return;
    }

	GLES_TIME_STOP(GLES_TIMES_glHint);
}

/***********************************************************************************
 Function Name      : glLineWidth(x)
 Inputs             : width
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets current line width state
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glLineWidth(GLfloat width)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glLineWidth);

    if (width <= 0) 
	{
		SetError(gc, GL_INVALID_VALUE);
		GLES_TIME_STOP(GLES_TIMES_glLineWidth);
		return;
    }
		
	/* HW uses 1/2 line width */
	gc->sState.sLine.fSmoothWidth = Clampf(width, (IMG_FLOAT)GLES_SMOOTH_LINE_WIDTH_MIN, (IMG_FLOAT)GLES_SMOOTH_LINE_WIDTH_MAX) / 2.0f;
	gc->sState.sLine.fAliasedWidth = Clampf(width, (IMG_FLOAT)GLES_ALIASED_LINE_WIDTH_MIN, (IMG_FLOAT)GLES_ALIASED_LINE_WIDTH_MAX) / 2.0f;

	GLES_TIME_STOP(GLES_TIMES_glLineWidth);
}
#endif

GLAPI void APIENTRY glLineWidthx(GLfixed width)
{
	IMG_UINT32 ui32Width = FIXED_TO_LONG(width);
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glLineWidthx);

	if (ui32Width <= 0) 
	{
		SetError(gc, GL_INVALID_VALUE);
		GLES_TIME_STOP(GLES_TIMES_glLineWidthx);
		return;
    }
	
	/* HW uses 1/2 line width */
	gc->sState.sLine.fSmoothWidth = (IMG_FLOAT)Clampi((IMG_INT32)ui32Width, GLES_SMOOTH_LINE_WIDTH_MIN,
													GLES_SMOOTH_LINE_WIDTH_MAX) / 2.0f;
	
	gc->sState.sLine.fAliasedWidth = (IMG_FLOAT)Clampi((IMG_INT32)ui32Width, GLES_ALIASED_LINE_WIDTH_MIN,
													GLES_ALIASED_LINE_WIDTH_MAX) / 2.0f;

	GLES_TIME_STOP(GLES_TIMES_glLineWidthx);
}

/***********************************************************************************
 Function Name      : PointSize
 Inputs             : gc, fSize
 Outputs            : -
 Returns            : -
 Description        : UTILITY: Sets current point size state
************************************************************************************/

IMG_VOID PointSize(GLESContext *gc, IMG_FLOAT fPointSize)
{
	IMG_FLOAT fSize;
	IMG_UINT32 ui32Size;

	if (fPointSize <= 0) 
	{
		SetError(gc, GL_INVALID_VALUE);
		return;
    }

	gc->sState.sPoint.fRequestedSize = fPointSize;

	fSize = Clampf(fPointSize, (IMG_FLOAT)GLES_SMOOTH_POINT_SIZE_MIN, 
								(IMG_FLOAT)GLES_SMOOTH_POINT_SIZE_MAX);

	/* HW uses 1/2 point size */
	gc->sState.sPoint.fSmoothSize = fSize / 2.0f;
	
	fSize = Clampf(fPointSize, (IMG_FLOAT)GLES_ALIASED_POINT_SIZE_MIN, 
								(IMG_FLOAT)GLES_ALIASED_POINT_SIZE_MAX);

	/* Aliased point size is rounded to nearest integer */
	ui32Size = (IMG_UINT32) (GLES_Half + fSize);

	/* HW uses 1/2 point size */
	gc->sState.sPoint.fAliasedSize = ui32Size / 2.0f;
}

/***********************************************************************************
 Function Name      : glPointSize(x)
 Inputs             : size
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Sets current point size state
************************************************************************************/
#if defined(PROFILE_COMMON)

GLAPI void APIENTRY glPointSize(GLfloat size)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glPointSize);

	PointSize(gc, size);

	GLES_TIME_STOP(GLES_TIMES_glPointSize);
}
#endif

GLAPI void APIENTRY glPointSizex(GLfixed size)
{
    __GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glPointSizex);

	PointSize(gc, FIXED_TO_FLOAT(size));

	GLES_TIME_STOP(GLES_TIMES_glPointSizex);
}

/***********************************************************************************
 Function Name      : ConvertToFixedWithMantissa
 Inputs             : fVal
 Outputs            : pi32Mantissa, pi32Exponent
 Returns            : Invalidity
 Description        : UTILITY: Converts a float into a fixed point mantissa and exponent
************************************************************************************/

static IMG_BOOL ConvertToFixedWithMantissa(IMG_FLOAT fVal, GLfixed *pi32Mantissa, GLint *pi32Exponent)
{
	IMG_INT32 i32Exp;
	IMG_FLOAT fMantissa;
	
	//fMantissa = GLES_FREXP(fVal, &i32Exp);
	fMantissa = fMantissa * 2147483648.0f; /* (ie shift by 31) */

	*pi32Mantissa = (GLint) fMantissa;
	*pi32Exponent = i32Exp - 15;

	if(fMantissa != fMantissa) 
		return IMG_TRUE;		/* fail on NaN, also could use isNan(mantissa) */
								/* should also fail on inf or failure of frexp */
	return IMG_FALSE;
}

/***********************************************************************************
 Function Name      : glQueryMatrixxOES
 Inputs             : mantissa, exponent
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Queries the current matrix in fixed form
************************************************************************************/

GLAPI GLbitfield APIENTRY glQueryMatrixxOES (GLfixed mantissa[16], GLint exponent[16])
{
#if 0
    GLESmatrix *psMatrix;
	IMG_UINT32 i;
	IMG_BOOL bInvalid;
	IMG_UINT32 ui32Invalid;
	IMG_FLOAT *pfMatrix;

    __GL_GET_CONTEXT_RETURN();

	GLES_TIME_START(GLES_TIMES_glQueryMatrixx);
 
	switch (gc->sState.eMatrixMode) 
	{
		case GL_MODELVIEW:
		default:
			psMatrix = &gc->sTransform.psModelView->sMatrix;
			break;
		case GL_PROJECTION:
			psMatrix = &gc->sTransform.psProjection->sMatrix;
			break;			
		case GL_TEXTURE:
			psMatrix = &gc->sTransform.apsTexture[gc->sState.sTexture.ui32ActiveTexture]->sMatrix;
			break;
#if (defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)) && !defined(PASSTHROUGH_BUILD)
		case GL_MATRIX0_ARB: case GL_MATRIX1_ARB: case GL_MATRIX2_ARB: case GL_MATRIX3_ARB:
		case GL_MATRIX4_ARB: case GL_MATRIX5_ARB: case GL_MATRIX6_ARB: case GL_MATRIX7_ARB:			
			psMatrix = &gc->sTransform.apsProgram[gc->sState.eMatrixMode - GL_MATRIX0_ARB]->sMatrix;
			break;
#endif
	}

	pfMatrix = &psMatrix->afMatrix[0][0];
	ui32Invalid = 0;

	for(i=0; i< 16; i++)
	{
		bInvalid = ConvertToFixedWithMantissa(pfMatrix[i], &mantissa[i], &exponent[i]);

		ui32Invalid |= (bInvalid << i);
	}

	GLES_TIME_STOP(GLES_TIMES_glQueryMatrixx);

	return ui32Invalid;
#endif
   return 0;
}


/***********************************************************************************
 Function Name      : SetError
 Inputs             : code
 Outputs            : -
 Returns            : -
 Description        : UTILTIY: Sets current error with code.
************************************************************************************/
IMG_VOID SetError(GLESContext *gc, GLenum code)
{
    if (!gc->i32Error) 
	{
		gc->i32Error = code;
    }
}

/***********************************************************************************
 Function Name      : GetApplicationHints
 Inputs             : -
 Outputs            : psAppHints
 Returns            : -
 Description        : UTILTIY: Gets application hints.
************************************************************************************/

IMG_BOOL GetApplicationHints (GLESAppHints *psAppHints)
{
	IMG_UINT32 ui32Default = 0;

	PVRSRVGetAppHint (IMG_OPENGLES, 0, "ForceExternalZBuffer", &psAppHints->bForceExternalZBuffer, 
                      IMG_UINT_TYPE, &ui32Default);

	ui32Default = 0xFFFFFFFF;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "SceneAntiAlias", &psAppHints->i32SceneAntiAlias, 
                      IMG_INT_TYPE, &ui32Default);

	ui32Default = GLES_MAX_PARAMBUFF_SIZE;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "ParameterBufferSize", &psAppHints->ui32ParameterBufferSize, 
                      IMG_UINT_TYPE, &ui32Default);
	
	ui32Default = 1;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "VSyncLocked", &psAppHints->bLockToVSync, 
                      IMG_UINT_TYPE, &ui32Default);

	ui32Default = 0;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "DumpProfileData", &psAppHints->bDumpProfileData, 
                      IMG_UINT_TYPE, &ui32Default);

	ui32Default = 0;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "ProfileStartFrame", &psAppHints->ui32ProfileStartFrame, 
                      IMG_UINT_TYPE, &ui32Default);

	ui32Default = 0xFFFFFFFF;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "ProfileEndFrame", &psAppHints->ui32ProfileEndFrame, 
                     IMG_UINT_TYPE, &ui32Default);


	ui32Default = 0x2;
	PVRSRVGetAppHint (IMG_OPENGLES, 0, "BackBuffers", &psAppHints->ui32BackBuffers, 
                      IMG_UINT_TYPE, &ui32Default);

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : BuildExtensionString
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : UTILITY: It builds an extension string from from different sources
************************************************************************************/
IMG_VOID BuildExtensionString(GLESContext *gc)
{
	const IMG_CHAR *pszExternalExtensionString;
	IMG_UINT32 ui32Length, i;

	DPF((DBG_VERBOSE, "BuildExtensionString"));

	ui32Length = 1;

	/* First add the the IMG extensions */
	for(i = 0 ; i < GLES_MAX_IMG_EXTENSIONS; i++)
	{
		if(GLESExtension[i].ui32ExtensionFlag & ui32ExtensionFlag)
		{
			ui32Length += strlen(GLESExtension[i].pszExtensionName);
		}
	}

	gc->pszExtensions = (IMG_CHAR*) GLESCalloc(gc, ui32Length * sizeof(IMG_CHAR));
	GLES_ASSERT(gc->pszExtensions);

	/* First add the the IMG extensions */
	for(i = 0 ; i < GLES_MAX_IMG_EXTENSIONS; i++)
	{
		if(GLESExtension[i].ui32ExtensionFlag & ui32ExtensionFlag)
		{
			strcat(gc->pszExtensions, GLESExtension[i].pszExtensionName);
		}
	}

	/* Then add other companies extensions */
	pszExternalExtensionString = GetExternalExtensionString();
	
	if(pszExternalExtensionString)
	{
		ui32Length += strlen(pszExternalExtensionString) + 2;
		gc->pszExtensions = (IMG_CHAR*)GLESRealloc(gc, gc->pszExtensions, ui32Length * sizeof(IMG_CHAR));
		strcat(gc->pszExtensions, " ");
		strcat(gc->pszExtensions, pszExternalExtensionString);
	}
}

/***********************************************************************************
 Function Name      : DestroyExtensionString
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : UTILITY: It destroys the previously built extension string
************************************************************************************/
IMG_VOID DestroyExtensionString(GLESContext *gc)
{
	if(gc->pszExtensions)
	{
		GLESFree(gc, gc->pszExtensions);
	}
}


/***********************************************************************************
 Function Name      : __GetProcAddress
 Inputs             : procname
 Outputs            : -
 Returns            : -
 Description        : UTILITY: It returns a function address if procname is valid
************************************************************************************/
typedef void (*GL_PROC)(IMG_VOID);

void (* __GetProcAddress (const char *procname))(IMG_VOID)
{
	/* those are the extensions that our driver exports */
#if defined(SUPPORT_VGP)
#if defined(PROFILE_COMMON)
	if(!strcmp(procname, "glClipPlanefIMG"))
	{
		return (GL_PROC)glClipPlanefIMG;
	}
#endif
	if(!strcmp(procname, "glClipPlanexIMG"))
	{
		return (GL_PROC)glClipPlanexIMG;
	}
#endif /* SUPPORT_VGP */

#if (defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)) && !defined(PASSTHROUGH_BUILD)

#if defined(PROFILE_COMMON)
	if(!strcmp(procname, "glVertexAttrib4fARB"))
	{
		return (GL_PROC)glVertexAttrib4fARB;
	}
	if(!strcmp(procname, "glProgramEnvParameter4fARB"))
	{
		return (GL_PROC)glProgramEnvParameter4fARB;
	}
	if(!strcmp(procname, "glProgramEnvParameter4fvARB"))
	{
		return (GL_PROC)glProgramEnvParameter4fvARB;
	}
	if(!strcmp(procname, "glProgramLocalParameter4fARB"))
	{
		return (GL_PROC)glProgramLocalParameter4fARB;
	}
	if(!strcmp(procname, "glProgramLocalParameter4fvARB"))
	{
		return (GL_PROC)glProgramLocalParameter4fvARB;
	}
#endif
	if(!strcmp(procname, "glVertexAttrib4xIMG"))
	{
		return (GL_PROC)glVertexAttrib4xIMG;
	}

	if(!strcmp(procname, "glProgramLocalParameter4xIMG"))
	{
		return (GL_PROC)glProgramLocalParameter4xIMG;
	}
	if(!strcmp(procname, "glProgramLocalParameter4xvIMG"))
	{
		return (GL_PROC)glProgramLocalParameter4xvIMG;
	}
	if(!strcmp(procname, "glProgramEnvParameter4xIMG"))
	{
		return (GL_PROC)glProgramEnvParameter4xIMG;
	}
	if(!strcmp(procname, "glProgramEnvParameter4xvIMG"))
	{
		return (GL_PROC)glProgramEnvParameter4xvIMG;
	}
	if(!strcmp(procname, "glVertexAttribPointerARB"))
	{
		return (GL_PROC)glVertexAttribPointerARB;
	}
	if(!strcmp(procname, "glEnableVertexAttribArrayARB"))
	{
		return (GL_PROC)glEnableVertexAttribArrayARB;
	}
	if(!strcmp(procname, "glDisableVertexAttribArrayARB"))
	{
		return (GL_PROC)glDisableVertexAttribArrayARB;
	}
	if(!strcmp(procname, "glProgramStringARB"))
	{
		return (GL_PROC)glProgramStringARB;
	}
	if(!strcmp(procname, "glBindProgramARB"))
	{
		return (GL_PROC)glBindProgramARB;
	}
	if(!strcmp(procname, "glDeleteProgramsARB"))
	{
		return (GL_PROC)glDeleteProgramsARB;
	}
	if(!strcmp(procname, "glGenProgramsARB"))
	{
		return (GL_PROC)glGenProgramsARB;
	}

#endif /* SUPPORT_VGP || SUPPORT_VGP_LITE */

	/* get external entry points */
	return GetExternalProcAddress(procname);
}

/*****************************************************************************
 End of file (misc.c)
*****************************************************************************/