Beispiel #1
0
Cubemap* TextureFactory::CreateCubemapFromFile(const char*const name, const std::vector<std::string>& paths, const TextureWrapMode wrapMode, const TextureFilterMode filterMode)
{
	if (strcmp(name, "") == 0)
	{
		LOG_ERROR("Cannot create a texture with an empty name string");
		return nullptr;
	}

	for (uint i = 0; i < paths.size(); i++)
	{
		if (strcmp(paths[i].c_str(), "") == 0)
		{
			LOG_ERROR("Cannot create a texture with an empty path string");
			return nullptr;
		}

		if (!FileUtils::CheckFileExists(paths[i].c_str()))
		{
			LOG_ERROR("Texture file \"", paths[i].c_str(), "\"was not found");
			return nullptr;
		}
	}

	Cubemap* texture = new Cubemap(name, paths, wrapMode, filterMode);
	
	if (!texture->Load())
	{
		LOG_ERROR("Failed to load cubemap: ", name);
		SafeDelete(texture);
		return nullptr;
	}

	return texture;
}
Cubemap *MaterialManager::cubemapFromXMLNode(TiXmlNode *node) {
	TiXmlElement *nodeElement = node->ToElement();
	if (!nodeElement) return NULL; // Skip comment nodes
	
	Cubemap *newCubemap = NULL;
	
	String name = nodeElement->Attribute("name");
	String xPos = nodeElement->Attribute("xPos");
	String xNeg = nodeElement->Attribute("xNeg");
	String yPos = nodeElement->Attribute("yPos");
	String yNeg = nodeElement->Attribute("yNeg");
	String zPos = nodeElement->Attribute("zPos");				
	String zNeg = nodeElement->Attribute("zNeg");
		
	newCubemap = CoreServices::getInstance()->getRenderer()->createCubemap(
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(xPos),
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(xNeg),
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(yPos),
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(yNeg),
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(zPos),
		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(zNeg)
	);
	newCubemap->setResourceName(name);
	return newCubemap;
}
Cubemap *MaterialManager::cubemapFromXMLNode(TiXmlNode *node) {
	TiXmlElement *nodeElement = node->ToElement();
	if (!nodeElement) return NULL; // Skip comment nodes
	
	Cubemap *newCubemap = NULL;
	
	String name = nodeElement->Attribute("name");
	String mapString = nodeElement->GetText();
	
	vector<String> maps = mapString.split(",");	
	if(maps.size() != 6) {
		Logger::log("Error: A cubemap must contain 6 images \n");
		return NULL;
	}
	
	newCubemap = CoreServices::getInstance()->getRenderer()->createCubemap(
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[0]),
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[1]),
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[2]),
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[3]),
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[4]),
							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[5])
	);
	newCubemap->setResourceName(name);
	return newCubemap;
}
Beispiel #4
0
void Renderer::onDraw(al::Graphics& gl)
{
    int faceIndex = mOmni.face();
    
    {
        
        
        // render cubemap
        if (cubemap && cubemap->getEyesCount() > 0)
        {
            Cubemap* eye = cubemap->getEye(0);
            if (eye->getFacesCount() > faceIndex)
            {
                CubemapFace* face = eye->getFace(faceIndex);
                
                glUseProgram(0);
                glDepthMask(GL_FALSE);
                
                // draw the background
                glDrawPixels(face->getWidth(),
                             face->getHeight(),
                             GL_RGB,
                             GL_UNSIGNED_BYTE,
                             (GLvoid*)face->getPixels());
                
                glDepthMask(GL_TRUE);
                
                
                
                if(newCubemap)
                {
                    if (onDisplayedCubemapFace) onDisplayedCubemapFace(this, faceIndex);
                }
            }
        }
    }
    
    light();
    mShader.begin();
    mOmni.uniforms(mShader);
    
    gl.pushMatrix();
    
    //gl.draw(cube);
    
    gl.pushMatrix();
    // rotate over time:
    gl.rotate(now*30., 0.707, 0.707, 0.);
    gl.translate(1., 1., 1.);
    //gl.draw(sphere);
    gl.popMatrix();
    
    gl.popMatrix();
    
    mShader.end();
}
Beispiel #5
0
void addFaceSubstreams0(void*)
{
	int portCounter = 0;
	for (int j = 0; j < cubemap->getEyesCount(); j++)
	{
		Cubemap* eye = cubemap->getEye(j);

		for (int i = 0; i < eye->getFacesCount(); i++)
		{
			faceStreams.push_back(FrameStreamState());
			FrameStreamState* state = &faceStreams.back();

			state->content = eye->getFace(i)->getContent();

			Port rtpPort(FACE0_RTP_PORT_NUM + portCounter);
			portCounter += 2;
			Groupsock* rtpGroupsock = new Groupsock(*env, destinationAddress, rtpPort, TTL);
			//rtpGroupsock->multicastSendOnly(); // we're a SSM source

			setReceiveBufferTo(*env, rtpGroupsock->socketNum(), bufferSize);

			// Create a 'H264 Video RTP' sink from the RTP 'groupsock':
			state->sink = H264VideoRTPSink::createNew(*env, rtpGroupsock, 96);

			ServerMediaSubsession* subsession = PassiveServerMediaSubsession::createNew(*state->sink);

			cubemapSMS->addSubsession(subsession);

			RawPixelSource* source = RawPixelSource::createNew(*env,
				state->content,
				avgBitRate);

			source->setOnSentNALU    (boost::bind(&onSentNALU,     _1, _2, _3, j, i));
			source->setOnEncodedFrame(boost::bind(&onEncodedFrame, _1, j, i));

			state->source = H264VideoStreamDiscreteFramer::createNew(*env,
				source);

			state->sink->startPlaying(*state->source, NULL, NULL);

			std::cout << "Streaming face " << i << " (" << ((j == 0) ? "left" : "right") << ") on port " << ntohs(rtpPort.num()) << " ..." << std::endl;
		}
	}
    
    announceStream(rtspServer, cubemapSMS, cubemapStreamName);
}
Beispiel #6
0
bool load()
{
	if (!shader_simple.loadAndLinkFromFile("./demo/11camera/simple") ||
		!shader_background.loadAndLinkFromFile("./demo/11camera/background"))
		return false;

	if (!cubemap.loadFromFile("./data/cubemaps/iceland_", ".jpg"))
		return false;

	glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
	cubemap.setTexParameteri(
		GL_LINEAR, 
		GL_LINEAR, 
		GL_CLAMP_TO_EDGE, 
		GL_CLAMP_TO_EDGE, 
		GL_CLAMP_TO_EDGE);

	return true;
}
extern "C" void EXPORT_API UnityRenderEvent (int eventID)
{
    // When we use the RenderCubemap.cs and USeRenderingPlugin.cs scripts
    // This function will get called twice (with different eventIDs).
    // We have to make sure that the extraction only happens once for the cubemap
	// and binoculars respectively!
    if (eventID == 1)
    {
        // Allocate cubemap the first time we render a frame.
        // By doing so, we can make sure that both
        // the cubemap and the binoculars are fully configured.
        if (!thisProcess)
        {
            allocateSHM(cubemapConfig, binocularsConfig);
        }
        
        presentationTime = boost::chrono::system_clock::now();
        
        std::vector<Frame*> frames;
        if (cubemap)
        {
			for (int j = 0; j < cubemap->getEyesCount(); j++)
			{
				Cubemap* eye = cubemap->getEye(j);
				for (int i = 0; i < eye->getFacesCount(); i++)
				{
					frames.push_back(eye->getFace(i)->getContent());
				}
			}
        }
        
        if (binoculars)
        {
            frames.push_back(binoculars->getContent());
        }
        
        copyFromGPUtoCPU(frames);
    }
}
Beispiel #8
0
int main (int argc, char** argv)
{

	/*---------------------- Initialize OpenGL and OpenCL ----------------------*/

	if (init_gl(argc,argv,&glinfo, window_size, "RT") != 0){
		std::cerr << "Failed to initialize GL" << std::endl;
		exit(1);
	} else { 
		std::cout << "Initialized GL succesfully" << std::endl;
	}

	if (init_cl(glinfo,&clinfo) != CL_SUCCESS){
		std::cerr << "Failed to initialize CL" << std::endl;
		exit(1);
	} else { 
		std::cout << "Initialized CL succesfully" << std::endl;
	}
	print_cl_info(clinfo);

        /* Initialize device interface */
        if (device.initialize(clinfo)) {
                std::cerr << "Failed to initialize device interface" << std::endl;
                exit(1);
        }
        /* Initialize generic gpu library */
        DeviceFunctionLibrary::initialize(clinfo);

	/*---------------------- Create shared GL-CL texture ----------------------*/
	gl_tex = create_tex_gl(window_size[0],window_size[1]);
        tex_id = device.new_memory();
        DeviceMemory& tex_mem = device.memory(tex_id);
        if (tex_mem.initialize_from_gl_texture(gl_tex)) {
                std::cerr << "Failed to create memory object from gl texture" << std::endl;
                exit(1);
        }

	/*---------------------- Set up scene ---------------------------*/
	frames = 15;
	const std::string pack = "pack1OBJ";
	// const std::string pack = "pack2OBJ";
	double wave_attenuation = 1.f;

        scenes.resize(frames);
	for (uint32_t i = 0; i < frames ; ++i) {

                scenes[i].initialize();
		std::stringstream grid_path,visual_path;
		grid_path << "models/obj/" << pack << "/gridFluid" << i+1 << ".obj";
		mesh_id grid_mid = scenes[i].load_obj_file_as_aggregate(grid_path.str());
		object_id grid_oid = scenes[i].add_object(grid_mid);
		Object& grid = scenes[i].object(grid_oid);
		grid.mat.diffuse = White;
		grid.mat.reflectiveness = 0.95f;
		grid.mat.refractive_index = 1.5f;
		grid.geom.setScale(makeVector(1.f,wave_attenuation,1.f));

		/* ---- Solids ------ */
		// visual_path << "models/obj/" << pack << "/visual" << visual_frame << ".obj";
		// mesh_id visual_mid = scenes[i].load_obj_file_as_aggregate(visual_path.str());
		// object_id visual_oid = scenes[i].geometry.add_object(visual_mid);
		// Object& visual = scenes[i].geometry.object(visual_oid);
		// visual.mat.diffuse = Red;

		// for (uint32_t j = 0; j < bridge_parts ; ++j) {
		// 	std::stringstream bridge_path;
		// 	bridge_path << "models/obj/" << pack << "/bridge" << j << i+1 << ".obj";
		// 	mesh_id bridge_mid = scenes[i].load_obj_file_as_aggregate(bridge_path.str());
		// 	object_id bridge_oid = scenes[i].geometry.add_object(bridge_mid);
		// 	Object& bridge = scenes[i].geometry.object(bridge_oid);
		// 	bridge.mat.diffuse = Green;
		// }

		// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot2.obj");
		// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot-low_res.obj");
		// object_id teapot_obj_id = scenes[i].geometry.add_object(teapot_mesh_id);
		// Object& teapot_obj = scenes[i].geometry.object(teapot_obj_id);
		// teapot_obj.geom.setPos(makeVector(-1.f,0.f,0.f));
		// teapot_obj.geom.setScale(makeVector(3.f,3.f,3.f));
		// teapot_obj.mat.diffuse = Green;
		// teapot_obj.mat.shininess = 1.f;
		// teapot_obj.mat.reflectiveness = 0.3f;

		/* ------------------*/

                // scenes[i].set_accelerator_type(KDTREE_ACCELERATOR);
                scenes[i].set_accelerator_type(BVH_ACCELERATOR);
		scenes[i].create_aggregate_mesh();
		scenes[i].create_aggregate_accelerator();
		Mesh& scene_mesh = scenes[i].get_aggregate_mesh();
                if (scenes[i].transfer_aggregate_mesh_to_device() 
                    || scenes[i].transfer_aggregate_accelerator_to_device())
                        std::cerr << "Failed to transfer scene info to device"<< std::endl;


		/*---------------------- Print scene data ----------------------*/
		std::cerr << "Scene " << i << " stats: " << std::endl;
		std::cerr << "\tTriangle count: " << scene_mesh.triangleCount() << std::endl;
		std::cerr << "\tVertex count: " << scene_mesh.vertexCount() << std::endl;
		std::cerr << std::endl;
	}


	/*---------------------- Set initial Camera paramaters -----------------------*/
	camera.set(makeVector(0,3,-30), makeVector(0,0,1), makeVector(0,1,0), M_PI/4.,
		   window_size[0] / (float)window_size[1]);

	/*---------------------------- Set tile size ------------------------------*/
	best_tile_size = clinfo.max_compute_units * clinfo.max_work_item_sizes[0];
	best_tile_size *= 64;
	best_tile_size = std::min(pixel_count, best_tile_size);

	/*---------------------- Initialize ray bundles -----------------------------*/
	int32_t ray_bundle_size = best_tile_size * 4;

	if (ray_bundle_1.initialize(ray_bundle_size)) {
		std::cerr << "Error initializing ray bundle 1" << std::endl;
		std::cerr.flush();
		exit(1);
	}

	if (ray_bundle_2.initialize(ray_bundle_size)) {
		std::cerr << "Error initializing ray bundle 2" << std::endl;
		std::cerr.flush();
		exit(1);
	}
	std::cout << "Initialized ray bundles succesfully" << std::endl;

	/*---------------------- Initialize hit bundle -----------------------------*/
	int32_t hit_bundle_size = ray_bundle_size;

	if (hit_bundle.initialize(hit_bundle_size)) {
		std::cerr << "Error initializing hit bundle" << std::endl;
		std::cerr.flush();
		exit(1);
	}
	std::cout << "Initialized hit bundle succesfully" << std::endl;

	/*----------------------- Initialize cubemap ---------------------------*/
	if (cubemap.initialize("textures/cubemap/Path/posx.jpg",
                               "textures/cubemap/Path/negx.jpg",
                               "textures/cubemap/Path/posy.jpg",
                               "textures/cubemap/Path/negy.jpg",
                               "textures/cubemap/Path/posz.jpg",
                               "textures/cubemap/Path/negz.jpg")) {  
		std::cerr << "Failed to initialize cubemap." << std::endl;
		exit(1);
	}
	std::cerr << "Initialized cubemap succesfully." << std::endl;

	/*------------------------ Initialize FrameBuffer ---------------------------*/
	if (framebuffer.initialize(window_size)) {
		std::cerr << "Error initializing framebuffer." << std::endl;
		exit(1);
	}
	std::cout << "Initialized framebuffer succesfully." << std::endl;

	/* ------------------ Initialize ray tracer kernel ----------------------*/
	if (tracer.initialize()){
		std::cerr << "Failed to initialize tracer." << std::endl;
		return 0;
	}
	std::cerr << "Initialized tracer succesfully." << std::endl;


	/* ------------------ Initialize Primary Ray Generator ----------------------*/
	if (prim_ray_gen.initialize()) {
		std::cerr << "Error initializing primary ray generator." << std::endl;
		exit(1);
	}
	std::cout << "Initialized primary ray generator succesfully." << std::endl;


	/* ------------------ Initialize Secondary Ray Generator ----------------------*/
	if (sec_ray_gen.initialize()) {
		std::cerr << "Error initializing secondary ray generator." << std::endl;
		exit(1);
	}
	sec_ray_gen.set_max_rays(ray_bundle_1.count());
	std::cout << "Initialized secondary ray generator succesfully." << std::endl;

	/*------------------------ Initialize RayShader ---------------------------*/
	if (ray_shader.initialize()) {
		std::cerr << "Error initializing ray shader." << std::endl;
		exit(1);
	}
	std::cout << "Initialized ray shader succesfully." << std::endl;

	/*----------------------- Enable timing in all clases -------------------*/
	framebuffer.timing(true);
	prim_ray_gen.timing(true);
	sec_ray_gen.timing(true);
	tracer.timing(true);
	ray_shader.timing(true);

	/*------------------------- Count mem usage -----------------------------------*/
	int32_t total_cl_mem = 0;
	total_cl_mem += pixel_count * 4; /* 4bpp texture */
	// for (uint32_t i = 0; i < frames; ++i)  
	// 	total_cl_mem += scene_info[i].size();
	total_cl_mem += ray_bundle_1.mem().size() + ray_bundle_2.mem().size();
	total_cl_mem += hit_bundle.mem().size();
	total_cl_mem += cubemap.positive_x_mem().size() * 6;
	total_cl_mem += framebuffer.image_mem().size();

	std::cout << "\nMemory stats: " << std::endl;
	std::cout << "\tTotal opencl mem usage: " 
		  << total_cl_mem/1e6 << " MB." << std::endl;
	// for (uint32_t i = 0; i < frames; ++i)  
	// 	std::cout << "\tScene " << i << " mem usage: " << scene_info[i].size()/1e6 << " MB." << std::endl;

	std::cout << "\tFramebuffer+Tex mem usage: " 
		  << (framebuffer.image_mem().size() + pixel_count * 4)/1e6
		  << " MB."<< std::endl;
	std::cout << "\tCubemap mem usage: " 
		  << (cubemap.positive_x_mem().size()*6)/1e6 
		  << " MB."<< std::endl;
	std::cout << "\tRay mem usage: " 
		  << (ray_bundle_1.mem().size()*2)/1e6
		  << " MB."<< std::endl;
	std::cout << "\tRay hit info mem usage: " 
		  << hit_bundle.mem().size()/1e6
		  << " MB."<< std::endl;

        /* !! ---------------------- Test area ---------------- */
	std::cerr << std::endl;
	std::cerr << "Misc info: " << std::endl;

	std::cerr << "Tile size: " << best_tile_size << std::endl;
	std::cerr << "Tiles: " << pixel_count / (float)best_tile_size << std::endl;
	std::cerr << "color_cl size: "
		  << sizeof(color_cl)
		  << std::endl;
	std::cerr << "directional_light_cl size: "
		  << sizeof(directional_light_cl)
		  << std::endl;

	std::cerr << "ray_cl size: "
		  << sizeof(ray_cl)
		  << std::endl;
	std::cerr << "sample_cl size: "
		  << sizeof(sample_cl)
		  << std::endl;
	std::cerr << "sample_trace_info_cl size: "
		  << sizeof(sample_trace_info_cl)
		  << std::endl;

	/*------------------------ Set GLUT and misc functions -----------------------*/
	rt_time.snap_time();
	seq_time.snap_time();

	glutKeyboardFunc(gl_key);
	glutMotionFunc(gl_mouse);
	glutDisplayFunc(gl_loop);
	glutIdleFunc(gl_loop);
	glutMainLoop();	

	clinfo.release_resources();

	return 0;
}
Beispiel #9
0
void gl_loop()
{
	static int i = 0;
	static int dir = 1;
	static int total_ray_count = 0;
	static double min_time=-1;
	static double max_time=-1;

	double prim_gen_time = 0;
	double sec_gen_time = 0;
	double prim_trace_time = 0;
	double sec_trace_time = 0;
	double prim_shadow_trace_time = 0;
	double sec_shadow_trace_time = 0;
	double shader_time = 0;
	double fb_clear_time = 0;
	double fb_copy_time = 0;

	glClear(GL_COLOR_BUFFER_BIT);

        if (device.acquire_graphic_resource(tex_id) ||
            cubemap.acquire_graphic_resources()) {
                std::cerr << "Error acquiring texture resource." << std::endl;
                exit(1);
        }

        for (size_t i = 0; i < scenes.size(); ++i) {
                Scene& scene = scenes[i];
                if (scene.acquire_graphic_resources()) {
                        std::cerr << "Error acquiring texture resource." << std::endl;
                        exit(1);
                }
        }

        if (framebuffer.clear()) {
		std::cerr << "Failed to clear framebuffer." << std::endl;
		exit(1);
	}
	fb_clear_time = framebuffer.get_clear_exec_time();

	cl_int arg = i%STEPS;
	int32_t tile_size = best_tile_size;

	directional_light_cl light;
	light.set_dir(1.f,-1.f,0.f);
	light.set_color(1.f,1.f,1.f);
	// light.set_dir(0.05f * (arg - 8.f) , -0.6f, 0.2f);
	// light.set_color(0.05f * (fabsf(arg)) + 0.1f, 0.2f, 0.05f * fabsf(arg+4.f));

	Scene &scene = scenes[current_frame];

	scene.set_dir_light(light);
	color_cl ambient;
	ambient[0] = ambient[1] = ambient[2] = 0.1f;
	scene.set_ambient_light(ambient);

	int32_t sample_count = pixel_count * prim_ray_gen.get_spp();
	for (int32_t offset = 0; offset < sample_count; offset+= tile_size) {

		
		RayBundle* ray_in =  &ray_bundle_1;
		RayBundle* ray_out = &ray_bundle_2;

		if (sample_count - offset < tile_size)
			tile_size = sample_count - offset;

		if (prim_ray_gen.generate(camera, *ray_in, window_size,
                                          tile_size, offset)) {
			std::cerr << "Error seting primary ray bundle" << std::endl;
			exit(1);
		}
		prim_gen_time += prim_ray_gen.get_exec_time();

		total_ray_count += tile_size;

		if (tracer.trace(scene, tile_size, *ray_in, hit_bundle)){
		// if (tracer.trace(scene, bvh_mem, tile_size, *ray_in, hit_bundle)){
			std::cerr << "Failed to trace." << std::endl;
			exit(1);
		}
		prim_trace_time += tracer.get_trace_exec_time();

		if (tracer.shadow_trace(scene, tile_size, *ray_in, hit_bundle)){
		//if (tracer.shadow_trace(scene, bvh_mem, tile_size, *ray_in, hit_bundle)){
			std::cerr << "Failed to shadow trace." << std::endl;
			exit(1);
		}
		prim_shadow_trace_time += tracer.get_shadow_exec_time();

		if (ray_shader.shade(*ray_in, hit_bundle, scene,
                                     cubemap, framebuffer, tile_size, true)){
			std::cerr << "Failed to update framebuffer." << std::endl;
			exit(1);
		}
		shader_time += ray_shader.get_exec_time();

		size_t sec_ray_count = tile_size;
		for (uint32_t i = 0; i < MAX_BOUNCE; ++i) {

			sec_ray_gen.generate(scene, *ray_in, sec_ray_count, 
					     hit_bundle, *ray_out, &sec_ray_count);
			sec_gen_time += sec_ray_gen.get_exec_time();

			std::swap(ray_in,ray_out);

			if (!sec_ray_count)
				break;
			if (sec_ray_count == ray_bundle_1.count())
				std::cerr << "Max sec rays reached!\n";

			total_ray_count += sec_ray_count;

			// if (tracer.trace(scene, bvh_mem, sec_ray_count, 
			if (tracer.trace(scene, sec_ray_count, 
                                         *ray_in, hit_bundle, true)) {
                                std::cerr << "Failed to trace." << std::endl;
                                exit(1);
                        }
			sec_trace_time += tracer.get_trace_exec_time();


			// if (tracer.shadow_trace(scene, bvh_mem, sec_ray_count, 
			if (tracer.shadow_trace(scene, sec_ray_count, 
                                                *ray_in, hit_bundle, true)) {
                                std::cerr << "Failed to shadow trace." << std::endl;
                                exit(1);
                        }
			sec_shadow_trace_time += tracer.get_shadow_exec_time();

			if (ray_shader.shade(*ray_in, hit_bundle, scene,
                                             cubemap, framebuffer, sec_ray_count)){
				std::cerr << "Ray shader failed execution." << std::endl;
				exit(1);
			}
			shader_time += ray_shader.get_exec_time();
		}

	}

	if (framebuffer.copy(device.memory(tex_id))){
		std::cerr << "Failed to copy framebuffer." << std::endl;
		exit(1);
	}
	fb_copy_time = framebuffer.get_copy_exec_time();
	double total_msec = rt_time.msec_since_snap();

	if (min_time < 0)
		min_time = total_msec;
	else
		min_time = std::min(min_time,total_msec);

	if (max_time < 0)
		max_time = total_msec;
	else
		max_time = std::max(max_time,total_msec);

        if (device.release_graphic_resource(tex_id) ||
            cubemap.release_graphic_resources()) {
                std::cerr << "Error releasing texture resource." << std::endl;
                exit(1);
        }

        for (size_t i = 0; i < scenes.size(); ++i) {
                if (scenes[i].release_graphic_resources()) {
                        std::cerr << "Error releasing texture resource." << std::endl;
                        exit(1);
                }
        }

        ////////////////// Immediate mode textured quad
	glBindTexture(GL_TEXTURE_2D, gl_tex);

	glBegin(GL_TRIANGLE_STRIP);

	glTexCoord2f(1.0,1.0);
	glVertex2f(1.0,1.0);

	glTexCoord2f(1.0,0.0);
	glVertex2f(1.0,-1.0);

	glTexCoord2f(0.0,1.0);
	glVertex2f(-1.0,1.0);

	glTexCoord2f(0.0,0.0);
	glVertex2f(-1.0,-1.0);

	glEnd();
	////////////////////////////////////////////

	i += dir;
	if (!(i % (STEPS-1))){
		dir *= -1;
	}		
	std::cout << "Time elapsed: " 
		  << total_msec << " milliseconds " 
		  << "\t" 
		  << (1000.f / total_msec)
		  << " FPS"
		  << "\t"
		  << total_ray_count
		  << " rays casted "
		  << "\t(" << pixel_count << " primary, " 
		  << total_ray_count-pixel_count << " secondary)"
		  << "               \r" ;
	std::flush(std::cout);
	rt_time.snap_time();
	total_ray_count = 0;

	std::cout << "\nPrim Gen time: \t" << prim_gen_time  << std::endl;
	std::cout << "Sec Gen time: \t" << sec_gen_time << std::endl;
	std::cout << "Tracer time: \t" << prim_trace_time + sec_trace_time  
		  << " (" <<  prim_trace_time << " - " << sec_trace_time 
		  << ")" << std::endl;
	std::cout << "Shadow time: \t" << prim_shadow_trace_time + sec_shadow_trace_time 
		  << " (" <<  prim_shadow_trace_time 
		  << " - " << sec_shadow_trace_time << ")" << std::endl;
	std::cout << "Shader time: \t " << shader_time << std::endl;
	std::cout << "Fb clear time: \t" << fb_clear_time << std::endl;
	std::cout << "Fb copy time: \t" << fb_copy_time << std::endl;
	std::cout << std::endl;

	glutSwapBuffers();
	current_frame = (current_frame+motion_rate)%frames;
	if (current_frame == 0) {
		double t = seq_time.msec_since_snap();
		     
		std::cout << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" << std::endl;
		std::cout << "Sequence stats:" << std::endl << std::endl;
		std::cout << "Frames: " << frames << std::endl;
		std::cout << "Sequence render time: " << t << "msec\t(" 
			  << frames*1000.f/t << " FPS)" <<   std::endl;
		std::cout << "Mean / Min / Max render time: " 
			  <<  t/frames << " / " 
			  <<  min_time << " / " 
			  <<  max_time << " msec" << std::endl;
		std::cout << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" << std::endl;
		max_time = -1;
		min_time = -1;
		seq_time.snap_time();
	}

}
        //----------------------------------------------------------------------------
        //----------------------------------------------------------------------------
		void CubemapProvider::LoadCubemap(Core::StorageLocation in_location, const std::string& in_filePath, const Core::IResourceOptionsBaseCSPtr& in_options, const Core::ResourceProvider::AsyncLoadDelegate& in_delegate, const Core::ResourceSPtr& out_resource)
        {
            //read the Cubemap JSON
            Json::Value jsonRoot;
            if (Core::JsonUtils::ReadJson(in_location, in_filePath, jsonRoot) == false)
            {
                CS_LOG_ERROR("Could not read face Cubemap file '" + in_filePath + "'.");
                out_resource->SetLoadState(Core::Resource::LoadState::k_failed);
                if(in_delegate != nullptr)
                {
                    Core::Application::Get()->GetTaskScheduler()->ScheduleMainThreadTask(std::bind(in_delegate, out_resource));
                }
                return;
            }
            
            const u32 k_numFaces = 6;
            const std::string k_faces[k_numFaces] = {"Right", "Left", "Top", "Bottom", "Front", "Back"};
            
			//MSVC does not support moving arrays of unique_ptr at this time and therefore we have
			//to create a shared pointer in order to pass it into the lambda
			auto imageDataContainer = std::make_shared<std::array<Texture::TextureDataUPtr, k_numFaces>>();
            std::array<Texture::Descriptor, k_numFaces> descs;
            
            for(u32 i = 0; i < k_numFaces; ++i)
            {
                auto textureFile = ParseCubemapFace(jsonRoot, k_faces[i]);
                if (textureFile.first == Core::StorageLocation::k_none || textureFile.second == "")
                {
                    CS_LOG_ERROR("Could not load face '" + k_faces[i] + "' in Cubemap '" + in_filePath + "'.");
                    out_resource->SetLoadState(Core::Resource::LoadState::k_failed);
                    if(in_delegate != nullptr)
                    {
                        Core::Application::Get()->GetTaskScheduler()->ScheduleMainThreadTask(std::bind(in_delegate, out_resource));
                    }
                    return;
                }
                
                Core::ImageSPtr image(Core::Image::Create());
                if (LoadImage(image, m_imageProviders, textureFile.first, textureFile.second) == false)
                {
                    CS_LOG_ERROR("Could not load image '" + textureFile.second + "' in Cubemap '" + in_filePath + "'");
                    out_resource->SetLoadState(Core::Resource::LoadState::k_failed);
                    if(in_delegate != nullptr)
                    {
                        Core::Application::Get()->GetTaskScheduler()->ScheduleMainThreadTask(std::bind(in_delegate, out_resource));
                    }
                    return;
                }
                
				(*imageDataContainer)[i] = image->MoveData();
                
                Texture::Descriptor desc;
                desc.m_width = image->GetWidth();
                desc.m_height = image->GetHeight();
                desc.m_format = image->GetFormat();
                desc.m_compression = image->GetCompression();
                desc.m_dataSize = image->GetDataSize();
                
                descs[i] = std::move(desc);
            }
            
            if(in_delegate == nullptr)
            {
                Cubemap* cubemap = (Cubemap*)out_resource.get();
                const CubemapResourceOptions* options = (const CubemapResourceOptions*)in_options.get();
                cubemap->Build(descs, std::move(*imageDataContainer), options->IsMipMapsEnabled(), options->IsRestoreCubemapDataEnabled());
                cubemap->SetWrapMode(options->GetWrapModeS(), options->GetWrapModeT());
                cubemap->SetFilterMode(options->GetFilterMode());
                out_resource->SetLoadState(Core::Resource::LoadState::k_loaded);
            }
            else
            {
				auto task([descs, imageDataContainer, in_options, in_delegate, out_resource]()
                {
                    Cubemap* cubemap = (Cubemap*)out_resource.get();
                    const CubemapResourceOptions* options = (const CubemapResourceOptions*)in_options.get();
                    cubemap->Build(descs, std::move(*imageDataContainer), options->IsMipMapsEnabled(), options->IsRestoreCubemapDataEnabled());
                    cubemap->SetWrapMode(options->GetWrapModeS(), options->GetWrapModeT());
                    cubemap->SetFilterMode(options->GetFilterMode());
                    out_resource->SetLoadState(Core::Resource::LoadState::k_loaded);
                    in_delegate(out_resource);
                });
                Core::Application::Get()->GetTaskScheduler()->ScheduleMainThreadTask(task);
            }
        }
