scop/src/run.c

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   run.c                                              :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: gbrochar <gbrochar@student.42.fr>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2020/12/23 19:38:05 by gbrochar          #+#    #+#             */
/*   Updated: 2020/12/23 21:25:26 by gbrochar         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "scop.h"


GLuint VBO;
GLuint IBO;
GLuint gScaleLocation;

const char* pVSFileName = "src/shader.vs";
const char*	pFSFileName = "src/shader.fs";

static void RenderSceneCB()
{
	glClear(GL_COLOR_BUFFER_BIT);

	static float Scale = 0.0f;

	Scale += 0.01f;

	glUniform1f(gScaleLocation, sinf(Scale));

	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
	// first GL_POINT or GL_TRIANGLES
	// second start of draw
	// third number of vertices to draw
	glDrawElements(GL_TRIANGLES, 228, GL_UNSIGNED_INT, 0);

	glDisableVertexAttribArray(0);

	glutSwapBuffers();
}

static void InitializeGlutCallbacks(void)
{
	glutDisplayFunc(RenderSceneCB);
	glutIdleFunc(RenderSceneCB);
}

static void CreateVertexBuffer(t_env *e)
{
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, e->object.vertices.ptr * sizeof(double), e->object.vertices.data, GL_STATIC_DRAW);
	glGenBuffers(1, &IBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, e->object.indices.ptr * sizeof(int), e->object.indices.data, GL_STATIC_DRAW); 
}

static void AddShader(GLuint ShaderProgram, const char* pShaderText, GLenum ShaderType)
{
	GLuint ShaderObj = glCreateShader(ShaderType);

	if (ShaderObj == 0)
	{
		fprintf(stderr, "Error creating shader type %d\n", ShaderType);
		exit(0);
	}

	const GLchar* p[1];
	p[0] = pShaderText;
	GLint Lengths[1];
	Lengths[0] = strlen(pShaderText);
	glShaderSource(ShaderObj, 1, p, Lengths);
	glCompileShader(ShaderObj);
	GLint success;
	glGetShaderiv(ShaderObj, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		GLchar InfoLog[1024];
		glGetShaderInfoLog(ShaderObj, 1024, NULL, InfoLog);
		fprintf(stderr, "Error compiling shader type %d: '%s'\n", ShaderType, InfoLog);
		exit(1);
	}

	glAttachShader(ShaderProgram, ShaderObj);
}

static void CompileShaders()
{
	GLuint ShaderProgram = glCreateProgram();

	if (ShaderProgram == 0)
	{
		fprintf(stderr, "Error creating shader program\n");
		exit(1);
	}

	char		*vs = (char *)malloc(BUFFER_SIZE * sizeof(char));
	char		*fs = (char *)malloc(BUFFER_SIZE * sizeof(char));
	char		*buffer = (char *)malloc(BUFFER_SIZE * sizeof(char));
	FILE		*fp;

	vs[0] = '\0';
	fs[0] = '\0';
	fp = fopen(pVSFileName, "r");
	while (fgets(buffer, 4096, fp))
	{
		buffer[strcspn(buffer, "\n") + 1] = '\0';
		strcat(vs, buffer);
	}
	fclose(fp);
	fp = fopen(pFSFileName, "r");
	while (fgets(buffer, 4096, fp))
	{
		buffer[strcspn(buffer, "\n") + 1] = '\0';
		strcat(fs, buffer);
	}
	fclose(fp);
	printf("%s", vs);
	printf("%s", fs);
	AddShader(ShaderProgram, vs, GL_VERTEX_SHADER);
	AddShader(ShaderProgram, fs, GL_FRAGMENT_SHADER);

	GLint Success = 0;
	GLchar ErrorLog[1024] = { 0 };

	glLinkProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
	if (Success == 0)
	{
		glGetProgramInfoLog(ShaderProgram, sizeof(ErrorLog), NULL, ErrorLog);
		fprintf(stderr, "Error linking shader program : '%s'\n", ErrorLog);
		exit(1);
	}

	glValidateProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_VALIDATE_STATUS, &Success);
	if (!Success)
	{
		glGetProgramInfoLog(ShaderProgram, sizeof(ErrorLog), NULL, ErrorLog);
		fprintf(stderr, "Invalid shader program '%s'\n", ErrorLog);
		exit(1);
	}

	glUseProgram(ShaderProgram);

	gScaleLocation = glGetUniformLocation(ShaderProgram, "gScale");
	// assert(gScaleLocation != 0xFFFFFFFF);
}

void			run(t_env *e)
{
	int			argc = 1;
	char		*argv[1];

	argv[0] = strdup("scop");
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(e->window.width, e->window.height);
	glutInitWindowPosition(100, 100);
	glutCreateWindow("scop");

	printf("%ld", e->object.indices.ptr);
	InitializeGlutCallbacks();
		// Must be done after glut is initialized !
	GLenum res = glewInit();
	if (res != GLEW_OK)
	{
		fprintf(stderr, "Error : '%s'\n", glewGetErrorString(res));
		exit (1);
	}
	printf("GL version: %s\n", glGetString(GL_VERSION));
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	CreateVertexBuffer(e);
	CompileShaders();
	glutMainLoop();
}