Irrlicht Engine

Code: Select all

#include <iostream>
#include <chrono>
#include <vector>
#include <string>
#include <thread>

// Define object states using bitwise operators
const int STATE_ACTIVE = 1 << 0; // 0001
const int STATE_INVISIBLE = 1 << 1; // 0010
const int PLAYER_COLLISION = 1 << 2; // 0100
const int ENEMY_COLLISION = 1 << 3; // 1000

// Conventional structure
struct ObjectState {
	bool active;
	bool invisible;
	bool playerCollision;
	bool enemyCollision;
};

// Function to measure execution time and memory usage
template <typename Func>
void measurePerformance(Func func, const std::string& name, int cycles) {
	// Prepare the CPU
	std::this_thread::sleep_for(std::chrono::seconds(2));

	auto start = std::chrono::high_resolution_clock::now();
	for (int i = 0; i < cycles; ++i) {
		func();
	}
	auto end = std::chrono::high_resolution_clock::now();
	std::chrono::duration<double> duration = end - start;

	std::cout << "Execution time of " << name << " for " << cycles << " cycles: " << duration.count() << " seconds" << std::endl;
}

// Function using bitwise operators
void bitwiseOperators() {
	std::vector<int> objects(1000000, STATE_ACTIVE | STATE_INVISIBLE | ENEMY_COLLISION);

	for (int state : objects) {
		if (state & STATE_ACTIVE) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				int result = state & (1 << i);
			}
		}
		if (state & STATE_INVISIBLE) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				int result = state & (1 << i);
			}
		}
		if (state & PLAYER_COLLISION) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				int result = state & (1 << i);
			}
		}
		if (state & ENEMY_COLLISION) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				int result = state & (1 << i);
			}
		}
	}
}

// Function using conventional methods
void conventionalMethods() {
	std::vector<ObjectState> objects(1000000, { true, true, false, true });

	for (const ObjectState& state : objects) {
		if (state.active) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				bool result = state.active && (i % 2 == 0);
			}
		}
		if (state.invisible) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				bool result = state.invisible && (i % 2 == 0);
			}
		}
		if (state.playerCollision) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				bool result = state.playerCollision && (i % 2 == 0);
			}
		}
		if (state.enemyCollision) {
			// Perform more complex operations
			for (int i = 0; i < 10; ++i) {
				// Simulation of complex operations
				bool result = state.enemyCollision && (i % 2 == 0);
			}
		}
	}
}

int main() {
	int cycles = 10;

	// Measure the performance of bitwise operators
	measurePerformance(bitwiseOperators, "bitwise operators", cycles);

	// Measure the performance of conventional methods
	measurePerformance(conventionalMethods, "conventional methods", cycles);

	// Measure memory usage
	std::cout << "Size of an object with bitwise operators: " << sizeof(int) << " bytes" << std::endl;
	std::cout << "Size of an object with conventional methods: " << sizeof(ObjectState) << " bytes" << std::endl;

	system("pause");
	return 0;
}