Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Untitled diff

Creado hace 11 añosEl diff nunca expira

59 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

319 líneas

30 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

310 líneas

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <GL/glew.h>

#include <GL/freeglut.h>

#define WINDOW_TITLE_PREFIX "Chapter 2"

int CurrentWidth = 800,

CurrentHeight = 600,

WindowHandle = 0;

unsigned FrameCount = 0;

GLuint

VertexShaderId,

FragmentShaderId,

ProgramId,

VaoId,

VboId,

ColorBufferId;

const GLchar* VertexShader =

{

"#version 400\n"\

"layout(location=0) in vec4 in_Position;\n"\

"layout(location=1) in vec4 in_Color;\n"\

"out vec4 ex_Color;\n"\

"void main(void)\n"\

"{\n"\

" gl_Position = in_Position;\n"\

" ex_Color = in_Color;\n"\

"}\n"

};

const GLchar* FragmentShader =

{

"#version 400\n"\

"in vec4 ex_Color;\n"\

"out vec4 out_Color;\n"\

"void main(void)\n"\

"{\n"\

" out_Color = ex_Color;\n"\

"}\n"

};

void Initialize(int, char*[]);

void InitWindow(int, char*[]);

void ResizeFunction(int, int);

void RenderFunction(void);

void TimerFunction(int);

void IdleFunction(void);

void Cleanup(void);

void CreateVBO(void);

void DestroyVBO(void);

void CreateShaders(void);

void DestroyShaders(void);

int main(int argc, char* argv[])

{

Initialize(argc, argv);

glutMainLoop();

exit(EXIT_SUCCESS);

}

void Initialize(int argc, char* argv[])

{

GLenum GlewInitResult;

InitWindow(argc, argv);

glewExperimental = GL_TRUE;

GlewInitResult = glewInit();

if (GLEW_OK != GlewInitResult) {

if (GLEW_OK != GlewInitResult)

fprintf(

{

stderr,

fprintf(stderr, "ERROR: %s/n", glewGetErrorString(GlewInitResult));

"ERROR: %s\n",

glewGetErrorString(GlewInitResult)

);

exit(EXIT_FAILURE);

}

fprintf(

stdout,

"INFO: OpenGL Version: %s\n",

glGetString(GL_VERSION)

);

CreateShaders();

CreateVBO();

glClearColor(1.0f, 0.0f, 0.0f, 1.0f);

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

}

void InitWindow(int argc, char* argv[])

{

glutInit(&argc, argv);

glutInitContextVersion(4, 0);

glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);

glutInitContextProfile(GLUT_CORE_PROFILE);

glutSetOption(

GLUT_ACTION_ON_WINDOW_CLOSE,

GLUT_ACTION_GLUTMAINLOOP_RETURNS

);

glutInitWindowSize(CurrentWidth, CurrentHeight);

glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);

if(WindowHandle < 1) {

if (WindowHandle < 1)

{

fprintf(

stderr,

"ERROR: Could not create a new rendering window.\n"

);

exit(EXIT_FAILURE);

}

glutReshapeFunc(ResizeFunction);

glutDisplayFunc(RenderFunction);

glutIdleFunc(IdleFunction);

glutTimerFunc(0, TimerFunction, 0);

glutCloseFunc(Cleanup);

}

void ResizeFunction(int Width, int Height)

{

CurrentWidth = Width;

CurrentHeight = Height;

glViewport(0, 0, CurrentWidth, CurrentHeight);

}

void RenderFunction(void)

{

++FrameCount;

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glDrawArrays(GL_TRIANGLES, 0, 3);

glutSwapBuffers();

glutPostRedisplay();

++FrameCount;

}

void IdleFunction(void)

{

glutPostRedisplay();

}

void TimerFunction(int Value)

