csgo/cstrike15_src/launcher_main/errorrenderloop.cpp

//========= Copyright (c) 2010, Valve Corporation, All rights reserved. ============//
/*   SCE CONFIDENTIAL                                       */
/*   PlayStation(R)3 Programmer Tool Runtime Library 350.001 */
/*   Copyright (C) 2009 Sony Computer Entertainment Inc.    */
/*   All Rights Reserved.                                   */
/*   File: main.cpp
 *   Description:
 *     simple graphics to show how to use libgcm
 *
 */
#include "errorrenderloop.h"
#include <ppu_intrinsics.h>

#define ARRAYSIZE( ARRAY ) ( sizeof( ARRAY ) / sizeof( ( ARRAY )[0] ) )


#ifdef _DEBUG
#define CELL_GCMUTIL_ASSERT(X) do{ if( !( X ) ) {printf( "Assert(%s)\n%s:%d\n", #X, __FILE__, __LINE__ ); __builtin_snpause(); } }while(0)
#define CELL_GCMUTIL_CHECK_ASSERT(X) CELL_GCMUTIL_ASSERT( X == CELL_OK )
#define CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(X) CELL_GCMUTIL_ASSERT(X != 0 )
#else
#define CELL_GCMUTIL_ASSERT(X)
#define CELL_GCMUTIL_CHECK_ASSERT(X) (X)
#define CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(X) (void)(X)
#endif


// For exit routine
static void sysutil_exit_callback(uint64_t status, uint64_t param, void* userdata);

extern uint32_t _binary_errorshader_vpo_start;
extern uint32_t _binary_errorshader_vpo_end;
extern uint32_t _binary_errorshader_fpo_start;
extern uint32_t _binary_errorshader_fpo_end;

PS3_GcmSharedData g_gcmSharedData;

using namespace cell::Gcm;


ErrorRenderLoop::ErrorRenderLoop()
{
	m_keepRunning = true;
	m_nLocalMemHeap = 0;
	vertex_program_ptr = 
		(unsigned char *)&_binary_errorshader_vpo_start;
	fragment_program_ptr = 
		(unsigned char *)&_binary_errorshader_fpo_start;
	frame_index = 0;
}




/* local memory allocation */
void *ErrorRenderLoop::localMemoryAlloc(const uint32_t size) 
{
	uint32_t allocated_size = (size + 1023) & (~1023);
	uint32_t base = m_nLocalMemHeap;
	m_nLocalMemHeap += allocated_size;
	return (void*)base;
}

void *ErrorRenderLoop::localMemoryAlign(const uint32_t alignment, 
		const uint32_t size)
{
	m_nLocalMemHeap = (m_nLocalMemHeap + alignment-1) & (~(alignment-1));
	return (void*)localMemoryAlloc(size);
}




void ErrorRenderLoop::setRenderTarget(const uint32_t Index)
{
	CellGcmSurface sf;
	sf.colorFormat 	= CELL_GCM_SURFACE_A8R8G8B8;
	sf.colorTarget	= CELL_GCM_SURFACE_TARGET_0;
	sf.colorLocation[0]	= CELL_GCM_LOCATION_LOCAL;
	sf.colorOffset[0] 	= color_offset[Index];
	sf.colorPitch[0] 	= color_pitch;

	sf.colorLocation[1]	= CELL_GCM_LOCATION_LOCAL;
	sf.colorLocation[2]	= CELL_GCM_LOCATION_LOCAL;
	sf.colorLocation[3]	= CELL_GCM_LOCATION_LOCAL;
	sf.colorOffset[1] 	= 0;
	sf.colorOffset[2] 	= 0;
	sf.colorOffset[3] 	= 0;
	sf.colorPitch[1]	= 64;
	sf.colorPitch[2]	= 64;
	sf.colorPitch[3]	= 64;

	sf.depthFormat 	= CELL_GCM_SURFACE_Z24S8;
	sf.depthLocation	= CELL_GCM_LOCATION_LOCAL;
	sf.depthOffset	= depth_offset;
	sf.depthPitch 	= depth_pitch;

	sf.type		= CELL_GCM_SURFACE_PITCH;
	sf.antialias	= CELL_GCM_SURFACE_CENTER_1;

	sf.width 		= display_width;
	sf.height 		= display_height;
	sf.x 		= 0;
	sf.y 		= 0;
	cellGcmSetSurface(&sf);
	//cellGcmSetAntiAliasingControl(CELL_GCM_TRUE, CELL_GCM_FALSE, CELL_GCM_FALSE, 0xffff);
}

