Comparar texto

Encontre a diferença entre dois arquivos de texto

Editor live

Recolher inalteradas

Sem quebra de linha

Layout

Nível de detalhe

Realce de sintaxe

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

Untitled diff

Criado há 11 anosO diff nunca expira

59 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

319 linhas

30 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

310 linhas

#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);

}

Diferenças salvas

Texto original

Abrir arquivo

#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 alterado

Abrir arquivo

#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);
	}
}