{

if (0 != Value) {

if (0 != Value)

char* TempString = (char*)

{

char * TempString = (char*)

malloc(512 + strlen(WINDOW_TITLE_PREFIX));

sprintf(

sprintf(TempString, "%s: %d Frames Per Second @ %d x %d", WINDOW_TITLE_PREFIX, FrameCount * 4, CurrentWidth, CurrentHeight);

TempString,

"%s: %d Frames Per Second @ %d x %d",

WINDOW_TITLE_PREFIX,

FrameCount * 4,

CurrentWidth,

CurrentHeight

);

glutSetWindowTitle(TempString);

free(TempString);

}

FrameCount = 0;

glutTimerFunc(250, TimerFunction, 1);

}

void Cleanup(void)

{

DestroyShaders();

DestroyVBO();

}

void CreateVBO(void)

{

GLfloat Vertices[] =

{

-0.8f, -0.8f, 0.0f, 1.0f,

0.0f, 0.8f, 0.0f, 1.0f,

0.8f, -0.8f, 0.0f, 1.0f

};

GLfloat Colors[] =

{

1.0f, 0.0f, 0.0f, 1.0f,

0.0f, 1.0f, 0.0f, 1.0f,

0.0f, 0.0f, 1.0f, 1.0f

};

GLenum ErrorCheckValue = glGetError();

glGenVertexArrays(1, &VaoId);

glBindVertexArray(VaoId);

glGenBuffers(1, &VboId);

glBindBuffer(GL_ARRAY_BUFFER, VboId);

glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);

glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);

glEnableVertexAttribArray(0);

glGenBuffers(1, &ColorBufferId);

glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);

glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);

glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);

glEnableVertexAttribArray(1);

ErrorCheckValue = glGetError();

if (ErrorCheckValue != GL_NO_ERROR)

{

fprintf(

stderr,

"ERROR: Could not create a VBO: %s \n",

gluErrorString(ErrorCheckValue)

);

exit(-1);

}

void DestroyVBO(void)

