DragonEngine/ModuleProgram.cpp at master · Dartemiss/DragonEngine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#include "Globals.h"
#include "Application.h"
#include "ModuleProgram.h"
#include "SDL/SDL.h"
#include "GL/glew.h"
#include "MathGeoLib/Math/float4x4.h"
#include "assert.h"
#include <string>
#include <streambuf>
#include <fstream>


bool ModuleProgram::Init()
{
	//Lighting shader
	uberProg = createProgramWithShaders("../Shaders/UberShader.vs", "../Shaders/UberShader.fs");

	//Skybox shader
	skyboxProg = createProgramWithShaders("../Shaders/Skybox.vs", "../Shaders/Skybox.fs");

	//Default shader
	defaultProg = createProgramWithShaders("../Shaders/VertexShader.vs", "../Shaders/FragmentShader.fs");

	return true;
}

bool ModuleProgram::CleanUp()
{
	glDeleteProgram(uberProg);
	glDeleteProgram(skyboxProg);
	glDeleteProgram(defaultProg);

	return true;
}

unsigned int ModuleProgram::createProgramWithShaders(const char * vertexFilename, const char * fragmentFilename) const
{
	LOG("Compiling Vertex Shader from %s", vertexFilename);
	unsigned int vertexShader = createShader(vertexFilename, GL_VERTEX_SHADER);
	LOG("Compiling Fragment Shader from %s", fragmentFilename);
	unsigned int fragmentShader = createShader(fragmentFilename, GL_FRAGMENT_SHADER);

	return createProgram(vertexShader, fragmentShader);
}

unsigned int ModuleProgram::createProgram(unsigned int vShader, unsigned int fShader) const
{
	unsigned int program = glCreateProgram();

	if (vShader != NULL)
	{
		LOG("Attaching Vertex Shader");
		glAttachShader(program, vShader);
	}

	if (fShader != NULL)
	{
		LOG("Attaching Fragment Shader");
		glAttachShader(program, fShader);
	}

	LOG("Linking program");
	glLinkProgram(program);

	int  success;
	char infoLog[512];
	glGetProgramiv(program, GL_LINK_STATUS, &success);
	if (!success) {
		glGetProgramInfoLog(program, 512, NULL, infoLog);
		LOG("\nERROR::PROGRAM::CREATION_FAILED");
		LOG("ERROR: %s\n", infoLog);
	}

	//Now we can delete shaders
	LOG("Deleting Vertex Shader");
	glDeleteShader(vShader);

	LOG("Deleting Fragment Shader\n");
	glDeleteShader(fShader);

	return program;
}

unsigned int ModuleProgram::createShader(const char * filename, unsigned int shaderType) const
{
	assert(filename != nullptr);

	char* data = readFile(filename);
	unsigned int shaderId = glCreateShader(shaderType);
	glShaderSource(shaderId, 1, &data, NULL);
	glCompileShader(shaderId);
	delete[] data;

	GLint success = GL_FALSE;
	int logLength;
	glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success);

	if (!success) {
		glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &logLength);
		std::vector<GLchar> shaderError((logLength > 1) ? logLength : 1);
		glGetShaderInfoLog(shaderId, logLength, NULL, &shaderError[0]);
		LOG("ERROR: Shader with path %s coudn't be compiled : %s\n", filename, &shaderError[0]);
	}

	return shaderId;
}

char* ModuleProgram::readFile(const char* file_name) const
{
	assert(file_name != nullptr);

	char* result = nullptr;
	FILE* file = nullptr;
	fopen_s(&file, file_name, "rb");
	if (file)
	{
		fseek(file, 0, SEEK_END);
		int size = ftell(file);
		rewind(file);
		result = new char[size + 1];
		fread(result, 1, size, file);
		result[size] = 0;
		fclose(file);
	}

	return result;
}