/* wait until flip */
static void waitFlip(void)
{
	while (cellGcmGetFlipStatus()!=0){
		sys_timer_usleep(300);
	}
	cellGcmResetFlipStatus();
}


void ErrorRenderLoop::flip(void)
{
	static int first=1;

	// wait until the previous flip executed
	if (first!=1) waitFlip();
	else cellGcmResetFlipStatus();

	if(cellGcmSetFlip(frame_index) != CELL_OK) return;
	cellGcmFlush();

	// resend status
	setDrawEnv();
	setRenderState();

	cellGcmSetWaitFlip();

	// New render target
	frame_index = (frame_index+1)%COLOR_BUFFER_NUM;
	setRenderTarget(frame_index);

	first=0;
}


void ErrorRenderLoop::initShader(void)
{
	vertex_program   = (CGprogram)vertex_program_ptr;
	fragment_program = (CGprogram)fragment_program_ptr;

	// init
	cellGcmCgInitProgram(vertex_program);
	cellGcmCgInitProgram(fragment_program);

	uint32_t ucode_size;
	void *ucode;
	cellGcmCgGetUCode(fragment_program, &ucode, &ucode_size);
	// 64B alignment required 
	void *ret = localMemoryAlign(64, ucode_size);
	fragment_program_ucode = ret;
	memcpy(fragment_program_ucode, ucode, ucode_size); 

	cellGcmCgGetUCode(vertex_program, &ucode, &ucode_size);
	vertex_program_ucode = ucode;
}

static void buildProjection(float *M, 
		const float top, 
		const float bottom, 
		const float left, 
		const float right, 
		const float near, 
		const float far)
{
	memset(M, 0, 16*sizeof(float)); 

	M[0*4+0] = (2.0f*near) / (right - left);
	M[1*4+1] = (2.0f*near) / (bottom - top);

	float A = (right + left) / (right - left);
	float B = (top + bottom) / (top - bottom);
	float C = -(far + near) / (far - near);
	float D = -(2.0f*far*near) / (far - near);

	M[0*4 + 2] = A;
	M[1*4 + 2] = B;
	M[2*4 + 2] = C;
	M[3*4 + 2] = -1.0f; 
	M[2*4 + 3] = D;
}

static void matrixMul(float *Dest, float *A, float *B)
{
	for (int i=0; i < 4; i++) {
		for (int j=0; j < 4; j++) {
			Dest[i*4+j] 
				= A[i*4+0]*B[0*4+j] 
				+ A[i*4+1]*B[1*4+j] 
				+ A[i*4+2]*B[2*4+j] 
				+ A[i*4+3]*B[3*4+j];
		}
	}
}

static void matrixTranslate(float *M, 
		const float x, 
		const float y, 
		const float z)
{
	memset(M, 0, sizeof(float)*16);
	M[0*4+3] = x;
	M[1*4+3] = y;
	M[2*4+3] = z;

	M[0*4+0] = 1.0f;
	M[1*4+1] = 1.0f;
	M[2*4+2] = 1.0f;
	M[3*4+3] = 1.0f;
}

/*
static void unitMatrix(float *M)
{
	M[0*4+0] = 1.0f;
	M[0*4+1] = 0.0f;
	M[0*4+2] = 0.0f;
	M[0*4+3] = 0.0f;

	M[1*4+0] = 0.0f;
	M[1*4+1] = 1.0f;
	M[1*4+2] = 0.0f;
	M[1*4+3] = 0.0f;

	M[2*4+0] = 0.0f;
	M[2*4+1] = 0.0f;
	M[2*4+2] = 1.0f;
	M[2*4+3] = 0.0f;

	M[3*4+0] = 0.0f;
	M[3*4+1] = 0.0f;
	M[3*4+2] = 0.0f;
	M[3*4+3] = 1.0f;
}

*/
#define CB_SIZE	(0x10000)

