vgpsections.c

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

};

/*
 * Prototype code for setting colour sources; initialized at runtime.
 */
HWVGPINST psColourSourceSectionPrototype[81];

/* Actual section that will be sent */
HWVGPINST psColourSourceSection[3];

#define SECTION_COLOURSOURCESETUP_SIZE						(3)
#define SECTION_COLOURSOURCESETUP_MAXIMUM_SIZE	\
	(sizeof(psColourSourceSection) / sizeof(*psColourSourceSection))



/*
 * Code to initialize lighting.
 */
HWVGPINST psLightingInitialize[] =
{
	/* Lighting initialization. */
	/* mov rVGPTNL_RTDIFFUSE.w, rVGPTNL_RDIFFUSESRC */
	VGPINST(MOV, DEST(VGPTNL_OUT_RTDIFFUSE, MASKW), SRC_RN(VGPTNL_RDIFFUSESRC), 0, 0, 0),
	/* mul rVGPTNL_RTDIFFUSE.xyz, cCONST_GLOBAL_AMBIENT_COLOUR, rVGPTNL_RAMBIENTSRC */
	VGPINST(MUL, DEST(VGPTNL_OUT_RTDIFFUSE, MASK_XYZ), SRC_CN(CONST_GLOBAL_AMBIENT_COLOUR), SRC_RN(VGPTNL_RAMBIENTSRC), 0, 0),
	/* mov r3.w, rVGPTNL_RSPECULARSRC */
	VGPINST(MOV, DEST(VGPTNL_OUT_RTSPECULAR, MASKW), SRC_RN(VGPTNL_RDIFFUSESRC), 0, 0, 0),
	/* mov r3.xyz, cCONST_ZERO */
	VGPINST(MOV, DEST(VGPTNL_OUT_RTSPECULAR, MASK_XYZ), SRC_CN(CONST_ZERO), 0, 0, 0),
	/* mov r7, cCONST_LIGHTING_ADDRESS_BASE */
	VGPINST(MOV, DEST(VGPTNL_OUT_RADDRESS, NOMASK), SRC_CN(CONST_LIGHTING_ADDRESS_BASE), 0, 0, 0),
};

#define SECTION_LIGHTINGINITIALIZE_SIZE	\
	(sizeof(psLightingInitialize) / sizeof(*psLightingInitialize))


/*
 * Code to transform the position and normal to view space
 */
HWVGPINST psPositionTransformToView[] =
{
	/* Position transform for lighting. */
	/* dp4 r0.x, v0, c4 */
	VGPINST(DP4, DEST(VGPTNL_OUT_RVIEWSPACEPOS, MASKX), SRC_VN(VPOS), SRC_CN(CONST_MODELTOVIEW_ROW0), 0, 0),
	/* dp4 r0.y, v0, c5 */
	VGPINST(DP4, DEST(VGPTNL_OUT_RVIEWSPACEPOS, MASKY), SRC_VN(VPOS), SRC_CN(CONST_MODELTOVIEW_ROW1), 0, 0),
	/* dp4 r0.z, v0, c6 */
	VGPINST(DP4, DEST(VGPTNL_OUT_RVIEWSPACEPOS, MASKZ), SRC_VN(VPOS), SRC_CN(CONST_MODELTOVIEW_ROW2), 0, 0),
	/* dp4 r0.w, v0, c7 */
	VGPINST(DP4, DEST(VGPTNL_OUT_RVIEWSPACEPOS, MASKW), SRC_VN(VPOS), SRC_CN(CONST_MODELTOVIEW_ROW3), 0, 0),

	/* Normal transform for lighting. */
	/* dp3 r1.x, v1, c4 */
	VGPINST(DP3, DEST(VGPTNL_OUT_RNORMAL, MASKX), SRC_VN(VNORMAL), SRC_CN(CONST_MODELTOVIEWINV_ROW0), 0, 0),
	/* dp3 r1.y, v1, c5 */
	VGPINST(DP3, DEST(VGPTNL_OUT_RNORMAL, MASKY), SRC_VN(VNORMAL), SRC_CN(CONST_MODELTOVIEWINV_ROW1), 0, 0),
	/* dp3 r1.z, v1, c6 */
	VGPINST(DP3, DEST(VGPTNL_OUT_RNORMAL, MASKZ), SRC_VN(VNORMAL), SRC_CN(CONST_MODELTOVIEWINV_ROW2), 0, 0),
	
	/* Normal normalise for lighting. */
	/* dp3 r1.w, r1, r1 */
	VGPINST(DP3, DEST(VGPTNL_OUT_RNORMAL, MASKW), SRC_RN(VGPTNL_RNORMAL), SRC_RN(VGPTNL_RNORMAL), 0, 0),
	/* rsq r1.w, r1.w */
	VGPINST(RSQRT, DEST(VGPTNL_OUT_RNORMAL, MASKW), SRC_SWZRN(VGPTNL_RNORMAL, SWZ_WWWW), 0, 0, 0),
	/* mul r1, r1, r1.w */
	VGPINST(MUL, DEST(VGPTNL_OUT_RNORMAL, NOMASK), SRC_RN(VGPTNL_RNORMAL), SRC_SWZRN(VGPTNL_RNORMAL, SWZ_WWWW), 0, 0),
};

