vprogram.c

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

		GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4x);
		return;
	}

	gc->sState.sVertexProgram.asEnvParam[index].fX = FIXED_TO_FLOAT(x);
	gc->sState.sVertexProgram.asEnvParam[index].fY = FIXED_TO_FLOAT(y);
	gc->sState.sVertexProgram.asEnvParam[index].fZ = FIXED_TO_FLOAT(z);
	gc->sState.sVertexProgram.asEnvParam[index].fW = FIXED_TO_FLOAT(w);

	gc->sState.sVertexProgram.ui32EnvParamDirtyMask |= (GLES_PROGRAM_ENV_REQUIRED << index);

	GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4x);
}

/***********************************************************************************
 Function Name      : glProgramEnvParameter4xvIMG
 Inputs             : target, index, params
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Specifies program environment constant value 
					  specified by index
************************************************************************************/

GLAPI_EXT void APIENTRY glProgramEnvParameter4xvIMG(GLenum target, GLuint index, const GLfixed *params)
{
	__GL_GET_CONTEXT();

	GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4xv);

	if(target != GL_VERTEX_PROGRAM_ARB)
	{
		SetError(gc, GL_INVALID_ENUM);
		GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4xv);
		return;
	}

	/* Check if index is out of range */
	if(index >= GLES_MAX_PROGRAM_ENV_PARAMS)
	{
		SetError(gc, GL_INVALID_VALUE);
		GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4xv);
		return;
	}

	gc->sState.sVertexProgram.asEnvParam[index].fX = FIXED_TO_FLOAT(params[0]);
	gc->sState.sVertexProgram.asEnvParam[index].fY = FIXED_TO_FLOAT(params[1]);
	gc->sState.sVertexProgram.asEnvParam[index].fZ = FIXED_TO_FLOAT(params[2]);
	gc->sState.sVertexProgram.asEnvParam[index].fW = FIXED_TO_FLOAT(params[3]);

	gc->sState.sVertexProgram.ui32EnvParamDirtyMask |= (GLES_PROGRAM_ENV_REQUIRED << index);

	GLES_TIME_START(GLES_TIMES_glProgramEnvParameter4xv);
}


/***********************************************************************************
 Function Name      : glEnableVertexAttribArrayARB
 Inputs             : array
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Enables attrib array specified by index
************************************************************************************/

GLAPI_EXT void APIENTRY glEnableVertexAttribArrayARB(GLuint index)
{
	__GL_GET_CONTEXT();
    
	GLES_TIME_START(GLES_TIMES_glEnableVertexAttribArray);

	if(index >= GLES_MAX_VERTEX_ATTRIBS)
	{
		SetError(gc, GL_INVALID_VALUE);
		GLES_TIME_STOP(GLES_TIMES_glEnableVertexAttribArray);
		return;
	}

	if (gc->sVertexArray.ui32ArrayEnables & (VARRAY_ATTRIB0_ENABLE << index))
	{
		GLES_TIME_STOP(GLES_TIMES_glEnableVertexAttribArray);
		return;
	}

	gc->sVertexArray.ui32ArrayEnables |= (VARRAY_ATTRIB0_ENABLE << index);

	gc->ui32DirtyMask |= GLES_DIRTY_SW_VARRAY;

	GLES_TIME_STOP(GLES_TIMES_glEnableVertexAttribArray);
}

/***********************************************************************************
 Function Name      : glDisableVertexAttribArrayARB
 Inputs             : array
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Disables attrib array specified by index
************************************************************************************/

GLAPI_EXT void APIENTRY glDisableVertexAttribArrayARB(GLuint index)
{
	__GL_GET_CONTEXT();
    
	GLES_TIME_START(GLES_TIMES_glDisableVertexAttribArray);

	if(index >= GLES_MAX_VERTEX_ATTRIBS)
	{
		SetError(gc, GL_INVALID_VALUE);
		GLES_TIME_STOP(GLES_TIMES_glDisableVertexAttribArray);
		return;
	}

	if (!(gc->sVertexArray.ui32ArrayEnables & (VARRAY_ATTRIB0_ENABLE << index)))
	{
		GLES_TIME_STOP(GLES_TIMES_glDisableVertexAttribArray);
		return;
	}

	gc->sVertexArray.ui32ArrayEnables &= ~(VARRAY_ATTRIB0_ENABLE << index);

	gc->ui32DirtyMask |= GLES_DIRTY_SW_VARRAY;

	GLES_TIME_STOP(GLES_TIMES_glDisableVertexAttribArray);
}

/***********************************************************************************
 Function Name      : glProgramStringARB
 Inputs             : target, format, len, string
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Specified the program binary string for the 
					  currently bound program
************************************************************************************/

