voxel-raycaster/include/util.hpp

#pragma once
#include <algorithm>
#include <bitset>
#include <cmath>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <tuple>
#include <SFML/System/Vector3.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/Graphics/Texture.hpp>
#include <imgui/imgui.h>
#include <imgui/imgui-multilines.hpp>
#include "Vector4.hpp"

const double PI = 3.141592653589793238463;
const float  PI_F = 3.14159265358979f;

struct fps_counter {
public:
	fps_counter() {

    };

    ~fps_counter() {
        for (auto i: fps_vectors){
            delete[] i;
        }
    };

	void frame(double delta_time) {

		// Apply 100 units of smoothing
		if (frame_count == 100) {
			frame_count = 0;
			fps_average = 0;
		}
		frame_count++;
		fps_average += (delta_time - fps_average) / frame_count;
        instant_fps = delta_time;
	}

	static float edit(const void* data, int idx){
		*(int*)data = idx;
		//return *(int*)(data+sizeof(int)*idx);
	};
	void draw() {

		if (arr_pos == 1000)
			arr_pos = 0;

		fps_array[arr_pos] = static_cast<float>(1.0 / instant_fps);
		arr_pos++;

		ImGui::Begin("Performance");
		//ImVec2 wh = ImGui::GetContentRegionAvail();
		ImVec2 wh(100, 200);

		int a[3] = {1, 2, 7};
		int b[3] = {5, 3, 1};
		int c[3] = {8, 1, 4};
		const void* to_data[3] = {&a, &b, &c};
		const char* to_names[3] = {"a", "b", "z"};
		ImGuiPlotType plottype = ImGuiPlotType_Lines;
		ImColor color = ImColor(255, 255, 255);
		//ImGui::PlotMultiLines(
		//		"label", 3, to_names, &color, &edit,
		//			to_data, 3, 0.0f, 10.0f, ImVec2(300, 300));

        std::vector<std::vector<int>> data = {
                {1, 2, 3, 4},
                {9, 3, 7, 1},
                {8, 3, 6, 2}
        };

        std::string title = "HELLO";

        std::vector<std::string> labels = {
                "ONE",
                "TWO",
                "THREE"
        };

        std::vector<ImColor> colors = {
                ImColor(255, 255, 255),
                ImColor(  0, 255,   0),
                ImColor(255,   0,   0),
        };

        sf::Vector2f graph_size(300, 300);

        ImGui::PlotMultiLines(data, title, labels, colors, 10, 0, graph_size);

		ImGui::PlotLines("FPS", fps_array, 1000, 0,
						 std::to_string(1.0 / fps_average).c_str(),
						 0.0f, 150.0f, wh);
		ImGui::End();
	}

private:

    const unsigned int FPS_ARRAY_LENGTH = 1000;
    std::vector<float*> fps_vectors;


	float fps_array[1000]{60};
    int arr_pos = 0;

	double instant_fps = 0;
    double frame_count = 0;
	double fps_average = 0;

};

inline sf::Vector3f SphereToCart(sf::Vector2f i) {

	auto r = sf::Vector3f(
		(1 * sin(i.y) * cos(i.x)),
		(1 * sin(i.y) * sin(i.x)),
		(1 * cos(i.y))
	);
	return r;
};

inline sf::Vector3f SphereToCart(sf::Vector3f i) {

	auto r = sf::Vector3f(
		(i.x * sin(i.z) * cos(i.y)),
		(i.x * sin(i.z) * sin(i.y)),
		(i.x * cos(i.z))
	);
	return r;
};


inline sf::Vector3f CartToSphere(sf::Vector3f in) {

	auto r = sf::Vector3f(
		sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
		atan(in.y / in.x),
		atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
	);
	return r;
};

inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {

	auto r = sf::Vector2f(
		atan2(sqrt(in.x * in.x + in.y * in.y), in.z), 
		atan2(in.y, in.x)
	);
	return r;
}

inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
	return head - base;
}

inline sf::Vector3f Normalize(sf::Vector3f in) {

	float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
	auto r = sf::Vector3f(
		in.x / multiplier,
		in.y / multiplier,
		in.z / multiplier
	);
	return r;
}

inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
	return a.x * b.x + a.y * b.y + a.z * b.z;
}

inline float Magnitude(sf::Vector3f in){
	return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
}

inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
	return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
}

inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
	return sqrt(DotProduct(a, b));
}

inline float DegreesToRadians(float in) {
	return static_cast<float>(in * PI / 180.0f);
}

inline float RadiansToDegrees(float in) {
	return static_cast<float>(in * 180.0f / PI);
}

inline std::string read_file(std::string file_name){

	std::ifstream input_file(file_name);

	if (!input_file.is_open()){
		std::cout << file_name << " could not be opened" << std::endl;
		return "";
	}

	std::stringstream buf;
	buf << input_file.rdbuf();
	input_file.close();
	return buf.str();
}

inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {

	*ss << "[" << std::bitset<15>(i) << "]";
	*ss << "[" << std::bitset<1>(i >> 15) << "]";
	*ss << "[" << std::bitset<8>(i >> 16) << "]";
	*ss << "[" << std::bitset<8>(i >> 24) << "]";
	*ss << "[" << std::bitset<32>(i >> 32) << "]";
}

inline void PrettyPrintUINT64(uint64_t i) {

	std::cout << "[" << std::bitset<15>(i) << "]";
	std::cout << "[" << std::bitset<1>(i >> 15) << "]";
	std::cout << "[" << std::bitset<8>(i >> 16) << "]";
	std::cout << "[" << std::bitset<8>(i >> 24) << "]";
	std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
}

inline void DumpLog(std::stringstream* ss, std::string file_name) {
	
	std::ofstream log_file;
	log_file.open(file_name);

	log_file << ss->str();
	log_file.close();
}

#ifdef _MSC_VER
#  include <intrin.h>
#  define __builtin_popcount _mm_popcnt_u32
#  define __builtin_popcountll _mm_popcnt_u64
#endif

inline int count_bits(int32_t v) {
	
	return static_cast<int>(__builtin_popcount(v));

	//v = v - ((v >> 1) & 0x55555555);                       // reuse input as temporary
	//v = (v & 0x33333333) + ((v >> 2) & 0x33333333);        // temp
	//return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
}

inline int count_bits(int64_t v) {

	return static_cast<int>(__builtin_popcountll(v));
	
	//int32_t left = (int32_t)(v);
	//int32_t right = (int32_t)(v >> 32);

	//left = left - ((left >> 1) & 0x55555555);                    // reuse input as temporary
	//left = (left & 0x33333333) + ((left >> 2) & 0x33333333);     // temp
	//left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count

	//right = right - ((right >> 1) & 0x55555555);                    // reuse input as temporary
	//right = (right & 0x33333333) + ((right >> 2) & 0x33333333);     // temp
	//right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count

	//return left + right;
}

inline void SetBit(int position, char* c) {
	*c |= (uint64_t)1 << position;
}

inline void FlipBit(int position, char* c) {
	*c ^= (uint64_t)1 << position;
}

inline int GetBit(int position, char* c) {
	return (*c >> position) & (uint64_t)1;
}

inline void SetBit(int position, uint64_t* c) {
	*c |= (uint64_t)1 << position;
}

inline void FlipBit(int position, uint64_t* c) {
	*c ^= (uint64_t)1 << position;
}

inline int GetBit(int position, uint64_t* c) {
	return (*c >> position) & (uint64_t)1;
}

inline bool CheckLeafSign(const uint64_t descriptor) {

	uint64_t valid_mask = 0xFF0000;

	// Return true if all 1's, false if contiguous 0's
	if ((descriptor & valid_mask) == valid_mask) {
		return true;
	}
	if ((descriptor & valid_mask) == 0) {
		return false;
	}

	// Error out, something funky
	abort();
}

inline bool CheckContiguousValid(const uint64_t c) {
	uint64_t bitmask = 0xFF0000;
	return (c & bitmask) == bitmask;
}

inline bool IsLeaf(const uint64_t descriptor) {

	uint64_t leaf_mask = 0xFF000000;
	uint64_t valid_mask = 0xFF0000;

	// Check for contiguous valid values of either 0's or 1's
	if (((descriptor & valid_mask) == valid_mask) || ((descriptor & valid_mask) == 0)) {

		// Check for a full leaf mask
		// Only if valid and leaf are contiguous, then it's a leaf
		if ((descriptor & leaf_mask) == leaf_mask)
			return true;

	}

	return false;
}