graphics.cpp

#include <iostream>
#include <fstream>
#include <string>

#include <GL\glew.h>
#include <SDL\SDL.h>

#ifdef main
#undef main
#endif // main

int main()
{
	/* init all */
	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
		std::cout << "Failed to init SDL\n";
	}

	SDL_Window* window = SDL_CreateWindow("Tanks", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL);
	if (!window) {
		std::cout << "Failed to create window\n";
	}

	SDL_GLContext context = SDL_GL_CreateContext(window);

	if (glewInit() != GLEW_OK) {
		std::cout << "Failed to init glew\n";
	}

	/* properties */
	SDL_GL_SetSwapInterval(1);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);

	/* main */
	float vertices[] = {
		-0.5f, 0.5f, 0.0f,
		 0.5f, 0.5f, 0.0f,
		 0.5f,-0.5f, 0.0f,
		-0.5f,-0.5f, 0.0f
	};

	unsigned int indices[] = {
		0, 1, 2,
		0, 2, 3
	};

	GLuint VAO, VBO, EBO;

	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glGenBuffers(1, &EBO);

	glBindVertexArray(VAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (GLvoid*)0);

	/* create shader */
	GLuint vertexShader, fragmentShader, testProgram;

	std::ifstream file;

	/* vertex shader */
	file.open("test.vert");
	std::string vertexShaderText((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
	file.close();

	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	const char* vertexShaderTextArray = vertexShaderText.c_str();
	glShaderSource(vertexShader, 1, &vertexShaderTextArray, NULL);
	glCompileShader(vertexShader);

	GLint compilationStatus;
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compilationStatus);
	if (compilationStatus == GL_FALSE) {
		GLint infoLogLength;
		glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &infoLogLength);

		GLchar *strInfoLog = new GLchar[infoLogLength + 1];
		glGetShaderInfoLog(vertexShader, infoLogLength, NULL, strInfoLog);

		std::cout << "Shader compilation error: " << strInfoLog << "\n";
		delete[] strInfoLog;
	}

	/* fragment shader */
	file.open("test.frag");
	std::string fragmentShaderText((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
	file.close();

	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	const char*fragmentShaderTextArray = fragmentShaderText.c_str();
	glShaderSource(fragmentShader, 1, &fragmentShaderTextArray, NULL);
	glCompileShader(fragmentShader);

	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compilationStatus);
	if (compilationStatus == GL_FALSE) {
		GLint infoLogLength;
		glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &infoLogLength);

		GLchar *strInfoLog = new GLchar[infoLogLength + 1];
		glGetShaderInfoLog(fragmentShader, infoLogLength, NULL, strInfoLog);

		std::cout << "Shader compilation error: " << strInfoLog << "\n";
		delete[] strInfoLog;
	}

	/* create shader program */
	testProgram = glCreateProgram();

	glAttachShader(testProgram, vertexShader);
	glAttachShader(testProgram, fragmentShader);
	glLinkProgram(testProgram);

	glGetProgramiv(testProgram, GL_LINK_STATUS, &compilationStatus);
	if (compilationStatus == GL_FALSE) {
		std::cout << "Program link error\n";
	}

	/* set uniforms */
	glUseProgram(testProgram);
	glBindAttribLocation(testProgram, 0, "position");


	bool isOpen = true;
	while (isOpen) {
		glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		SDL_Event e;
		while (SDL_PollEvent(&e)) {
			switch (e.type)
			{
			case SDL_QUIT:
				isOpen = false;
				break;
			default:
				break;
			}
		}

		
		glBindVertexArray(VAO);
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
		glBindVertexArray(0);


		SDL_GL_SwapWindow(window);
	}

	/* clear all */
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);
	glDeleteVertexArrays(1, &VAO);

	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);
	glDeleteProgram(testProgram);

	SDL_GL_DeleteContext(context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}