GLAPI_EXT void APIENTRY glProgramStringARB(GLenum target, GLenum format, GLsizei len, 
									   const void *string)
{
	GLESVertexProgram *psProgram;
	GLESVPHeader *psHeader;
	GLESVPHeader2 *psInfo;
	IMG_VOID *pvCode;
	IMG_UINT32 ui32ConstantIndex, ui32LocalEnvIndex;
	IMG_UINT32 i, ui32StateIndex;
	GLESVPBindingInput *psBinding, *psBindingList;
	IMG_UINT auVGPWordCount[4] = {0, 0, 0, 0};
	IMG_UINT auVGPEndianIndex[4];
	IMG_CHAR *psProgramString;
	IMG_UINT32 ui32MatrixNumber, ui32MatrixRow, ui32LayerNumber;

	__GL_GET_CONTEXT();
    
	GLES_TIME_START(GLES_TIMES_glProgramString);

	if(target != GL_VERTEX_PROGRAM_ARB)
	{
		SetError(gc, GL_INVALID_ENUM);
		GLES_TIME_STOP(GLES_TIMES_glProgramString);
		return;
	}

	/* Check if index is out of range */
	if(format != GL_PROGRAM_FORMAT_BINARY_IMG)
	{
		SetError(gc, GL_INVALID_ENUM);
		GLES_TIME_STOP(GLES_TIMES_glProgramString);
		return;
	}

	psProgram = gc->sVertexProgram.psCurrentProgram;
	psProgram->bValid = IMG_FALSE;

	psHeader = (GLESVPHeader *)string;

	/* 
	   Check for presence of 'VGP ' at start of the data.
	   Due to endian issues it may not be in 'V','G','P',' ' order so we must check for all 
	   variants. The order in which it is found will determine how the data in the file is unpacked.
	*/
	for (i = 0; i < 4; i++)
	{
		IMG_CHAR cLetter = (IMG_CHAR)((psHeader->ui32MagicID >> (i * 8)) & 0xFF);
 
		switch (cLetter)
		{
			case 'V':
				auVGPWordCount[0]++;
				auVGPEndianIndex[0] = i;
				break;
			case 'G':
				auVGPWordCount[1]++;
				auVGPEndianIndex[1] = i;
				break;
			case 'P':
				auVGPWordCount[2]++;
				auVGPEndianIndex[2] = i;
				break;
			case ' ':
				auVGPWordCount[3]++;
				auVGPEndianIndex[3] = i;
				break;
			default:
				SetError(gc, GL_INVALID_OPERATION);
				GLES_TIME_STOP(GLES_TIMES_glProgramString);
				return;
		}
	}
	/* Check all chars of 'VGP ' were present */
	if (auVGPWordCount[0] != 1 ||
		auVGPWordCount[1] != 1 ||
		auVGPWordCount[2] != 1 ||
		auVGPWordCount[3] != 1)
	{
bad_op:
		SetError(gc, GL_INVALID_OPERATION);
		GLES_TIME_STOP(GLES_TIMES_glProgramString);
		return;
	}

	psProgramString = (IMG_CHAR *)string;

	/* Was the endian format used to create the file different from the current one? */
	if (auVGPEndianIndex[0] != 0 ||
		auVGPEndianIndex[1] != 1 ||
		auVGPEndianIndex[2] != 2 ||
		auVGPEndianIndex[3] != 3)
	{
		/* Create a copy of the string */
		IMG_CHAR *psNewString = GLESMalloc(gc, sizeof(IMG_CHAR) * len);

		HostMemCopy(psNewString, psProgramString, sizeof(IMG_CHAR) * len); 

		/* Copy the string back to the original in the natively supported endian format */
		for (i = 0; i < (IMG_UINT32)len; i+= 4)
		{
			psProgramString[i + 0] = psNewString[i + auVGPEndianIndex[0]];
			psProgramString[i + 1] = psNewString[i + auVGPEndianIndex[1]];
			psProgramString[i + 2] = psNewString[i + auVGPEndianIndex[2]];
			psProgramString[i + 3] = psNewString[i + auVGPEndianIndex[3]];
		}

		GLESFree(gc, psNewString);
	}

	if(psHeader->ui8VersionMinor != 1 || psHeader->ui8VersionMajor != 1)
	{
		goto bad_op;
	}

	if(psHeader->ui32CodeSize > GLES_MAX_VGP_INSTRUCTIONS)
	{
		goto bad_op;
	}

	psProgram->ui32CodeSizeInBytes = psHeader->ui32CodeSize * 2 * sizeof(IMG_UINT32);

	for(i=0; i < MBX1_VGPCODE_SECTION_COUNT; i++)
		psProgram->aui32SectionDefinitions[i] = psHeader->aui32Sections[i];

	/* Just throw away old program */
	if(psProgram->pui32Code)
		GLESFree(gc, (IMG_VOID *)psProgram->pui32Code);

	psProgram->pui32Code = GLESCalloc(gc, psProgram->ui32CodeSizeInBytes);

	pvCode = (IMG_UINT8 *)string + sizeof(GLESVPHeader);

	HostMemCopy((IMG_VOID *)psProgram->pui32Code, pvCode, psProgram->ui32CodeSizeInBytes);

	psInfo = (GLESVPHeader2 *)((IMG_UINT8 *)pvCode + psProgram->ui32CodeSizeInBytes);

	psProgram->sInfo.ui32Flags = psInfo->ui32Flags;
	psProgram->sInfo.ui32NumBindings = psInfo->ui32NumBindings;

#if defined(SUPPORT_VGP_LITE)
	if(((psProgram->sInfo.ui32Flags & VGPFLAGS_TYPE_MASK) >> VGPFLAGS_TYPE_SHIFT) == VGPFLAGS_TYPE_STANDARD)
	{
		goto bad_op;
	}
#else
	if(((psProgram->sInfo.ui32Flags & VGPFLAGS_TYPE_MASK) >> VGPFLAGS_TYPE_SHIFT) == VGPFLAGS_TYPE_VGPLITE)
	{
		goto bad_op;
	}
#endif

#if defined(FIX_HW_PRN_81)
	if(((psProgram->sInfo.ui32Flags & VGPFLAGS_PLATFORM_MASK) >> VGPFLAGS_PLATFORM_SHIFT) == VGPFLAGS_PLATFORM_GENERIC)
	{
		goto bad_op;
	}
#else
	if(((psProgram->sInfo.ui32Flags & VGPFLAGS_PLATFORM_MASK) >> VGPFLAGS_PLATFORM_SHIFT) == VGPFLAGS_PLATFORM_ARMVP)
	{
		goto bad_op;
	}
#endif

	/* Sense of section description is wrong way round - reconfigure */
	for(i = 0;i < VGP_VERTPROG_NUM_SECTIONS; i++)
	{
		if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_PASSTHROUGH)
		{
			psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_PASSTHROUGH] = i;	
			break;
		}
	}

	/* Sense of section description is wrong way round - reconfigure */
	for(i = 0;i < VGP_VERTPROG_NUM_SECTIONS; i++)
	{
		if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_USERCODE)
		{
			psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_USERCODE] = i;	
			break;
		}
	}

	if(psProgram->sInfo.ui32Flags & (VGPFLAGS_SECTIONTYPE_TEXLAYER1REDIRECT << VGPFLAGS_SECTIONTYPE_SHIFT))
	{
		/* Sense of section description is wrong way round - reconfigure */
		for(i = 0;i < VGP_VERTPROG_NUM_SECTIONS; i++)
		{
			if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_TEXLAYER1REDIRECT)
			{
				psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_TEXLAYER1REDIRECT] = i;	
				break;
			}
		}
		psProgram->bRedirectSectionPresent = IMG_TRUE;
	}

	if(psProgram->sInfo.ui32Flags & (VGPFLAGS_SECTIONTYPE_FOGLINEAR << VGPFLAGS_SECTIONTYPE_SHIFT))
	{
		/* Sense of section description is wrong way round - reconfigure */
		for(i = 0;i < VGP_VERTPROG_NUM_SECTIONS; i++)
		{
			if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_FOGLINEAR)
				psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_FOGLINEAR] = i;	
	
			if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_FOGEXP)
				psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_FOGEXP] = i;	
		
			if(psInfo->aui32SectionDesc[i] == VGP_SECTIONDESC_FOGEXP2)
				psProgram->sInfo.aui32SectionDesc[VGP_SECTIONDESC_FOGEXP2] = i;	
		}

		psProgram->bFogSectionsPresent = IMG_TRUE;	
	}

	psBindingList = (GLESVPBindingInput *)((IMG_UINT8 *)pvCode + psProgram->ui32CodeSizeInBytes + sizeof(GLESVPHeader2));

	psProgram->ui32InputMask = 0;
	psProgram->ui32LocalParamMask = 0;
	psProgram->ui32LocalParamDirtyMask = 0;
	psProgram->ui32StateMask = 0;
	psProgram->ui32StateDirtyMask = 0;
	ui32ConstantIndex = 0;
	ui32StateIndex = 0;
	
	/* first loop through all the inputs and calculate their number */

	for(i=0; i < psProgram->sInfo.ui32NumBindings; i++)
	{