Exemple #1
0
// All threads start execution here.
int main()
{
	if (__builtin_nyuzi_read_control_reg(0) == 0)
		init_vga(VGA_MODE_640x480);
	else
		workerThread();

	startAllThreads();

	RenderContext *context = new RenderContext();
	RenderTarget *renderTarget = new RenderTarget();
	Surface *colorBuffer = new Surface(kFbWidth, kFbHeight, (void*) 0x200000);
	Surface *depthBuffer = new Surface(kFbWidth, kFbHeight);
	renderTarget->setColorBuffer(colorBuffer);
	renderTarget->setDepthBuffer(depthBuffer);
	context->bindTarget(renderTarget);
	context->enableDepthBuffer(true);
	context->bindShader(new TextureShader());

	const RenderBuffer kVertices(kCubeVertices, kNumCubeVertices, 5 * sizeof(float));
	const RenderBuffer kIndices(kCubeIndices, kNumCubeIndices, sizeof(int));
	context->bindVertexAttrs(&kVertices);

	Texture *texture = new Texture();
	texture->setMipSurface(0, new Surface(128, 128, (void*) kTestTexture));
	texture->enableBilinearFiltering(true);
	context->bindTexture(0, texture);

	Matrix projectionMatrix = Matrix::getProjectionMatrix(kFbWidth, kFbHeight);
	Matrix modelViewMatrix;
	Matrix rotationMatrix;
	modelViewMatrix = Matrix::getTranslationMatrix(Vec3(0.0f, 0.0f, -3.0f));
	modelViewMatrix *= Matrix::getScaleMatrix(2.0f);
	modelViewMatrix *= Matrix::getRotationMatrix(M_PI / 3.5, Vec3(1, -1, 0));
	rotationMatrix = Matrix::getRotationMatrix(M_PI / 8, Vec3(1, 1, 0.0f));

	for (int frame = 0; frame < 1; frame++)
	{
		TextureUniforms uniforms;
		uniforms.fMVPMatrix = projectionMatrix * modelViewMatrix;
		context->bindUniforms(&uniforms, sizeof(uniforms));
		context->clearColorBuffer();
		context->drawElements(&kIndices);
		context->finish();
		modelViewMatrix *= rotationMatrix;
	}

	return 0;
}
Exemple #2
0
int main()
{
	RenderTarget *renderTarget = new RenderTarget();
	Surface *colorBuffer = new (memalign(64, sizeof(Surface))) Surface(kFbWidth, kFbHeight, (void*) 0x200000);
	Surface *zBuffer = new (memalign(64, sizeof(Surface))) Surface(kFbWidth, kFbHeight);
	renderTarget->setColorBuffer(colorBuffer);
	renderTarget->setZBuffer(zBuffer);
	RenderContext *context = new RenderContext(renderTarget);
	
	VertexShader *vertexShader = new (memalign(64, sizeof(PhongVertexShader))) PhongVertexShader();
	PixelShader *pixelShader = new PhongPixelShader(renderTarget);

	pixelShader->enableZBuffer(true);
	context->bindShader(vertexShader, pixelShader);

	PhongUniforms *uniforms = new PhongUniforms;
	uniforms->fLightVector[0] = 0.7071067811f;
	uniforms->fLightVector[1] = 0.7071067811f; 
	uniforms->fLightVector[2] = 0.0f;
	uniforms->fDirectional = 0.6f;		
	uniforms->fAmbient = 0.2f;

	context->bindUniforms(uniforms);

	Matrix projectionMatrix = Matrix::getProjectionMatrix(kFbWidth, kFbHeight);
	Matrix modelViewMatrix;
	Matrix rotationMatrix;
	context->bindGeometry(kTeapotVertices, kNumTeapotVertices, kTeapotIndices, kNumTeapotIndices);
	modelViewMatrix = Matrix::getTranslationMatrix(0.0f, 0.1f, 0.25f);
	modelViewMatrix = modelViewMatrix * Matrix::getRotationMatrix(M_PI, -1.0f, 0.0f, 0.0f);
	
	rotationMatrix = Matrix::getRotationMatrix(M_PI / 8, 0.707f, 0.707f, 0.0f);

	for (int frame = 0; frame < 1; frame++)
	{
		uniforms->fMVPMatrix = projectionMatrix * modelViewMatrix;
		uniforms->fNormalMatrix = modelViewMatrix.upper3x3();
		context->renderFrame();
		modelViewMatrix = modelViewMatrix * rotationMatrix;
	}
	
	return 0;
}
Exemple #3
0
// All threads start execution here.
int main()
{
    void *frameBuffer;
    if (get_current_thread_id() != 0)
        worker_thread();

    // Set up render context
    frameBuffer = init_vga(VGA_MODE_640x480);

    start_all_threads();

    RenderContext *context = new RenderContext();
    RenderTarget *renderTarget = new RenderTarget();
    Surface *colorBuffer = new Surface(kFbWidth, kFbHeight, frameBuffer);
    Surface *depthBuffer = new Surface(kFbWidth, kFbHeight);
    renderTarget->setColorBuffer(colorBuffer);
    renderTarget->setDepthBuffer(depthBuffer);
    context->bindTarget(renderTarget);
    context->enableDepthBuffer(true);
    context->bindShader(new CheckerboardShader());

    const RenderBuffer kVertices(kRoomVertices, kNumRoomVertices, 5 * sizeof(float));
    const RenderBuffer kIndices(kRoomIndices, kNumRoomIndices, sizeof(int));
    context->bindVertexAttrs(&kVertices);

    Matrix projectionMatrix = Matrix::getProjectionMatrix(kFbWidth, kFbHeight);
    Matrix modelViewMatrix = Matrix::getRotationMatrix(M_PI / 3, Vec3(0.0f, 1.0f, 0.0f));
    Matrix rotationMatrix = Matrix::getRotationMatrix(M_PI / 16, Vec3(0.0f, 1.0f, 0.0f));

    for (int frame = 0; frame < 1; frame++)
    {
        CheckerboardUniforms uniforms;
        uniforms.fMVPMatrix = projectionMatrix * modelViewMatrix;
        context->bindUniforms(&uniforms, sizeof(uniforms));
        context->drawElements(&kIndices);
        context->finish();
        modelViewMatrix *= rotationMatrix;
    }

    return 0;
}
Exemple #4
0
// All threads start execution here.
int main()
{
	if (__builtin_nyuzi_read_control_reg(0) != 0)
		workerThread();

	// Start worker threads
	__builtin_nyuzi_write_control_reg(30, 0xffffffff);

	RenderContext *context = new RenderContext();
	RenderTarget *renderTarget = new RenderTarget();
	Surface *colorBuffer = new Surface(kFbWidth, kFbHeight, (void*) 0x200000);
	Surface *depthBuffer = new Surface(kFbWidth, kFbHeight);
	renderTarget->setColorBuffer(colorBuffer);
	renderTarget->setDepthBuffer(depthBuffer);
	context->bindTarget(renderTarget);
	context->enableDepthBuffer(true);
	context->bindShader(new CheckerboardShader());

	const RenderBuffer kVertices(kRoomVertices, kNumRoomVertices, 5 * sizeof(float));
	const RenderBuffer kIndices(kRoomIndices, kNumRoomIndices, sizeof(int));
	context->bindGeometry(&kVertices, &kIndices);

	Matrix projectionMatrix = Matrix::getProjectionMatrix(kFbWidth, kFbHeight);
	Matrix modelViewMatrix = Matrix::getRotationMatrix(M_PI / 3, Vec3(0.0f, 1.0f, 0.0f));
	Matrix rotationMatrix = Matrix::getRotationMatrix(M_PI / 16, Vec3(0.0f, 1.0f, 0.0f));

	for (int frame = 0; frame < 1; frame++)
	{
		CheckerboardUniforms uniforms;
		uniforms.fMVPMatrix = projectionMatrix * modelViewMatrix;
		context->bindUniforms(&uniforms, sizeof(uniforms));
		context->submitDrawCommand();
		context->finish();
		modelViewMatrix *= rotationMatrix;
	}
	
	exit(1);	// Stop worker threads
	return 0;
}
Exemple #5
0
// All threads start execution here.
int main()
{
    void *frameBuffer;
    if (get_current_thread_id() != 0)
        worker_thread();

    // Set up render context
    frameBuffer = init_vga(VGA_MODE_640x480);
    RenderContext *context = new RenderContext(0x1000000);
    RenderTarget *renderTarget = new RenderTarget();
    Surface *colorBuffer = new Surface(FB_WIDTH, FB_HEIGHT, Surface::RGBA8888,
        (void*) frameBuffer);
    Surface *zBuffer = new Surface(FB_WIDTH, FB_HEIGHT, Surface::FLOAT);
    renderTarget->setColorBuffer(colorBuffer);
    renderTarget->setDepthBuffer(zBuffer);
    context->bindTarget(renderTarget);
    context->enableDepthBuffer(true);
    context->bindShader(new TextureShader());

    // Read resources
    PakFile pak;
    pak.open("pak0.pak");
    pak.readBspFile("maps/e1m1.bsp");
    Texture *atlasTexture = pak.getTextureAtlasTexture();

    LevelRenderer renderer;
    renderer.setBspData(pak.getBspTree(), pak.getPvsList(), pak.getBspTree()
                        + pak.getNumInteriorNodes(), pak.getNumLeaves(),
                        atlasTexture, pak.getLightmapAtlasTexture());
    Entity *ent = pak.findEntityByClassName("info_player_start");
    if (!ent)
    {
        printf("Error, couldn't find start position\n");
        return 1;
    }

    float facingAngle = float(atoi(ent->getAttribute("angle"))) / 360.0 * M_PI * 2;
    gCameraOrientationMatrix = Matrix::lookAt(Vec3(0, 0, 0), Vec3(cos(facingAngle),
                               sin(facingAngle), 0), kUpVector);

    float coords[3];
    parseCoordinateString(ent->getAttribute("origin"), coords);
    for (int i = 0; i < 3; i++)
        gCameraPos[i] = coords[i];

    printf("position %g %g %g angle %g\n", coords[0], coords[1], coords[2], facingAngle);

    // Start worker threads
    start_all_threads();

    TextureUniforms uniforms;
    Matrix projectionMatrix = Matrix::getProjectionMatrix(FB_WIDTH, FB_HEIGHT);

    for (int frame = 0; ; frame++)
    {
        processKeyboardEvents();

        context->enableWireframeMode(gWireframeRendering);
        atlasTexture->enableBilinearFiltering(gBilinearFiltering);

        // Set up uniforms
        Matrix viewMatrix = gCameraOrientationMatrix * Matrix::getTranslationMatrix(-gCameraPos);
        uniforms.fMVPMatrix = projectionMatrix * viewMatrix;
        uniforms.enableLightmap = gEnableLightmap;
        uniforms.enableTexture = gEnableTexture;

        context->bindUniforms(&uniforms, sizeof(uniforms));

        renderer.render(context, gCameraPos);

        clock_t startTime = clock();
        context->finish();
        printf("rendered frame in %d uS\n", clock() - startTime);
    }
}
// All threads start execution here.
int main()
{
	if (__builtin_nyuzi_read_control_reg(0) != 0)
		workerThread();
	
	// Set up resource data
	char *resourceData = readResourceFile();
	const FileHeader *resourceHeader = (FileHeader*) resourceData;
	const TextureEntry *texHeader = (TextureEntry*)(resourceData + sizeof(FileHeader));
	const MeshEntry *meshHeader = (MeshEntry*)(resourceData + sizeof(FileHeader) + resourceHeader->numTextures
		* sizeof(TextureEntry));
	Texture **textures = new Texture*[resourceHeader->numTextures];

	printf("%d textures %d meshes\n", resourceHeader->numTextures, resourceHeader->numMeshes);

	// Create texture objects
	for (unsigned int textureIndex = 0; textureIndex < resourceHeader->numTextures; textureIndex++)
	{
#if TEST_TEXTURE
		textures[textureIndex] = createCheckerboardTexture();
#else
		textures[textureIndex] = new Texture();
		textures[textureIndex]->enableBilinearFiltering(true);
		int offset = texHeader[textureIndex].offset;
		for (unsigned int mipLevel = 0; mipLevel < texHeader[textureIndex].mipLevels; mipLevel++)
		{
			int width = texHeader[textureIndex].width >> mipLevel;
			int height = texHeader[textureIndex].height >> mipLevel;
			Surface *surface = new Surface(width, height, resourceData + offset);
			textures[textureIndex]->setMipSurface(mipLevel, surface);
			offset += width * height * 4;
		}
#endif
	}
	
	// Create Render Buffers
	RenderBuffer *vertexBuffers = new RenderBuffer[resourceHeader->numMeshes];
	RenderBuffer *indexBuffers = new RenderBuffer[resourceHeader->numMeshes];
	for (unsigned int meshIndex = 0; meshIndex < resourceHeader->numMeshes; meshIndex++)
	{
		const MeshEntry &entry = meshHeader[meshIndex];
		vertexBuffers[meshIndex].setData(resourceData + entry.offset, 
			entry.numVertices, sizeof(float) * kAttrsPerVertex);
		indexBuffers[meshIndex].setData(resourceData + entry.offset + entry.numVertices 
			* kAttrsPerVertex * sizeof(float), entry.numIndices, sizeof(int));
	}

	// Set up render state
	RenderContext *context = new RenderContext(0x1000000);
	RenderTarget *renderTarget = new RenderTarget();
	Surface *colorBuffer = new Surface(FB_WIDTH, FB_HEIGHT, (void*) 0x200000);
	Surface *depthBuffer = new Surface(FB_WIDTH, FB_HEIGHT);
	renderTarget->setColorBuffer(colorBuffer);
	renderTarget->setDepthBuffer(depthBuffer);
	context->bindTarget(renderTarget);
	context->enableDepthBuffer(true);
#if SHOW_DEPTH
	context->bindShader(new DepthShader());
#else
	context->bindShader(new TextureShader());
#endif
	context->setClearColor(0.52, 0.80, 0.98);

	Matrix projectionMatrix = Matrix::getProjectionMatrix(FB_WIDTH, FB_HEIGHT);

	TextureUniforms uniforms;
	uniforms.fLightDirection = Vec3(-1, -0.5, 1).normalized();
	uniforms.fDirectional = 0.5f;		
	uniforms.fAmbient = 0.4f;
	float theta = 0.0;

	startAllThreads();

	for (int frame = 0; ; frame++)
	{
		Matrix modelViewMatrix = Matrix::lookAt(Vec3(cos(theta) * 6, 3, sin(theta) * 6), Vec3(0, 3.1, 0), 
			Vec3(0, 1, 0));
		theta = theta + M_PI / 8;
		if (theta > M_PI * 2)
			theta -= M_PI * 2;
		
		uniforms.fMVPMatrix = projectionMatrix * modelViewMatrix;
		uniforms.fNormalMatrix = modelViewMatrix.upper3x3();
		
		context->clearColorBuffer();
		for (unsigned int meshIndex = 0; meshIndex < resourceHeader->numMeshes; meshIndex++)
		{
			const MeshEntry &entry = meshHeader[meshIndex];
			if (entry.textureId != 0xffffffff)
			{
				assert(entry.textureId < resourceHeader->numTextures);
				context->bindTexture(0, textures[entry.textureId]);
				uniforms.fHasTexture = true;
			}
			else
				uniforms.fHasTexture = false;
			
			context->bindUniforms(&uniforms, sizeof(uniforms));
			context->bindVertexAttrs(&vertexBuffers[meshIndex]);
			context->drawElements(&indexBuffers[meshIndex]);
		}

		int startInstructions = __builtin_nyuzi_read_control_reg(6);
		context->finish();
		printf("rendered frame in %d instructions\n", __builtin_nyuzi_read_control_reg(6) 
			- startInstructions);
	}
	
	return 0;
}