Pascal Engeler
Interactive Wave Simulator

Repository

data = stbi_load(file.c_str(), &width, &height, &nrChannels, STBI_rgb_alpha);
//...
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
3840 //screen width in pixels
2160 //screen height in pixels
4440 //texture width in texels
3360 //texture height in texels
0    //screen offset left in texels
600  //screen offset right in texels
600  //screen offset bottom in texels
600  //screen offset top in texels
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, texture_width, texture_height, 0, GL_RGBA, GL_FLOAT, data_target.data());
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, palette_.size()/4, 0, GL_RGBA, GL_FLOAT, palette_.data());
Message m (getSomeMessage());
if(m.target == MESSAGETARGET::WAVE){
    WAVEMESSAGE message = std::get<WAVEMESSAGE>(m.message);
    switch(message){
        case WAVEMESSAGE::RESET_WAVE:
            //process RESET_WAVE here
            break;
        case WAVEMESSAGE::RESET_DAMPING:
            //process RESET_DAMPING here
            break;
        default:
            break;
    }
}
Shader stepshader((shader_path_ + "stepwave.vert").c_str(), (shader_path_ + "stepwave.frag").c_str());
layout (location = 0) in vec3 verCoords;
layout (location = 1) in vec2 texCoords;
uniform sampler2D tex_damping_static; //static damping
uniform sampler2D tex_damping_dynamic; //dynamic damping
layout (location = 0) in vec2 verCoords;
layout (location = 1) in vec2 texCoords;
uniform sampler2D source_texture;
layout (location = 0) in vec3 verCoords;
uniform sampler2D source_texture;
layout (location = 0) in vec2 verCoords;
layout (location = 1) in vec2 texCoords;
uniform float color_multiplier;
uniform sampler2D source_texture;
layout (location = 0) in vec3 verCoords;
layout (location = 1) in vec2 texCoords;
uniform sampler2D tex_wave; //wave
uniform sampler2D tex_damp; //damping
uniform sampler1D tex_palette; //colour palette
layout (location = 0) in vec3 verCoords;
layout (location = 1) in vec2 texCoords;
uniform float dx;
uniform float dy;
uniform float c1;
uniform float c2;
uniform float t;
uniform float amplitude;
uniform float frequency;
uniform sampler2D tex_wave;
uniform sampler2D tex_damp;
#include <glad/glad.h>
#include <SDL.h>
#include <toolbox.hpp>
#include <wave_handler.hpp>
#include <infrastructure.hpp>
#include <iostream>
#include <input_handler.hpp>
#include <gui_handler.hpp>
#include <slim_blockchain_handler.hpp>
#include <drawing_handler.hpp>
#include <chrono>
#include <thread>
#include <pattern_handler.hpp>
#include <timeout_handler.hpp>

/*Screen resolution*/
#define WIDTH 3840
#define HEIGHT 2160


int main(int argc, char** argv) {
#ifndef NDEBUG
	std::cout << "DEBUGGING" << std::endl;
#endif

	/*Paths*/
    std::string top_path = "C:\\Users\\Executor\\Desktop\\ft_top\\";

	//Derived paths
	std::string rsc_path = top_path + "resource\\"; //resources top path
	std::string img_path = rsc_path + "images\\"; //images for GUI
	std::string tex_path = rsc_path + "textures\\rocket\\"; //textures
	std::string font_path = top_path + "fonts\\"; //fonts
	std::string shd_path = top_path + "shaders\\"; //shaders

	//Expected texture dimensions
	int tex_offscreen_left = 0;
	int tex_offscreen_right = 600;
	int tex_offscreen_bottom = 600;
	int tex_offscreen_top = 600;
	int texwidth = WIDTH + tex_offscreen_left + tex_offscreen_right;
	int texheight = HEIGHT + tex_offscreen_bottom + tex_offscreen_top;

    //First construct a Toolbox and a WaveHandler
	Toolbox tb(WIDTH, HEIGHT, texwidth, texheight, tex_offscreen_left, tex_offscreen_right,
                tex_offscreen_bottom, tex_offscreen_top, shd_path, tex_path, rsc_path);
	WaveHandler waves(tb);
	waves.initialize(tex_path + "bare", rsc_path + "ft_palette");

    //Finish Toolbox initialization using the WaveHandler
	waves.generate_and_transfer_textures(tb);

    //Now construct the other modules
	InputHandler ioHandler;
	GuiHandler guiHandler(0.15f);
	guiHandler.init(tb, img_path, font_path);
	SlimBlockchainHandler bch(tb);
	DrawingHandler drah(tb);
	PatternHandler paha(tb);
	TimeoutHandler tiha(600);

	//Scale Gui
	ImGui::GetStyle().ScaleAllSizes(2.f);

    //Game Loop
	while (tb.g_state != static_cast<int>(GSTATE::EXIT)) {

		//Start of new frame
		//Clear Toolbox
		tb.newFrame();

		//I/O Handler update
		ioHandler.update(tb);

		//Timeout Handler update
		tiha.update(tb);

		//Gui Handler
		guiHandler.update(tb);

		//Waves Handler update
		waves.update(tb);

        /*Perform updates that may alter the damping textures*/
		//Blockchain Handler update
		bch.update(tb);

		//Drawing Handler update
		drah.update(tb);

		//Pattern Handler update
		paha.update(tb);

        /*Damping textures are final, now we can step the wave*/
		//Wave Handler stepping
		waves.prepare_step();
		waves.step(tb, 6);

        /*Finally, we render first the wave and then the GUI on top*/
		//Wave Handler rendering
		waves.render();

		//Gui Handler rendering
		guiHandler.render(tb);

		//Swap Windows
		SDL_GL_SwapWindow(tb.infra.window());

		//Check for OpenGL errors
#ifndef NDEBUG
		GLint err = glGetError();
		if (err != GL_NO_ERROR) {
			std::cout << "Error Code: " << err << std::endl;
			std::cout << "GL_NO_ERROR: " << GL_NO_ERROR << std::endl;
			std::cout << "GL_INVALID_ENUM: " << GL_INVALID_ENUM << std::endl;
			std::cout << "GL_INVALID_VALUE: " << GL_INVALID_VALUE << std::endl;
			std::cout << "GL_INVALID_OPERATION: " << GL_INVALID_OPERATION << std::endl;
			std::cout << "GL_INVALID_FRAMEBUFFER_OPERATION: " << GL_INVALID_FRAMEBUFFER_OPERATION << std::endl;
			std::cout << "GL_OUT_OF_MEMORY: " << GL_OUT_OF_MEMORY << std::endl;
		}

		//Potential delay for single frame debugging
		//std::this_thread::sleep_for(std::chrono::milliseconds(1000));
#endif
	}

	return 0;
}