WebSVN – gelsvn – Diff – /trunk/apps/OBJViewer/objview.cpp

 #endif
 #include <string.h>
 #include <stdlib.h>
 #include <iostream>
-#include <CGLA/Vec2i.h>
-#include <CGLA/Vec2f.h>
 #include <IL/il.h>
 #include <IL/ilu.h>
+#include <CGLA/Vec2i.h>
+#include <CGLA/Vec2f.h>
 #include <CGLA/Vec3f.h>
 #include <CGLA/Mat4x4f.h>
 #include "GLGraphics/gel_glut.h"
 #include "GLGraphics/QuatTrackBall.h"
 #include "GLGraphics/draw.h"
 #include "Geometry/TriMesh.h"
 #include "Geometry/obj_load.h"
+#include "ply_load.h"
 using namespace std;
 using namespace CGLA;
 using namespace Geometry;
 using namespace GLGraphics;
 namespace
+{
-int win_size_x = 800;
+	int win_size_x = 800;
-int win_size_y = 800;
+	int win_size_y = 800;
+	QuatTrackBall* ball;
-QuatTrackBall* ball;
+	int spin_timer = 20;
-int spin_timer = 20;
+	void spin(int x);
-void spin(int x);
+	int main_window;
+	TriMesh mesh;
-int main_window;
-bool load_image_into_texture(const std::string& name, GLuint& id)
+	bool load_image_into_texture(const std::string& name, GLuint& id)
-{
+	{
-    unsigned char* image = 0;
+		unsigned char* image = 0;
-    unsigned int bpp = 0;
+		unsigned int bpp = 0;
-    unsigned int size_x = 0;
+		unsigned int size_x = 0;
-    unsigned int size_y = 0;
+		unsigned int size_y = 0;
-    unsigned int load_size_x = 0;
+		unsigned int load_size_x = 0;
-    unsigned int load_size_y = 0;
+		unsigned int load_size_y = 0;
-    ILenum Error;
+		ILenum Error;
-    ILuint  ImgId;
+		ILuint  ImgId;
-    static bool washere = false;
+		static bool washere = false;
-    if(!washere)
+		if(!washere)
-    {
+		{
-        ilInit();
+			ilInit();
-        iluInit();
+			iluInit();
-        washere=true;
+			washere=true;
-    }
+		}
-    ilEnable(IL_CONV_PAL);
+		ilEnable(IL_CONV_PAL);
-    ilEnable(IL_ORIGIN_SET);
+		ilEnable(IL_ORIGIN_SET);
-    ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
+		ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
-    ilGenImages(1, &ImgId);
+		ilGenImages(1, &ImgId);
-    ilBindImage(ImgId);
+		ilBindImage(ImgId);
-    char* name_cstr = const_cast<char*>(name.c_str());
+		char* name_cstr = const_cast<char*>(name.c_str());
-    if(!ilLoadImage(name_cstr))
+		if(!ilLoadImage(name_cstr))
-    {
+		{
-        cout << "could not load <" << name_cstr  << ">" << endl;
+			cout << "could not load <" << name_cstr  << ">" << endl;
-        return false;
+			return false;
-    }
+		}
-    load_size_x = ilGetInteger(IL_IMAGE_WIDTH);
+		load_size_x = ilGetInteger(IL_IMAGE_WIDTH);
-    load_size_y = ilGetInteger(IL_IMAGE_HEIGHT);
+		load_size_y = ilGetInteger(IL_IMAGE_HEIGHT);
-    bpp = ilGetInteger(IL_IMAGE_BITS_PER_PIXEL);
+		bpp = ilGetInteger(IL_IMAGE_BITS_PER_PIXEL);
-    if (bpp==24)
+		if (bpp==24)
-        ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
+			ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
-    else if (bpp==32)
+		else if (bpp==32)
-        ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
+			ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
-    else if (bpp==8)
+		else if (bpp==8)
-        ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
+			ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
-    else
+		else
-        assert(0);
+			assert(0);
-    unsigned int i;
+		unsigned int i;
-    for (i=2;i<=4096 ;i*=2)
+		for (i=2;i<=4096 ;i*=2)
-        if (i>=load_size_x)
+			if (i>=load_size_x)
-            break;
+				break;
-    size_x = i;
+		size_x = i;
-    for (i=2;i<=4096 ;i*=2)
+		for (i=2;i<=4096 ;i*=2)
-        if (i>=load_size_y)
+			if (i>=load_size_y)
-            break;
+				break;
-    size_y = i;
+		size_y = i;
-    if(size_x != load_size_x || size_y != load_size_y)
+		if(size_x != load_size_x || size_y != load_size_y)
-    {
+		{
-        iluImageParameter(ILU_FILTER, ILU_BILINEAR);
+			iluImageParameter(ILU_FILTER, ILU_BILINEAR);
-        iluScale(size_x, size_y, 1);
+			iluScale(size_x, size_y, 1);
-    }
+		}
-    const int image_size =size_x*size_y*ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
+		const int image_size =size_x*size_y*ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
-    image = new unsigned char[image_size];
+		image = new unsigned char[image_size];
-    memcpy(image, ilGetData(), image_size);
+		memcpy(image, ilGetData(), image_size);
-    ilDeleteImages(1, &ImgId);
+		ilDeleteImages(1, &ImgId);
-    bool any_errors=false;
+		bool any_errors=false;
-    while ((Error = ilGetError())) {
+		while ((Error = ilGetError())) {
-        cout << __LINE__ << "Error: " << iluErrorString(Error) << endl;
+			cout << __LINE__ << "Error: " << iluErrorString(Error) << endl;
-        any_errors = true;
+			any_errors = true;
-    }
+		}
-    if(any_errors) return false;
+		if(any_errors) return false;
-    GLint internalFormat=0;
+		GLint internalFormat=0;
-    GLenum format=0;
+		GLenum format=0;
-    glGenTextures(1, &id);
+		glGenTextures(1, &id);
-    switch (bpp)
+		switch (bpp)
-    {
+		{
-    case 8:
+			case 8:
-        internalFormat =  GL_LUMINANCE;
+				internalFormat =  GL_LUMINANCE;
-        format = GL_LUMINANCE;
+				format = GL_LUMINANCE;
-        break;
+				break;
-    case 24:
+			case 24:
-        internalFormat =  GL_RGB;
+				internalFormat =  GL_RGB;
-        format = GL_RGB;
+				format = GL_RGB;
-        break;
+				break;
-    case 32:
+			case 32:
-        internalFormat =  GL_RGBA;
+				internalFormat =  GL_RGBA;
-        format = GL_RGBA;
+				format = GL_RGBA;
-        break;
+				break;
-    default:
+			default:
-        return false;
+				return false;
-    }
+		}
-    glBindTexture(GL_TEXTURE_2D, id);
+		glBindTexture(GL_TEXTURE_2D, id);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, size_x, size_y, 0,
+		glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, size_x, size_y, 0,
-                 format, GL_UNSIGNED_BYTE, image);
+					 format, GL_UNSIGNED_BYTE, image);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    return true;
+		return true;
-}
+	}
-void enable_textures(TriMesh& tm)
+	void enable_textures(TriMesh& tm)
-{
+	{
-    for(unsigned int i=0;i<tm.materials.size(); ++i)
+		for(unsigned int i=0;i<tm.materials.size(); ++i)
-    {
+		{
-        Material& mat = tm.materials[i];
+			Material& mat = tm.materials[i];
-        if(mat.tex_name != "")
+			if(mat.tex_name != "")
-        {
+			{
-            string name = mat.tex_path + mat.tex_name;
+				string name = mat.tex_path + mat.tex_name;
-            GLuint tex_id;
+				GLuint tex_id;
-            if(load_image_into_texture(name, tex_id))
+				if(load_image_into_texture(name, tex_id))
-							mat.tex_id = tex_id;
+					mat.tex_id = tex_id;
-				}
+			}
-    }
+		}
-}
+	}
-bool depth_pick(int x, int y,Vec3f& wp)
+	bool depth_pick(int x, int y,Vec3f& wp)
-{
+	{
-    // Enquire about the viewport dimensions
+		// Enquire about the viewport dimensions
-    GLint viewport[4];
+		GLint viewport[4];
-    glGetIntegerv(GL_VIEWPORT, viewport);
+		glGetIntegerv(GL_VIEWPORT, viewport);
-    // Get the minimum and maximum depth values.
+		// Get the minimum and maximum depth values.
-    float minmax_depth[2];
+		float minmax_depth[2];
-    glGetFloatv(GL_DEPTH_RANGE, minmax_depth);
+		glGetFloatv(GL_DEPTH_RANGE, minmax_depth);
-    // Read a single pixel at the position of the mouse cursor.
+		// Read a single pixel at the position of the mouse cursor.
-    float depth;
+		float depth;
-    glReadPixels(x, viewport[3]-y, 1,1, GL_DEPTH_COMPONENT,
+		glReadPixels(x, viewport[3]-y, 1,1, GL_DEPTH_COMPONENT,
-                 GL_FLOAT, (void*) &depth);
+					 GL_FLOAT, (void*) &depth);
-    // If the depth corresponds to the far plane, we clicked on the
+		// If the depth corresponds to the far plane, we clicked on the
-    // background.
+		// background.
-    if(depth == minmax_depth[1])
+		if(depth == minmax_depth[1])
-        return false;
+			return false;
-    // The lines below copy the viewing transformation from OpenGL
+		// The lines below copy the viewing transformation from OpenGL
-    // to local variables. The call to gluLookAt must have exactly
+		// to local variables. The call to gluLookAt must have exactly
-    // the same parameters as when the scene is drawn.
+		// the same parameters as when the scene is drawn.
-    glLoadIdentity();
+		glLoadIdentity();
-    ball->set_gl_modelview();
+		ball->set_gl_modelview();
-    double mvmat[16];
+		double mvmat[16];
-    glGetDoublev(GL_MODELVIEW_MATRIX, mvmat);
+		glGetDoublev(GL_MODELVIEW_MATRIX, mvmat);
-    // Copy the projection matrix. We assume it is unchanged.
+		// Copy the projection matrix. We assume it is unchanged.
-    double prjmat[16];
+		double prjmat[16];
-    glGetDoublev(GL_PROJECTION_MATRIX, prjmat);
+		glGetDoublev(GL_PROJECTION_MATRIX, prjmat);
-    // Now unproject the point from screen to world coordinates.
+		// Now unproject the point from screen to world coordinates.
-    double ox, oy, oz;
+		double ox, oy, oz;
-    gluUnProject(x,viewport[3]-y,depth,
+		gluUnProject(x,viewport[3]-y,depth,
-                 mvmat,prjmat,viewport,
+					 mvmat,prjmat,viewport,
-                 &ox, &oy, &oz);
+					 &ox, &oy, &oz);
-    wp = Vec3f(ox,oy,oz);
+		wp = Vec3f(ox,oy,oz);
-    return true;
+		return true;
-}
+	}
-TriMesh mesh;
 void mouse_motion(int x, int y)
