scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2024-12-01 11:56:58 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
bgfx/3rdparty/openctm/tools/ctmviewer.cpp

1788 lines
48 KiB
C++
Raw Normal View History

Added more examples.
2012-10-07 23:41:18 -04:00
//-----------------------------------------------------------------------------
// Product: OpenCTM tools
// File: ctmviewer.cpp
// Description: 3D file viewer. The program can be used to view OpenCTM files
// in an interactive OpenGL window. Files in other supported
// formats can also be viewed.
//-----------------------------------------------------------------------------
// Copyright (c) 2009-2010 Marcus Geelnard
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//-----------------------------------------------------------------------------
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <GL/glew.h>
#ifdef __APPLE_CC__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <openctm.h>
#include "mesh.h"
#include "meshio.h"
#include "sysdialog.h"
#include "systimer.h"
#include "image.h"
#include "common.h"
using namespace std;
// We need PI
#ifndef PI
#define PI 3.141592653589793238462643f
#endif
// Configuration constants
#define FOCUS_TIME 0.1
#define DOUBLE_CLICK_TIME 0.25
//-----------------------------------------------------------------------------
// GLSL source code (generated from source by bin2c)
//-----------------------------------------------------------------------------
#include "phong_vert.h"
#include "phong_frag.h"
//-----------------------------------------------------------------------------
// Icon bitmaps
//-----------------------------------------------------------------------------
#include "icons/icon_open.h"
#include "icons/icon_save.h"
#include "icons/icon_texture.h"
#include "icons/icon_help.h"
//-----------------------------------------------------------------------------
// The GLViewer application class (declaration)
//-----------------------------------------------------------------------------
class GLButton;
class GLViewer {
private:
// File information for the current mesh
string mFileName, mFilePath;
long mFileSize;
// Window state cariables
int mWidth, mHeight;
GLint mDepthBufferResolution;
int mOldMouseX, mOldMouseY;
double mLastClickTime;
bool mMouseRotate;
bool mMouseZoom;
bool mMousePan;
bool mFocusing;
Vector3 mFocusStartPos;
Vector3 mFocusEndPos;
double mFocusStartTime;
double mFocusEndTime;
double mFocusStartDistance;
double mFocusEndDistance;
// Camera state
Vector3 mCameraPosition;
Vector3 mCameraLookAt;
Vector3 mCameraUp;
GLdouble mModelviewMatrix[16];
GLdouble mProjectionMatrix[16];
GLint mViewport[4];
// Mesh information
Mesh * mMesh;
Vector3 mAABBMin, mAABBMax;
GLuint mDisplayList;
GLuint mTexHandle;
// Polygon rendering mode (fill / line)
GLenum mPolyMode;
// GLSL objects
bool mUseShader;
GLuint mShaderProgram;
GLuint mVertShader;
GLuint mFragShader;
// List of GUI buttons
list<GLButton *> mButtons;
// Master timer resource
SysTimer mTimer;
/// Set up the camera.
void SetupCamera();
/// Initialize the GLSL shader (requires OpenGL 2.0 or better).
void InitShader();
/// Initialize the texture.
void InitTexture(const char * aFileName);
/// Set up the scene lighting.
void SetupLighting();
/// Set up the material.
void SetupMaterial();
/// Draw a mesh
void DrawMesh(Mesh * aMesh);
/// Load a file to the mesh
void LoadFile(const char * aFileName, const char * aOverrideTexture);
/// Load a texture file
void LoadTexture(const char * aFileName);
/// Draw an outline box.
void DrawOutlineBox(int x1, int y1, int x2, int y2,
float r, float g, float b, float a);
/// Draw a string using GLUT. The string is shown on top of an alpha-blended
/// quad.
void DrawString(string aString, int x, int y);
/// Draw 2D overlay
void Draw2DOverlay();
/// Get 3D coordinate under the mouse cursor.
bool WinCoordTo3DCoord(int x, int y, Vector3 &aPoint);
/// Update the focus position of the camera.
void UpdateFocus();
public:
/// Constructor
GLViewer();
/// Destructor
~GLViewer();
/// Open another file
void ActionOpenFile();
/// Save the file
void ActionSaveFile();
/// Open a texture file
void ActionOpenTexture();
/// Toggle wire frame view on/off
void ActionToggleWireframe();
/// Fit model to the screen (re-focus)
void ActionFitToScreen();
/// Set camera up direction to Y
void ActionCameraUpY();
/// Set camera up direction to Z
void ActionCameraUpZ();
/// Zoom camera one step in
void ActionZoomIn();
/// Zoom camera one step out
void ActionZoomOut();
/// Exit program
void ActionExit();
/// Show a help dialog
void ActionHelp();
/// Redraw function.
void WindowRedraw(void);
/// Resize function.
void WindowResize(int w, int h);
/// Mouse click function
void MouseClick(int button, int state, int x, int y);
/// Mouse move function
void MouseMove(int x, int y);
/// Keyboard function
void KeyDown(unsigned char key, int x, int y);
/// Keyboard function (special keys)
void SpecialKeyDown(int key, int x, int y);
/// Run the application
void Run(int argc, char **argv);
};
//-----------------------------------------------------------------------------
// A class for OpenGL rendered GUI buttons
//-----------------------------------------------------------------------------
class GLButton {
private:
// Texture handle
GLuint mTexHandle;
// Highlight on/off
bool mHighlight;
public:
/// Constructor.
GLButton()
{
mTexHandle = 0;
mPosX = 0;
mPosY = 0;
mWidth = 32;
mHeight = 32;
mHighlight = false;
mParent = NULL;
}
/// Destructor.
virtual ~GLButton()
{
if(mTexHandle)
glDeleteTextures(1, &mTexHandle);
}
/// Set glyph for this button.
void SetGlyph(const unsigned char * aBitmap, int aWidth, int aHeight,
int aComponents)
{
// Update the button size
mWidth = aWidth;
mHeight = aHeight;
// Upload the texture to OpenGL
if(mTexHandle)
glDeleteTextures(1, &mTexHandle);
glGenTextures(1, &mTexHandle);
if(mTexHandle)
{
// Determine the color format
GLuint format;
if(aComponents == 3)
format = GL_RGB;
else if(aComponents == 4)
format = GL_RGBA;
else
format = GL_LUMINANCE;
glBindTexture(GL_TEXTURE_2D, mTexHandle);
if(GLEW_VERSION_1_4)
{
// Generate mipmaps automatically and use them
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, aComponents, aWidth, aHeight, 0,
format, GL_UNSIGNED_BYTE, (GLvoid *) aBitmap);
}
}
/// Redraw function.
void Redraw()
{
// Set opacity of the icon
if(mHighlight)
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
else
glColor4f(1.0f, 1.0f, 1.0f, 0.7f);
// Enable texturing
if(mTexHandle)
{
glBindTexture(GL_TEXTURE_2D, mTexHandle);
glEnable(GL_TEXTURE_2D);
}
// Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Draw the icon as a textured quad
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2i(mPosX, mPosY);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(mPosX + mWidth, mPosY);
glTexCoord2f(1.0f, 1.0f);
glVertex2i(mPosX + mWidth, mPosY + mHeight);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(mPosX, mPosY + mHeight);
glEnd();
// We're done
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
}
/// Mouse move function. The function returns true if the state of the
/// button has changed.
bool MouseMove(int x, int y)
{
bool hit = (x >= mPosX) && (x < (mPosX + mWidth)) &&
(y >= mPosY) && (y < (mPosY + mHeight));
bool changed = (mHighlight != hit);
mHighlight = hit;
return changed;
}
/// Mouse click function.
bool MouseClick(int aState, int x, int y)
{
bool hit = (x >= mPosX) && (x < (mPosX + mWidth)) &&
(y >= mPosY) && (y < (mPosY + mHeight));
if(hit && (aState == GLUT_DOWN))
DoAction();
return hit;
}
/// The action function that will be performed when a button is clicked.
virtual void DoAction() {}
GLint mPosX, mPosY;
GLint mWidth, mHeight;
GLViewer * mParent;
};
//-----------------------------------------------------------------------------
// Customized button classes (implementing different actions)
//-----------------------------------------------------------------------------
class OpenButton: public GLButton {
public:
void DoAction()
{
if(!mParent)
return;
mParent->ActionOpenFile();
}
};
class SaveButton: public GLButton {
public:
void DoAction()
{
if(!mParent)
return;
mParent->ActionSaveFile();
}
};
class OpenTextureButton: public GLButton {
public:
void DoAction()
{
if(!mParent)
return;
mParent->ActionOpenTexture();
}
};
class HelpButton: public GLButton {
public:
void DoAction()
{
if(!mParent)
return;
mParent->ActionHelp();
}
};
//-----------------------------------------------------------------------------
// GLUT callback function prototypes
//-----------------------------------------------------------------------------
void GLUTWindowRedraw(void);
void GLUTWindowResize(int w, int h);
void GLUTMouseClick(int button, int state, int x, int y);
void GLUTMouseMove(int x, int y);
void GLUTKeyDown(unsigned char key, int x, int y);
void GLUTSpecialKeyDown(int key, int x, int y);
//-----------------------------------------------------------------------------
// GLViewer: OpenGL related functions
//-----------------------------------------------------------------------------
/// Set up the camera.
void GLViewer::SetupCamera()
{
if(mMesh)
mMesh->BoundingBox(mAABBMin, mAABBMax);
else
{
mAABBMin = Vector3(-1.0f, -1.0f, -1.0f);
mAABBMax = Vector3(1.0f, 1.0f, 1.0f);
}
mCameraLookAt = (mAABBMax + mAABBMin) * 0.5f;
float delta = (mAABBMax - mAABBMin).Abs();
if(mCameraUp.z > 0.0f)
mCameraPosition = Vector3(mCameraLookAt.x,
mCameraLookAt.y - 0.8f * delta,
mCameraLookAt.z + 0.2f * delta);
else
mCameraPosition = Vector3(mCameraLookAt.x,
mCameraLookAt.y + 0.2f * delta,
mCameraLookAt.z + 0.8f * delta);
}
/// Initialize the GLSL shader (requires OpenGL 2.0 or better).
void GLViewer::InitShader()
{
const GLchar * src[1];
// Load vertex shader
mVertShader = glCreateShader(GL_VERTEX_SHADER);
src[0] = (const GLchar *) phongVertSrc;
glShaderSource(mVertShader, 1, src, NULL);
// Load fragment shader
mFragShader = glCreateShader(GL_FRAGMENT_SHADER);
src[0] = (const GLchar *) phongFragSrc;
glShaderSource(mFragShader, 1, src, NULL);
int status;
// Compile the vertex shader
glCompileShader(mVertShader);
glGetShaderiv(mVertShader, GL_COMPILE_STATUS, &status);
if(!status)
throw runtime_error("Could not compile vertex shader.");
// Compile the fragment shader
glCompileShader(mFragShader);
glGetShaderiv(mFragShader, GL_COMPILE_STATUS, &status);
if(!status)
throw runtime_error("Could not compile fragment shader.");
// Link the shader program
mShaderProgram = glCreateProgram();
glAttachShader(mShaderProgram, mVertShader);
glAttachShader(mShaderProgram, mFragShader);
glLinkProgram(mShaderProgram);
glGetProgramiv(mShaderProgram, GL_LINK_STATUS, &status);
if(!status)
throw runtime_error("Could not link shader program.");
mUseShader = true;
}
/// Initialize the texture.
void GLViewer::InitTexture(const char * aFileName)
{
Image image;
// Load texture from a file
if(aFileName)
{
// Check if file exists, and determine actual file name (relative or absolute)
bool fileExists = false;
string name = string(aFileName);
FILE * inFile = fopen(name.c_str(), "rb");
if(inFile)
fileExists = true;
else if(mFilePath.size() > 0)
{
// Try the same path as the mesh file
name = mFilePath + string(aFileName);
inFile = fopen(name.c_str(), "rb");
if(inFile)
fileExists = true;
}
if(inFile)
fclose(inFile);
if(fileExists)
{
cout << "Loading texture (" << aFileName << ")..." << endl;
try
{
image.LoadFromFile(name.c_str());
}
catch(exception &e)
{
cout << "Error loading texture: " << e.what() << endl;
image.Clear();
}
}
}
// If no texture was loaded
if(image.IsEmpty())
{
cout << "Loading texture (dummy)..." << endl;
// Create a default, synthetic texture
image.SetSize(256, 256, 1);
for(int y = 0; y < image.mHeight; ++ y)
{
for(int x = 0; x < image.mWidth; ++ x)
{
if(((x & 0x000f) == 0) || ((y & 0x000f) == 0))
image.mData[y * image.mWidth + x] = 192;
else
image.mData[y * image.mWidth + x] = 255;
}
}
}
// Upload the texture to OpenGL
if(!image.IsEmpty())
glGenTextures(1, &mTexHandle);
else
mTexHandle = 0;
if(mTexHandle)
{
// Determine the color format
GLuint format;
if(image.mComponents == 3)
format = GL_RGB;
else if(image.mComponents == 4)
format = GL_RGBA;
else
format = GL_LUMINANCE;
glBindTexture(GL_TEXTURE_2D, mTexHandle);
if(GLEW_VERSION_1_4)
{
// Generate mipmaps automatically and use them
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, image.mComponents, image.mWidth, image.mHeight, 0, format, GL_UNSIGNED_BYTE, (GLvoid *) &image.mData[0]);
}
}
/// Set up the scene lighting.
void GLViewer::SetupLighting()
{
GLfloat pos[4], ambient[4], diffuse[4], specular[4];
// Set scene lighting properties
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
ambient[0] = 0.2;
ambient[1] = 0.2;
ambient[2] = 0.2;
ambient[3] = 1.0;
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
// Set-up head light (GL_LIGHT0)
pos[0] = mCameraPosition.x;
pos[1] = mCameraPosition.y;
pos[2] = mCameraPosition.z;
pos[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_POSITION, pos);
ambient[0] = 0.0f;
ambient[1] = 0.0f;
ambient[2] = 0.0f;
ambient[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
diffuse[0] = 0.8f;
diffuse[1] = 0.8f;
diffuse[2] = 0.8f;
diffuse[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
specular[0] = 1.0f;
specular[1] = 1.0f;
specular[2] = 1.0f;
specular[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glEnable(GL_LIGHT0);
}
/// Set up the material.
void GLViewer::SetupMaterial()
{
GLfloat specular[4], emission[4];
// Set up the material
specular[0] = 0.3f;
specular[1] = 0.3f;
specular[2] = 0.3f;
specular[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
emission[0] = 0.0f;
emission[1] = 0.0f;
emission[2] = 0.0f;
emission[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 40.0f);
// Use color material for the diffuse and ambient components
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
/// Draw a mesh
void GLViewer::DrawMesh(Mesh * aMesh)
{
// We always have vertices
glVertexPointer(3, GL_FLOAT, 0, &aMesh->mVertices[0]);
glEnableClientState(GL_VERTEX_ARRAY);
// Do we have normals?
if(aMesh->mNormals.size() == aMesh->mVertices.size())
{
glNormalPointer(GL_FLOAT, 0, &aMesh->mNormals[0]);
glEnableClientState(GL_NORMAL_ARRAY);
}
// Do we have texture coordinates?
if(aMesh->mTexCoords.size() == aMesh->mVertices.size())
{
glTexCoordPointer(2, GL_FLOAT, 0, &aMesh->mTexCoords[0]);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
// Do we have colors?
if(aMesh->mColors.size() == aMesh->mVertices.size())
{
glColorPointer(4, GL_FLOAT, 0, &aMesh->mColors[0]);
glEnableClientState(GL_COLOR_ARRAY);
}
// Use glDrawElements to draw the triangles...
glShadeModel(GL_SMOOTH);
if(GLEW_VERSION_1_2)
glDrawRangeElements(GL_TRIANGLES, 0, aMesh->mVertices.size() - 1,
aMesh->mIndices.size(), GL_UNSIGNED_INT,
&aMesh->mIndices[0]);
else
glDrawElements(GL_TRIANGLES, aMesh->mIndices.size(), GL_UNSIGNED_INT,
&aMesh->mIndices[0]);
// We do not use the client state anymore...
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
// Load a file to the mesh
void GLViewer::LoadFile(const char * aFileName, const char * aOverrideTexture)
{
// Get the file size
ifstream f(aFileName, ios::in | ios::binary);
if(f.fail())
throw runtime_error("Unable to open the file.");
f.seekg(0, ios_base::end);
long tmpFileSize = (long) f.tellg();
f.close();
// Load the mesh
cout << "Loading " << aFileName << "..." << flush;
mTimer.Push();
Mesh * newMesh = new Mesh();
try
{
ImportMesh(aFileName, newMesh);
}
catch(exception &e)
{
delete newMesh;
throw;
}
if(mMesh)
delete mMesh;
mMesh = newMesh;
cout << "done (" << int(mTimer.PopDelta() * 1000.0 + 0.5) << " ms)" << endl;
// Get the file name (excluding the path), and the path (excluding the file name)
mFileName = ExtractFileName(string(aFileName));
mFilePath = ExtractFilePath(string(aFileName));
// The temporary file size is now the official file size...
mFileSize = tmpFileSize;
// Set window title
string windowCaption = string("OpenCTM viewer - ") + mFileName;
glutSetWindowTitle(windowCaption.c_str());
// If the file did not contain any normals, calculate them now...
if(mMesh->mNormals.size() != mMesh->mVertices.size())
{
cout << "Calculating normals..." << flush;
mTimer.Push();
mMesh->CalculateNormals();
cout << "done (" << int(mTimer.PopDelta() * 1000.0 + 0.5) << " ms)" << endl;
}
// Load the texture
if(mTexHandle)
glDeleteTextures(1, &mTexHandle);
mTexHandle = 0;
if(mMesh->mTexCoords.size() == mMesh->mVertices.size())
{
string texFileName = mMesh->mTexFileName;
if(aOverrideTexture)
texFileName = string(aOverrideTexture);
if(texFileName.size() > 0)
InitTexture(texFileName.c_str());
else
InitTexture(0);
}
// Setup texture parameters for the shader
if(mUseShader)
{
glUseProgram(mShaderProgram);
// Set the uUseTexture uniform
GLint useTexLoc = glGetUniformLocation(mShaderProgram, "uUseTexture");
if(useTexLoc >= 0)
glUniform1i(useTexLoc, glIsTexture(mTexHandle));
// Set the uTex uniform
GLint texLoc = glGetUniformLocation(mShaderProgram, "uTex");
if(texLoc >= 0)
glUniform1i(texLoc, 0);
glUseProgram(0);
}
// Load the mesh into a displaylist
if(mDisplayList)
glDeleteLists(mDisplayList, 1);
mDisplayList = glGenLists(1);
glNewList(mDisplayList, GL_COMPILE);
DrawMesh(mMesh);
glEndList();
// Init the camera for the new mesh
mCameraUp = Vector3(0.0f, 0.0f, 1.0f);
SetupCamera();
}
// Load a texture file
void GLViewer::LoadTexture(const char * aFileName)
{
// Load the texture
if(mTexHandle)
glDeleteTextures(1, &mTexHandle);
mTexHandle = 0;
if(mMesh->mTexCoords.size() == mMesh->mVertices.size())
InitTexture(aFileName);
// Setup texture parameters for the shader
if(mUseShader)
{
glUseProgram(mShaderProgram);
// Set the uUseTexture uniform
GLint useTexLoc = glGetUniformLocation(mShaderProgram, "uUseTexture");
if(useTexLoc >= 0)
glUniform1i(useTexLoc, glIsTexture(mTexHandle));
// Set the uTex uniform
GLint texLoc = glGetUniformLocation(mShaderProgram, "uTex");
if(texLoc >= 0)
glUniform1i(texLoc, 0);
glUseProgram(0);
}
}
// Draw an outline box.
void GLViewer::DrawOutlineBox(int x1, int y1, int x2, int y2,
float r, float g, float b, float a)
{
// Draw a blended box
// Note: We add (1,1) to the (x2,y2) corner to cover the entire pixel range
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_QUADS);
glColor4f(r, g, b, 0.7f * a);
glVertex2i(x1, y1);
glVertex2i(x2+1, y1);
glColor4f(r, g, b, 0.7f * a + 0.3f);
glVertex2i(x2+1, y2+1);
glVertex2i(x1, y2+1);
glEnd();
glDisable(GL_BLEND);
// Draw a solid outline
glPushMatrix();
glTranslatef(0.5f, 0.5f, 0.0f); // Compensate for 0.5 pixel center offset
glColor4f(r, g, b, 1.0f);
glBegin(GL_LINE_LOOP);
glVertex2i(x1, y1-1);
glVertex2i(x2, y1-1);
glVertex2i(x2+1, y1);
glVertex2i(x2+1, y2);
glVertex2i(x2, y2+1);
glVertex2i(x1, y2+1);
glVertex2i(x1-1, y2);
glVertex2i(x1-1, y1);
glEnd();
glPopMatrix();
}
// Draw a string using GLUT. The string is shown on top of an alpha-blended
// quad.
void GLViewer::DrawString(string aString, int x, int y)
{
// Calculate the size of the string box
int x0 = x, y0 = y;
int x1 = x0, y1 = y0;
int x2 = x0, y2 = y0;
for(unsigned int i = 0; i < aString.size(); ++ i)
{
int c = (int) aString[i];
if(c == (int) 10)
{
x2 = x;
y2 += 13;
}
else if(c != (int) 13)
{
x2 += glutBitmapWidth(GLUT_BITMAP_8_BY_13, c);
if(x2 > x1) x1 = x2;
}
}
y1 = y2 + 13;
// Draw a alpha blended box
DrawOutlineBox(x0-4, y0-3, x1+4, y1+4, 0.3f, 0.3f, 0.3f, 0.6f);
// Print the text
glColor3f(1.0f, 1.0f, 1.0f);
x2 = x;
y2 = y + 13;
for(unsigned int i = 0; i < aString.size(); ++ i)
{
int c = (int) aString[i];
if(c == (int) 10)
{
x2 = x;
y2 += 13;
}
else if(c != (int) 13)
{
glRasterPos2i(x2, y2);
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, c);
x2 += glutBitmapWidth(GLUT_BITMAP_8_BY_13, c);
}
}
}
// Draw 2D overlay
void GLViewer::Draw2DOverlay()
{
// Setup the matrices for a width x height 2D screen
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, (double) mWidth, (double) mHeight, 0.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Setup the rendering pipeline for 2D rendering
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
// Render an info string
if(mMesh)
{
stringstream s;
s << mFileName << " (" << (mFileSize + 512) / 1024 << "KB)" << endl;
s << mMesh->mVertices.size() << " vertices" << endl;
s << mMesh->mIndices.size() / 3 << " triangles";
DrawString(s.str(), 10, mHeight - 50);
}
// Calculate buttons bounding box, and draw it as an outline box
int x1 = 9999, y1 = 9999, x2 = 0, y2 = 0;
for(list<GLButton *>::iterator b = mButtons.begin(); b != mButtons.end(); ++ b)
{
if((*b)->mPosX < x1) x1 = (*b)->mPosX;
if(((*b)->mPosX + (*b)->mWidth) > x2) x2 = (*b)->mPosX + (*b)->mWidth;
if((*b)->mPosY < y1) y1 = (*b)->mPosY;
if(((*b)->mPosY + (*b)->mHeight) > y2) y2 = (*b)->mPosY + (*b)->mHeight;
}
DrawOutlineBox(x1-5, y1-5, x2+5, y2+5, 0.3f, 0.3f, 0.3f, 0.6f);
// Render all the buttons (last = on top)
for(list<GLButton *>::iterator b = mButtons.begin(); b != mButtons.end(); ++ b)
(*b)->Redraw();
}
/// Get 3D coordinate under the mouse cursor.
bool GLViewer::WinCoordTo3DCoord(int x, int y, Vector3 &aPoint)
{
// Read back the depth value at at (x, y)
GLfloat z = 0.0f;
glReadPixels(x, mHeight - y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, (GLvoid *) &z);
if((z > 0.0f) && (z < 1.0f))
{
// Convert the window coordinate to space coordinates
GLdouble objX, objY, objZ;
gluUnProject((GLdouble) x, (GLdouble) (mHeight - y), (GLdouble) z,
mModelviewMatrix, mProjectionMatrix, mViewport,
&objX, &objY, &objZ);
aPoint = Vector3((float) objX, (float) objY, (float) objZ);
return true;
}
else
return false;
}
/// Update the focus position of the camera.
void GLViewer::UpdateFocus()
{
double w = (mTimer.GetTime() - mFocusStartTime) / (mFocusEndTime - mFocusStartTime);
Vector3 dir = Normalize(mCameraPosition - mCameraLookAt);
if(w < 1.0)
{
w = pow(w, 0.2);
mCameraLookAt = mFocusStartPos + (mFocusEndPos - mFocusStartPos) * w;
mCameraPosition = mCameraLookAt + dir * (mFocusStartDistance + (mFocusEndDistance - mFocusStartDistance) * w);
}
else
{
mCameraLookAt = mFocusEndPos;
mCameraPosition = mCameraLookAt + dir * mFocusEndDistance;
mFocusing = false;
}
glutPostRedisplay();
}
//-----------------------------------------------------------------------------
// Actions (user activated functions)
//-----------------------------------------------------------------------------
/// Open another file
void GLViewer::ActionOpenFile()
{
SysOpenDialog od;
od.mFilters.push_back(string("All supported 3D files|*.ctm;*.ply;*.stl;*.3ds;*.dae;*.obj;*.lwo;*.off"));
od.mFilters.push_back(string("OpenCTM (.ctm)|*.ctm"));
od.mFilters.push_back(string("Stanford triangle format (.ply)|*.ply"));
od.mFilters.push_back(string("Stereolitography (.stl)|*.stl"));
od.mFilters.push_back(string("3D Studio (.3ds)|*.3ds"));
od.mFilters.push_back(string("COLLADA (.dae)|*.dae"));
od.mFilters.push_back(string("Wavefront geometry file (.obj)|*.obj"));
od.mFilters.push_back(string("LightWave object (.lwo)|*.lwo"));
od.mFilters.push_back(string("Geomview object file format (.off)|*.off"));
if(od.Show())
{
try
{
LoadFile(od.mFileName.c_str(), NULL);
glutPostRedisplay();
}
catch(exception &e)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Error";
mb.mText = string(e.what());
mb.Show();
}
}
}
/// Save the file
void GLViewer::ActionSaveFile()
{
if(!mMesh)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Save File";
mb.mText = string("No mesh has been loaded.");
mb.Show();
return;
}
SysSaveDialog sd;
sd.mFilters.push_back(string("All files|*"));
sd.mFilters.push_back(string("OpenCTM (.ctm)|*.ctm"));
sd.mFilters.push_back(string("Stanford triangle format (.ply)|*.ply"));
sd.mFilters.push_back(string("Stereolitography (.stl)|*.stl"));
sd.mFilters.push_back(string("3D Studio (.3ds)|*.3ds"));
sd.mFilters.push_back(string("COLLADA (.dae)|*.dae"));
sd.mFilters.push_back(string("Wavefront geometry file (.obj)|*.obj"));
sd.mFilters.push_back(string("LightWave object (.lwo)|*.lwo"));
sd.mFilters.push_back(string("Geomview object file format (.off)|*.off"));
sd.mFilters.push_back(string("VRML 2.0 (.wrl)|*.wrl"));
sd.mFileName = mFileName;
if(sd.Show())
{
try
{
Options opt;
// Do not export normals that do not come from the original file
if(!mMesh->mOriginalNormals)
opt.mNoNormals = true;
// Export the mesh
ExportMesh(sd.mFileName.c_str(), mMesh, opt);
}
catch(exception &e)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Error";
mb.mText = string(e.what());
mb.Show();
}
}
}
/// Open a texture file
void GLViewer::ActionOpenTexture()
{
if(!mMesh || (mMesh->mTexCoords.size() < 1))
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Open Texture File";
mb.mText = string("This mesh does not have any texture coordinates.");
mb.Show();
return;
}
SysOpenDialog od;
od.mCaption = string("Open Texture File");
od.mFilters.push_back(string("All supported texture files|*.jpg;*.jpeg;*.png"));
od.mFilters.push_back(string("JPEG|*.jpg;*.jpeg"));
od.mFilters.push_back(string("PNG|*.png"));
if(od.Show())
{
try
{
LoadTexture(od.mFileName.c_str());
mMesh->mTexFileName = ExtractFileName(od.mFileName);
glutPostRedisplay();
}
catch(exception &e)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Error";
mb.mText = string(e.what());
mb.Show();
}
}
}
/// Toggle wire frame view on/off
void GLViewer::ActionToggleWireframe()
{
if(mPolyMode == GL_LINE)
mPolyMode = GL_FILL;
else
mPolyMode = GL_LINE;
glutPostRedisplay();
}
/// Fit model to the screen (re-focus)
void GLViewer::ActionFitToScreen()
{
double now = mTimer.GetTime();
mFocusStartTime = now;
mFocusEndTime = now + FOCUS_TIME;
mFocusStartPos = mCameraLookAt;
mFocusStartDistance = (mCameraLookAt - mCameraPosition).Abs();
mFocusEndPos = (mAABBMax + mAABBMin) * 0.5f;
mFocusEndDistance = 0.825 * (mAABBMax - mAABBMin).Abs();
mFocusing = true;
UpdateFocus();
glutPostRedisplay();
}
/// Set camera up direction to Y
void GLViewer::ActionCameraUpY()
{
mCameraUp = Vector3(0.0f, 1.0f, 0.0f);
SetupCamera();
glutPostRedisplay();
}
/// Set camera up direction to Z
void GLViewer::ActionCameraUpZ()
{
mCameraUp = Vector3(0.0f, 0.0f, 1.0f);
SetupCamera();
glutPostRedisplay();
}
/// Zoom camera one step in
void GLViewer::ActionZoomIn()
{
double now = mTimer.GetTime();
mFocusStartTime = now;
mFocusEndTime = now + FOCUS_TIME;
mFocusStartPos = mCameraLookAt;
mFocusStartDistance = (mCameraLookAt - mCameraPosition).Abs();
mFocusEndPos = mCameraLookAt;
mFocusEndDistance = (1.0/1.5) * mFocusStartDistance;
mFocusing = true;
UpdateFocus();
glutPostRedisplay();
}
/// Zoom camera one step out
void GLViewer::ActionZoomOut()
{
double now = mTimer.GetTime();
mFocusStartTime = now;
mFocusEndTime = now + FOCUS_TIME;
mFocusStartPos = mCameraLookAt;
mFocusStartDistance = (mCameraLookAt - mCameraPosition).Abs();
mFocusEndPos = mCameraLookAt;
mFocusEndDistance = 1.5 * mFocusStartDistance;
mFocusing = true;
UpdateFocus();
glutPostRedisplay();
}
/// Exit program
void GLViewer::ActionExit()
{
// Note: In freeglut you can do glutLeaveMainLoop(), which is more graceful
exit(0);
}
/// Show a help dialog
void GLViewer::ActionHelp()
{
stringstream helpText;
helpText << "ctmviewer - OpenCTM file viewer" << endl;
helpText << "Copyright (c) 2009-2010 Marcus Geelnard" << endl << endl;
helpText << "Keyboard actions:" << endl;
helpText << " W - Toggle wire frame view on/off" << endl;
helpText << " F - Fit model to the screen" << endl;
helpText << " Y - Set Y as the up axis (change camera view)" << endl;
helpText << " Z - Set Z as the up axis (change camera view)" << endl;
helpText << " +/- - Zoom in/out with the camera" << endl;
helpText << " ESC - Exit program" << endl << endl;
helpText << "Mouse control:" << endl;
helpText << " Left button - Rotate camera" << endl;
helpText << " Middle button or wheel - Zoom camera" << endl;
helpText << " Right button - Pan camera" << endl;
helpText << " Double click - Focus on indicated surface";
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtInformation;
mb.mCaption = "Help";
mb.mText = helpText.str();
mb.Show();
}
//-----------------------------------------------------------------------------
// GLUT callback functions
//-----------------------------------------------------------------------------
/// Redraw function.
void GLViewer::WindowRedraw(void)
{
// Get buffer properties
glGetIntegerv(GL_DEPTH_BITS, &mDepthBufferResolution);
// Set the viewport to be the entire window
glViewport(0, 0, mWidth, mHeight);
// Clear the buffer(s)
glClear(GL_DEPTH_BUFFER_BIT);
// Draw a gradient background
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glBegin(GL_QUADS);
glColor3f(0.4f, 0.5f, 0.7f);
glVertex3f(-1.0f, -1.0f, 0.5f);
glColor3f(0.3f, 0.4f, 0.7f);
glVertex3f(1.0f, -1.0f, 0.5f);
glColor3f(0.1f, 0.1f, 0.2f);
glVertex3f(1.0f, 1.0f, 0.5f);
glColor3f(0.1f, 0.15f, 0.24f);
glVertex3f(-1.0f, 1.0f, 0.5f);
glEnd();
// Calculate screen ratio (width / height)
float ratio;
if(mHeight == 0)
ratio = 1.0f;
else
ratio = (float) mWidth / (float) mHeight;
// Calculate optimal near and far Z clipping planes
float farZ = (mAABBMax - mAABBMin).Abs() +
(mCameraPosition - mCameraLookAt).Abs();
if(farZ < 1e-20f)
farZ = 1e-20f;
float nearZ;
if(mDepthBufferResolution >= 24)
nearZ = 0.0001f * farZ;
else
nearZ = 0.01f * farZ;
// Set up perspective projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, ratio, nearZ, farZ);
// Set up the camera modelview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(mCameraPosition.x, mCameraPosition.y, mCameraPosition.z,
mCameraLookAt.x, mCameraLookAt.y, mCameraLookAt.z,
mCameraUp.x, mCameraUp.y, mCameraUp.z);
// Read back camera matrices
glGetDoublev(GL_MODELVIEW_MATRIX, mModelviewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, mProjectionMatrix);
glGetIntegerv(GL_VIEWPORT, mViewport);
// Set up the lights
SetupLighting();
// Enable material shader
if(mUseShader)
glUseProgram(mShaderProgram);
else
glEnable(GL_LIGHTING);
// Draw the mesh
SetupMaterial();
glEnable(GL_DEPTH_TEST);
glPolygonMode(GL_FRONT_AND_BACK, mPolyMode);
if(mTexHandle)
{
glBindTexture(GL_TEXTURE_2D, mTexHandle);
glEnable(GL_TEXTURE_2D);
glColor3f(1.0f, 1.0f, 1.0f);
}
else
glColor3f(0.9f, 0.86f, 0.7f);
if(mDisplayList)
glCallList(mDisplayList);
glDisable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Disable material shader
if(mUseShader)
glUseProgram(0);
else
glDisable(GL_LIGHTING);
// Draw 2D overlay (information text etc)
Draw2DOverlay();
// Swap buffers
glutSwapBuffers();
// Focusing?
if(mFocusing)
{
UpdateFocus();
glutPostRedisplay();
}
}
/// Resize function.
void GLViewer::WindowResize(int w, int h)
{
// Store the new window size
mWidth = w;
mHeight = h;
}
/// Mouse click function
void GLViewer::MouseClick(int button, int state, int x, int y)
{
bool clickConsumed = false;
if(button == GLUT_LEFT_BUTTON)
{
// Check if any of the GUI buttons were clicked
for(list<GLButton *>::iterator b = mButtons.begin(); b != mButtons.end(); ++ b)
{
if((*b)->MouseClick(state, x, y))
clickConsumed = true;
}
if(!clickConsumed)
{
if(state == GLUT_DOWN)
{
double now = mTimer.GetTime();
if((now - mLastClickTime) < DOUBLE_CLICK_TIME)
{
// Double click occured
Vector3 mouseCoord3D;
if(WinCoordTo3DCoord(x, y, mouseCoord3D))
{
mFocusStartTime = now;
mFocusEndTime = now + FOCUS_TIME;
mFocusStartPos = mCameraLookAt;
mFocusEndPos = mouseCoord3D;
mFocusStartDistance = (mCameraLookAt - mCameraPosition).Abs();
mFocusEndDistance = mFocusStartDistance;
mFocusing = true;
}
mLastClickTime = -1000.0;
}
else
{
// Single click occured
mMouseRotate = true;
mLastClickTime = now;
}
}
else if(state == GLUT_UP)
mMouseRotate = false;
}
}
else if(button == GLUT_MIDDLE_BUTTON)
{
if(state == GLUT_DOWN)
mMouseZoom = true;
else if(state == GLUT_UP)
mMouseZoom = false;
}
else if(button == GLUT_RIGHT_BUTTON)
{
if(state == GLUT_DOWN)
mMousePan = true;
else if(state == GLUT_UP)
mMousePan = false;
}
else if(button == 3) // Mouse wheel up on some systems
{
if(state == GLUT_DOWN)
ActionZoomIn();
}
else if(button == 4) // Mouse wheel down on some systems
{
if(state == GLUT_DOWN)
ActionZoomOut();
}
mOldMouseX = x;
mOldMouseY = y;
// Focusing?
if(mFocusing)
{
UpdateFocus();
glutPostRedisplay();
}
}
/// Mouse move function
void GLViewer::MouseMove(int x, int y)
{
bool needsRedraw = false;
float deltaX = (float) x - (float) mOldMouseX;
float deltaY = (float) y - (float) mOldMouseY;
mOldMouseX = x;
mOldMouseY = y;
if(mMouseRotate)
{
// Calculate delta angles
float scale = 3.0f;
if(mHeight > 0)
scale /= (float) mHeight;
float deltaTheta = -scale * deltaX;
float deltaPhi = -scale * deltaY;
// Adjust camera angles
Vector3 viewVector = mCameraPosition - mCameraLookAt;
float r = sqrtf(viewVector.x * viewVector.x +
viewVector.y * viewVector.y +
viewVector.z * viewVector.z);
float phi, theta;
if(r > 1e-20f)
{
if(mCameraUp.z > 0.0f)
{
phi = acosf(viewVector.z / r);
theta = atan2f(viewVector.y, viewVector.x);
}
else
{
phi = acosf(viewVector.y / r);
theta = atan2f(-viewVector.z, viewVector.x);
}
}
else
{
if(mCameraUp.z > 0.0f)
phi = viewVector.z > 0.0f ? 0.05f * PI : 0.95f * PI;
else
phi = viewVector.y > 0.0f ? 0.05f * PI : 0.95f * PI;
theta = 0.0f;
}
phi += deltaPhi;
theta += deltaTheta;
if(phi > (0.95f * PI))
phi = 0.95f * PI;
else if(phi < (0.05f * PI))
phi = 0.05f * PI;
// Update the camera position
if(mCameraUp.z > 0.0f)
{
viewVector.x = r * cos(theta) * sin(phi);
viewVector.y = r * sin(theta) * sin(phi);
viewVector.z = r * cos(phi);
}
else
{
viewVector.x = r * cos(theta) * sin(phi);
viewVector.y = r * cos(phi);
viewVector.z = -r * sin(theta) * sin(phi);
}
mCameraPosition = mCameraLookAt + viewVector;
needsRedraw = true;
}
else if(mMouseZoom)
{
// Calculate delta angles
float scale = 3.0f;
if(mHeight > 0)
scale /= (float) mHeight;
float zoom = scale * deltaY;
// Adjust camera zoom
Vector3 viewVector = mCameraPosition - mCameraLookAt;
viewVector = viewVector * powf(2.0f, zoom);
// Update the camera position
mCameraPosition = mCameraLookAt + viewVector;
needsRedraw = true;
}
else if(mMousePan)
{
// Calculate delta movement
float scale = 1.0f * (mCameraPosition - mCameraLookAt).Abs();
if(mHeight > 0)
scale /= (float) mHeight;
float panX = scale * deltaX;
float panY = scale * deltaY;
// Calculate camera movement
Vector3 viewDir = Normalize(mCameraPosition - mCameraLookAt);
Vector3 rightDir = Normalize(Cross(viewDir, mCameraUp));
Vector3 upDir = Normalize(Cross(rightDir, viewDir));
Vector3 moveDelta = rightDir * panX + upDir * panY;
// Update the camera position
mCameraPosition += moveDelta;
mCameraLookAt += moveDelta;
needsRedraw = true;
}
else
{
// Call mouse move for all the GUI buttons
for(list<GLButton *>::iterator b = mButtons.begin(); b != mButtons.end(); ++ b)
{
if((*b)->MouseMove(x, y))
needsRedraw = true;
}
}
// Redraw?
if(needsRedraw)
glutPostRedisplay();
}
/// Keyboard function
void GLViewer::KeyDown(unsigned char key, int x, int y)
{
if(key == 15) // CTRL+O
ActionOpenFile();
else if(key == 19) // CTRL+S
ActionSaveFile();
else if(key == 'w')
ActionToggleWireframe();
else if(key == 'f')
ActionFitToScreen();
else if(key == 'y')
ActionCameraUpY();
else if(key == 'z')
ActionCameraUpZ();
else if(key == '+')
ActionZoomIn();
else if(key == '-')
ActionZoomOut();
else if(key == 27) // ESC
ActionExit();
}
/// Keyboard function (special keys)
void GLViewer::SpecialKeyDown(int key, int x, int y)
{
if(key == GLUT_KEY_F1)
ActionHelp();
}
//-----------------------------------------------------------------------------
// Application main code
//-----------------------------------------------------------------------------
/// Constructor
GLViewer::GLViewer()
{
// Clear internal state
mFileName = "";
mFilePath = "";
mFileSize = 0;
mWidth = 1;
mHeight = 1;
mDepthBufferResolution = 16;
mOldMouseX = 0;
mOldMouseY = 0;
mMouseRotate = false;
mMouseZoom = false;
mMousePan = false;
mCameraUp = Vector3(0.0f, 0.0f, 1.0f);
mFocusStartPos = Vector3(0.0f, 0.0f, 0.0f);
mFocusEndPos = Vector3(0.0f, 0.0f, 0.0f);
mFocusStartTime = 0.0;
mFocusEndTime = 0.0;
mFocusStartDistance = 1.0;
mFocusEndDistance = 1.0;
mFocusing = false;
mLastClickTime = -1000.0;
mDisplayList = 0;
mPolyMode = GL_FILL;
mTexHandle = 0;
mUseShader = false;
mShaderProgram = 0;
mVertShader = 0;
mFragShader = 0;
mMesh = NULL;
}
/// Destructor
GLViewer::~GLViewer()
{
// Free all GUI buttons
for(list<GLButton *>::iterator b = mButtons.begin(); b != mButtons.end(); ++ b)
delete (*b);
// Free the mesh
if(mMesh)
delete mMesh;
}
/// Run the application
void GLViewer::Run(int argc, char **argv)
{
try
{
// Init GLUT
glutInit(&argc, argv);
// Create the glut window
glutInitWindowSize(640, 480);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("OpenCTM viewer");
// Init GLEW (for OpenGL 2.x support)
if(glewInit() != GLEW_OK)
throw runtime_error("Unable to initialize GLEW.");
// Load the phong shader, if we can
if(GLEW_VERSION_2_0)
InitShader();
else if(GLEW_VERSION_1_2)
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
// Set the GLUT callback functions (these are bridged to the corresponding
// class methods)
glutReshapeFunc(GLUTWindowResize);
glutDisplayFunc(GLUTWindowRedraw);
glutMouseFunc(GLUTMouseClick);
glutMotionFunc(GLUTMouseMove);
glutPassiveMotionFunc(GLUTMouseMove);
glutKeyboardFunc(GLUTKeyDown);
glutSpecialFunc(GLUTSpecialKeyDown);
// Create GUI buttons
GLButton * b1 = new OpenButton();
mButtons.push_back(b1);
b1->mParent = this;
b1->SetGlyph(icon_open, 32, 32, 4);
b1->mPosX = 12;
b1->mPosY = 10;
GLButton * b2 = new SaveButton();
mButtons.push_back(b2);
b2->mParent = this;
b2->SetGlyph(icon_save, 32, 32, 4);
b2->mPosX = 60;
b2->mPosY = 10;
GLButton * b3 = new OpenTextureButton();
mButtons.push_back(b3);
b3->mParent = this;
b3->SetGlyph(icon_texture, 32, 32, 4);
b3->mPosX = 108;
b3->mPosY = 10;
GLButton * b4 = new HelpButton();
mButtons.push_back(b4);
b4->mParent = this;
b4->SetGlyph(icon_help, 32, 32, 4);
b4->mPosX = 156;
b4->mPosY = 10;
// Load the file
if(argc >= 2)
{
const char * overrideTexName = NULL;
if(argc >= 3)
overrideTexName = argv[2];
LoadFile(argv[1], overrideTexName);
}
// Enter the main loop
glutMainLoop();
}
catch(ctm_error &e)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Error";
mb.mText = string("OpenCTM error: ") + string(e.what());
mb.Show();
}
catch(exception &e)
{
SysMessageBox mb;
mb.mMessageType = SysMessageBox::mtError;
mb.mCaption = "Error";
mb.mText = string(e.what());
mb.Show();
}
cout << endl;
}
//-----------------------------------------------------------------------------
// Bridge GLUT callback functions to class methods
//-----------------------------------------------------------------------------
// NOTE: This is just a hack to be able to reference the application class
// object from the GLUT callback functions, since there is no way (afaik) to
// pass user data (i.e. the object reference) through GLUT...
static GLViewer * gGLViewer = NULL;
/// Redraw function.
void GLUTWindowRedraw(void)
{
if(gGLViewer)
gGLViewer->WindowRedraw();
}
/// Resize function.
void GLUTWindowResize(int w, int h)
{
if(gGLViewer)
gGLViewer->WindowResize(w, h);
}
/// Mouse click function
void GLUTMouseClick(int button, int state, int x, int y)
{
if(gGLViewer)
gGLViewer->MouseClick(button, state, x, y);
}
/// Mouse move function
void GLUTMouseMove(int x, int y)
{
if(gGLViewer)
gGLViewer->MouseMove(x, y);
}
/// Keyboard function
void GLUTKeyDown(unsigned char key, int x, int y)
{
if(gGLViewer)
gGLViewer->KeyDown(key, x, y);
}
/// Keyboard function (special keys)
void GLUTSpecialKeyDown(int key, int x, int y)
{
if(gGLViewer)
gGLViewer->SpecialKeyDown(key, x, y);
}
//-----------------------------------------------------------------------------
// Program startup
//-----------------------------------------------------------------------------
/// Program entry.
int main(int argc, char **argv)
{
// Run the application class
gGLViewer = new GLViewer;
gGLViewer->Run(argc, argv);
delete gGLViewer;
gGLViewer = NULL;
return 0;
}
Reference in a new issue Copy permalink