int32_t ErrorRenderLoop::initDisplay(void)
{
	uint32_t color_depth=4; // ARGB8
	uint32_t z_depth=4;     // COMPONENT24
	void *color_base_addr;
	void *depth_base_addr;
	void *color_addr[COLOR_BUFFER_NUM];
	void *depth_addr;
	CellVideoOutResolution resolution;

	// display initialize

	// read the current video status
	// INITIAL DISPLAY MODE HAS TO BE SET BY RUNNING SETMONITOR.SELF
	CellVideoOutState videoState;
	CELL_GCMUTIL_CHECK_ASSERT(cellVideoOutGetState(CELL_VIDEO_OUT_PRIMARY, 0, &videoState));
	CELL_GCMUTIL_CHECK_ASSERT(cellVideoOutGetResolution(videoState.displayMode.resolutionId, &resolution));

	display_width = resolution.width;
	display_height = resolution.height;
	color_pitch = display_width*color_depth;
	depth_pitch = display_width*z_depth;

	uint32_t color_size =   color_pitch*display_height;
	uint32_t depth_size =  depth_pitch*display_height;

	CellVideoOutConfiguration videocfg;
	memset(&videocfg, 0, sizeof(CellVideoOutConfiguration));
	videocfg.resolutionId = videoState.displayMode.resolutionId;
	videocfg.format = CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_X8R8G8B8;
	videocfg.pitch = color_pitch;

	// set video out configuration with waitForEvent set to 0 (4th parameter)
	CELL_GCMUTIL_CHECK_ASSERT(cellVideoOutConfigure(CELL_VIDEO_OUT_PRIMARY, &videocfg, NULL, 0));
	CELL_GCMUTIL_CHECK_ASSERT(cellVideoOutGetState(CELL_VIDEO_OUT_PRIMARY, 0, &videoState));

	switch (videoState.displayMode.aspect){
	  case CELL_VIDEO_OUT_ASPECT_4_3:
		  display_aspect_ratio=4.0f/3.0f;
		  break;
	  case CELL_VIDEO_OUT_ASPECT_16_9:
		  display_aspect_ratio=16.0f/9.0f;
		  break;
	  default:
		  printf("unknown aspect ratio %x\n", videoState.displayMode.aspect);
		  display_aspect_ratio=16.0f/9.0f;
	}

	cellGcmSetFlipMode(CELL_GCM_DISPLAY_VSYNC);

	// get config
	CellGcmConfig config;
	cellGcmGetConfiguration(&config);
	// buffer memory allocation
	m_nLocalMemHeap = (uint32_t)config.localAddress;

	color_base_addr = localMemoryAlign(64, COLOR_BUFFER_NUM*color_size);

	for (int i = 0; i < COLOR_BUFFER_NUM; i++) {
	    color_addr[i]= (void *)((uint32_t)color_base_addr+ (i*color_size));
	    CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(color_addr[i], &color_offset[i]));
	}

	// regist surface
	for (int i = 0; i < COLOR_BUFFER_NUM; i++) {
		CELL_GCMUTIL_CHECK_ASSERT(cellGcmSetDisplayBuffer(i, color_offset[i], color_pitch, display_width, display_height));
	}

	depth_base_addr = localMemoryAlign(64, depth_size);
	depth_addr = depth_base_addr;
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(depth_addr, &depth_offset));

	return 0;
}