+{
     ball->roll_ball(Vec2i(x,y));
+}
 void mouse(int btn, int state, int x, int y)
+{
-  if(state == GLUT_DOWN)
+	if(state == GLUT_DOWN)
-  {
+	{
-	if(btn == GLUT_LEFT_BUTTON)
+		if(btn == GLUT_LEFT_BUTTON)
-	   ball->grab_ball(ROTATE_ACTION, Vec2i(x,y));
+			ball->grab_ball(ROTATE_ACTION, Vec2i(x,y));
-    else if(btn == GLUT_MIDDLE_BUTTON)
+		else if(btn == GLUT_MIDDLE_BUTTON)
-	  ball->grab_ball(ZOOM_ACTION, Vec2i(x, y));
+			ball->grab_ball(ZOOM_ACTION, Vec2i(x, y));
-    else if(btn == GLUT_RIGHT_BUTTON)
+		else if(btn == GLUT_RIGHT_BUTTON)
-	  ball->grab_ball(PAN_ACTION, Vec2i(x, y));
+			ball->grab_ball(PAN_ACTION, Vec2i(x, y));
-  }
+	}
-  else if(state == GLUT_UP)
+	else if(state == GLUT_UP)
-    ball->release_ball();
+		ball->release_ball();
+}
 void spin(int x)