{

GLenum ErrorCheckValue = glGetError();

glDisableVertexAttribArray(1);

glDisableVertexAttribArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glDeleteBuffers(1, &ColorBufferId);

glDeleteBuffers(1, &VboId);

glBindVertexArray(0);

glDeleteVertexArrays(1, &VaoId);

ErrorCheckValue = glGetError();

if (ErrorCheckValue != GL_NO_ERROR)

{

fprintf(

stderr,

"ERROR: Could not destroy the VBO: %s \n",

gluErrorString(ErrorCheckValue)

);

exit(-1);

}

void CreateShaders(void)

{

GLenum ErrorCheckValue = glGetError();

VertexShaderId = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(VertexShaderId, 1, &VertexShader, NULL);

glCompileShader(VertexShaderId);

FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(FragmentShaderId, 1, &FragmentShader, NULL);

glCompileShader(FragmentShaderId);

ProgramId = glCreateProgram();

glAttachShader(ProgramId, VertexShaderId);

glAttachShader(ProgramId, FragmentShaderId);

glLinkProgram(ProgramId);

glUseProgram(ProgramId);

ErrorCheckValue = glGetError();

if (ErrorCheckValue != GL_NO_ERROR)

{

fprintf(

stderr,

"ERROR: Could not create the shaders: %s \n",

gluErrorString(ErrorCheckValue)

);

exit(-1);

}

void DestroyShaders(void)

{

GLenum ErrorCheckValue = glGetError();

glUseProgram(0);

glDetachShader(ProgramId, VertexShaderId);

glDetachShader(ProgramId, FragmentShaderId);

glDeleteShader(FragmentShaderId);

glDeleteShader(VertexShaderId);

glDeleteProgram(ProgramId);

ErrorCheckValue = glGetError();

if (ErrorCheckValue != GL_NO_ERROR)

{

fprintf(

stderr,

"ERROR: Could not destroy the shaders: %s \n",

gluErrorString(ErrorCheckValue)

);

exit(-1);

}

Diferencias guardadas

Texto original

Abrir archivo

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#define WINDOW_TITLE_PREFIX "Chapter 2"

int CurrentWidth = 800,
	CurrentHeight = 600,
	WindowHandle = 0;

unsigned FrameCount = 0;

GLuint
	VertexShaderId,
	FragmentShaderId,
	ProgramId,
	VaoId,
	VboId,
	ColorBufferId;

const GLchar* VertexShader =
{
	"#version 400\n"\

"layout(location=0) in vec4 in_Position;\n"\
	"layout(location=1) in vec4 in_Color;\n"\
	"out vec4 ex_Color;\n"\

"void main(void)\n"\
	"{\n"\
	"	gl_Position = in_Position;\n"\
	"	ex_Color = in_Color;\n"\
	"}\n"
};

const GLchar* FragmentShader =
{
	"#version 400\n"\

"in vec4 ex_Color;\n"\
	"out vec4 out_Color;\n"\

"void main(void)\n"\
	"{\n"\
	"	out_Color = ex_Color;\n"\
	"}\n"
};

void Initialize(int, char*[]);
void InitWindow(int, char*[]);
void ResizeFunction(int, int);
void RenderFunction(void);
void TimerFunction(int);
void IdleFunction(void);
void Cleanup(void);
void CreateVBO(void);
void DestroyVBO(void);
void CreateShaders(void);
void DestroyShaders(void);

int main(int argc, char* argv[])
{
	Initialize(argc, argv);

glutMainLoop();
	
	exit(EXIT_SUCCESS);
}

void Initialize(int argc, char* argv[])
{
	GLenum GlewInitResult;

InitWindow(argc, argv);

glewExperimental = GL_TRUE;
	GlewInitResult = glewInit();

if (GLEW_OK != GlewInitResult) {
		fprintf(
			stderr,
			"ERROR: %s\n",
			glewGetErrorString(GlewInitResult)
		);
		exit(EXIT_FAILURE);
	}
	
	fprintf(
		stdout,
		"INFO: OpenGL Version: %s\n",
		glGetString(GL_VERSION)
	);

CreateShaders();
	CreateVBO();

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}

void InitWindow(int argc, char* argv[])
{
	glutInit(&argc, argv);
	
	glutInitContextVersion(4, 0);
	glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
	glutInitContextProfile(GLUT_CORE_PROFILE);

glutSetOption(
		GLUT_ACTION_ON_WINDOW_CLOSE,
		GLUT_ACTION_GLUTMAINLOOP_RETURNS
	);
	
	glutInitWindowSize(CurrentWidth, CurrentHeight);

glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);

if(WindowHandle < 1) {
		fprintf(
			stderr,
			"ERROR: Could not create a new rendering window.\n"
		);
		exit(EXIT_FAILURE);
	}
	
	glutReshapeFunc(ResizeFunction);
	glutDisplayFunc(RenderFunction);
	glutIdleFunc(IdleFunction);
	glutTimerFunc(0, TimerFunction, 0);
	glutCloseFunc(Cleanup);
}

void ResizeFunction(int Width, int Height)
{
	CurrentWidth = Width;
	CurrentHeight = Height;
	glViewport(0, 0, CurrentWidth, CurrentHeight);
}

void RenderFunction(void)
{
	++FrameCount;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	glDrawArrays(GL_TRIANGLES, 0, 3);

glutSwapBuffers();
	glutPostRedisplay();
}

void IdleFunction(void)
{
	glutPostRedisplay();
}

void TimerFunction(int Value)
{
	if (0 != Value) {
		char* TempString = (char*)
			malloc(512 + strlen(WINDOW_TITLE_PREFIX));

sprintf(
			TempString,
			"%s: %d Frames Per Second @ %d x %d",
			WINDOW_TITLE_PREFIX,
			FrameCount * 4,
			CurrentWidth,
			CurrentHeight
		);

glutSetWindowTitle(TempString);
		free(TempString);
	}
	
	FrameCount = 0;
	glutTimerFunc(250, TimerFunction, 1);
}

void Cleanup(void)
{
	DestroyShaders();
	DestroyVBO();
}

void CreateVBO(void)
{
	GLfloat Vertices[] = 
	{
		-0.8f, -0.8f, 0.0f, 1.0f,
		 0.0f,  0.8f, 0.0f, 1.0f,
		 0.8f, -0.8f, 0.0f, 1.0f
	};

GLfloat Colors[] = 
	{
		1.0f, 0.0f, 0.0f, 1.0f,
		0.0f, 1.0f, 0.0f, 1.0f,
		0.0f, 0.0f, 1.0f, 1.0f
	};

GLenum ErrorCheckValue = glGetError();
	
	glGenVertexArrays(1, &VaoId);
	glBindVertexArray(VaoId);

glGenBuffers(1, &VboId);
	glBindBuffer(GL_ARRAY_BUFFER, VboId);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(0);
	
	glGenBuffers(1, &ColorBufferId);
	glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(1);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not create a VBO: %s \n",
			gluErrorString(ErrorCheckValue)
		);

exit(-1);
	}
}