//  65  verts in  polySurfaceShape1
ErrorRenderLoop::Vertex_t g_verts_polySurfaceShape1[65] = {
	{0.287,2.232,-0.144,  0.398,0.702,-0.590, 0xFFFF5FFF },
	{-0.287,2.232,-0.144,  -0.404,0.699,-0.590, 0xFFFF00FF },
	{-1.634,-0.134,-0.134,  -0.808,-0.006,-0.588, 0xFFFF00FF },
	{-1.366,-0.598,-0.134,  -0.413,-0.695,-0.589, 0xFFFF00FF },
	{1.345,-0.635,-0.155,  0.400,-0.700,-0.592, 0xFFFF00FF },
	{1.655,-0.097,-0.155,  0.806,0.001,-0.592, 0xFFFF00FF },
	{0.287,2.232,0.144,  0.455,0.835,0.308, 0xFFFF5FFF },
	{-0.287,2.232,0.144,  -0.462,0.832,0.309, 0xFFFF5FFF },
	{-1.634,-0.134,0.134,  -0.937,-0.034,0.347, 0xFFFF00FF },
	{-1.366,-0.598,0.134,  -0.484,-0.795,0.367, 0xFFFF5FFF },
	{1.345,-0.635,0.155,  0.470,-0.802,0.369, 0xFFFF5FFF },
	{1.655,-0.097,0.155,  0.937,-0.027,0.348, 0xFFFF00FF },
	{0.000,0.500,-0.257,  -0.007,0.000,-1.000, 0xFFFF00FF },
	{0.000,0.274,0.422,  0.000,0.962,0.272, 0xFF0076FF },
	{0.000,-0.085,0.422,  0.000,-0.962,0.272, 0xFF0076FF },
	{-0.173,0.094,0.422,  -0.964,0.000,0.266, 0xFF0076FF },
	{0.173,0.094,0.422,  0.964,0.000,0.266, 0xFF0076FF },
	{-0.058,0.445,0.422,  -0.592,-0.698,0.404, 0xFF0076FF },
	{0.058,0.445,0.422,  0.591,-0.698,0.404, 0xFF0076FF },
	{0.002,2.002,0.422,  0.019,0.915,0.403, 0xFF0000FF },
	{0.173,1.774,0.422,  0.871,0.278,0.405, 0xFF0000FF },
	{-0.172,1.789,0.422,  -0.864,0.296,0.407, 0xFF0000FF },
	{0.088,0.787,0.422,  0.963,-0.084,0.256, 0xFF0076FF },
	{-0.088,0.787,0.422,  -0.963,-0.082,0.256, 0xFF0076FF },
	{0.124,1.192,0.422,  0.949,-0.082,0.304, 0xFF0000FF },
	{-0.123,1.192,0.422,  -0.950,-0.081,0.302, 0xFF0000FF },
	{0.161,1.597,0.422,  0.935,-0.070,0.347, 0xFF0000FF },
	{-0.159,1.597,0.422,  -0.936,-0.071,0.345, 0xFF0000FF },
	{0.000,0.274,0.349,  0.000,0.818,-0.575, 0xFFFFFFFF },
	{-0.173,0.094,0.349,  -0.815,0.000,-0.579, 0xFFFFFFFF },
	{0.000,-0.085,0.349,  0.000,-0.818,-0.575, 0xFF0076FF },
	{0.173,0.094,0.349,  0.815,0.000,-0.579, 0xFF0076FF },
	{0.173,1.774,0.349,  0.739,0.219,-0.637, 0xFFFFFFFF },
	{0.002,2.002,0.349,  0.018,0.825,-0.566, 0xFFFFFFFF },
	{-0.172,1.789,0.349,  -0.738,0.235,-0.633, 0xFFFFFFFF },
	{0.058,0.445,0.349,  0.549,-0.600,-0.582, 0xFFFFFFFF },
	{0.088,0.787,0.349,  0.704,-0.063,-0.707, 0xFFFFFFFF },
	{-0.088,0.787,0.349,  -0.704,-0.062,-0.707, 0xFFFFFFFF },
	{0.124,1.192,0.349,  0.704,-0.063,-0.707, 0xFFFFFFFF },
	{-0.123,1.192,0.349,  -0.704,-0.062,-0.707, 0xFFFFFFFF },
	{0.161,1.597,0.349,  0.708,-0.055,-0.704, 0xFFFFFFFF },
	{-0.159,1.597,0.349,  -0.707,-0.056,-0.705, 0xFFFFFFFF },
	{-0.058,0.445,0.349,  -0.549,-0.600,-0.582, 0xFFFFFFFF },
	{0.280,2.195,0.188,  0.318,0.461,0.828, 0xFFFF5FFF },
	{-0.279,2.195,0.188,  -0.323,0.457,0.829, 0xFFFF5FFF },
	{0.000,0.508,0.298,  -0.007,0.000,1.000, 0xFFFF00FF },
	{-1.591,-0.110,0.178,  -0.535,0.082,0.841, 0xFFFF00FF },
	{-1.331,-0.561,0.178,  -0.213,-0.432,0.877, 0xFFFF5FFF },
	{1.310,-0.597,0.199,  0.199,-0.432,0.880, 0xFFFF5FFF },
	{1.612,-0.074,0.199,  0.529,0.089,0.844, 0xFFFF00FF },
	{-0.150,1.762,0.445,  -0.414,0.061,0.908, 0xFF0000FF },
	{0.150,1.747,0.445,  0.414,0.057,0.909, 0xFF0000FF },
	{0.002,1.965,0.445,  0.016,0.404,0.915, 0xFF0000FF },
	{-0.076,0.808,0.445,  -0.498,-0.043,0.866, 0xFF0076FF },
	{0.050,0.482,0.445,  0.464,-0.229,0.856, 0xFF0076FF },
	{0.077,0.808,0.445,  0.497,-0.043,0.866, 0xFF0076FF },
	{-0.107,1.194,0.445,  -0.459,-0.037,0.888, 0xFF0000FF },
	{0.108,1.194,0.445,  0.457,-0.037,0.888, 0xFF0000FF },
	{-0.138,1.580,0.445,  -0.423,-0.034,0.905, 0xFF0000FF },
	{0.140,1.580,0.445,  0.422,-0.034,0.906, 0xFF0000FF },
	{-0.050,0.482,0.445,  -0.464,-0.229,0.856, 0xFF0076FF },
	{0.000,-0.067,0.447,  0.000,-0.599,0.800, 0xFF0076FF },
	{0.000,0.255,0.447,  0.000,0.599,0.800, 0xFF0076FF },
	{-0.155,0.094,0.447,  -0.603,0.000,0.798, 0xFF0076FF },
	{0.155,0.094,0.447,  0.603,0.000,0.798, 0xFF0076FF },
};
//  118  triangles
uint16_t g_tris_polySurfaceShape1[118][3] = {
	{  0, 1, 6  }
	,  {  6, 1, 7  }
	,  {  1, 2, 7  }
	,  {  7, 2, 8  }
	,  {  2, 3, 8  }
	,  {  8, 3, 9  }
	,  {  3, 4, 9  }
	,  {  9, 4, 10  }
	,  {  4, 5, 10  }
	,  {  10, 5, 11  }
	,  {  5, 0, 11  }
	,  {  11, 0, 6  }
	,  {  1, 0, 12  }
	,  {  2, 1, 12  }
	,  {  3, 2, 12  }
	,  {  4, 3, 12  }
	,  {  5, 4, 12  }
	,  {  0, 5, 12  }
	,  {  43, 44, 45  }
	,  {  44, 46, 45  }
	,  {  46, 47, 45  }
	,  {  47, 48, 45  }
	,  {  48, 49, 45  }
	,  {  49, 43, 45  }
	,  {  28, 30, 29  }
	,  {  30, 28, 31  }
	,  {  32, 34, 33  }
	,  {  35, 37, 36  }
	,  {  36, 39, 38  }
	,  {  38, 41, 40  }
	,  {  34, 40, 41  }
	,  {  40, 34, 32  }
	,  {  37, 35, 42  }
	,  {  39, 36, 37  }
	,  {  41, 38, 39  }
	,  {  62, 63, 61  }
	,  {  61, 64, 62  }
	,  {  51, 52, 50  }
	,  {  54, 55, 53  }
	,  {  55, 57, 56  }
	,  {  57, 59, 58  }
	,  {  50, 58, 59  }
	,  {  59, 51, 50  }
	,  {  53, 60, 54  }
	,  {  56, 53, 55  }
	,  {  58, 56, 57  }
	,  {  13, 28, 15  }
	,  {  28, 29, 15  }
	,  {  15, 29, 14  }
	,  {  29, 30, 14  }
	,  {  14, 30, 16  }
	,  {  30, 31, 16  }
	,  {  16, 31, 13  }
	,  {  31, 28, 13  }
	,  {  20, 32, 19  }
	,  {  32, 33, 19  }
	,  {  19, 33, 21  }
	,  {  33, 34, 21  }
	,  {  18, 35, 22  }
	,  {  35, 36, 22  }
	,  {  22, 36, 24  }
	,  {  36, 38, 24  }
	,  {  24, 38, 26  }
	,  {  38, 40, 26  }
	,  {  21, 34, 27  }
	,  {  34, 41, 27  }
	,  {  26, 40, 20  }
	,  {  40, 32, 20  }
	,  {  23, 37, 17  }
	,  {  37, 42, 17  }
	,  {  17, 42, 18  }
	,  {  42, 35, 18  }
	,  {  25, 39, 23  }
	,  {  39, 37, 23  }
	,  {  27, 41, 25  }
	,  {  41, 39, 25  }
	,  {  7, 44, 6  }
	,  {  6, 44, 43  }
	,  {  8, 46, 7  }
	,  {  7, 46, 44  }
	,  {  9, 47, 8  }
	,  {  8, 47, 46  }
	,  {  9, 10, 47  }
	,  {  47, 10, 48  }
	,  {  10, 11, 48  }
	,  {  48, 11, 49  }
	,  {  11, 6, 49  }
	,  {  49, 6, 43  }
	,  {  19, 21, 52  }
	,  {  21, 50, 52  }
	,  {  19, 52, 20  }
	,  {  52, 51, 20  }
	,  {  18, 22, 54  }
	,  {  22, 55, 54  }
	,  {  22, 24, 55  }
	,  {  24, 57, 55  }
	,  {  26, 59, 24  }
	,  {  59, 57, 24  }
	,  {  21, 27, 50  }
	,  {  27, 58, 50  }
	,  {  20, 51, 26  }
	,  {  51, 59, 26  }
	,  {  18, 54, 17  }
	,  {  54, 60, 17  }
	,  {  17, 60, 23  }
	,  {  60, 53, 23  }
	,  {  23, 53, 25  }
	,  {  53, 56, 25  }
	,  {  27, 25, 58  }
	,  {  25, 56, 58  }
	,  {  14, 61, 15  }
	,  {  61, 63, 15  }
	,  {  13, 15, 62  }
	,  {  15, 63, 62  }
	,  {  13, 62, 16  }
	,  {  62, 64, 16  }
	,  {  14, 16, 61  }
	,  {  16, 64, 61  }
};



