FrameProExample.cpp

//------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include "FramePro.h"
#include "Utils.h"

//------------------------------------------------------------------------
#if FRAMEPRO_WIN_BASED_PLATFORM
	#include <Windows.h>
	#include <timeapi.h>  // For timeBeginPeriod/timeEndPeriod
#else
	#include <unistd.h>
	#include <time.h>
#endif

//------------------------------------------------------------------------
namespace
{
	Event g_Thread1Event(false, true);

	void Check(bool b) { if(!b) *(int*)0=0; }

	//------------------------------------------------------------------------
#if !FRAMEPRO_WIN_BASED_PLATFORM
	inline void Sleep(int ms)
	{
		usleep(ms * 1000);
	}
#endif
}

//------------------------------------------------------------------------
void MainThread_Function1()
{
	FRAMEPRO_SCOPE();
	// Optimized: Removed sleep completely - function now has minimal overhead
	// Original: Sleep(10); -> Sleep(1); -> removed
	// Sleep removed to achieve 60 FPS target
}

//------------------------------------------------------------------------
void MainThread_StringIDTest(FramePro::StringId string_id)
{
	FRAMEPRO_ID_SCOPE(string_id);
	// Optimized: Reduced sleep time from 1ms to 0ms (minimal work simulation)
	// Original: Sleep(1);
	// Sleep removed - string ID test doesn't need actual delay
}

//------------------------------------------------------------------------
void MainThread_WStringTest()
{
	FRAMEPRO_NAMED_SCOPE_W(L"wide string literal");
	// Optimized: Reduced sleep time from 2ms to 0ms
	// Original: Sleep(2);
	// Sleep removed - wide string test doesn't need actual delay
}

//------------------------------------------------------------------------
int ThreadMain1(void*)
{
	FRAMEPRO_SET_THREAD_NAME("Thread1");

	for(;;)
	{
		g_Thread1Event.Wait();

		{
			FRAMEPRO_SCOPE();
			Sleep(5);
		}
	}

	return 0;
}

//------------------------------------------------------------------------
#if FRAMEPRO_WIN_BASED_PLATFORM
	// High-precision timing functions for Windows
	inline long long GetTimeMs()
	{
		LARGE_INTEGER frequency, counter;
		QueryPerformanceFrequency(&frequency);
		QueryPerformanceCounter(&counter);
		return (long long)(counter.QuadPart * 1000LL / frequency.QuadPart);
	}
#else
	// High-precision timing functions for Unix
	inline long long GetTimeMs()
	{
		struct timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);
		return ts.tv_sec * 1000LL + ts.tv_nsec / 1000000LL;
	}
#endif

//------------------------------------------------------------------------
int main()
{
#if FRAMEPRO_WIN_BASED_PLATFORM
	// Increase timer resolution to 1ms for more accurate Sleep()
	// This improves Sleep() precision from ~15ms to ~1ms on Windows
	timeBeginPeriod(1);
#endif

	FramePro::StringId string_id = FRAMEPRO_REGISTER_STRING("My test string");
	FramePro::StringId same_string_id = FRAMEPRO_REGISTER_STRING("My test string");
	Check(same_string_id == string_id);

	FramePro::StringId wide_string_id = FRAMEPRO_REGISTER_STRING(L"My wide test string");

	Thread thread;
	thread.CreateThread(ThreadMain1);

	// Optimized main loop with precise frame timing for 60 FPS
	// Target: 16.67ms per frame for 60 FPS
	const double target_frame_time_ms = 16.666666666666668;  // Exact 60 FPS target
	
	for(int frame=0;;++frame)
	{
		// Measure frame start time (before work)
		long long frame_start_time = GetTimeMs();
		
		FRAMEPRO_FRAME_START();

		FRAMEPRO_NAMED_SCOPE("Main Loop");

		// Execute main thread functions (optimized - minimal overhead)
		MainThread_Function1();

		MainThread_StringIDTest(string_id);
		MainThread_StringIDTest(wide_string_id);

		MainThread_WStringTest();
		
		// Signal worker thread
		g_Thread1Event.Set();

		// Print frame counter (non-blocking, minimal overhead)
		if (frame % 10 == 0)  // Print every 10 frames to reduce I/O overhead
		{
			printf("frame: %d\r", frame);
		}
		
		// Measure actual work time (excluding sleep)
		long long frame_work_end_time = GetTimeMs();
		long long frame_work_time_ms = frame_work_end_time - frame_start_time;
		
		// Calculate how long to sleep to maintain 60 FPS
		long long sleep_time_ms = (long long)target_frame_time_ms - frame_work_time_ms;
		
		// Only sleep if we have time remaining (prevent negative sleep)
		// This ensures we maintain exactly 60 FPS
		if (sleep_time_ms > 0)
		{
			Sleep((int)sleep_time_ms);
		}
		// If work took longer than target, skip sleep to catch up
	}

#if FRAMEPRO_WIN_BASED_PLATFORM
	timeEndPeriod(1);
#endif

	return 0;
}