void gfx_gl_error(char * fmt, ...)
{
if(globals.opengl)
{
GLenum err;
err = glGetError();
if(err != GL_NO_ERROR)
{
va_list ap;
char buf[1024];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
fprintf(stderr, "OpenGL error %d: %s\n%s\n", (int) err, gluErrorString(err), buf);
}
assert(err == GL_NO_ERROR);
}
}
void ExitOnGLError(const char* error_message)
{
const GLenum ErrorValue = glGetError();
if (ErrorValue != GL_NO_ERROR)
{
const char* APPEND_DETAIL_STRING = ": %s\n";
const size_t APPEND_LENGTH = strlen(APPEND_DETAIL_STRING) + 1;
const size_t message_length = strlen(error_message);
char* display_message = (char*)malloc(message_length + APPEND_LENGTH);
memcpy(display_message, error_message, message_length);
memcpy(&display_message[message_length], APPEND_DETAIL_STRING, APPEND_LENGTH);
fprintf(stderr, display_message, gluErrorString(ErrorValue));
free(display_message);
exit(EXIT_FAILURE);
}
}
void draw(void)
{
// set the background color of the world
cColorf color = camera->getParentWorld()->getBackgroundColor();
glClearColor(color.getR(), color.getG(), color.getB(), color.getA());
// clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render world in the window display
camera->renderView(width, height);
// check for any OpenGL errors
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
// Swap buffers
glutSwapBuffers();
}
void SimText3D::transferToTexture(GLuint texID)
{
if(texID==-1)texID=texture;
glBindTexture(texture_target, texID);
static PFNGLTEXIMAGE3DPROC glTexImage3D = (PFNGLTEXIMAGE3DPROC) wglGetProcAddress("glTexImage3D");
static PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) wglGetProcAddress("glTexSubImage3D");
//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
//To copy texels from the framebuffer, use glCopyTexSubImage2D.
//glBindTexture(GL_TEXTURE_2D, textureID); //A texture you have already created with glTexImage2D
//glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height); //Copy back buffer to texture
//Then came the programmable GPU. There aren't texture units anymore. Today, you have texture samplers. These are also called texture image units (TIU) which you can get with
//int MaxTextureImageUnits;
//glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &MaxTextureImageUnits);
//For texture coordinates, you can get the max with
//int MaxTextureCoords;
//glGetIntegerv(GL_MAX_TEXTURE_COORDS, &MaxTextureCoords);
if(dim_num==1)glTexImage1D(texture_target,0,internal_format,width,0,texture_format,t_type,arr);
if(dim_num==2)glTexImage2D(texture_target,0,internal_format,width,height,0,texture_format,t_type,arr);
if(dim_num==3)
{
glTexImage3D(texture_target,0,internal_format,width,height,depth,0,texture_format,t_type,0);
glTexSubImage3D(texture_target,0,0,0,0,width,height,depth,texture_format,t_type,arr);
}
GLenum errCode;
const GLubyte *errString;
errCode=glGetError();
if (errCode!=GL_NO_ERROR)
{
errString=gluErrorString(errCode);
// std::cout<<ln((char*)errString);
}
}
void draw(void)
{
GLenum err;
GLdouble secs, degrees;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* one revolution every 10 seconds... */
secs = get_secs();
secs = secs - 10.*trunc(secs / 10.);
degrees = (secs/10.) * (360.);
draw_room();
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
if (degrees < 180) {
/* sphere behind cone */
glCullFace(GL_FRONT);
draw_sphere(degrees);
draw_cone();
glCullFace(GL_BACK);
draw_sphere(degrees);
draw_cone();
} else {
/* cone behind sphere */
glCullFace(GL_FRONT);
draw_cone();
draw_sphere(degrees);
glCullFace(GL_BACK);
draw_cone();
draw_sphere(degrees);
}
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
glutSwapBuffers();
}
void updateGraphics(void)
{
// update content of position label
for (int i=0; i<numHapticDevices; i++)
{
// read position of device an convert into millimeters
cVector3d pos;
hapticDevices[i]->getPosition(pos);
pos.mul(1000);
// create a string that concatenates the device number and its position.
string strID;
cStr(strID, i);
string strLabel = "#" + strID + " x: ";
cStr(strLabel, pos.x, 2);
strLabel = strLabel + " y: ";
cStr(strLabel, pos.y, 2);
strLabel = strLabel + " z: ";
cStr(strLabel, pos.z, 2);
labels[i]->m_string = strLabel;
}
// render world
camera->renderView(displayW, displayH);
// Swap buffers
glutSwapBuffers();
// check for any OpenGL errors
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
// inform the GLUT window to call updateGraphics again (next frame)
if (simulationRunning)
{
glutPostRedisplay();
}
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float startFps = glutGet(GLUT_ELAPSED_TIME);
float deltaFps = startFps - oldfps;
oldfps = startFps;
gm->update(1/deltaFps*1000);
gm->render();
/* check for errors that may occur in OpenGL */
GLenum err = glGetError();
if (err != GL_NO_ERROR)
std::cout << "OpenGL error: " << gluErrorString(err) << std::endl;
std::cout.flush();
if(keyPressed[KEY_ID_W]==true) gm->getCam()->moveForward();
if(keyPressed[KEY_ID_A]==true) gm->getCam()->moveLeft();
if(keyPressed[KEY_ID_D]==true) gm->getCam()->moveRight();
if(keyPressed[KEY_ID_S]==true) gm->getCam()->moveBackward();
if(keyPressed[KEY_ID_X]==true) gm->getCam()->moveUp();
if(keyPressed[KEY_ID_C]==true) gm->getCam()->moveDown();
if (keyPressed[KEY_ID_RIGHT] == true) gm->getShip()->moveRight();
if (keyPressed[KEY_ID_LEFT] == true) gm->getShip()->moveLeft();
if (keyPressed[KEY_ID_UP] == true) gm->getShip()->moveUp();
if (keyPressed[KEY_ID_DOWN] == true) gm->getShip()->moveDown();
if ((keyPressed[KEY_ID_SPACE] == true)&& (gm->getShip()->getLife() > 0))
{
gm->addBulletPlayer();
keyPressed[KEY_ID_SPACE] = false;
}
glutSwapBuffers();
glutPostRedisplay();
}
void draw(void)
{
GLenum err;
GLfloat s, absx, abs1minusx;
glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
glRasterPos2i(0, 0);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, in0);
absx = fabs(x);
abs1minusx = fabs(1.-x);
s = absx > abs1minusx ? absx : abs1minusx;
if (!isIR) {
glAccum(GL_ACCUM, (1. - x) / s);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, in1);
glAccum(GL_ACCUM, x/s);
glAccum(GL_RETURN, s);
} else {
if (fabs(x) < 1. && fabs(1. - x) < 1) {
glAccum(GL_ACCUM, 1. - x);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, in1);
glAccum(GL_ACCUM, x);
glAccum(GL_RETURN, 1);
} else {
absx = fabs(x);
abs1minusx = fabs(1.-x);
s = absx > abs1minusx ? absx : abs1minusx;
glAccum(GL_ACCUM, .8 * ((1. - x) / s));
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, in1);
glAccum(GL_ACCUM, .8 * x/s);
glAccum(GL_RETURN, 1.2 * s);
}
}
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
glutSwapBuffers();
}
void draw(void)
{
GLenum err;
GLdouble secs;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_room();
draw_cone();
secs = get_secs();
/* draw the transparent object... */
glEnable(GL_POLYGON_STIPPLE);
draw_sphere(secs * 360. / 10.);
glDisable(GL_POLYGON_STIPPLE);
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
glutSwapBuffers();
}
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 (EXIT_FAILURE);
}
}
/*
* DO NOT call this function before the gl context has initialized. It will make an infinite loop.
* This is because glGetError always returns GL_INVALID_OPERATION before there exists a context. There's
* code in here to catch the loop and stop, but it will still produce unnecessary scary output.
*/
void checkGlError(int line /*= -1*/) {
GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR) {
OUTSTREAM << "<!> GL error(s) detected";
if (line > 0) {
OUTSTREAM << " at line " << line;
}
OUTSTREAM << ":\n";
int loopGuard = 0;
while (glErr != GL_NO_ERROR) {
if (++loopGuard <= 10) {
OUTSTREAM << "\t\t\t" << gluErrorString(glErr) << std::endl;
glErr = glGetError();
}
else {
OUTSTREAM << "\t\t\t<!> Suppressing further errors...\n";
break;
}
}
}
}
int CheckGLError(char *file, int line)
{
//return 0;
GLenum glErr,glErr2;
int retCode = 0;
glErr = glErr2 = glGetError();
while (glErr != GL_NO_ERROR)
{
char* str1 = (char*)gluErrorString(glErr);
if (str1)
cout << "GL Error #" << glErr << "(" << str1 << ") " << " in File " << file << " at line: " << line << endl;
else
cout << "GL Error #" << glErr << " in File " << file << " at line: " << line << endl;
retCode = 1;
glErr = glGetError();
}
if (glErr2 != GL_NO_ERROR) while(1)Sleep(100);;
return 0;
}
void updateGraphics(void)
{
int px;
// update haptic rate label
labelHapticRate->setString ("haptic rate: "+cStr(frequencyCounter.getFrequency(), 0) + " [Hz]");
px = (int)(0.5 * (displayW - labelHapticRate->getWidth()));
labelHapticRate->setLocalPos(px, 15);
// render world
camera->renderView(displayW, displayH);
// swap buffers
glutSwapBuffers();
// check for any OpenGL errors
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
}
/**
* Checks for OpenGL errors.
* Extremely useful debugging function: When developing,
* make sure to call this after almost every GL call.
*/
void checkGLErrors (const char *label) {
GLenum errCode;
const GLubyte *errStr;
if ((errCode = glGetError()) != GL_NO_ERROR) {
errStr = gluErrorString(errCode);
printf("OpenGL ERROR: ");
printf((char*)errStr);
printf("(Label: ");
printf(label);
printf(")\n");
}
else {
printf("[ OK ]");
printf((char*)errStr);
printf("(Label: ");
printf(label);
printf(")\n");
}
}
/* Fonction callback par defaut appelee lors d'un rafraichissement de fenetre */
static void fonctionAffichage(void)
{
#ifdef DEBUG_MODE
GLenum erreur;
#endif
// glLoadIdentity();
/* On appelle tout simplement la fonction generique de gestion des evenements */
gestionEvenement(Affichage);
glutSwapBuffers();
#ifdef DEBUG_MODE
/* Afficher une erreur OpenGL si celle-ci a eu lieu */
if
((erreur = glGetError()) != GL_NO_ERROR)
{
printf("Erreur OpenGL %d : ", (int)erreur);
puts((const char *)gluErrorString(erreur));
}
#endif
}
bool initGL()
{
c2x= new float[animalgridsize*animalgridsize];
c2y= new float[animalgridsize*animalgridsize];
Centro2x= new float[animalgridsize*animalgridsize];
Centro2y= new float[animalgridsize*animalgridsize];
glutSetWindow(1);
//Initialize Projection Matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
double auxborder=border*territorialidad;
glOrtho( -auxborder-0.5, auxborder, -auxborder-0.5, auxborder, 1.0, -1.0 );
//Initialize Modelview Matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
//Initialize clear color
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
// rojo, verde, azul y alfa.
//Valore entre 0 y 1 punto flotante.
//Check for error
GLenum error = glGetError();
if( error != GL_NO_ERROR )
{
printf( "Muere, no pude inicializar OpenGL!! %s\n", gluErrorString( error ) );
return false;
};
return true;
};
static void
loadpic(void)
{
GLubyte bufferter[256 * 256], terrainpic[256 * 256];
FILE *FilePic;
int i, tmp;
GLenum gluerr;
if ((FilePic = fopen("terrain.dat", "r")) == NULL) {
fprintf(stderr, "Error loading terrain.dat\n");
exit(-1);
}
fread(bufferter, 256 * 256, 1, FilePic);
fclose(FilePic);
for (i = 0; i < (256 * 256); i++) {
terrain[i] = (bufferter[i] * (heightMnt / 255.0f));
calccolor((GLfloat) bufferter[i], terraincolor[i]);
tmp = (((int) bufferter[i]) + 96);
terrainpic[i] = (tmp > 255) ? 255 : tmp;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 1, 256, 256, GL_LUMINANCE,
GL_UNSIGNED_BYTE,
(GLvoid *) (&terrainpic[0])))) {
fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
exit(-1);
}
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_TEXTURE_2D);
}
static int
SetupGLProgram()
{
GLenum error_check_value = glGetError();
if(VertexShaderID)
glDeleteShader(VertexShaderID);
VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(VertexShaderID, 1, &VertexShaderSource, NULL);
glCompileShader(VertexShaderID);
if(FragShaderID)
glDeleteShader(FragShaderID);
FragShaderID = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(FragShaderID, 1, &FragShaderSource, NULL);
glCompileShader(FragShaderID);
if (GLProgramID)
{
glUseProgram(0);
glDeleteProgram(GLProgramID);
}
GLProgramID = glCreateProgram();
glAttachShader(GLProgramID, VertexShaderID);
glAttachShader(GLProgramID, FragShaderID);
glLinkProgram(GLProgramID);
glUseProgram(GLProgramID);
error_check_value = glGetError();
if (error_check_value != GL_NO_ERROR)
{
fprintf(stderr, "error: %s: %s\n",
__FUNCTION__,
gluErrorString(error_check_value));
exit(1);
}
return 1;
}
void updateGraphics(void)
{
// update object normals
object->computeAllNormals(true);
// render world
camera->renderView(displayW, displayH);
// Swap buffers
glutSwapBuffers();
// check for any OpenGL errors
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
// inform the GLUT window to call updateGraphics again (next frame)
if (simulationRunning)
{
glutPostRedisplay();
}
}
void CreateVBO(void)
{
Vertex Vertices[] =
{
{ { -0.8f, -0.8f, 0.0f, 1.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
{ { 0.0f, 0.8f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
{ { 0.8f, -0.8f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
};
GLenum ErrorCheckValue = glGetError();
const size_t BufferSize = sizeof(Vertices);
const size_t VertexSize = sizeof(Vertices[0]);
const size_t RgbOffset = sizeof(Vertices[0].XYZW);
glGenVertexArrays(1, &VaoId);
glBindVertexArray(VaoId);
glGenBuffers(1, &BufferId);
glBindBuffer(GL_ARRAY_BUFFER, BufferId);
glBufferData(GL_ARRAY_BUFFER, BufferSize, Vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, VertexSize, 0);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, VertexSize, (GLvoid*)RgbOffset);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
ErrorCheckValue = glGetError();
if (ErrorCheckValue != GL_NO_ERROR)
{
fprintf(
stderr,
"ERROR: Could not create a VBO: %s \n",
gluErrorString(ErrorCheckValue)
);
exit(-1);
}
}
/*****************************************************************************************
VBO Functions
*****************************************************************************************/
void setSphereBuffers() {
/* Passing data to buffers */
glBindBuffer(GL_ARRAY_BUFFER, sphereObj.buffers[VERTEX]);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*sphereObj.numVerts, sphereObj.vertArray, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, sphereObj.buffers[NORMAL]);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*sphereObj.numVerts, sphereObj.normArray, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sphereObj.buffers[INDEX]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int)*sphereObj.numIndices, sphereObj.indexArray, GL_DYNAMIC_DRAW);
int error = glGetError();
if(error != 0) {
printf("\nint:%d string:%s\n", error, gluErrorString(error));
}
/* Unbind buffers */
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
sphereObj.bufferUpdate = false;
}
void GLError(const char* file, int line)
{
GLenum errorCode = glGetError();
std::stringstream errorSS;
while(errorCode != GL_NO_ERROR)
{
const GLubyte* errorString = gluErrorString(errorCode);
errorSS << file << "(" << line << ")" << std::endl
<< " " << " GL ERROR " << errorCode << ": " << "(" << errorString << ")\n";
errorCode = glGetError();
}
if(!errorSS.str().empty())
{
trace("\n***********OpengGL Error*************")
trace(errorSS.str())
DebugBreak();
}
}
/**
* @brief Enables the shader. This will effectively replace the render pipeline functions by
* the program shader
* In case the geometry shader fails
* - Check whether the input geometry primitive type sent by the draw call is
* the same as the shader's
*/
void Shader::enable() {
// Validate the program
/**
* XXX: do only during developpement to avoid this overhead in release
**/
static int i=0;
if(i==0)
{
glValidateProgram(mProgramHandle);
i++;
}
else
{
// std::cout << "aezfgbfvdnjk"<<std::endl;
}
GLenum errCode;
if ((errCode = glGetError()) != GL_NO_ERROR) {
std::cerr << "Shader::enable: Error: " << std::endl;
const GLubyte *errString;
errString = gluErrorString(errCode);
std::cerr<< "OpenGL Error (" << errCode << "): "<< errString << std::endl;
if(errCode = GL_INVALID_OPERATION) {
std::cerr << "GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object."<< std::endl
<< "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped." << std::endl;
exit(1);
}
}
// Enable the program
glUseProgram(mProgramHandle);
// Bind the textures
bindTextures();
if(vao)
{
glBindVertexArray(vao);
}
}
void onResize(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)w/(GLfloat)h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
0.0, 0.0, 5.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0
);
GLenum err = glGetError();
if (err != GL_NO_ERROR)
{
printf("onResize() ERROR: %s\n", gluErrorString(err));
}
}
bool Text::init()
{
bool success = true;
if(mProgramID==0) {
mProgramID = glCreateProgram();
mVertexShader.init(GLShader::VERTEX, mProgramID);
success = mVertexShader.compile();
mFragmentShader.init(GLShader::FRAGMENT, mProgramID);
success = mFragmentShader.compile();
success = GLShader::linkProgram(mProgramID);
GLfloat vertexData[] =
{
-0.5f, -0.5f,
0.5f, -0.5f,
0.5f, 0.5f,
-0.5f, 0.5f
};
GLuint indexData[] = { 0, 1, 2, 3 };
glGenBuffers(1, &mVBO);
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
glBufferData(GL_ARRAY_BUFFER, 2 * 4 * sizeof(GLfloat), vertexData, GL_STATIC_DRAW);
glGenBuffers(1, &mIBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * sizeof(GLuint), indexData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, NULL); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
}
GLenum error = glGetError();
if (error != GL_NO_ERROR) {
std::cout << "Error initializing App!" << gluErrorString(error) << std::endl;
success = false;
}
return success;
}
void draw(void)
{
GLenum err;
GLdouble secs, degrees;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* one revolution every 10 seconds... */
secs = get_secs();
secs = secs - 10.*trunc(secs / 10.);
degrees = (secs/10.) * (360.);
#if 0
draw_room();
#endif
draw_torus(degrees);
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
glutSwapBuffers();
}
int isExtensionSupported(const char *extension)
{
/* This function is based on the example in Mark Kilgard's
article about openGL extensions.
WARNING!!! an OpenGL context must be established before
calling this function!!! */
const GLubyte *extensions= NULL;
const GLubyte *start;
GLubyte *where, *terminator;
const GLubyte *errstr;
GLenum err;
/* Extension names should not have spaces,
so return "not supported" if the name is malformed. */
where= (GLubyte *) strchr(extension, ' ');
if(where || *extension == '\0') return 0;
extensions= glGetString(GL_EXTENSIONS);
err= glGetError();
errstr= gluErrorString(err);
if(!extensions) return 0;
/* Parsing OpenGL extension strings is tricky.
handle sub-strings etc. */
start= extensions;
for( ; ; ) {
where= (GLubyte *) strstr((const char *) start, extension);
if(!where) break;
terminator= where+strlen(extension);
if(where == start || *(where-1) == ' ') {
if(*terminator == ' ' || *terminator == '\0') {
return 1;
}
}
start= terminator;
}
return 0;
}
bool initGL()
{
//Initialize Projection Matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
//Initialize Modelview Matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
//Initialize clear color
glClearColor( 0.f, 0.f, 0.f, 1.f );
//Check for error
GLenum error = glGetError();
if( error != GL_NO_ERROR )
{
printf( "Error initializing OpenGL! %s\n", gluErrorString( error ) );
return false;
}
return true;
}
void updateGraphics(void)
{
// render world
camera->renderView(displayW, displayH);
// Swap buffers
glutSwapBuffers();
// check for any OpenGL errors
GLenum err;
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));
// inform the GLUT window to call updateGraphics again (next frame)
if (simulationRunning)
{
glutPostRedisplay();
}
// rotate the following objcts to create some animation
object1->rotate(cVector3d(0,0,1), 0.02);
object3->rotate(cVector3d(1,1,1), -0.01);
}
/**
* Create renderbuffer.
* @param [in] size Renderbuffer size.
* @param [in] format Renderbuffer format.
* @param [in] samples Samples count (default=-0).
* @return true if the renderbuffer was succesfully created.
*/
bool Renderbuffer::create(const glm::ivec2& size, Texture::PixelFormat format, size_t samples)
{
if(_id)
{
destroy();
}
glGenRenderbuffers(1, &_id);
_format = format;
_size = size;
_samples = samples;
glBindRenderbuffer(GL_RENDERBUFFER, _id);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, _samples, _format.internalFormat(), _size.x, _size.y);
GLenum err = glGetError();
bool ret = (GL_NO_ERROR == err);
if(!ret)
{
Log_Error(Dumb::Module::Render, "Failed to create renderbuffer: %s", gluErrorString (err));
}
glBindRenderbuffer(GL_RENDERBUFFER, 0);
return ret;
}