void ErrorRenderLoop::setDrawEnv(void)
{
	cellGcmSetColorMask(CELL_GCM_COLOR_MASK_B|
			CELL_GCM_COLOR_MASK_G|
			CELL_GCM_COLOR_MASK_R|
			CELL_GCM_COLOR_MASK_A);

	cellGcmSetColorMaskMrt(0);
	uint16_t x,y,w,h;
	float min, max;
	float scale[4],offset[4];

	x = 0;
	y = 0;
	w = display_width;
	h = display_height;
	min = 0.0f;
	max = 1.0f;
	scale[0] = w * 0.5f;
	scale[1] = h * -0.5f;
	scale[2] = (max - min) * 0.5f;
	scale[3] = 0.0f;
	offset[0] = x + scale[0];
	offset[1] = y + h * 0.5f;
	offset[2] = (max + min) * 0.5f;
	offset[3] = 0.0f;

	cellGcmSetViewport(x, y, w, h, min, max, scale, offset);
	cellGcmSetClearColor((64<<0)|(64<<8)|(64<<16)|(64<<24));

	cellGcmSetDepthTestEnable(CELL_GCM_TRUE);
	cellGcmSetDepthFunc(CELL_GCM_LESS);

}

void ErrorRenderLoop::setRenderState(void)
{
	cellGcmSetVertexProgram(vertex_program, vertex_program_ucode);
	cellGcmSetVertexDataArray(position_index,
			0, 
			sizeof(Vertex_t), 
			3, 
			CELL_GCM_VERTEX_F, 
			CELL_GCM_LOCATION_LOCAL, 
			m_nVertPositionOffset);
	cellGcmSetVertexDataArray(normal_index,
		0, 
		sizeof(Vertex_t), 
		3, 
		CELL_GCM_VERTEX_F, 
		CELL_GCM_LOCATION_LOCAL, 
		m_nVertNormalOffset);
	cellGcmSetVertexDataArray(color_index,
			0, 
			sizeof(Vertex_t), 
			4, 
			CELL_GCM_VERTEX_UB, 
			CELL_GCM_LOCATION_LOCAL, 
			m_nVertColorOffset );



	cellGcmSetFragmentProgram(fragment_program, fragment_offset);

}


