Git Gud Engine

demo.cpp

#pragma comment(lib,"kami.lib")
#pragma comment(lib,"Lua.lib")

#include <kami.h>

#include <resources.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <vector>

struct System
{
	klib::GC gc;
	Resources::Resource<klib::Texture, unsigned int> texture;
};

template<typename T> struct Tile2D
{
	T x,y,id;
	Tile2D(T X, T Y, T ID) : x(X), y(Y), id(ID) {};
};

void load_map(json::Value mapJson, std::vector<int> &mapData);

int main(){
	int status = 1;
	clock_t t0 = clock(),t1 = 0,t2 = 0;
	System sys = {klib::GC("Demo")};

	sys.texture.load(0, "images/bg.png");
	sys.texture.load(1, "images/sprites.png");
	sys.texture.load(2, "images/color_ramp.png");
	
	sys.gc.InitShaders(1, false, "2d.vert", "2d.frag");
	sys.gc.InitShaders(2, false, "simple.vert", "post.frag");
	sys.gc.InitShaders(3, false, "tile.vert", "tile.frag", "tile.geom");

	GLuint shaderProgram2 = sys.gc.GetShaderID(3);

	// Map
	std::ifstream mapDataFile("test.json");
	json::Value mapJson;
	json::read(mapDataFile, mapJson);
	int width = mapJson.GetIntMember("width");
	int height = mapJson.GetIntMember("height");
	int tileCount = width*height;
	std::vector<int> mapData(tileCount+1);
	load_map(mapJson, mapData);

	// Create Vertex Array Object
	klib::glObj<Tile2D<GLfloat>> level;

	std::vector<Tile2D<GLfloat>> v;
	std::vector<GLuint> e;

	auto i = 0;

	for (auto tile : mapData){
		if (tile != 0){
			int col = i % width;
			int row = floor(i / height);
			v.emplace_back(col * 16, row * 16, tile - 1);
			e.push_back(v.size());
		}
		i++;
	}

	// We no longer need this so why keep it around?
	mapData.clear();

	// Push to GPU
	level.create(v, e);

	// Specify the layout of the vertex data
	GLint posAttrib = glGetAttribLocation(shaderProgram2, "pos");
	glEnableVertexAttribArray(posAttrib);
	glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);

	GLint idAttrib = glGetAttribLocation(shaderProgram2, "id");
	glEnableVertexAttribArray(idAttrib);
	glVertexAttribPointer(idAttrib, 1, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));

	GLint uniTrans2 = glGetUniformLocation(shaderProgram2, "trans");

	while (sys.gc.ProcessEvent(&status))
	{
		t0 = clock();
		if (t0-t1 >= CLOCKS_PER_SEC/sys.gc.fps || true){
			t1 = clock();

			sys.gc.HandleEvent([&] (std::vector<klib::KLGLKeyEvent>::iterator key) {
				if (!key->isDown()){
					if (key->getCode() == klib::KLGLKeyEvent::KEY_ESCAPE){
						status = 0;
					}
				}
				key->finished();
			});

			sys.gc.OpenFBO();
			sys.gc.OrthogonalStart();
			{
				sys.gc.Blit2D(&sys.texture.get(0), 0, 0);

				sys.gc.BindShaders(3);
				glBindTexture(GL_TEXTURE_2D, sys.texture.get(1).gltexture);
				glm::mat4 trans;
				trans = glm::translate(
					trans,
					glm::vec3(sys.gc.windowManager->mousePos.x, sys.gc.windowManager->mousePos.y, 0.0f)
					);
				
				glUniformMatrix4fv(uniTrans2, 1, GL_FALSE, glm::value_ptr(trans));

				level.draw(GL_POINTS);

				glActiveTexture(GL_TEXTURE2);
				glBindTexture(GL_TEXTURE_2D, sys.texture.get(2).gltexture);
				sys.gc.BindShaders(2);
				glUniform1f(glGetUniformLocation(sys.gc.GetShaderID(2), "time"), clock());
				glUniform2f(glGetUniformLocation(sys.gc.GetShaderID(2), "resolution"), sys.gc.buffer.width, sys.gc.buffer.height);
				glUniform1i(glGetUniformLocation(sys.gc.GetShaderID(2), "ramp"), 2);
				sys.gc.BindMultiPassShader(2, 1, false);
				sys.gc.UnbindShaders();
			}
			sys.gc.OrthogonalEnd();
			sys.gc.Swap();
		}
	}

	return 0;
}

void load_map(json::Value mapJson, std::vector<int> &mapData){
	json::Value const& layers = mapJson.GetArrayMember("layers");
	std::size_t numLayers = layers.GetNumElements();

	for( std::size_t layerIdx = 0; layerIdx < numLayers; ++layerIdx ){
		json::Value const& layer = layers.GetElement(layerIdx);
		std::string layerName = layer.GetStringMember("name");

		if (layerName == "tilemap"){ // Parse the tilemap bitmap data and store it for rendering
			json::Value const& layerData = layer.GetArrayMember("data");
			std::size_t numBytes = layerData.GetNumElements();

			for (std::size_t dataIdx = 0; dataIdx < numBytes; ++dataIdx){
				mapData[dataIdx] = layerData.GetElement(dataIdx).GetInt();
				if (mapData[dataIdx] != 0){
					//cl("Non-Zero Tile: %d, %d [%d]\n", (int)floor(dataIdx/map.width), dataIdx%map.height, mapData[dataIdx]);
				}
			}
		}
	}
}