gplib/tests/math.cpp

#include "test_scaffold.h"
#include "gp/array.hpp"
#include "gp/math.hpp"
#include "gp/rendering/renderer.hpp"
#include "gp/rendering/bmp_viewport.hpp"
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <chrono>


struct sin_test : public test_scaffold {
	sin_test() {
		name = __FILE__ ":1";
	}


	virtual int run() {
		int res = 0;
		for(float i = 0; i < 100; i += 0.1) {
			float v = gp::sin(i);
			float ref = sin(i);
			res += 0.3 < gp::abs<float>(ref - v)*100.0/(gp::abs(ref+0.00000001));
		}
		for(float i = 0; i < 100; i += 0.1) {
			float v = gp::cos(i);
			float ref = cos(i);
			res += 0.3 < gp::abs<float>(ref - v)*100.0/(gp::abs(ref+0.00000001));
		}

		return res;
	}
};

append_test dummy_mldffh6f(new sin_test{});


struct render_test : public test_scaffold {
	render_test() {
		name = __FILE__ ":2";
	}


	virtual int run() {
		int res = 0;
		renderer a;
		a._resolution = vec2{128,64};
		a.passes = 5;
		a.projection_end = 3;

		a.sky_box = [](vec3) -> color_t {
				color_t ret;
				ret.r() = 0.5;
				ret.g() = 0.5;
				ret.b() = 1;
				ret.a() = 1;
				return ret;
			};
		auto red = a.materials.push(
			[&](vec3 p) -> color_t {
				color_t ret;
				ret.r() = 1;
				ret.g() = 0;
				ret.b() = 0;
				ret.a() = 1;
				return ret;
			}
		);
		auto green = a.materials.push(
			[&](vec3 p) -> color_t {
				color_t ret;
				ret.r() = 0;
				ret.g() = 1;
				ret.b() = 0;
				ret.a() = 1;
				return ret;
			}
		);

		auto l_sdf = gp::difference_sdf<float>(
			gp::sphere_sdf<float>({0.0,0.0,0.0}, 1.0),
			gp::sphere_sdf<float>({-0.75,0.0,0.0}, 1.0)
		);
		auto sphere = a.scene_elements.push(
			[&](vec3 pos) -> render_point {
				render_point ret;
				ret.distance = l_sdf(pos);
				ret.material = red;
				return ret;
			}
		);

		auto l_sdf_b = gp::sphere_sdf<float>({-0.75,0.0,0.0}, 1.0);
		auto sphere2 = a.scene_elements.push(
			[&](vec3 pos) -> render_point {
				render_point ret;
				ret.distance = l_sdf_b(pos);
				ret.material = green;
				return ret;
			}
		);

		a._camera.position = vec3{0, 0, -2};
		a._camera.normal = vec3{0, 0, 1};

		using pic_color = gp::vec4_g<uint8_t>;

		gp::bmp_viewport<true, pic_color> vp{
			{128,64},
			[&](gp::vec2_g<int32_t> p) -> pic_color {
				auto orig = a.render({(float)p.x,(float)p.y});
				pic_color ret{};
				ret.x = (uint8_t)(orig.x*255);
				ret.y = (uint8_t)(orig.y*255);
				ret.z = (uint8_t)(orig.z*255);
				ret.w = (uint8_t)(orig.w*255);
				return ret;
			}
		};

		gp::array<char, 300000>* buff = new gp::array<char, 300000>();

		auto begin = std::chrono::steady_clock::now();

		auto r_end = vp.write(buff->as_buffer());

		auto end = std::chrono::steady_clock::now();

		std::cout << "render time: " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << std::endl;



		auto myfile = std::fstream("render.bmp", std::ios::out | std::ios::binary);

		myfile.write(buff->begin().data, r_end - buff->begin());

		myfile.close();

		delete buff;	

		//gp_config::assertion(a.render(vec2{64,32}).x == color_t{1.0,0,0,1.0}.x, "red sphere not perceived");
		//gp_config::assertion(a.render(vec2{0,0}).x == color_t{0.0,0,1.0,1.0}.x, "blue sky not perceived");

		return res;
	}
};

append_test dummy_ml8576f(new render_test{});