void AngleMatrix( float yaw, float pitch, float roll, float matrix[16] )
{
	float sy = sinf(yaw),cy = cosf( yaw ),sp = sinf( pitch ),cp = cosf( pitch ),sr = sinf( roll ),cr = cosf( roll );

	// matrix = (YAW * PITCH) * ROLL
	matrix[0*4+0] = cp*cy;
	matrix[1*4+0] = cp*sy;
	matrix[2*4+0] = -sp;

	// NOTE: Do not optimize this to reduce multiplies! optimizer bug will screw this up.
	matrix[0*4+1] = sr*sp*cy+cr*-sy;
	matrix[1*4+1] = sr*sp*sy+cr*cy;
	matrix[2*4+1] = sr*cp;
	matrix[0*4+2] = (cr*sp*cy+-sr*-sy);
	matrix[1*4+2] = (cr*sp*sy+-sr*cy);
	matrix[2*4+2] = cr*cp;

	matrix[0*4+3] = 0.0f;
	matrix[1*4+3] = 0.0f;
	matrix[2*4+3] = 0.0f;
	
	matrix[3*4+0] = 0;
	matrix[3*4+1] = 0;
	matrix[3*4+2] = 0;
	matrix[3*4+3] = 1;
}



// call this AFTER setRenderState and setRenderObject
void ErrorRenderLoop::setTransforms(float *M)
{
	// transform
	float P[16];
	float V[16];
	float VP[16];

	// projection 
	buildProjection(P, -1.0f, 1.0f, -1.0f, 1.0f, 1.0, 10000.0f); 

	// 16:9 scale or 4:3 scale
	matrixTranslate(V, 0.0f, 0.0f, -4.0);
	V[0*4 + 0] = 1.0f / display_aspect_ratio;
	V[1*4 + 1] = 1.0f; 

	// model view 
	matrixMul(VP, P, V);

	matrixMul(MVP, VP, M);

	cellGcmSetVertexProgramParameter(model_view_projection, MVP);
}