void DestroyVBO(void)
{
	GLenum ErrorCheckValue = glGetError();

glDisableVertexAttribArray(1);
	glDisableVertexAttribArray(0);
	
	glBindBuffer(GL_ARRAY_BUFFER, 0);

glDeleteBuffers(1, &ColorBufferId);
	glDeleteBuffers(1, &VboId);

glBindVertexArray(0);
	glDeleteVertexArrays(1, &VaoId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not destroy the VBO: %s \n",
			gluErrorString(ErrorCheckValue)
		);

exit(-1);
	}
}

void CreateShaders(void)
{
	GLenum ErrorCheckValue = glGetError();
	
	VertexShaderId = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShaderId, 1, &VertexShader, NULL);
	glCompileShader(VertexShaderId);

FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShaderId, 1, &FragmentShader, NULL);
	glCompileShader(FragmentShaderId);

ProgramId = glCreateProgram();
		glAttachShader(ProgramId, VertexShaderId);
		glAttachShader(ProgramId, FragmentShaderId);
	glLinkProgram(ProgramId);
	glUseProgram(ProgramId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not create the shaders: %s \n",
			gluErrorString(ErrorCheckValue)
		);

exit(-1);
	}
}

void DestroyShaders(void)
{
	GLenum ErrorCheckValue = glGetError();

glUseProgram(0);

glDetachShader(ProgramId, VertexShaderId);
	glDetachShader(ProgramId, FragmentShaderId);

glDeleteShader(FragmentShaderId);
	glDeleteShader(VertexShaderId);

glDeleteProgram(ProgramId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not destroy the shaders: %s \n",
			gluErrorString(ErrorCheckValue)
		);

exit(-1);
	}
}

Texto modificado

Abrir archivo

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#define WINDOW_TITLE_PREFIX "Chapter 2"

int CurrentWidth = 800,
CurrentHeight = 600,
WindowHandle = 0;

unsigned FrameCount = 0;

GLuint
VertexShaderId,
FragmentShaderId,
ProgramId,
VaoId,
VboId,
ColorBufferId;

const GLchar* VertexShader =
{
	"#version 400\n"\

"layout(location=0) in vec4 in_Position;\n"\
	"layout(location=1) in vec4 in_Color;\n"\
	"out vec4 ex_Color;\n"\

"void main(void)\n"\
	"{\n"\
	"	gl_Position = in_Position;\n"\
	"	ex_Color = in_Color;\n"\
	"}\n"
};

const GLchar* FragmentShader = 
{
	"#version 400\n"\

"in vec4 ex_Color;\n"\
	"out vec4 out_Color;\n"\

"void main(void)\n"\
	"{\n"\
	"	out_Color = ex_Color;\n"\
	"}\n"
};

void Initialize(int, char*[]);
void InitWindow(int, char*[]);
void ResizeFunction(int, int);
void RenderFunction(void);
void TimerFunction(int);
void IdleFunction(void);

void Cleanup(void);
void CreateVBO(void);
void DestroyVBO(void);
void CreateShaders(void);
void DestroyShaders(void);

int main(int argc, char* argv[])
{
	Initialize(argc, argv);

glutMainLoop();

exit(EXIT_SUCCESS);
}

void Initialize(int argc, char* argv[])
{
	GLenum GlewInitResult;

InitWindow(argc, argv);

GlewInitResult = glewInit();

if (GLEW_OK != GlewInitResult)
	{
		fprintf(stderr, "ERROR: %s/n", glewGetErrorString(GlewInitResult));
		exit(EXIT_FAILURE);
	}

fprintf(
		stdout,
		"INFO: OpenGL Version: %s\n",
		glGetString(GL_VERSION)
		);

CreateShaders();
	CreateVBO();
	glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
}

void InitWindow(int argc, char* argv[])
{
	glutInit(&argc, argv);

glutInitContextVersion(4, 0);
	glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
	glutInitContextProfile(GLUT_CORE_PROFILE);

glutSetOption(
		GLUT_ACTION_ON_WINDOW_CLOSE,
		GLUT_ACTION_GLUTMAINLOOP_RETURNS
		);

glutInitWindowSize(CurrentWidth, CurrentHeight);

glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);