#define SECTION_POSTOVIEW_BASE_SIZE					(4)
#define SECTION_POSTOVIEW_NORMAL_SIZE				(7)
#define SECTION_POSTOVIEW_NORMALISENORMAL_SIZE		(10)	
#define SECTION_POSTOVIEW_MAXIMUM_SIZE	\
	(sizeof(psPositionTransformToView) / sizeof(*psPositionTransformToView))



/*
 * Code to set up the local viewer position from the vertex position.
 */
HWVGPINST psLocalViewerFromVertex[] =
{
	/* Set up the local viewer from the vertex position. */
	/* mov rVGPTNL_RLOCALVIEWERPOS, -vVGPTNL_RVIEWSPACEPOS */
	VGPINST(MOV, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, NOMASK), SRC_NEGRN(VGPTNL_RVIEWSPACEPOS), 0, 0, 0),
	/* dp3 r8.w, r8, r8 */
	VGPINST(DP3, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, MASKW), SRC_RN(VGPTNL_RLOCALVIEWERPOS), 
			SRC_RN(VGPTNL_RLOCALVIEWERPOS), 0, 0),

	/* Check if Zero is greater than or equal to DP3 result */
	VGPINST(SGE, DEST(R9, MASKZ), SRC_CN(CONST_ZERO), SRC_SWZRN(VGPTNL_RLOCALVIEWERPOS, SWZ_WWWW), 0, 0),

	/* Add the SGE result to DP3 result ( 0 or 1) to prevent infinities */
	VGPINST(ADD, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, MASKW), SRC_SWZRN(9, SWZ_ZZZZ), SRC_SWZRN(VGPTNL_RLOCALVIEWERPOS, SWZ_WWWW), 0, 0),

	/* rsq r8.w, r8.w */
	VGPINST(RSQRT, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, MASKW), SRC_SWZRN(VGPTNL_RLOCALVIEWERPOS, SWZ_WWWW), 0, 0, 0),

	/* Subtract the SGE result from RSQRT result ( 0 or 1) */
	VGPINST(ADD, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, MASKW), SRC_NEGSWZRN(9, SWZ_ZZZZ), SRC_SWZRN(VGPTNL_RLOCALVIEWERPOS, SWZ_WWWW), 0, 0),

	/* mul r8, r8, r8.w */
	VGPINST(MUL, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, NOMASK), SRC_RN(VGPTNL_RLOCALVIEWERPOS), 
			SRC_SWZRN(VGPTNL_RLOCALVIEWERPOS, SWZ_WWWW), 0, 0),
};

#define SECTION_LOCALVIEWERFROMVERTEX_SIZE	\
	(sizeof(psLocalViewerFromVertex) / sizeof(*psLocalViewerFromVertex))

/*
 * Code to set up the local viewer position from a constant.
 */
HWVGPINST psLocalViewerFromConstant[] =
{
	/* Set up the local viewer from a constant. */
	/* mov rVGPTNL_RLOCALVIEWERPOS, cCONST_LOCAL_VIEWER_DEFAULT */
	VGPINST(MOV, DEST(VGPTNL_OUT_RLOCALVIEWERPOS, NOMASK), SRC_CN(CONST_LOCAL_VIEWER_DEFAULT), 0, 0, 0),
};

#define SECTION_LOCALVIEWERFROMCONSTANT_SIZE \
	(sizeof(psLocalViewerFromConstant) / sizeof(*psLocalViewerFromConstant))

#if defined (SUPPORT_VGP)

/*
 * Code to implement a directional light.
 */