int32_t ErrorRenderLoop::setRenderObject(void)
{
	void *ret = localMemoryAlign(128, sizeof(Vertex_t) * ARRAYSIZE( g_verts_polySurfaceShape1 ) );
	m_pVertexBuffer = (Vertex_t*)ret;
	memcpy( m_pVertexBuffer, g_verts_polySurfaceShape1, sizeof( g_verts_polySurfaceShape1 ) );
	
	m_pIndexBuffer = (uint16_t *)localMemoryAlign( 128, sizeof( uint16_t ) * ARRAYSIZE( g_tris_polySurfaceShape1 ) * 3 );
	memcpy( m_pIndexBuffer, g_tris_polySurfaceShape1, sizeof( g_tris_polySurfaceShape1 ) );

	model_view_projection = cellGcmCgGetNamedParameter(vertex_program, "modelViewProj");
	CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(model_view_projection);
	CGparameter position = cellGcmCgGetNamedParameter(vertex_program, "position");
	CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(position);
	CGparameter normal = cellGcmCgGetNamedParameter(vertex_program, "normal");
	CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(normal);
	CGparameter color = cellGcmCgGetNamedParameter(vertex_program, "color");
	CELL_GCMUTIL_CG_PARAMETER_CHECK_ASSERT(color);

	// get Vertex Attribute index
	position_index = cellGcmCgGetParameterResource(vertex_program, position) - CG_ATTR0;
	normal_index = cellGcmCgGetParameterResource(vertex_program, normal) - CG_ATTR0;
	color_index = cellGcmCgGetParameterResource(vertex_program, color) - CG_ATTR0;

	// fragment program offset
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(fragment_program_ucode, &fragment_offset));
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(&m_pVertexBuffer->x, &m_nVertPositionOffset));
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(&m_pVertexBuffer->nx, &m_nVertNormalOffset));
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(&m_pVertexBuffer->rgba, &m_nVertColorOffset));
	CELL_GCMUTIL_CHECK_ASSERT(cellGcmAddressToOffset(m_pIndexBuffer, &m_nIndexBufferLocalMemoryOffset));
	
	return 0;
}


const uint32_t g_nInitCmdBuffer = 0x1000;

int32_t SimpleContextCallback( struct CellGcmContextData *pData, uint32_t nSize )
{
	*pData->current = CELL_GCM_JUMP( g_nInitCmdBuffer );
	__sync();
	CellGcmControl * pControlRegister = cellGcmGetControlRegister();
	pControlRegister->put = g_nInitCmdBuffer;
	do 
	{
		sys_timer_usleep( 60 );
	} while ( pControlRegister->get != g_nInitCmdBuffer );
	pData->current = pData->begin;
	return CELL_OK;
}


