Exemple #1
0
void RemoteReleaseControlImpl::AsyncRelease()
{
   // if another transfer is in progress, wait for completion
   if (m_evtReleaseImageTransferInProgress.Wait(0))
   {
      m_evtReleaseImageTransferDone.Wait();
   }

   m_evtReleaseImageTransferInProgress.Set();


   // set save target
   ShutterReleaseSettings::T_enSaveTarget enSaveTarget;
   {
      LightweightMutex::LockType lock(m_mtxShutterReleaseSettings);
      enSaveTarget = m_shutterReleaseSettings.SaveTarget();
   }

   PropertyAccess pa(m_hCamera);
   Variant val;
   // note: PSREC doesn't have a value for saveToBoth
   val.Set<prUInt16>(
      enSaveTarget == ShutterReleaseSettings::saveToHost ? 0x0002 :
      enSaveTarget == ShutterReleaseSettings::saveToCamera ? 0x0008 : 0x000a );
   val.SetType(Variant::typeUInt16);
   pa.Set(prPTP_DEV_PROP_CAPTURE_TRANSFER_MODE, val);

   Timer releaseTimer;
   releaseTimer.Start();

   // may return prWAIT_TIMEOUT_ERROR?, prINVALID_FN_CALL, prINVALID_HANDLE, prMEM_ALLOC_FAILED or @ERR
   prResponse err = PR_RC_Release(m_hCamera);
   LOG_TRACE(_T("PR_RC_Release(%08x) returned %08x\n"), m_hCamera, err);

   if (err != prOK)
      m_subjectStateEvent.Call(RemoteReleaseControl::stateEventReleaseError, 0);

   CheckError(_T("PR_RC_Release"), err, __FILE__, __LINE__);

   releaseTimer.Stop();
   LOG_TRACE(_T("PR_RC_Release took %u ms\n"), unsigned(releaseTimer.Elapsed() * 1000));

   // wait for event
   m_evtReleaseImageReady.Wait();

   try
   {
      StartImageDownload(m_hReleaseImage, true);
   }
   catch (const CameraException&)
   {
      m_subjectStateEvent.Call(RemoteReleaseControl::stateEventReleaseError, 0);
   }
}
Exemple #2
0
int main()
{
	int n_start = 25;
	int end_n = 1600;
	int n_step = 2;

	//Timer First Time is Wrong 
	timer.Start();
	Sleep(1000);
	timer.Stop();
	double t = timer.Elapsed();

	if (pick_accelerator())
	{
		cout << "This Program compare GPU and CPU performance for 'N'*'N' matrix multiplication." << endl;
		cout << endl << "______________________________________________________" << endl << "N:\tCPU Time:\tGPU Time:\t\t" << endl << "______________________________________________________" << endl;
		for (int n = n_start; n <= end_n; n *= n_step)
		{
			matrix mat1(n, n), mat2(n, n);
			mat1.random(1, 100);
			mat2.random(1, 100);

			//GPU Time Calc
			timer.Start();
			matrix mc_g = mat1.gpu_multiply<32>(&mat2);
			timer.Stop();
			double gpuTime = timer.Elapsed();

			//CPU Time Calc
			timer.Start();
			matrix mc_c = mat1.cpu_multiply(&mat2);
			timer.Stop();
			double cpuTime = timer.Elapsed();

			std::cout << n<< "\t" << cpuTime << " ms\t" << gpuTime << " ms\t" << endl << endl;
		}
	}
	getch();
	return 0;
}
Exemple #3
0
int testAlgo(bool (*algoFunc)(std::vector<int>&, int), std::vector<double>& prevTimes, int algoIndex, const std::vector<int>& v, int x)
{
	Timer t;

	std::vector<int> vTmp(v);
	t.Reset();
	bool res = algoFunc(vTmp, x);

	int time = t.Elapsed().count();
	// if(prevTimes[algoIndex] == 0) {
	// 	prevTimes[algoIndex] = time;
	// }

	return time;
}
Exemple #4
0
void test2(void* scratch, uint scratchSize)
{
	StackAlloc alloc(scratch, ((u8*)scratch)+scratchSize);
	Scope a(alloc, "");
	Timer* timer = eiNewInterface(a, Timer)();
	eiInfo(AllocProfile, "########Standard List########");
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			std::list<int> lst;
			for(int itr = 0; itr < 50; itr++)
			{
				lst.push_front(itr);
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
	}

	struct ListItem
	{
		int data;
		ListItem* next;
	};

	eiInfo(AllocProfile, "########Malloc/Free########");
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			ListItem* lst = 0;
			for(int itr = 0; itr < 50; itr++)
			{
				ListItem* push = (ListItem*)Malloc(sizeof(ListItem));
				push->next = lst;
				push->data = itr;
				lst = push;
			}

			while(lst)
			{
				ListItem* dead = lst;
				lst = dead->next;
				Free(dead);
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
	}

	eiInfo(AllocProfile, "########New/Delete########");
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			ListItem* lst = 0;
			for(int itr = 0; itr < 50; itr++)
			{
				ListItem* push = new ListItem;
				push->next = lst;
				push->data = itr;
				lst = push;
			}

			while(lst)
			{
				ListItem* dead = lst;
				lst = dead->next;
				delete dead;
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
	}

	eiInfo(AllocProfile, "########Pool########");
	Pool<ListItem, false> pool(a,10000);
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			ListItem* lst = 0;
			for(int itr = 0; itr < 50; itr++)
			{
				ListItem* push = pool.Alloc();//(ListItem*)lca.newObject(sizeof(ListItem));
				push->next = lst;
				push->data = itr;
				lst = push;
			}

			while(lst)
			{
				ListItem* dead = lst;
				lst = dead->next;
				pool.Release(dead);//lca.deleteObject(dead);
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
	}
	
	eiInfo(AllocProfile, "########eiNew########");
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			Scope t(a,"");
			ListItem* lst = 0;
			for(int itr = 0; itr < 50; itr++)
			{
				ListItem* push = eiNew(t, ListItem);
				push->next = lst;
				push->data = itr;
				lst = push;
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
	}

	eiInfo(AllocProfile, "########eiAlloc########");
	for(int itrSample = 0; itrSample < 3; itrSample++)
	{
		double begin = timer->Elapsed();
		for(int itrItr = 0; itrItr < 10; itrItr++)
		{
			Scope t(a,"");
			ListItem* lst = 0;
			for(int itr = 0; itr < 50; itr++)
			{
				ListItem* push = eiAlloc(t, ListItem);
				push->next = lst;
				push->data = itr;
				lst = push;
			}
		}
		double end = timer->Elapsed();
		eiInfo(AllocProfile, "Sample %d Time: %f ms", itrSample, float(end - begin)*1000.0f);
		
		char* data = (char*)Malloc(640*1024);//640KiB should be enough for anybody
		int& fooVec = *new(data) int;
		data += sizeof(fooVec);
	}
}
Exemple #5
0
int main(int argc, char* argv[]) {
	// Initialize logger
	logFile.open("engine_test.log");
	logFilePath = std::experimental::filesystem::current_path();
	logFilePath /= "engine_test.log";
	cout << "Log files can be found at:\n   ";
	cout << "   " << logFilePath << endl;

	if (logFile.is_open()) {
		logger.OpenStream(&logFile);
	}
	else {
		logger.OpenStream(&std::cout);
	}

	// Set exception terminate handler
	std::set_terminate(OnTerminate);


	// Create the window itself
	Window window;
	window.SetTitle("QC Simulator");
	window.SetSize({ 960, 640 });


	// Create GraphicsEngine
	systemLogStream.Event("Initializing Graphics Engine...");

	std::unique_ptr<IGxapiManager> gxapiMgr;
	std::unique_ptr<IGraphicsApi, ReportDeleter> gxapi;
	std::unique_ptr<GraphicsEngine> engine;
	std::unique_ptr<QCWorld> qcWorld;
	std::unique_ptr<InputHandler> inputHandler;
	std::unique_ptr<Input> joyInput;
	std::unique_ptr<Input> keyboardInput;

	try {
		// Create manager
		systemLogStream.Event("Creating GxApi Manager...");
		gxapiMgr.reset(new GxapiManager());
		auto adapters = gxapiMgr->EnumerateAdapters();
		std::string cardList;
		for (auto adapter : adapters) {
			cardList += "\n";
			cardList += adapter.name;
		}
		systemLogStream.Event("Available graphics cards:" + cardList);


		// Create graphics api
		int device = 0;
		if (argc == 3 && argv[1] == std::string("--device") && isdigit(argv[2][0])) {
			device = argv[2][0] - '0'; // works for single digits, good enough, lol
		}
		systemLogStream.Event("Creating GraphicsApi...");
		gxapi.reset(gxapiMgr->CreateGraphicsApi(adapters[device].adapterId));
		std::stringstream ss;
		ss << "Using graphics card: " << adapters[device].name;
		systemLogStream.Event(ss.str());


		// Create graphics engine
		systemLogStream.Event("Creating Graphics Engine...");

		GraphicsEngineDesc desc;
		desc.fullScreen = false;
		desc.graphicsApi = gxapi.get();
		desc.gxapiManager = gxapiMgr.get();
		desc.width = window.GetClientSize().x;
		desc.height = window.GetClientSize().y;
		desc.targetWindow = window.GetNativeHandle();
		desc.logger = &logger;

		engine.reset(new GraphicsEngine(desc));

		// Load graphics pipeline
		std::string pipelineFileName = SelectPipeline(gxapi.get());
		std::string exeDir = System::GetExecutableDir();
		std::ifstream pipelineFile(INL_PIPELINE_DIRECTORY "\\" + pipelineFileName);
		if (!pipelineFile.is_open()) {
			throw FileNotFoundException("Failed to open pipeline JSON.");
		}
		std::string pipelineDesc((std::istreambuf_iterator<char>(pipelineFile)), std::istreambuf_iterator<char>());
		engine->LoadPipeline(pipelineDesc);


		// Create mini world
		qcWorld.reset(new QCWorld(engine.get()));
		

		// Create input handling
		inputHandler = std::make_unique<InputHandler>(qcWorld.get());

		window.OnResize += Delegate<void(ResizeEvent)>{ &InputHandler::OnResize, inputHandler.get() };

		auto joysticks = Input::GetDeviceList(eInputSourceType::JOYSTICK);
		if (!joysticks.empty()) {
			joyInput = std::make_unique<Input>(joysticks.front().id);
			joyInput->SetQueueMode(eInputQueueMode::QUEUED);
			joyInput->OnJoystickMove += Delegate<void(JoystickMoveEvent)>{ &InputHandler::OnJoystickMove, inputHandler.get() };
		}
		auto keyboards = Input::GetDeviceList(eInputSourceType::KEYBOARD);
		if (!keyboards.empty()) {
			keyboardInput = std::make_unique<Input>(keyboards.front().id);
			keyboardInput->SetQueueMode(eInputQueueMode::QUEUED);
			keyboardInput->OnKeyboard += Delegate<void(KeyboardEvent)>{ &InputHandler::OnKey, inputHandler.get() };
		}

		window.OnResize += [&engine, &qcWorld](ResizeEvent evt) {
			engine->SetScreenSize(evt.clientSize.x, evt.clientSize.y);
			qcWorld->ScreenSizeChanged(evt.clientSize.x, evt.clientSize.y);
		};

		logger.Flush();
	}
	catch (Exception& ex) {
		errorMessage = std::string("Error creating GraphicsEngine: ") + ex.what() + "\n" + ex.StackTraceStr();
		systemLogStream.Event(errorMessage);
		logger.Flush();
	}
	catch (std::exception& ex) {
		errorMessage = std::string("Error creating GraphicsEngine: ") + ex.what();
		systemLogStream.Event(errorMessage);
		logger.Flush();
	}

	if (!qcWorld) {
		return 0;
	}


	// Main rendering loop
	Timer timer;
	timer.Start();
	double frameTime = 0.05, frameRateUpdate = 0;
	std::vector<double> frameTimeHistory;
	float avgFps = 0;

	auto CaptionHandler = [&window](Vec2i cursorPos) {
		Vec2i size = window.GetSize();
		RectI rc;
		rc.top = 5;
		rc.bottom = 50;
		rc.right = size.x - 5;
		rc.left = size.x - 50;
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::CLOSE;
		rc.Move({ -50, 0 });
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::MAXIMIZE;
		rc.Move({ -50, 0 });
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::MINIMIZE;
		if (cursorPos.y < 55) {
			return eWindowCaptionButton::BAR;
		}
		return eWindowCaptionButton::NONE;
	};
	//window.SetBorderless(true);
	//window.SetCaptionButtonHandler(CaptionHandler);

	while (!window.IsClosed()) {
		inputHandler->SetFocused(window.IsFocused());
		window.CallEvents();
		if (joyInput) {
			joyInput->CallEvents();
		}
		if (keyboardInput) {
			keyboardInput->CallEvents();
		}

		try {
			// Update world
			qcWorld->UpdateWorld(frameTime);
			qcWorld->RenderWorld(frameTime);

			// Calculate elapsed time for frame.
			frameTime = timer.Elapsed();
			timer.Reset();

			// Calculate average framerate
			frameRateUpdate += frameTime;
			if (frameRateUpdate > 0.5) {
				frameRateUpdate = 0;

				double avgFrameTime = 0.0;
				for (auto v : frameTimeHistory) {
					avgFrameTime += v;
				}
				avgFrameTime /= frameTimeHistory.size();
				avgFps = 1 / avgFrameTime;

				frameTimeHistory.clear();
			}
			frameTimeHistory.push_back(frameTime);

			// Set info text as window title
			unsigned width, height;
			engine->GetScreenSize(width, height);
			std::string title = "Graphics Engine Test | " + std::to_string(width) + "x" + std::to_string(height) + " | FPS=" + std::to_string((int)avgFps);
			window.SetTitle(title);
		}
		catch (Exception& ex) {
			std::stringstream trace;
			trace << "Graphics engine error:" << ex.what() << "\n";
			ex.PrintStackTrace(trace);
			systemLogStream.Event(trace.str());
			PostQuitMessage(0);
		}
		catch (std::exception& ex) {
			systemLogStream.Event(std::string("Graphics engine error: ") + ex.what());
			logger.Flush();
			PostQuitMessage(0);
		}
	}

	cout << "Shutting down." << endl;
	return 0;
}
Exemple #6
0
void GameLoop(HWND hwnd)
{
	render_context->ClearFrameBuffer(ARGB_BLACK);
	//************
	if (timer.Elapsed() - updateTimer > updateTick)
	{
		int          index;              // looping var
		static int   curr_texture = 7;   // currently active texture
		static int   curr_lightmap = 1;
		static float scalef = 0.5; // texture scaling factor

		// copy texture into temp display texture for rendering and scaling
		//temp_text.CopyBitmap(0, 0, textures[curr_texture], 0, 0, TEXTSIZE, TEXTSIZE);
		///////////////////////////////////////////
		// our little image processing algorithm :)
		//Cmodulated = s*C1 = (s*r1, s*g1, s*b1)
     
		////////////////////////////////////////

		// draw texture
		//temp_text.DrawBitmap24(render_context, WINDOW_WIDTH, 0);
		//DrawBottomTri(render_context, 200, 0, 100, 400, 400, 400, ARGB_RED, WINDOW_WIDTH);
		//DrawTopTri(render_context, 0, 200, 400, 200, 200, 400, ARGB_RED, WINDOW_WIDTH);
		DrawTriangle(render_context, 0, 200, 400, 250, 200, 400, ARGB_RED, WINDOW_WIDTH);
		//textures[curr_texture].DrawBitmap24(render_context, WINDOW_WIDTH, 0);
		//lightmaps[curr_lightmap].DrawBitmap24(render_context, WINDOW_WIDTH, 0);

		// test if user wants to change texture
		if (KEY_DOWN(VK_RIGHT))
		{
			if (++curr_texture > NUM_TEXT - 1)
				curr_texture = NUM_TEXT - 1;

		} // end if

		if (KEY_DOWN(VK_LEFT))
		{
			if (--curr_texture < 0)
				curr_texture = 0;

		} // end if

		// is user changing scaling factor
		if (keyboard_state[DIK_UP])
		{
			scalef += .01;
			if (scalef > 10)
				scalef = 10;
		} // end if

		if (keyboard_state[DIK_DOWN])
		{
			scalef -= .01;
			if (scalef < 0)
				scalef = 0;
		} // end if

		/*	
		for (int x = 0; x < bitmap24bit.bitmapinfoheader.biWidth; x++)
		{
			for (int y = 0; y < bitmap24bit.bitmapinfoheader.biHeight; y++)
			{
				unsigned char B = *(bitmap24bit.buffer + y * 640 * 3 + x * 3 + 0);
				unsigned char G = *(bitmap24bit.buffer + y * 640 * 3 + x * 3 + 1);
				unsigned char R = *(bitmap24bit.buffer + y * 640 * 3 + x * 3 + 2);

				render_context->frame_buffer[x + y * 640] = ARGB(0, (int)R, (int)G, (int)B);
			}
		}
		*/

		window_hdc = GetDC(hwnd);
		SelectObject(buffer_hdc, now_bitmap);
		BitBlt(window_hdc, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, buffer_hdc, 0, 0, SRCCOPY);
		ReleaseDC(hwnd, window_hdc);
	}
	frames++;
	if (timer.Elapsed() - elapsed > 1.0f)
	{
		elapsed += 1.0f;
		cout << frames << "fps" << endl;
		frames = 0;
	}
	// **************
}
Exemple #7
0
void GameLoop(HWND hwnd)
{
	render_context->ClearFrameBuffer();

	static Mat4f mrot; // general rotation matrix
	static float x_ang = 0.0f, y_ang = 0.2f, z_ang = 0.0f;

	//每秒执行60次部分
	if (timer.Elapsed() - updateTimer > updateTick)
	{
		updateTimer = updateTimer + updateTick;
		// reset angles
		//x_ang = 0.0f;
		if (KEY_DOWN(VK_UP))
			obj.world_pos.z = obj.world_pos.z - 0.5f;
		if (KEY_DOWN(VK_DOWN))
			obj.world_pos.z = obj.world_pos.z + 0.5f;
		/*if (KEY_DOWN(VK_LEFT))
			x_ang = 0.2f;
		if (KEY_DOWN(VK_RIGHT))
			x_ang = -0.2f;*/
		
	}

	//尽快执行部分
	{
		// 重设剔除、裁剪、隐面标志位
		obj.Reset();

		// 产生绕三轴旋转矩阵
		mrot = Mat4f::Rotation(x_ang, y_ang, z_ang);

		// 直接对局部坐标变换,存入局部坐标
		obj.Transform(mrot, TRANSFORM_LOCAL_ONLY, 1);

		// 模型坐标到世界坐标变换
		obj.ModelToWorld();

		// 建立相机变换矩阵,此例中一般为单位矩阵
		//cam.BuildMatrixEuler(CAM_ROT_SEQ_ZYX);

		// 执行隐面剔除
		obj.RemoveBackFaces(cam);

		// 世界坐标到相机坐标变换
		obj.WorldToCamera(cam);

		//获得三角形的法向量
		obj.GetTriangleNormal();

		// 相机坐标投影变换
		obj.CameraToPerspective(cam);

		obj.ClipUDLR();

		// 投影坐标到屏幕坐标
		obj.PerspectiveToScreen(cam);

		// 光照纹理方式绘制
		obj.DrawPlane(render_context, WINDOW_WIDTH);
		
		window_hdc = GetDC(hwnd);
		SelectObject(buffer_hdc, now_bitmap);
		BitBlt(window_hdc, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, buffer_hdc, 0, 0, SRCCOPY);
		ReleaseDC(hwnd, window_hdc);
	}

	//每秒执行1次部分
	frames++;
	if (timer.Elapsed() - elapsed > 1.0f)
	{
		elapsed += 1.0f;
		cout << frames << "fps" << endl;
		frames = 0;
	}

}