HWVGPINST psDirectionalLightSection[] =
{
	/* Move the address pointer onto the next light. */
	/* amv a0.x, rVGPTNL_RADDRESS */
	VGPINST(AMV, DEST_A0X, SRC_RN(VGPTNL_RADDRESS), 0, 0, 0),

#if defined (FIX_HW_PRN_270)
	/* We need a 2 cycle latency between an AMV instruction and a MAD that uses relative addressing */
	VGPINST(NOP, 0, 0, 0, 0, 0),
#endif /* FIX_HW_PRN_270 */

	/* add rVGPTNL_RADDRESS, rVGPTNL_RADDRESS, c[CONST_LIGHT_SIZE] */
	VGPINST(ADD, DEST(VGPTNL_OUT_RADDRESS, NOMASK), SRC_RN(VGPTNL_RADDRESS), SRC_CN(CONST_LIGHT_SIZE), 0, 0),

	/* Multiply the light ambient colour by the ambient source and add to the through diffuse. */
	/* mad rVGPTNL_RTDIFFUSE, c[a.x + CONST_DIRLIGHT_AMBIENT], rVGPTNL_RAMBIENTSRC, rVGPTNL_RTDIFFUSE */
	VGPINST(MAD, DEST(VGPTNL_OUT_RTDIFFUSE, NOMASK), SRC_CN(CONST_DIRLIGHT_AMBIENT), SRC_RN(VGPTNL_RAMBIENTSRC),
			SRC_RN(VGPTNL_RTDIFFUSE), 1),

	/* Calculate the diffuse. */
	/* Take the dot product between the light direction and the normal. */
	/* dp3 r9.y, c[a.x + CONST_DIRLIGHT_DIRECTION], rVGPTNL_RNORMAL */
	VGPINST(DP3, DEST(R9, MASKY), SRC_CN(CONST_DIRLIGHT_DIRECTION), SRC_RN(VGPTNL_RNORMAL), 0, 1),
	/* Set r9.y to zero if it is less than zero */
	VGPINST(MAX, DEST(R9, MASKY), SRC_CN(CONST_ZERO), SRC_SWZRN(9, SWZ_YYYY), 0, 0),
	/* Save the result of ((dot <= 0) ? 1 : 0) to r9.z */
	VGPINST(SLT, DEST(R9, MASKZ), SRC_CN(CONST_ZERO), SRC_SWZRN(9, SWZ_YYYY), 0, 0),
	/* Add the dot product times the diffuse source and the light diffuse colour to the through diffuse. */
	/* mul r10, r9.y, c[a.x + CONST_DIRLIGHT_DIFFUSE] */
	VGPINST(MUL, DEST(R10, NOMASK), SRC_SWZRN(9, SWZ_YYYY), SRC_CN(CONST_DIRLIGHT_DIFFUSE), 0, 1),
	/* mad rVGPTNL_RTDIFFUSE.xyz, r10, rVGPTNL_RDIFFUSESRC, rVGPTNL_RTDIFFUSE */
	VGPINST(MAD, DEST(VGPTNL_OUT_RTDIFFUSE, MASK_XYZ), SRC_RN(10), SRC_RN(VGPTNL_RDIFFUSESRC), SRC_RN(VGPTNL_RTDIFFUSE), 0),

	/* Calculate the specular. */
	/* Calculate a halfway vector between the light and the vertex. */
	/* add r10, c[a.x + CONST_DIRLIGHT_DIRECTION], r8 */
	VGPINST(ADD, DEST(R10, NOMASK), SRC_CN(CONST_DIRLIGHT_DIRECTION), SRC_RN(8), 0, 1),
	/* Normalise. */
	/* dp3 r10.w, r10, r10 */
	VGPINST(DP3, DEST(R10, MASKW), SRC_RN(10), SRC_RN(10), 0, 0),
	/* rsq r10.w, r10.w */
	VGPINST(RSQRT, DEST(R10, MASKW), SRC_SWZRN(10, SWZ_WWWW), 0, 0, 0),
	/* mul r10, r10, r10.w */
	VGPINST(MUL, DEST(R10, NOMASK), SRC_RN(10), SRC_SWZRN(10, SWZ_WWWW), 0, 0),
	/* Take the dot product of the resuling vector and the normal. */
	/* dp3 r9.x, r10, rVGPTNL_RNORMAL */
	VGPINST(DP3, DEST(R9, MASKX), SRC_RN(10), SRC_RN(VGPTNL_RNORMAL), 0, 0),
	/* Set r9.x to zero if dot(direction, normal) <= 0. */
	/* mul r9.x, r9.x, r9.z */
	VGPINST(MUL, DEST(R9, MASKX), SRC_SWZRN(9, SWZ_XXXX), SRC_SWZRN(9, SWZ_ZZZZ), 0, 0),
	/* Set r10.x to zero if it is less than the specular threshold. */
	/* slt r10.x, c[CONST_SPECULAR_THRESHOLD].x, r9.x */
//	VGPINST(SLT, DEST(R10, MASKX), SRC_SWZCN(CONST_SPECULAR_THRESHOLD, SWZ_XXXX), SRC_SWZRN(9, SWZ_XXXX), 0, 0),
	/* mul r9.x, r9.x, r10.x */
//	VGPINST(MUL, DEST(R9, MASKX), SRC_SWZRN(9, SWZ_XXXX), SRC_SWZRN(10, SWZ_XXXX), 0, 0),
	/* Calculate pow(r9.x, material power) */
	/* mov r9.y, r9.x */
	VGPINST(MOV, DEST(R9, MASKY), SRC_SWZRN(9, SWZ_XXXX), 0, 0, 0),
	/* mov r9.w, cCONST_MATERIAL_POWER */
	VGPINST(MOV, DEST(R9, MASKW), SRC_CN(CONST_MATERIAL_POWER), 0, 0, 0),
	/* lit r9.z, r9 */
	VGPINST(LIT, DEST(R9, MASKZ), SRC_RN(9), 0, 0, 0),
	/* Add the result times by the specular source and the light specular to the through specular. */
	/* mul r9, r9.z, c[a.x + CONST_DIRLIGHT_SPECULAR] */
	VGPINST(MUL, DEST(R9, NOMASK), SRC_SWZRN(9, SWZ_ZZZZ), SRC_CN(CONST_DIRLIGHT_SPECULAR), 0, 1),
	/* mad rVGPTNL_RTSPECULAR.xyz, r9, rVGPTNL_RSPECULARSRC, rVGPTNL_RTSPECULAR */
	VGPINST(MAD, DEST(VGPTNL_OUT_RTSPECULAR, MASK_XYZ), SRC_RN(9), SRC_RN(VGPTNL_RSPECULARSRC), SRC_RN(VGPTNL_RTSPECULAR), 0), 
};