int ErrorRenderLoop::Run( void )
{
	// Exit routines
	{
		// register sysutil exit callback
		CELL_GCMUTIL_CHECK_ASSERT( cellSysutilRegisterCallback( 0, sysutil_exit_callback, this ) );
		
		CELL_GCMUTIL_CHECK_ASSERT( cellSysutilCheckCallback() );
		if ( !m_keepRunning )
			return 0;
	}
	
	if( g_gcmSharedData.m_pIoMemory )
	{
		// GCM has already been initialized, no need to reinitialize it.
		// But we have to  drive RSX to our new command buffer
		const uint32_t nCmdBufferOverfetchSlack = 1024;
		//printf( "Entering Error Render Loop, reusing IO memory @%p size 0x%X; initial ctx={%p,%p,%p;fn=%p}\n", g_gcmSharedData.m_pIoMemory, g_gcmSharedData.m_nIoMemorySize, gCellGcmCurrentContext->begin, gCellGcmCurrentContext->current, gCellGcmCurrentContext->end, gCellGcmCurrentContext->callback );
		cellGcmSetCurrentBuffer( 
			// start command buffer right after initialization fixed command buffer (always the first 4 k of IO memory)
			( uint32_t* )( uint32_t( g_gcmSharedData.m_pIoMemory ) + g_nInitCmdBuffer ), 
			// the size is all of IO memory, minus initialization command buffer, minus overfetch amount in the end of command buffer to avoid a crash,
			// minus 4 bytes to insert a JUMP to the start of command buffer when we run out of space
			g_gcmSharedData.m_nIoMemorySize - nCmdBufferOverfetchSlack - g_nInitCmdBuffer - sizeof( uint32_t ) );
		CellGcmContextData *pCurrentContext = gCellGcmCurrentContext;
		pCurrentContext->callback = SimpleContextCallback;
		
		CellGcmControl * pControlRegister = cellGcmGetControlRegister();
		uint32_t nPut = pControlRegister->put;
		uint32_t * pCurrentCmd = ( uint32_t* )( uint32_t( g_gcmSharedData.m_pIoMemory ) + nPut );
		pCurrentContext->current = pCurrentCmd; // de facto current
		
// 		#ifndef _CERT
// 		if ( pControlRegister->put != g_nInitCmdBuffer || gCellGcmCurrentContext->current != ( uint32_t* )( uint32_t( g_gcmSharedData.m_pIoMemory ) + g_nInitCmdBuffer ) )
// 		{
// 			__builtin_snpause();
// 		}
// 		#endif
	}
	else
	{
		sys_addr_t allocatedAddress = NULL;
		int smaResult = sys_memory_allocate( 1 * 1024 * 1024, SYS_MEMORY_PAGE_SIZE_1M, &allocatedAddress );
		if( smaResult != CELL_OK )
			return smaResult;
		void* host_addr = (void*)allocatedAddress;
		printf( "Entering Error Render loop, IO memory @%p...\n", host_addr );
		CELL_GCMUTIL_ASSERT(host_addr != NULL);
		CELL_GCMUTIL_CHECK_ASSERT(cellGcmInit(CB_SIZE, HOST_SIZE, host_addr));
	}

	if (initDisplay()!=0)	return -1;

	initShader();

	setDrawEnv();

	if (setRenderObject())
		return -1;

	setRenderState();

	// 1st time
	setRenderTarget(frame_index);

	// rendering loop
	CELL_GCMUTIL_ASSERT(m_keepRunning);
	float flTime = 0;
	uint32_t nFrames = 0;
	while (m_keepRunning) {
		// check system event
		CELL_GCMUTIL_CHECK_ASSERT( cellSysutilCheckCallback() );

		// clear frame buffer
		cellGcmSetClearSurface(
			CELL_GCM_CLEAR_Z |
			CELL_GCM_CLEAR_R |
			CELL_GCM_CLEAR_G |
			CELL_GCM_CLEAR_B |
			CELL_GCM_CLEAR_A
		);
		float tm[16];
		AngleMatrix(0.1f * sinf( flTime * 0.5f ), 0.5f * sinf( flTime * 0.45f ), 0.1f * sinf( flTime*0.02f ), tm);
		setTransforms(tm);
		// set draw command
		if( flTime > 4.0f )
		{
			cellGcmSetDrawIndexArray(CELL_GCM_PRIMITIVE_TRIANGLES, 3 * ARRAYSIZE( g_tris_polySurfaceShape1 ), CELL_GCM_DRAW_INDEX_ARRAY_TYPE_16, CELL_GCM_LOCATION_LOCAL, m_nIndexBufferLocalMemoryOffset );
		}

		// start reading the command buffer
		flip();
		flTime += 1/60.0f;
		nFrames ++;
	}
	printf( "Exiting Error Render loop, %u frames rendered", nFrames );
	cellSysutilUnregisterCallback( 0 );
	
	// Let RSX wait for final flip
	cellGcmSetWaitFlip();

	// Let PPU wait for all commands done (include waitFlip)
	cellGcmFinish(1);
	
	// let's just leak this memory to avoid problems due to initializing GCM in different places, it doesn't matter
	//sys_memory_free( g_gcmSharedData.m_pIoMemory );
	
	printf(".\n");

	return 0;
}

void sysutil_exit_callback(uint64_t status, uint64_t param, void* userdata)
{
	(void) param;
	(void) userdata;

	switch(status) {
	case CELL_SYSUTIL_REQUEST_EXITGAME:
		((ErrorRenderLoop*)userdata)->m_keepRunning = false;
		break;
	case CELL_SYSUTIL_DRAWING_BEGIN:
	case CELL_SYSUTIL_DRAWING_END:
	case CELL_SYSUTIL_SYSTEM_MENU_OPEN:
	case CELL_SYSUTIL_SYSTEM_MENU_CLOSE:
	case CELL_SYSUTIL_BGMPLAYBACK_PLAY:
	case CELL_SYSUTIL_BGMPLAYBACK_STOP:
	default:
		break;
	}
}