TA3D

Code: Select all

static void DrawMyObjects()
{
	// Put your code here to render all your 3D objects
	// OpenGL / DirectX
}


int main()
{
	// FPS Limit
	// The VSync should be disabled (otherwise the fps will be stuck to 60 - 59.9 actually)
	unsigned int fpsLimit = 35; /* Frame per Second */

	// Duration of a single frame (in ms)
	unsigned int fpsDelta = 1000 / fpsLimit;
	if (fpsDelta < 4)
	{
		// We have not enough precision with milli seconds to limit the number of FPS
		fpsLimit = 0; // Disabling the limit
	}

	// The time in milli seconds when the last frame was processed
	// This variable will be used to reduce the number of FPS
	uint64 lastCheckpointLimit = 0;

	// We would like to compute the number of FPS every second
	// But we have to wait a little that the system is stable.
	// The first FPS value will less than the real one, psychology better
	uint64 lastCheckpointFPSCount = TimeInMilliSeconds() + 400; // ms, arbitrary value to delay the first calculation

	// The number of FPS since the last check
	unsigned int frameCountSinceLastTime = 0;
	// FPS
	unsigned int fpsCount = 0;

	// Entering the main loop
	while (true)
	{
		uint64 newCheckpoint = TimeInMilliSeconds();

		if (fpsLimit)
		{
			// We have to limit the number of FPS
			//
			// We will compute the time (in milliseconds) that the last frame took
			// to be rendered.
			uint32 delta = (uint32)(newCheckpoint - lastCheckpointLimit);
			while (delta < fpsDelta)
			{
				// We could only sleep for 1 ms. But we can safely reduce the number
				// of calls to the sleep routine (assuming fpsDelta >= 4).
				SleepMilliSeconds((delta >> 2) /* div 4 */);
				// We may have to wait again. Checking...
				newCheckpoint = TimeInMilliSeconds();
				delta = (uint32)(newCheckpoint - lastCheckpointLimit);
			}
			// Reset
			lastCheckpointLimit = newCheckpoint;
		}

		// FPS
		if (newCheckpoint - lastCheckpointFPSCount >= 1000)
		{
			// FPS ?
			fps = round((double)frameCountSinceLastTime / (((double)(newCheckpoint - lastCheckpointFPSCount)) / 1000.));
			std::cout << fps << " FPS" << std::endl;
			// Reset
			lastCheckpointFPSCount = newCheckpoint;
			frameCountSinceLastTime = 0;
		}

		// Put your Code for drawing 3D Objects here (OpenGL/DirectX)
		DrawMyObjects();

		// A frame has been rendered
		++frameCountSinceLastTime;
	}
}

Code: Select all

void sort(int* list, unsigned short size);

Code: Select all

ResultFlags sort(void* list, size_t eltSize, unsigned short size, SortingAlgorithm algo, ComparisonDelegate compare, Logger logs) throw;

Code: Select all

template<class ComparisonDelegate,
             template<typename T, template<typename ELEM, typename = std::allocator<ELEM> > class CONT> class SortingAlgorithm = QuickSort>
class Sorter
{
public:
	template <typename T,
                      template <typename ELEM, typename> class CONT>
	static void operator()(CONT& list)
	{
		SortingAlgorithm<T, CONT<T> > sorter;
		sorter(list);
	}
};

Code: Select all

std::vector<int> myList;
sort(myList);

Code: Select all

std::vector<MyClass> mylist;
Sorter<myComparer<MyClass>, mySortingAlgorithm> sort;
sort(mylist);