vgp.c

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

/**************************************************************************
 * Name         : vgp.c
 * Author       : BCB
 * Created      : 09/05/2003
 *
 * Copyright    : 2003 by Imagination Technologies Limited. All rights reserved.
 *              : No part of this software, either material or conceptual 
 *              : may be copied or distributed, transmitted, transcribed,
 *              : stored in a retrieval system or translated into any 
 *              : human or computer language in any form by any means,
 *              : electronic, mechanical, manual or other-wise, or 
 *              : disclosed to third parties without the express written
 *              : permission of Imagination Technologies Limited, Unit 8, HomePark
 *              : Industrial Estate, King's Langley, Hertfordshire,
 *              : WD4 8LZ, U.K.
 *
 * Platform     : ANSI
 *
 * $Date: 2004/10/26 09:09:56 $ $Revision: 1.23.1.3 $
 * $Log: vgp.c $
 * ./
 *  --- Revision Logs Removed --- 
 **************************************************************************/
#define MODULE_ID MODID_VGP

/* Exclude this file from non-VGP builds */
#if defined( SUPPORT_VGP ) || defined( SUPPORT_VGP_LITE )

#include "context.h"
#include "vgp.h"

#if !defined(PASSTHROUGH_BUILD)
#if defined( SUPPORT_VGP )
#include "vgpcode.h"
#else
#include "vgplitecode.h"
#endif
#endif /* PASSTHROUGH_BUILD */

#include "vgpcodept.h"

#include "slaveport.h"
#include <string.h>


/******************************************************************************************/

/* 
	VGP Streams
	-----------

	Always set the VGP source streams to put data into 
	the VGP registers in the following order:

	XYZW			->		V0
	Normal			->		V1
	Base Colour		->		V2
	Offset Colour	->		V3
	Texture 0		->		V4
	Texture 1		->		V5
	etc.
*/

/***********************************************************************************
 Function Name      : LoadVGPConstants
 Inputs             : gc, pui32ConstantData, ui32Size, ui32Start
 Outputs            : -
 Returns            : -
 Description        : Loads VGP constants through slaveport.
************************************************************************************/

IMG_VOID LoadVGPConstants(GLESContext *gc, IMG_FLOAT *pfConstantData, IMG_UINT32 ui32Size, IMG_UINT32 ui32Start)
{
	IMG_UINT32 ui32TAControlStream;

	/*
		VGP Constants Block Header: TA Object type = VGP Constants, VGP Constants Start, End
	*/
	ui32TAControlStream =	MBX1_TAOBJTYPE_VGP_CONSTANTS									| 
							(ui32Start + ui32Size - 1) << MBX1_VGPCONSTANTS_ENDADDR_SHIFT	|
							(ui32Start << MBX1_VGPCONSTANTS_STARTADDR_SHIFT);

	EmitState(gc, &ui32TAControlStream, 1);
	EmitState(gc, (IMG_UINT32 *)pfConstantData, 4 * ui32Size);

	GLES_INC_COUNT(GLES_TIMER_VGP_CONSTANTS_COUNT, 4 * ui32Size);
}