#define SECTION_DIRECTIONALLIGHT_MAXIMUM_SIZE	\
	(sizeof(psDirectionalLightSection) / sizeof(*psDirectionalLightSection))

#define SECTION_DIRECTIONALLIGHT_BASE_SIZE					(9)
#define SECTION_DIRECTIONALLIGHT_SPECULAR_SIZE	\
	(SECTION_DIRECTIONALLIGHT_MAXIMUM_SIZE)

/*
 * Code to implement a point light.
 */
HWVGPINST psPointLightSection[] =
{
	/* Move the address pointer onto the next light. */
	/* amv a0.x, r7 */
	VGPINST(AMV, DEST_A0X, SRC_RN(VGPTNL_RADDRESS), 0, 0, 0),
	/* add r7, r7, c[16] */
	VGPINST(ADD, DEST(VGPTNL_OUT_RADDRESS, NOMASK), SRC_RN(VGPTNL_RADDRESS), SRC_CN(CONST_LIGHT_SIZE), 0, 0),

	/* Calculate a vector from the position to the light. */
	/* add r9, c[a.x + 0], -r0 */
	VGPINST(ADD, DEST(R9, NOMASK), SRC_CN(CONST_PSLIGHT_POS), SRC_NEGRN(VGPTNL_RVIEWSPACEPOS), 0, 1),
	/* Calculate the magnitude of the vector. */
	/* dp3 r10.x, r9, r9 */
	VGPINST(DP3, DEST(R10, MASKX), SRC_RN(9), SRC_RN(9), 0, 0),
	/* Set r10.y to zero if we are going to ignore the result. */
	/* slt r10.y, r10.x, c[a.x + 1].xxxx */
	VGPINST(SLT, DEST(R10, MASKY), SRC_SWZRN(10, SWZ_XXXX), SRC_SWZCN(CONST_PSLIGHT_PARAMS, SWZ_XXXX), 0, 1),
	/* Set r10.z to the square root of the magnitude. */
	/* rsq r10.z, r10.x */
	VGPINST(RSQRT, DEST(R10, MASKZ), SRC_SWZRN(10, SWZ_XXXX), 0, 0, 0),
	/* rcp r10.z, r10.z */
	VGPINST(RCP, DEST(R10, MASKZ), SRC_SWZRN(10, SWZ_ZZZZ), 0, 0, 0),
	/* Set r10.w to attenuation. */
	/* mul r10.w, r10.x, c[a.x + 1].wwww */
	VGPINST(MUL, DEST(R10, MASKW), SRC_SWZRN(10, SWZ_XXXX), SRC_SWZCN(CONST_PSLIGHT_PARAMS, SWZ_WWWW), 0, 1),
	/* mad r10.w, c[a.x + 1].zzzz, r10.z, r10.w */
	VGPINST(MAD, DEST(R10, MASKW), SRC_SWZCN(CONST_PSLIGHT_PARAMS, SWZ_ZZZZ), SRC_SWZRN(10, SWZ_ZZZZ), 
			SRC_SWZRN(10, SWZ_WWWW), 1),
	/* add r10.w, r10.w, c[a.x + 1].yyyy */
	VGPINST(ADD, DEST(R10, MASKW), SRC_SWZRN(10, SWZ_WWWW), SRC_SWZCN(CONST_PSLIGHT_PARAMS, SWZ_YYYY), 0, 1),
	/* rcp r10.w, r10.w */
	VGPINST(RCP, DEST(R10, MASKW), SRC_SWZRN(10, SWZ_WWWW), 0, 0, 0),
	/* rcp r10.z, r10.z */
	VGPINST(RCP, DEST(R10, MASKZ), SRC_SWZRN(10, SWZ_ZZZZ), 0, 0, 0),

	/* Do the ambient calculation. */
	/* mul r11, c[a.x + 2], r4 */
	VGPINST(MUL, DEST(R11, NOMASK), SRC_CN(CONST_PSLIGHT_AMBIENT), SRC_RN(VGPTNL_RAMBIENTSRC), 0, 1),
	/* mul r11, r11, r10.y */
	VGPINST(MUL, DEST(R11, NOMASK), SRC_RN(11), SRC_SWZRN(10, SWZ_YYYY), 0, 0),
	/* mad r2.xyz, r11, r10.w, r2 */
	VGPINST(MAD, DEST(VGPTNL_OUT_RTDIFFUSE, MASK_XYZ), SRC_RN(11), SRC_SWZRN(10, SWZ_WWWW), SRC_RN(VGPTNL_RTDIFFUSE), 0),

	/* Do the diffuse calculation. */
	/* r11.x = dot(light_position - vertex_position, normal)
	/* dp3 r11.x, r9, r1 */
	VGPINST(DP3, DEST(R11, MASKX), SRC_RN(9), SRC_RN(VGPTNL_RNORMAL), 0, 1),
	/* max r11,x, r11.x, 0 */
	VGPINST(MAX, DEST(R11, MASKX), SRC_CN(CONST_ZERO), SRC_SWZRN(11, SWZ_XXXX), 0, 0),
	/* mul r11.x, r11.x, r10.z */
	VGPINST(MUL, DEST(R11, MASKX), SRC_SWZRN(11, SWZ_XXXX), SRC_SWZRN(10, SWZ_ZZZZ), 0, 0),
	/* mul r11.x, r11.x, r10.w */
	VGPINST(MUL, DEST(R11, MASKX), SRC_SWZRN(11, SWZ_XXXX), SRC_SWZRN(10, SWZ_WWWW), 0, 0),
	/* mul r12, r11.x, c[a.x + 3] */
	VGPINST(MUL, DEST(R12, NOMASK), SRC_SWZRN(11, SWZ_XXXX), SRC_CN(CONST_PSLIGHT_DIFFUSE), 0, 1),
	/* mul r12, r12, r5 */
	VGPINST(MUL, DEST(R12, NOMASK), SRC_RN(12), SRC_RN(CONST_PSLIGHT_DIRECTION), 0, 0),
	/* mad r2.xyz, r12, r10.y, r2 */
	VGPINST(MAD, DEST(VGPTNL_OUT_RTDIFFUSE, MASK_XYZ), SRC_RN(12), SRC_SWZRN(10, SWZ_YYYY), SRC_RN(VGPTNL_RTDIFFUSE), 0),

	/* The specular calculation. */
	/* If dot <= 0 then we are going to ignore the specular calculation. */