vertex.c

psp开发用的所有头文件。包含所有系统API。需要psp-gcc编译器。在www.psp-dev.com上有

			addMenuItem(context,numWeightsMenu,createRadioButton("2",0),NumWeightsMenu,GU_WEIGHTS(2));
			addMenuItem(context,numWeightsMenu,createRadioButton("3",0),NumWeightsMenu,GU_WEIGHTS(3));
			addMenuItem(context,numWeightsMenu,createRadioButton("4",0),NumWeightsMenu,GU_WEIGHTS(4));
			addMenuItem(context,numWeightsMenu,createRadioButton("5",0),NumWeightsMenu,GU_WEIGHTS(5));
			addMenuItem(context,numWeightsMenu,createRadioButton("6",0),NumWeightsMenu,GU_WEIGHTS(6));
			addMenuItem(context,numWeightsMenu,createRadioButton("7",0),NumWeightsMenu,GU_WEIGHTS(7));
			addMenuItem(context,numWeightsMenu,createRadioButton("8",0),NumWeightsMenu,GU_WEIGHTS(8));
		}

		MenuItem* numVerticesMenu = addMenuItem(context,vertexFormatMenu,createMenuContainer("Num. Vertices"),NoAction,0);
		{
			addMenuItem(context,numVerticesMenu,createRadioButton("1",1),NumVerticesMenu,GU_VERTICES(1));
			addMenuItem(context,numVerticesMenu,createRadioButton("2",0),NumVerticesMenu,GU_VERTICES(2));
			addMenuItem(context,numVerticesMenu,createRadioButton("3",0),NumVerticesMenu,GU_VERTICES(3));
			addMenuItem(context,numVerticesMenu,createRadioButton("4",0),NumVerticesMenu,GU_VERTICES(4));
			addMenuItem(context,numVerticesMenu,createRadioButton("5",0),NumVerticesMenu,GU_VERTICES(5));
			addMenuItem(context,numVerticesMenu,createRadioButton("6",0),NumVerticesMenu,GU_VERTICES(6));
			addMenuItem(context,numVerticesMenu,createRadioButton("7",0),NumVerticesMenu,GU_VERTICES(7));
			addMenuItem(context,numVerticesMenu,createRadioButton("8",0),NumVerticesMenu,GU_VERTICES(8));
		}

		MenuItem* memoryMenu = addMenuItem(context,vertexFormatMenu,createMenuContainer("Memory Location"),NoAction,0);
		{
			addMenuItem(context,memoryMenu,createRadioButton("System RAM",1),MemoryMenu,0);
			addMenuItem(context,memoryMenu,createRadioButton("Video RAM",0),MemoryMenu,1);
		}
	}


	MenuItem* indexBufferMenu = addMenuItem(context,0,createMenuContainer("Index Buffer"),NoAction,0);
	{
		addMenuItem(context,indexBufferMenu,createRadioButton("Disabled",1),IndexBufferMenu,0);
		addMenuItem(context,indexBufferMenu,createRadioButton("Enabled",0),IndexBufferMenu,1);

		MenuItem* indexFormatMenu = addMenuItem(context,indexBufferMenu,createMenuContainer("Format"),NoAction,0);
		{
			addMenuItem(context,indexFormatMenu,createRadioButton("8-bit",0),IndexFormatMenu,GU_INDEX_8BIT);
			addMenuItem(context,indexFormatMenu,createRadioButton("16-bit",1),IndexFormatMenu,GU_INDEX_16BIT);
		}

		MenuItem* indexMemoryMenu = addMenuItem(context,indexBufferMenu,createMenuContainer("Memory Location"),NoAction,0);
		{
			addMenuItem(context,indexMemoryMenu,createRadioButton("System RAM",1),IndexMemoryMenu,0);
			addMenuItem(context,indexMemoryMenu,createRadioButton("Video RAM",0),IndexMemoryMenu,1);
		}

		MenuItem* indexCacheMenu = addMenuItem(context,indexBufferMenu,createMenuContainer("Cache Test Size"),NoAction,0);
		{
			addMenuItem(context,indexCacheMenu,createRadioButton("Disabled",1),IndexCacheMenu,batchSize);
			addMenuItem(context,indexCacheMenu,createRadioButton("4",0),IndexCacheMenu,4);
			addMenuItem(context,indexCacheMenu,createRadioButton("8",0),IndexCacheMenu,8);
			addMenuItem(context,indexCacheMenu,createRadioButton("16",0),IndexCacheMenu,16);
			addMenuItem(context,indexCacheMenu,createRadioButton("32",0),IndexCacheMenu,32);
		}
	}

	addMenuItem(context,0,createTriggerButton("Quit"),QuitTrigger,0);

	unsigned int vertexMask = GU_COLOR_8888|GU_VERTEX_32BITF;
	unsigned int vertexSize = getVertexSize(vertexMask);
	int exitRequested = 0;
	int changed = 1;
	int memorySelection = 0;
	int indexEnabled = 0;
	int indexFormat = GU_INDEX_16BIT;
	int indexCacheSize = batchSize;
	int indexMemory = 0;
	u64 tickCount = 0;
	u32 tickResolution = sceRtcGetTickResolution();
	u32 vertexCount = 0;
	float avgVertexSpeed = 0;
	int batchCount = 1;

	while(running() && !exitRequested)
	{
		SceCtrlData pad;
		if (!sceCtrlPeekBufferPositive(&pad,1))
			pad = oldPad;

		MenuItem* action = handleMenu(context, &pad);
		if (action)
		{
			switch (action->id)
			{
				case TextureMenu:
				{
					vertexMask = (vertexMask & ~GU_TEXTURE_BITS) | action->data;
					changed = 1;
				}
				break;

				case ColorMenu:
				{
					vertexMask = (vertexMask & ~GU_COLOR_BITS) | action->data;
					changed = 1;
				}
				break;

				case NormalMenu:
				{
					vertexMask = (vertexMask & ~GU_NORMAL_BITS) | action->data;
					changed = 1;
				}
				break;

				case VertexMenu:
				{
					vertexMask = (vertexMask & ~GU_VERTEX_BITS) | action->data;
					changed = 1;
				}
				break;

				case WeightMenu:
				{
					vertexMask = (vertexMask & ~GU_WEIGHT_BITS) | action->data;
					changed = 1;
				}
				break;

				case NumWeightsMenu:
				{
					vertexMask = (vertexMask & ~GU_WEIGHTS_BITS) | action->data;
					changed = 1;
				}
				break;

				case NumVerticesMenu:
				{
					vertexMask = (vertexMask & ~GU_VERTICES_BITS) | action->data;
					changed = 1;
				}
				break;

				case IndexBufferMenu:
				{
					indexEnabled = action->data;
					vertexMask = (vertexMask & ~GU_INDEX_BITS) | (indexEnabled ? indexFormat : 0);
					changed = 1;
				}
				break;

				case IndexFormatMenu:
				{
					indexFormat = action->data;
					vertexMask = (vertexMask & ~GU_INDEX_BITS) | (indexEnabled ? indexFormat : 0);
					changed = 1;
				}
				break;

				case IndexCacheMenu:
				{
					indexCacheSize = action->data;
					changed = 1;
				}
				break;

				case IndexMemoryMenu:
				{
					indexMemory = action->data;
					changed = 1;
				}
				break;

				case MemoryMenu:
				{
					memorySelection = action->data;
					changed = 1;
				}
				break;

				case QuitTrigger:
					exitRequested = 1;
				break;

				case NoAction:
				default:
					break;
			}
		}

		if (changed)
		{
			pspDebugScreenSetOffset((int)fbp1);
			pspDebugScreenSetXY((60/2)-(31/2),33/2); // TODO: center?
			pspDebugScreenPrintf("--- Rebuilding buffers ---");

			// re-generate buffers

			generateVertexBuffer(vertexMask,memorySelection ? vramVertexBuffer : ramVertexBuffer,batchSize);
			if (indexEnabled)
			{
				switch (vertexMask & GU_INDEX_BITS)
				{
					case GU_INDEX_8BIT:
					{
						unsigned char* indexBuffer = indexMemory ? vramIndexBuffer : ramIndexBuffer;
						int i;
						for (i = 0; i < batchSize; ++i)
							*indexBuffer++ = (i % indexCacheSize);
					}
					break;

					case GU_INDEX_16BIT:
					{
						unsigned short* indexBuffer = indexMemory ? vramIndexBuffer : ramIndexBuffer;
						int i;
						for (i = 0; i < batchSize; ++i)
							*indexBuffer++ = (i % indexCacheSize);
					}
					break;
				}
			}



			vertexSize = getVertexSize(vertexMask);
			sceKernelDcacheWritebackAll();
			changed = 0;

			vertexCount = 0;
			tickCount = 0;
			avgVertexSpeed = 0;
			batchCount = 1;
		}

		// TODO: additional input processing here

		oldPad = pad;

		sceGuStart(GU_SEND,list);

		// run gu stuff not to be measured

		sceGuStart(GU_DIRECT,list);

		sceGuClearColor(0xff554433);
		sceGuClearDepth(0);
		sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);

		sceGumMatrixMode(GU_PROJECTION);
		sceGumLoadIdentity();
		sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);

		sceGumMatrixMode(GU_VIEW);
		sceGumLoadIdentity();

		sceGumMatrixMode(GU_MODEL);
		sceGumLoadIdentity();

		sceGuFinish();
		sceGuSync(0,0);

		// draw cube

		sceGuStart(GU_SEND,list);
		int i;
		for (i = 0; i < batchCount; ++i)
			sceGumDrawArray(GU_POINTS,vertexMask,batchSize,indexMemory ? vramIndexBuffer : ramIndexBuffer,memorySelection ? vramVertexBuffer : ramVertexBuffer);
		sceGuFinish();
		vertexCount += batchSize * batchCount;

		PspGeContext tempGeContext;
		u64 tick1,tick2;
		sceRtcGetCurrentTick(&tick1);
		sceGuSendList(GU_TAIL,list,&tempGeContext);
		sceGuSync(0,0);
		sceRtcGetCurrentTick(&tick2);

		// rescale number of batches if they rendered faster/slower than threshold

		if (((tick2-tick1) < (tickResolution * (1.0f/60.0f) * 0.8f)) || ((tick2-tick1) > (tickResolution * (1.0f/60.0f) * 1.0f)))
		{
			batchCount = (int)((tickResolution * (1.0f/60.0f) * 0.8f) / (((tick2-tick1) / (float)batchCount)));
			batchCount = batchCount > 130 ? 130 : batchCount < 1 ? 1 : batchCount;
		}

		tickCount += (tick2-tick1);
		if (tickCount > tickResolution)
		{
			float timeSpan = tickCount / (float)tickResolution;
			avgVertexSpeed = (vertexCount / timeSpan) / 1000000;

			tickCount = 0;
			vertexCount = 0;
		}

		pspDebugScreenSetOffset((int)fbp0);
		pspDebugScreenSetXY(0,0);
		pspDebugScreenPrintf("Mask: 0x%08x, Size: %u", vertexMask, vertexSize,val);
		if (avgVertexSpeed)
			pspDebugScreenPrintf(", %.2f million vertices / sec.",avgVertexSpeed);
		else
			pspDebugScreenPrintf(", accumulating (%.2f%%)...",100.0f * (tickCount / (float)tickResolution));

		pspDebugScreenSetXY(0,32);
		pspDebugScreenPrintf("This is performance numbers, not real world numbers!");

		renderMenu(context,0,2);

		sceDisplayWaitVblankStart();
		fbp1 = fbp0;
		fbp0 = sceGuSwapBuffers();

		val++;
	}

	sceGuTerm();

	sceKernelExitGame();
	return 0;
}