/***********************************************************************************
 Function Name      : LoadVGPProgram
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Loads VGP code through slaveport.
************************************************************************************/
IMG_VOID LoadVGPProgram(GLESContext *gc)
{
	IMG_UINT32 ui32TAControlStream = MBX1_TAOBJTYPE_VGP_CODE;
	IMG_UINT32 ui32CodeSize;
	IMG_UINT32 *pui32VGPCode;

	if(gc->ui32TnLEnables & GLES_TL_VERTEX_PROGRAM_ENABLE)
	{
		/* Pass code size in 32 bit words */
		ui32CodeSize = gc->sVertexProgram.psCurrentProgram->ui32CodeSizeInBytes >> 2;
		pui32VGPCode = gc->sVertexProgram.psCurrentProgram->pui32Code;
		gc->bLastProgramLoadedFF = IMG_FALSE;
	}
	else
	{
		ui32CodeSize = gui32VGPCodeSize;
		pui32VGPCode = (IMG_UINT32 *)gaui32VGPCode;
		gc->bLastProgramLoadedFF = IMG_TRUE;
	}
	
	ui32TAControlStream = MBX1_TAOBJTYPE_VGP_CODE | ((ui32CodeSize >> 1) - 1);

	EmitState(gc, &ui32TAControlStream, 1);
	EmitState(gc, pui32VGPCode, ui32CodeSize);

	/* Reload fixed constants for FF VGP program */
	if(!(gc->ui32TnLEnables & GLES_TL_VERTEX_PROGRAM_ENABLE))
	{
		GLEScoord asFixedConstants[VGP_FIXED_CONSTANTS_SIZE] = 
			{{0.0, 0.0, 1.0, 0.0},								/* VGP_ZEROZEROONEZERO */
			{VGP_LIGHT_CONSTANT_SIZE, VGP_LIGHT_CONSTANT_SIZE,	/* VGP_LIGHT_SIZE */
			VGP_LIGHT_CONSTANT_SIZE, VGP_LIGHT_CONSTANT_SIZE}};
	
		LoadVGPConstants(gc, &gc->sState.sViewport.sFrontBackClip[0].fX, VGP_CLIPPLANES_SIZE, VGP_CLIPPLANES_START);
		LoadVGPConstants(gc, &asFixedConstants[0].fX, VGP_FIXED_CONSTANTS_SIZE, VGP_FIXED_CONSTANTS_START);
	}

	GLES_INC_COUNT(GLES_TIMER_VGP_CODE_COUNT, ui32CodeSize);
}

/***********************************************************************************
 Function Name      : LoadAllVGPSectionDefinitions
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Loads all VGP section definitions through slaveport.
************************************************************************************/
IMG_VOID LoadAllVGPSectionDefinitions(GLESContext *gc)
{
	IMG_UINT32 ui32Loop;
	IMG_UINT32 ui32SectionDefinitions = MBX1_TAOBJTYPE_VGP_CONTROL;
	IMG_UINT32 ui32NumberSections;

	if(gc->ui32TnLEnables & GLES_TL_VERTEX_PROGRAM_ENABLE)
	{
		ui32NumberSections = MBX1_VGPCODE_SECTION_COUNT;
	}
	else
	{
		ui32NumberSections = VGP_FF_TNL_NUM_SECTIONS;
	}

	for(ui32Loop=0; ui32Loop < ui32NumberSections; ui32Loop++)
	{
		ui32SectionDefinitions |= (MBX1_VGPCONTROL_SECTION0DEF_ENABLE << ui32Loop);
	}

	/* 
		VGP Control
	*/
	EmitState(gc, &ui32SectionDefinitions, 1);

	if(gc->ui32TnLEnables & GLES_TL_VERTEX_PROGRAM_ENABLE)
	{
		EmitState(gc, (IMG_UINT32 *)gc->sVertexProgram.psCurrentProgram->aui32SectionDefinitions, MBX1_VGPCODE_SECTION_COUNT);
	}
	else
	{
		EmitState(gc, (IMG_UINT32 *)gaui32VGPSectionDefinitions, VGP_FF_TNL_NUM_SECTIONS);
	}
}

#if !defined(PASSTHROUGH_BUILD)
/***********************************************************************************
 Function Name      : LoadLightingVGPSectionDefinitions
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Loads lighting VGP section definitions through slaveport.
					  Checks for various types of enabled lights and sets up
					  loop counts as appropriate.
************************************************************************************/
IMG_VOID LoadLightingVGPSectionDefinitions(GLESContext *gc)
{
	IMG_UINT32 ui32SectionDefinitions = MBX1_TAOBJTYPE_VGP_CONTROL;

#if defined(OPENGLES1_1)
	IMG_UINT32 ui32LightingSection;

	ui32SectionDefinitions |= (1 << VGP_SECTION_GENERIC_LIGHTING);

	ui32LightingSection = gaui32VGPSectionDefinitions[VGP_SECTION_GENERIC_LIGHTING];
	
	ui32LightingSection |= gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_INFINITE] ? 
							(gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_INFINITE] - 1) <<  MBX1_VGPSECTDEF_COUNT_SHIFT: 0;

	EmitState(gc, &ui32SectionDefinitions, 1);
	EmitState(gc, &ui32LightingSection, 1);
