Removed all GLUT dependencies!

This commit is contained in:
Paolo Cignoni 2006-05-25 09:22:58 +00:00
parent de11419338
commit 47e62b3c6e
2 changed files with 225 additions and 2 deletions

View File

@ -23,12 +23,14 @@
/**************************************************************************** /****************************************************************************
History History
$Log: not supported by cvs2svn $ $Log: not supported by cvs2svn $
Revision 1.11 2006/03/29 07:54:03 cignoni
Wrong matrix type in cone (thx Maarten)
****************************************************************************/ ****************************************************************************/
#ifndef __VCG_GLADDONS #ifndef __VCG_GLADDONS
#define __VCG_GLADDONS #define __VCG_GLADDONS
#include <GL/glut.h>
#include <wrap/gl/math.h> #include <wrap/gl/math.h>
#include <wrap/gl/space.h> #include <wrap/gl/space.h>
#include <vcg/space/point3.h> #include <vcg/space/point3.h>
@ -36,7 +38,7 @@ $Log: not supported by cvs2svn $
namespace vcg namespace vcg
{ {
#include "gl_geometry.h"
/** Class Add_Ons. /** Class Add_Ons.
This is class draw 3d icons on the screen This is class draw 3d icons on the screen
*/ */

221
wrap/gl/gl_geometry.h Normal file
View File

@ -0,0 +1,221 @@
/* Portion of this file were more or less adapted from
* freeglut_geometry.c
*
* Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
* that was Written by Pawel W. Olszta, <olszta@sourceforge.net>
*/
#include<stdlib.h>
#include<math.h>
/*
* Compute lookup table of cos and sin values forming a cirle
*
* Notes:
* It is the responsibility of the caller to free these tables
* The size of the table is (n+1) to form a connected loop
* The last entry is exactly the same as the first
* The sign of n can be flipped to get the reverse loop
*/
static void fghCircleTable(double **sint,double **cost,const int n)
{
int i;
/* Table size, the sign of n flips the circle direction */
const int size = abs(n);
/* Determine the angle between samples */
const double angle = 2*M_PI/(double)( ( n == 0 ) ? 1 : n );
/* Allocate memory for n samples, plus duplicate of first entry at the end */
*sint = (double *) calloc(sizeof(double), size+1);
*cost = (double *) calloc(sizeof(double), size+1);
/* Bail out if memory allocation fails, fgError never returns */
if (!(*sint) || !(*cost))
{
free(*sint);
free(*cost);
abort(); //fgError("Failed to allocate memory in fghCircleTable");
}
/* Compute cos and sin around the circle */
(*sint)[0] = 0.0;
(*cost)[0] = 1.0;
for (i=1; i<size; i++)
{
(*sint)[i] = sin(angle*i);
(*cost)[i] = cos(angle*i);
}
/* Last sample is duplicate of the first */
(*sint)[size] = (*sint)[0];
(*cost)[size] = (*cost)[0];
}
/*
* Draws a solid sphere
*/
void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
{
int i,j;
/* Adjust z and radius as stacks are drawn. */
double z0,z1;
double r0,r1;
/* Pre-computed circle */
double *sint1,*cost1;
double *sint2,*cost2;
// FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );
fghCircleTable(&sint1,&cost1,-slices);
fghCircleTable(&sint2,&cost2,stacks*2);
/* The top stack is covered with a triangle fan */
z0 = 1.0;
z1 = cost2[(stacks>0)?1:0];
r0 = 0.0;
r1 = sint2[(stacks>0)?1:0];
glBegin(GL_TRIANGLE_FAN);
glNormal3d(0,0,1);
glVertex3d(0,0,radius);
for (j=slices; j>=0; j--)
{
glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
}
glEnd();
/* Cover each stack with a quad strip, except the top and bottom stacks */
for( i=1; i<stacks-1; i++ )
{
z0 = z1; z1 = cost2[i+1];
r0 = r1; r1 = sint2[i+1];
glBegin(GL_QUAD_STRIP);
for(j=0; j<=slices; j++)
{
glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 );
glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);
glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
}
glEnd();
}
/* The bottom stack is covered with a triangle fan */
z0 = z1;
r0 = r1;
glBegin(GL_TRIANGLE_FAN);
glNormal3d(0,0,-1);
glVertex3d(0,0,-radius);
for (j=0; j<=slices; j++)
{
glNormal3d(cost1[j]*r0, sint1[j]*r0, z0 );
glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);
}
glEnd();
/* Release sin and cos tables */
free(sint1);
free(cost1);
free(sint2);
free(cost2);
}
/*
* Draws a wire sphere
*/
void glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
{
int i,j;
/* Adjust z and radius as stacks and slices are drawn. */
double r;
double x,y,z;
/* Pre-computed circle */
double *sint1,*cost1;
double *sint2,*cost2;
//FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );
fghCircleTable(&sint1,&cost1,-slices );
fghCircleTable(&sint2,&cost2, stacks*2);
/* Draw a line loop for each stack */
for (i=1; i<stacks; i++)
{
z = cost2[i];
r = sint2[i];
glBegin(GL_LINE_LOOP);
for(j=0; j<=slices; j++)
{
x = cost1[j];
y = sint1[j];
glNormal3d(x,y,z);
glVertex3d(x*r*radius,y*r*radius,z*radius);
}
glEnd();
}
/* Draw a line loop for each slice */
for (i=0; i<slices; i++)
{
glBegin(GL_LINE_STRIP);
for(j=0; j<=stacks; j++)
{
x = cost1[i]*sint2[j];
y = sint1[i]*sint2[j];
z = cost2[j];
glNormal3d(x,y,z);
glVertex3d(x*radius,y*radius,z*radius);
}
glEnd();
}
/* Release sin and cos tables */
free(sint1);
free(cost1);
free(sint2);
free(cost2);
}