Windows, camera and a bit of shader

CMakeLists.txt

@@ -37,6 +37,9 @@ include_directories(${executable}
 
 file(GLOB SourceFiles 
 	${SrcDIR}/*
+	${SrcDIR}/util/*
+	${SrcDIR}/util/imgui*
+	${SrcDIR}/renderer/*
 )
 
 add_executable(${executable} ${SourceFiles})

include/logger.h

@@ -0,0 +1,154 @@
+#ifndef INCLUDE_LOGGER_H_
+#define INCLUDE_LOGGER_H_
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <map>
+
+#ifdef _WIN32
+#include <Windows.h>
+typedef enum {
+	CONSOLE_COLOUR_FG_BLACK = 0,
+	CONSOLE_COLOUR_FG_BLUE = FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_GREEN = FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_RED = FOREGROUND_RED,
+	CONSOLE_COLOUR_FG_MAGENTA = FOREGROUND_RED | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_GRAY = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_GRAY = FOREGROUND_INTENSITY,
+	CONSOLE_COLOUR_FG_LIGHT_BLUE = FOREGROUND_INTENSITY | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_GREEN = FOREGROUND_INTENSITY | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_LIGHT_CYAN = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_RED = FOREGROUND_INTENSITY | FOREGROUND_RED,
+	CONSOLE_COLOUR_FG_LIGHT_MAGENTA = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_YELLOW = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_WHITE = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_DEFAULT = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_BG_DEFAULT = 0
+} ConsoleColour;
+
+#ifdef _WIN32
+	static HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+	static WORD wOldColorAttrs;
+	static CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+#endif
+
+#else
+typedef enum {
+	CONSOLE_COLOUR_FG_DEFAULT = 39,
+	CONSOLE_COLOUR_FG_BLACK = 30,
+	CONSOLE_COLOUR_FG_RED = 31,
+	CONSOLE_COLOUR_FG_GREEN = 32,
+	CONSOLE_COLOUR_FG_YELLOW = 33,
+	CONSOLE_COLOUR_FG_BLUE = 34,
+	CONSOLE_COLOUR_FG_MAGENTA = 35,
+	CONSOLE_COLOUR_FG_CYAN = 36,
+	CONSOLE_COLOUR_FG_LIGHT_GRAY = 37,
+	CONSOLE_COLOUR_FG_DARK_GRAY = 90,
+	CONSOLE_COLOUR_FG_LIGHT_RED = 91,
+	CONSOLE_COLOUR_FG_LIGHT_GREEN = 92,
+	CONSOLE_COLOUR_FG_LIGHT_YELLOW = 93,
+	CONSOLE_COLOUR_FG_LIGHT_BLUE = 94,
+	CONSOLE_COLOUR_FG_LIGHT_MAGENTA = 95,
+	CONSOLE_COLOUR_FG_LIGHT_CYAN = 96,
+	CONSOLE_COLOUR_FG_WHITE = 97,
+	CONSOLE_COLOUR_BG_RED = 41,
+	CONSOLE_COLOUR_BG_GREEN = 42,
+	CONSOLE_COLOUR_BG_BLUE = 44,
+	CONSOLE_COLOUR_BG_DEFAULT = 49
+} ConsoleColour;
+#endif
+
+class Colour {
+public:
+	static void resetColour();
+
+	template<typename T>
+	static void consoleColour(T colour) {
+	#ifdef _WIN32
+		SetConsoleTextAttribute(h, colour);
+	#else
+		std::cout << "\033[" << colour << "m";
+	#endif
+	}
+};
+
+typedef enum {
+	LOGGER_INFO = CONSOLE_COLOUR_FG_GREEN,
+	LOGGER_WARN = CONSOLE_COLOUR_FG_YELLOW,
+	LOGGER_ERROR = CONSOLE_COLOUR_FG_LIGHT_RED,
+	LOGGER_PANIC = CONSOLE_COLOUR_FG_RED,
+	LOGGER_DEBUG = CONSOLE_COLOUR_FG_BLUE
+} LogType;
+
+typedef enum {
+	LOGGER_EXIT,
+	LOGGER_ENDL
+} LogAction;
+
+class Logger {
+public:
+	std::stringstream outStream;
+	std::map<LogType, std::string> lookupTable;
+	Logger();
+
+	Logger& operator<< (const LogType type) {
+		std::cout << "[";
+		Colour::consoleColour(type);
+		std::cout << lookupTable[type];
+		Colour::consoleColour(CONSOLE_COLOUR_FG_DEFAULT);
+		std::cout << "] ";
+		return *this;
+	}
+
+	Logger& operator<< (const LogAction action) {
+		if (action == LOGGER_ENDL) {
+			std::cout << outStream.str() << std::endl;
+			outStream.str(std::string());;
+			outStream.flush();
+		}
+		if (action == LOGGER_EXIT)
+			exit(0);
+		return *this;
+	}
+
+	template<typename T>
+	Logger& operator<< (const T& data) {
+		outStream << data;
+		return *this;
+	}
+};
+
+#endif
+
+#ifdef LOGGER_DEFINITION
+#undef LOGGER_DEFINITION
+
+void Colour::resetColour() {
+#ifdef _WIN32
+	SetConsoleTextAttribute(h, CONSOLE_COLOUR_BG_DEFAULT);
+	SetConsoleTextAttribute(h, CONSOLE_COLOUR_FG_DEFAULT);
+#else
+	std::cout
+		<< "\033[" << CONSOLE_COLOUR_BG_DEFAULT << "m"
+		<< "\033[" << CONSOLE_COLOUR_FG_DEFAULT << "m";
+#endif
+}
+
+Logger::Logger() {
+
+#ifdef _WIN32
+	GetConsoleScreenBufferInfo(h, &csbiInfo);
+	wOldColorAttrs = csbiInfo.wAttributes;
+#endif
+
+	lookupTable[LOGGER_INFO] = "INFO";
+	lookupTable[LOGGER_WARN] = "WARN";
+	lookupTable[LOGGER_ERROR] = "ERROR";
+	lookupTable[LOGGER_PANIC] = "PANIC";
+	lookupTable[LOGGER_DEBUG] = "DEBUG";
+}
+
+#endif

src/common.hpp

@@ -0,0 +1,17 @@
+#ifndef MINECRAFT_COMMON_H_
+#define MINECRAFT_COMMON_H_
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <glad/glad.h>
+#include <KHR/khrplatform.h>
+
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+#endif

src/game.cpp

@@ -0,0 +1,91 @@
+#include "game.hpp"
+
+#define LOGGER_DEFINITION
+#include <logger.h>
+
+#include "common.hpp"
+
+
+Game::Game() {
+
+}
+
+void Game::Setup(int w, int h) {
+	m_logger = std::make_shared<Logger>();
+
+	*m_logger << "----------------" << LOGGER_ENDL;
+	*m_logger << "Minecraft 1.14.2" << LOGGER_ENDL;
+	*m_logger << "----------------" << LOGGER_ENDL;
+	*m_logger << LOGGER_ENDL;
+
+
+	*m_logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
+	SDL_Init(SDL_INIT_EVERYTHING);
+
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
+
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+
+	// Create GL window
+	*m_logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
+	m_window = SDL_CreateWindow("Minecraft 1.14.2",
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED, w, h,
+		SDL_WINDOW_OPENGL);
+
+	// Create GL context
+	*m_logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
+	m_glContext = SDL_GL_CreateContext(m_window);
+
+	// SDL_WarpMouseInWindow(window, w / 2, h / 2);
+	// SDL_SetRelativeMouseMode(SDL_TRUE);
+
+	// Set VSYNC swap interval
+	SDL_GL_SetSwapInterval(0);
+
+	*m_logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
+
+	// Load OpenGL
+	gladLoadGLLoader(SDL_GL_GetProcAddress);
+	glEnable(GL_MULTISAMPLE);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+	
+	*m_logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
+	*m_logger << LOGGER_ENDL;
+	IsDisplayOpen = true;
+}
+
+void Game::Input(SDL_Event* e) {
+	while (SDL_PollEvent(e))
+		if (e->type == SDL_QUIT)
+			IsDisplayOpen = false;
+}
+
+void Game::Run() {
+	
+	SDL_Event e;
+
+	while (IsDisplayOpen) {
+
+		Input(&e);
+
+		SDL_GL_SwapWindow(m_window);
+
+		glClear(GL_DEPTH_BUFFER_BIT);
+		const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f };
+		glClearBufferfv(GL_COLOR, 0, clear);
+
+	}
+
+}

src/game.hpp

@@ -0,0 +1,41 @@
+#ifndef MINECRAFT_GAME_H_
+#define MINECRAFT_GAME_H_
+
+#include <memory>
+#include <vector>
+
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+class Logger;
+class Camera;
+
+
+class Game {
+public:
+	Game();
+
+	void Setup(int w, int h);
+
+	void Input(SDL_Event* e);
+
+	void Run();
+
+	bool IsDisplayOpen = false;
+
+private:
+	SDL_Window* m_window = nullptr;
+	SDL_GLContext m_glContext = nullptr;
+
+	std::shared_ptr<Logger> m_logger;
+
+
+	std::vector<std::shared_ptr<Camera>> m_cameras;
+	std::shared_ptr<Camera> m_activeCamera;
+
+};
+
+#endif

src/main.cpp

@@ -1,5 +1,13 @@
 #include <iostream>
 
+#include "game.hpp"
+
 int main(int argc, char** argv) {
-	std::cout << "smh" << std::endl;
+
+	Game game;
+	game.Setup(1080, 720);
+	game.Run();
+
+	return 0;
+
 }

src/renderer/camera.cpp

@@ -0,0 +1,85 @@
+#include "camera.hpp"
+
+void Camera::UpdateView() {
+	// roll can be removed from here. because is not actually used in FPS camera
+	glm::mat4 matRoll = glm::mat4(1.0f);//identity matrix; 
+	glm::mat4 matPitch = glm::mat4(1.0f);//identity matrix
+	glm::mat4 matYaw = glm::mat4(1.0f);//identity matrix
+
+	// roll, pitch and yaw are used to store our angles in our class
+	matRoll = glm::rotate(matRoll, roll, glm::vec3(0.0f, 0.0f, 1.0f));
+	matPitch = glm::rotate(matPitch, pitch, glm::vec3(1.0f, 0.0f, 0.0f));
+	matYaw = glm::rotate(matYaw, yaw, glm::vec3(0.0f, 1.0f, 0.0f));
+
+	// order matters
+	glm::mat4 rotate = matRoll * matPitch * matYaw;
+
+	glm::mat4 translate = glm::mat4(1.0f);
+	translate = glm::translate(translate, -eyeVector);
+
+	viewMatrix = rotate * translate;
+}
+
+glm::mat4 Camera::GetViewMatrix() {
+	return viewMatrix;
+}
+
+glm::vec3 Camera::GetPos() {
+	return eyeVector;
+}
+
+void Camera::HandleMouse(SDL_Event e) {
+	if (e.type != SDL_MOUSEMOTION)
+		return;
+
+
+	float mouseDX = e.motion.xrel;
+	float mouseDY = e.motion.yrel;
+
+	glm::vec2 mouseDelta{ mouseDX, mouseDY };
+
+	MouseMoved(mouseDelta);
+}
+
+void Camera::MoveCamera() {
+	float dx = 0;
+	float dz = 0;
+
+	const Uint8* state = SDL_GetKeyboardState(NULL);
+
+	if (state[SDL_SCANCODE_W])
+		dz += 2;
+	if (state[SDL_SCANCODE_S])
+		dz += -2;
+	if (state[SDL_SCANCODE_A])
+		dx += -2;
+	if (state[SDL_SCANCODE_D])
+		dx += 2;
+	// if (state[SDL_SCANCODE_Z])
+
+	// if (state[SDL_SCANCODE_LSHIFT])
+
+
+	// get current view matrix
+	glm::mat4 mat = GetViewMatrix();
+	// row major
+	glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]);
+	glm::vec3 strafe(mat[0][0], mat[1][0], mat[2][0]);
+
+	// forward vector must be negative to look forward. 
+	// read :http://in2gpu.com/2015/05/17/view-matrix/
+	eyeVector += (-dz * forward + dx * strafe) * CameraSpeed;
+
+	// update the view matrix
+	UpdateView();
+}
+
+void Camera::MouseMoved(glm::vec2 mouseDelta) {
+	// note that yaw and pitch must be converted to radians.
+	// this is done in UpdateView() by glm::rotate
+	yaw += MouseSensitivity * mouseDelta.x;
+	pitch += MouseSensitivity * mouseDelta.y;
+
+	UpdateView();
+}
+

src/renderer/camera.hpp

@@ -0,0 +1,27 @@
+#ifndef MINECRAFT_RENDERER_CAMERA_H_
+#define MINECRAFT_RENDERER_CAMERA_H_
+
+#include "../common.hpp"
+
+class Camera {
+public:
+	Camera();
+
+	void UpdateView();
+	glm::mat4 GetViewMatrix();
+	glm::vec3 GetPos();
+
+	void HandleMouse(SDL_Event e);
+	void MoveCamera();
+	void MouseMoved(glm::vec2 mouseDelta);
+
+	float MouseSensitivity = 0.0025f;
+	float CameraSpeed = 1.0f;
+
+private:
+	float roll, pitch, yaw;
+	glm::vec3 eyeVector;
+	glm::mat4 viewMatrix;
+};
+
+#endif

src/renderer/shader.hpp

@@ -0,0 +1,6 @@
+#ifndef MINECRAFT_RENDERER_SHADER_H_
+#define MINECRAFT_RENDERER_SHADER_H_
+
+
+
+#endif