if (WindowHandle < 1)
	{
		fprintf(
			stderr,
			"ERROR: Could not create a new rendering window.\n"
			);
		exit(EXIT_FAILURE);
	}

glutReshapeFunc(ResizeFunction);
	glutDisplayFunc(RenderFunction);
	glutIdleFunc(IdleFunction);
	glutTimerFunc(0, TimerFunction, 0);
	glutCloseFunc(Cleanup);
}

void ResizeFunction(int Width, int Height)
{
	CurrentWidth = Width;
	CurrentHeight = Height;
	glViewport(0, 0, CurrentWidth, CurrentHeight);
}

void RenderFunction(void)
{
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glDrawArrays(GL_TRIANGLES, 0, 3);

glutSwapBuffers();
	glutPostRedisplay();
	++FrameCount;
}

void IdleFunction(void)
{
	glutPostRedisplay();
}

void TimerFunction(int Value)
{
	if (0 != Value)
	{
		char * TempString = (char*)
			malloc(512 + strlen(WINDOW_TITLE_PREFIX));

sprintf(TempString, "%s: %d Frames Per Second @ %d x %d", WINDOW_TITLE_PREFIX, FrameCount * 4, CurrentWidth, CurrentHeight);

glutSetWindowTitle(TempString);
		free(TempString);
	}

FrameCount = 0;
	glutTimerFunc(250, TimerFunction, 1);
}

void Cleanup(void)
{
	DestroyShaders();
	DestroyVBO();
}

void CreateVBO(void)
{
	GLfloat Vertices[] =
	{
		-0.8f, -0.8f, 0.0f, 1.0f,
		 0.0f, 0.8f, 0.0f, 1.0f,
		 0.8f, -0.8f, 0.0f, 1.0f
	};

GLfloat Colors[] =
	{
		1.0f, 0.0f, 0.0f, 1.0f,
		0.0f, 1.0f, 0.0f, 1.0f,
		0.0f, 0.0f, 1.0f, 1.0f
	};

GLenum ErrorCheckValue = glGetError();

glGenVertexArrays(1, &VaoId);
	glBindVertexArray(VaoId);

glGenBuffers(1, &ColorBufferId);
	glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(1);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not create a VBO: %s \n",
			gluErrorString(ErrorCheckValue)
			);

exit(-1);
	}
}

void DestroyVBO(void)
{
	GLenum ErrorCheckValue = glGetError();

glDisableVertexAttribArray(1);
	glDisableVertexAttribArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glDeleteBuffers(1, &ColorBufferId);
	glDeleteBuffers(1, &VboId);

glBindVertexArray(0);
	glDeleteVertexArrays(1, &VaoId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not destroy the VBO: %s \n",
			gluErrorString(ErrorCheckValue)
			);

exit(-1);
	}
}

void CreateShaders(void)
{
	GLenum ErrorCheckValue = glGetError();

VertexShaderId = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShaderId, 1, &VertexShader, NULL);
	glCompileShader(VertexShaderId);

FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShaderId, 1, &FragmentShader, NULL);
	glCompileShader(FragmentShaderId);

ProgramId = glCreateProgram();
	glAttachShader(ProgramId, VertexShaderId);
	glAttachShader(ProgramId, FragmentShaderId);
	glLinkProgram(ProgramId);
	glUseProgram(ProgramId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not create the shaders: %s \n",
			gluErrorString(ErrorCheckValue)
			);

exit(-1);
	}
}

void DestroyShaders(void)
{
	GLenum ErrorCheckValue = glGetError();

glUseProgram(0);

glDetachShader(ProgramId, VertexShaderId);
	glDetachShader(ProgramId, FragmentShaderId);

glDeleteShader(FragmentShaderId);
	glDeleteShader(VertexShaderId);

glDeleteProgram(ProgramId);

ErrorCheckValue = glGetError();
	if (ErrorCheckValue != GL_NO_ERROR)
	{
		fprintf(
			stderr,
			"ERROR: Could not destroy the shaders: %s \n",
			gluErrorString(ErrorCheckValue)
			);

exit(-1);
	}
}