Beispiel #11
0
int32_t 
RayShader::shade(RayBundle& rays, HitBundle& hb, Scene& scene, 
        Cubemap& cm, FrameBuffer& fb, size_t size, bool primary)
{
        if (m_timing)
                m_timer.snap_time();

        DeviceInterface& device = *DeviceInterface::instance();
        function_id shade_id = primary? p_shade_id : s_shade_id;

        DeviceFunction& shade_function = device.function(shade_id);

        if (shade_function.set_arg(0, fb.image_mem()))
                return -1;

        if (shade_function.set_arg(1,hb.mem()))
                return -1;

        if (shade_function.set_arg(2,rays.mem()))
                return -1;

        if (shade_function.set_arg(3,scene.material_list_mem()))
                return -1;

        if (shade_function.set_arg(4,scene.material_map_mem()))
                return -1;

        if (shade_function.set_arg(5,cm.positive_x_mem()))
                return -1;

        if (shade_function.set_arg(6,cm.negative_x_mem()))
                return -1;

        if (shade_function.set_arg(7,cm.positive_y_mem()))
                return -1;

        if (shade_function.set_arg(8,cm.negative_y_mem()))
                return -1;

        if (shade_function.set_arg(9,cm.positive_z_mem()))
                return -1;

        if (shade_function.set_arg(10,cm.negative_z_mem()))
                return -1;

        /*Texture_0 to Texture_25*/
        if (shade_function.set_arg(11,scene.texture_atlas.texture_mem(0)))
                return -1;
        if (shade_function.set_arg(12,scene.texture_atlas.texture_mem(1)))
                return -1;
        if (shade_function.set_arg(13,scene.texture_atlas.texture_mem(2)))
                return -1;
        if (shade_function.set_arg(14,scene.texture_atlas.texture_mem(3)))
                return -1;
        if (shade_function.set_arg(15,scene.texture_atlas.texture_mem(4)))
                return -1;
        if (shade_function.set_arg(16,scene.texture_atlas.texture_mem(5)))
                return -1;
        if (shade_function.set_arg(17,scene.texture_atlas.texture_mem(6)))
                return -1;
        if (shade_function.set_arg(18,scene.texture_atlas.texture_mem(7)))
                return -1;
        if (shade_function.set_arg(19,scene.texture_atlas.texture_mem(8)))
                return -1;
        if (shade_function.set_arg(20,scene.texture_atlas.texture_mem(9)))
                return -1;
        if (shade_function.set_arg(21,scene.texture_atlas.texture_mem(10)))
                return -1;
        if (shade_function.set_arg(22,scene.texture_atlas.texture_mem(11)))
                return -1;
        if (shade_function.set_arg(23,scene.texture_atlas.texture_mem(12)))
                return -1;
        if (shade_function.set_arg(24,scene.texture_atlas.texture_mem(13)))
                return -1;
        if (shade_function.set_arg(25,scene.texture_atlas.texture_mem(14)))
                return -1;
        if (shade_function.set_arg(26,scene.texture_atlas.texture_mem(15)))
                return -1;
        if (shade_function.set_arg(27,scene.texture_atlas.texture_mem(16)))
                return -1;
        if (shade_function.set_arg(28,scene.texture_atlas.texture_mem(17)))
                return -1;
        if (shade_function.set_arg(29,scene.texture_atlas.texture_mem(18)))
                return -1;
        if (shade_function.set_arg(30,scene.texture_atlas.texture_mem(19)))
                return -1;
        if (shade_function.set_arg(31,scene.texture_atlas.texture_mem(20)))
                return -1;
        if (shade_function.set_arg(32,scene.texture_atlas.texture_mem(21)))
                return -1;
        if (shade_function.set_arg(33,scene.texture_atlas.texture_mem(22)))
                return -1;
        if (shade_function.set_arg(34,scene.texture_atlas.texture_mem(23)))
                return -1;
        if (shade_function.set_arg(35,scene.texture_atlas.texture_mem(24)))
                return -1;
        if (shade_function.set_arg(36,scene.texture_atlas.texture_mem(25)))
                return -1;

        cl_uint sample_count = size;
        if (shade_function.set_arg(37,sizeof(cl_uint), &sample_count))
                return -1;

        cl_int use_cubemap = cm.enabled;
        if (shade_function.set_arg(38,sizeof(cl_int), &use_cubemap))
                return -1;

        if (shade_function.set_arg(39,scene.lights_mem()))
                return -1;

        size_t group_size = shade_function.max_group_size();
        if (shade_function.enqueue_single_dim(size,group_size))
                return -1;
        device.enqueue_barrier();

        if (m_timing) {
                device.finish_commands();
                m_time_ms = m_timer.msec_since_snap();
        }

        return 0;

}
Beispiel #12
0
void Game::start()
{
	int width = 800;
	int height = 600;

	// context creation
	this->context = new Context();
	this->context->initialize(4, 3);
	this->context->createWindow(width, height, 1, "ZPG", false, false, true);
	this->context->setKeyCallback([](GLFWwindow* window, int key, int scan, int action, int modifier) { InputController::getInstance().onKeyCallback(window, key, scan, action, modifier); });
	this->context->setMousePositionCallback([](GLFWwindow* window, double x, double y) { InputController::getInstance().onMouseMoveCallback(window, x, y); });
	this->context->setMouseScrollCallback([](GLFWwindow* window, double xOffset, double yOffset) { InputController::getInstance().onMouseScrollCallback(window, xOffset, yOffset); });
	this->context->setMouseButtonCallback([](GLFWwindow* window, int button, int action, int modifier) { InputController::getInstance().onMouseButtonCallback(window, button, action, modifier); });
	this->context->setWindowSizeCallback([](GLFWwindow* window, int width, int height) { Game::getInstance().onWindowSizeCallback(window, width, height); });
	this->context->setShowMouseCursor(false);
	this->context->setDepthTest(true);
	this->context->setDepthFunc(GL_LEQUAL);
	this->context->setStencilTest(true);
	this->context->setStencilMask(0xFF);
	this->context->setStencilFunc(GL_ALWAYS, 1, 0xFF);
	this->context->setStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
	this->context->setCulling(true);
	this->context->setBlending(true);
	this->context->setBlendingFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	this->screenQuad = new ScreenQuad();

	// manager preload
	AudioManager::getInstance().initialize();
	TextureManager::getInstance().preloadTextures();
	ModelManager::getInstance().preloadModels();
	FontManager::getInstance().initialize(width, height);

	ShaderLoader::getInstance().addCodeMapping("#LIGHT_DEFINITIONS", FileHelper::loadFile("Shaders/Headers/light_definitions.frag"));
	ShaderLoader::getInstance().addCodeMapping("#PHONG_CALCULATIONS", FileHelper::loadFile("Shaders/Headers/phong_calculations.frag"));

	ProgramManager::getInstance().preloadPrograms();
	Program program = ProgramManager::getInstance().get(ProgramManager::PROGRAM_MODEL);
	ProgramManager::getInstance().use(ProgramManager::PROGRAM_MODEL);

	FramebufferManager::getInstance().preloadFramebuffers();

	// initial object spawn 
	Camera* cameraScript = new Camera(new CameraController(10.0f), glm::vec3(0.0f, 0.0f, -1.0f), 45.0f, 4.0f / 3.0f, 0.1f, 1000.0f);
	this->camera = new GameObject(cameraScript, nullptr, new BasicPhysicsComponent(false, new SphereBoundingBox(1.0f)));
	this->camera->getTransform().setPosition(glm::vec3(0.0f, 0.0f, 8.0f));
	this->camera->getTags().set(Tag::Camera);
	this->scene.add(this->camera);

	ProgramManager::getInstance().observeCamera(cameraScript);

	// objects
	float distance = 3.0f;
	GameObject* cube = new GameObject(nullptr, new ModelRenderComponent(ModelManager::getInstance().get(ModelManager::MODEL_CUBE), Color::Blue));
	this->scene.add(cube);
	cube->getTransform().setPosition(glm::vec3(distance, 0.0f, 0.0f));

	cube = new GameObject(nullptr, new ModelRenderComponent(ModelManager::getInstance().get(ModelManager::MODEL_CUBE), Color::Red));
	this->scene.add(cube);
	cube->getTransform().setPosition(glm::vec3(-distance, 0.0f, 0.0f));

	cube = new GameObject(nullptr, new ModelRenderComponent(ModelManager::getInstance().get(ModelManager::MODEL_CUBE), Color::Green));
	this->scene.add(cube);
	cube->getTransform().setPosition(glm::vec3(0.0f, distance, 0.0f));

	cube = new GameObject(nullptr, new ModelRenderComponent(ModelManager::getInstance().get(ModelManager::MODEL_CUBE), Color::Yellow));
	this->scene.add(cube);
	cube->getTransform().setPosition(glm::vec3(0.0f, -distance, 0.0f));

	// lights
	DirectionalLight *dirLight = new DirectionalLight(glm::vec3(10.0f, 10.0f, 10.0f), Phong(Color::White * 0.001f, Color::White, Color::White * 0.1f));
	GameObject* light = new GameObject(new LightComponent(dirLight, "directionalLight"));
	light->getTags().set(Tag::Light);
	this->scene.add(light);

	GeometryObject planeGeometry(VERTICES_PLANE, 2 * sizeof(glm::vec3), 6);
	planeGeometry.setAttributePositionNormal();

	GeometryObject cubeGeometry(VERTICES_CUBE, sizeof(glm::vec3), 36);
	cubeGeometry.setAttributePosition();

	PointLight* pointLight = new PointLight(Attenuation::ATT_DISTANCE_LONG, Phong(Color::White * 0.1f, Color::White, Color::White));
	light = new GameObject(
		new LightComponent(pointLight, "pointLights", 0),
		new SimpleConstantRenderer(cubeGeometry, ProgramManager::PROGRAM_GEOMETRY_CONSTANT, Color::White)
	);
	light->getTransform().setPosition(glm::vec3(0.0f, 0.0f, 0.0f));
	light->getTags().set(Tag::Light);
	this->scene.add(light);

	program.setUniform1i("pointLightCount", 1);

	SpotLight* spotLight = new SpotLight(glm::vec3(0.0f, 0.0f, -1.0f), 12.5f, 17.5f, Attenuation::ATT_DISTANCE_LONG, dirLight->phong);
	GameObject* spotLightObj = new GameObject(new LightComponent(spotLight, "spotLight"));
	spotLightObj->getTags().set(Tag::Light);
	this->scene.add(spotLightObj);

	GameObject* floor = new GameObject(nullptr, new SimpleConstantRenderer(planeGeometry, ProgramManager::PROGRAM_MODEL, Color::Purple));
	floor->getTransform().setScale(glm::vec3(10.0f));
	floor->getTransform().setPosition(glm::vec3(0.0f, -5.0f, 0.0f));
	this->scene.add(floor);

	// skybox
	const std::string skyboxPath = "Resources/Textures/skybox/";
	std::vector<Image> skyboxFaces;
	skyboxFaces.push_back(Image(skyboxPath + "right.jpg"));
	skyboxFaces.push_back(Image(skyboxPath + "left.jpg"));
	skyboxFaces.push_back(Image(skyboxPath + "top.jpg"));
	skyboxFaces.push_back(Image(skyboxPath + "bottom.jpg"));
	skyboxFaces.push_back(Image(skyboxPath + "back.jpg"));
	skyboxFaces.push_back(Image(skyboxPath + "front.jpg"));

	Cubemap skyboxCubemap;
	skyboxCubemap.allocate();
	skyboxCubemap.set2DImages(skyboxFaces);

	GameObject* skybox = new GameObject(nullptr, new SkyboxRenderer(skyboxCubemap));
	this->scene.add(skybox);

	GameObject* crossHair = new GameObject(nullptr, new SpriteRenderer(TextureManager::TEXTURE_CROSSHAIR));
	crossHair->getTransform().setScale(glm::vec3(50.0f, 50.0f, 1.0f));
	this->scene.add(crossHair);

	Timer timer(0.01f);
	Timer switchTimer(0.05f);

	context->loop([&](Context& context)	// physics
	{
		//this->physicsHandler.simulate(this->scene.getObjectManager().getObjects(), this->scene.getObjectManager().getObjectCount(), Context::getFixedDeltaTime());
	},	
	[&](Context& context)	// render
	{
		float delta = context.getDeltaTime();
		timer.update(delta);
		switchTimer.update(delta);

		FramebufferManager::getInstance().get(FramebufferManager::FRAMEBUFFER_POSTPROCESS).bind();

		RenderUtils::clearColor(0.0f, 0.0f, 0.0f, 1.0f);
		RenderUtils::clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

		context.setDepthTest(true);

		spotLight->direction = cameraScript->getFront();
		spotLightObj->getTransform().setPosition(camera->getTransform().getPosition());

		crossHair->getTransform().setPosition(glm::vec3(context.getWindowWidth() / 2.0f, context.getWindowHeight() / 2.0f, 0.0f));

		this->scene.update();
		this->scene.draw();

		GLchar byte;
		glReadPixels(context.getWindowWidth() / 2, context.getWindowHeight() / 2, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &byte);	// stencil value at the center

		this->screenQuad->drawScreen(context);

		if (timer.resetIfReady())
		{
			FontManager::getInstance().renderText("FPS: " + std::to_string(round(1.0f / delta)), 10.0f, height - 20.0f, 0.5f, glm::vec3(1.0f, 1.0f, 0.0f));
		}

		if (InputController::getInstance().isButtonPressed(GLFW_KEY_ESCAPE))
		{
			context.closeWindow();
		}
		else if (InputController::getInstance().isButtonPressed(GLFW_KEY_SPACE) && switchTimer.resetIfReady())
		{
			// switch render strategy
		}

		InputController::getInstance().afterUpdate();
		
		this->scene.updateFrameEnd();
	});

	// resource disposal
	this->screenQuad->dispose();
	delete this->screenQuad;

	this->scene.dispose();
	ProgramManager::getInstance().dispose();
	ModelManager::getInstance().dispose();
	TextureManager::getInstance().dispose();
	FramebufferManager::getInstance().dispose();
	AudioManager::getInstance().dispose();
	FontManager::getInstance().dispose();

	context->terminate();
}
Beispiel #13
0
 CubemapStereoFrame(StereoCubemap* cubemap) : cubemap_(cubemap) {
     Cubemap* left = cubemap_->getEye(0);
     Cubemap* right = cubemap_->getEye(1);
     if(cubemap_->getEyesCount() == 2) {
         faces[0][0] = new CubemapPixelData(left->getFace(0));
         faces[0][1] = new CubemapPixelData(left->getFace(1));
         faces[0][2] = new CubemapPixelData(left->getFace(2));
         faces[0][3] = new CubemapPixelData(left->getFace(3));
         faces[0][4] = new CubemapPixelData(left->getFace(4));
         faces[0][5] = new CubemapPixelData(left->getFace(5));
         faces[1][0] = new CubemapPixelData(right->getFace(0));
         faces[1][1] = new CubemapPixelData(right->getFace(1));
         faces[1][2] = new CubemapPixelData(right->getFace(2));
         faces[1][3] = new CubemapPixelData(right->getFace(3));
         faces[1][4] = new CubemapPixelData(right->getFace(4));
         faces[1][5] = new CubemapPixelData(right->getFace(5));
     } else {
         faces[0][0] = new CubemapPixelData(left->getFace(0));
         faces[0][1] = new CubemapPixelData(left->getFace(1));
         faces[0][2] = new CubemapPixelData(left->getFace(2));
         faces[0][3] = new CubemapPixelData(left->getFace(3));
         faces[0][4] = new CubemapPixelData(left->getFace(4));
         faces[0][5] = new CubemapPixelData(left->getFace(5));
         faces[1][0] = new CubemapPixelData(left->getFace(0));
         faces[1][1] = new CubemapPixelData(left->getFace(1));
         faces[1][2] = new CubemapPixelData(left->getFace(2));
         faces[1][3] = new CubemapPixelData(left->getFace(3));
         faces[1][4] = new CubemapPixelData(left->getFace(4));
         faces[1][5] = new CubemapPixelData(left->getFace(5));
     }
 }