+{
-  ball->do_spin();
+	ball->do_spin();
-  glutTimerFunc(spin_timer, spin, 0);
+	glutTimerFunc(spin_timer, spin, 0);
-  glutPostRedisplay();
+	glutPostRedisplay();
+}
-/*
-void idle()
-{
-    if ( glutGetWindow() != main_window )
-        glutSetWindow(main_window);
-    glutPostRedisplay();
-}
-*/
 void display()
+{
     static bool washere = false;
     static unsigned int l;
     if(!washere)
         l = glGenLists(1);
         glNewList(l, GL_COMPILE);
         draw(mesh);
         glEndList();
         washere = true;
-      glutTimerFunc(spin_timer, spin, 0);
+		glutTimerFunc(spin_timer, spin, 0);
+	}
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
     ball->set_gl_modelview();
     glCallList(l);
 void keyboard(unsigned char key, int x, int y)
+{
     switch(key)
+    {
-    case '\033': exit(0); break;
+		case '\033': exit(0); break;
-    //case '+': ball->closer(); break;
+			//case '+': ball->closer(); break;
-    //case '-': ball->farther(); break;
+			//case '-': ball->farther(); break;
-    //default:
+			//default:
-    //    ball->up_axis(key);
+			//    ball->up_axis(key);
+    }
+}
+}
 int main(int argc, char** argv)
     glutDisplayFunc(display);
     glutKeyboardFunc(keyboard);
     glutMotionFunc(mouse_motion);
     glutMouseFunc(mouse);
     //glutIdleFunc(idle);
     // GL INIT
     glClearColor(.8f, 0.9f, 1.0f, 0.f);
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_LIGHTING);
     glEnable(GL_LIGHT0);
     glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
     glShadeModel(GL_SMOOTH);
     // LOAD OBJ
     string fn;
     if(argc>1)
         fn = argv[1];
     else
         fn = "../../data/head.obj";
-    cout << "Loading " << fn << endl;
+	if(fn.substr(fn.length()-4,fn.length())==".obj")
+	{
-    if(fn == "") exit(0);
+		obj_load(fn, mesh);
+	}
+	else if(fn.substr(fn.length()-4,fn.length())==".ply")
+	{
-    obj_load(fn, mesh);
+		ply_load(fn, mesh);
+	}
+	else
+	{
+		cout << "Either the format was unrecognized or the file did not have the appropriate extension" << endl;
+		exit(0);
+	}
-    enable_textures(mesh);
+/*    enable_textures(mesh);
     if(!mesh.has_normals())
+    {
         cout << "Computing normals" << endl;
         mesh.compute_normals();
+    }
+*/
     // Initialize Trackball
     Vec3f c;
     float r;
     mesh.get_bsphere(c,r);
     r *= 1.5;
     ball = new QuatTrackBall(c,r,800,800);
     // Setup projection
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     gluPerspective(53,1.0f,r/100.0,r*3.0);
     glMatrixMode(GL_MODELVIEW);
     // Pass control to GLUT
     glutMainLoop();
     return 0;
+}

Subversion Repositories gelsvn

(root)/trunk/apps/OBJViewer/objview.cpp – Rev 299 → 337