#else
	IMG_UINT32 aui32LightingSection[3];
	IMG_UINT32 ui32NumInfiniteLights = 0, ui32NumPointLights = 0, ui32NumSpotLights = 0;

	ui32SectionDefinitions |= (1 << VGP_SECTION_INFINITE_LIGHTING);
	ui32SectionDefinitions |= (1 << VGP_SECTION_POINT_LIGHTING);
	ui32SectionDefinitions |= (1 << VGP_SECTION_SPOT_LIGHTING);

	/* 
		VGP Control
	*/
	aui32LightingSection[0] = gaui32VGPSectionDefinitions[VGP_SECTION_INFINITE_LIGHTING];
	aui32LightingSection[1] = gaui32VGPSectionDefinitions[VGP_SECTION_POINT_LIGHTING];
	aui32LightingSection[2] = gaui32VGPSectionDefinitions[VGP_SECTION_SPOT_LIGHTING];

	/* Section definitions have 0=1 for the iteration count! */
	ui32NumInfiniteLights = gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_INFINITE] ? 
							gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_INFINITE] - 1 : 0;
	
	ui32NumPointLights = gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_POINT] ? 
							gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_POINT] - 1 : 0;
	
	ui32NumSpotLights = gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_SPOT] ? 
						gc->sLight.aui32NumEnabled[GLES_LIGHT_TYPE_SPOT] - 1 : 0;
		
	aui32LightingSection[0] |= ui32NumInfiniteLights << MBX1_VGPSECTDEF_COUNT_SHIFT;
	aui32LightingSection[1] |= ui32NumPointLights << MBX1_VGPSECTDEF_COUNT_SHIFT;
	aui32LightingSection[2] |= ui32NumSpotLights << MBX1_VGPSECTDEF_COUNT_SHIFT;

	EmitState(gc, &ui32SectionDefinitions, 1);
	EmitState(gc, aui32LightingSection, 3);
#endif
}
#endif /* PASSTHROUGH_BUILD */


/***********************************************************************************
 Function Name      : GetVGPPassthoughInputFormat
 Inputs             : gc, bColored, bTextured
 Outputs            : -
 Returns            : InputFormat word
 Description        : Sets up VGP input registers based on vertex program state.
************************************************************************************/

IMG_UINT32 GetVGPPassthoughInputFormat(GLESContext *gc, IMG_BOOL bColored, IMG_BOOL bTextured)
{
	IMG_UINT32 ui32PositionShift, ui32ColorShift, ui32TexCoordShift, ui32InputFormatWord;

	if(!gc->bLastProgramLoadedFF)
	{
		IMG_UINT32 *pui32InputRegister = gc->sVertexProgram.psCurrentProgram->aui32FFInputRegisterMapping;
	
		ui32PositionShift = (pui32InputRegister[GLES_VP_PASSTHROUGH_POSITION_INDEX] * MBX1_VGPIFDEF_SREG_LSHIFT);
		ui32ColorShift = (pui32InputRegister[GLES_VP_PASSTHROUGH_COLOR_INDEX] * MBX1_VGPIFDEF_SREG_LSHIFT);
		ui32TexCoordShift = (pui32InputRegister[GLES_VP_PASSTHROUGH_TEXCOORD_INDEX] * MBX1_VGPIFDEF_SREG_LSHIFT);
	}
	else
	{
		ui32PositionShift = (VGP_VERTEX_POS * MBX1_VGPIFDEF_SREG_LSHIFT);
		ui32ColorShift = (VGP_VERTEX_BASECOL * MBX1_VGPIFDEF_SREG_LSHIFT);
		ui32TexCoordShift = (VGP_VERTEX_TEX_START * MBX1_VGPIFDEF_SREG_LSHIFT);
	}
	
	ui32InputFormatWord = (MBX1_VGPIFDEF_SREG_3D_FLOAT << ui32PositionShift);

	if(bColored)
		ui32InputFormatWord |= (MBX1_VGPIFDEF_SREG_4D_ARGB << ui32ColorShift);

	if(bTextured)
		ui32InputFormatWord |= (MBX1_VGPIFDEF_SREG_2D_FLOAT << ui32TexCoordShift);

	return ui32InputFormatWord;
}