teapot now using vertex arrays or vertex attribute arrays, using handwritten Bezier surface evaluation code
in fg_geometry, fixed up normal generation for visualization and added support for drawing texture coordinates (teapot has texture coordinates, other geometric shapes don't) git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@1567 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
dcnieho
parent
fc84854e33
commit
6581072673
@ -49,7 +49,7 @@ static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
|
||||
GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
|
||||
);
|
||||
static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
|
||||
#endif
|
||||
static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
@ -57,12 +57,11 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n
|
||||
GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2,
|
||||
GLint attribute_v_coord, GLint attribute_v_normal
|
||||
);
|
||||
static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart,
|
||||
GLint attribute_v_coord, GLint attribute_v_normal);
|
||||
GLint attribute_v_coord, GLint attribute_v_normal, GLint attribute_v_texture);
|
||||
/* declare function for generating visualization of normals */
|
||||
static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
|
||||
static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices);
|
||||
#ifndef GL_ES_VERSION_2_0
|
||||
static void fghDrawNormalVisualization11();
|
||||
#endif
|
||||
@ -134,7 +133,7 @@ static void fghDrawNormalVisualization20(GLint attribute_v_coord);
|
||||
*
|
||||
* Feel free to contribute better naming ;)
|
||||
*/
|
||||
static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
|
||||
GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
|
||||
)
|
||||
@ -159,9 +158,9 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei num
|
||||
/* Draw the geometric shape with filled triangles
|
||||
*
|
||||
* Arguments:
|
||||
* GLfloat *vertices, GLfloat *normals, GLsizei numVertices
|
||||
* The vertex coordinate and normal buffers, and the number of entries in
|
||||
* those
|
||||
* GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices
|
||||
* The vertex coordinate, normal and texture coordinate buffers, and the
|
||||
* number of entries in those
|
||||
* GLushort *vertIdxs
|
||||
* a vertex indices buffer, optional (not passed for the polyhedra with
|
||||
* triangular faces)
|
||||
@ -182,23 +181,23 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei num
|
||||
* numParts * numVertPerPart gives the number of entries in the vertex
|
||||
* array vertIdxs
|
||||
*/
|
||||
static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
|
||||
{
|
||||
GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord;
|
||||
GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal;
|
||||
GLint attribute_v_texture = -1; // TODO!!!
|
||||
|
||||
if (fgStructure.CurrentWindow->State.VisualizeNormals)
|
||||
/* generate normals for each vertex to be drawn as well */
|
||||
fghGenerateNormalVisualization(vertices, normals, numVertices,
|
||||
vertIdxs, numParts, numVertIdxsPerPart);
|
||||
fghGenerateNormalVisualization(vertices, normals, numVertices);
|
||||
|
||||
if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1))
|
||||
{
|
||||
/* User requested a 2.0 draw */
|
||||
fghDrawGeometrySolid20(vertices, normals, numVertices,
|
||||
fghDrawGeometrySolid20(vertices, normals, textcs, numVertices,
|
||||
vertIdxs, numParts, numVertIdxsPerPart,
|
||||
attribute_v_coord, attribute_v_normal);
|
||||
attribute_v_coord, attribute_v_normal, attribute_v_texture);
|
||||
|
||||
if (fgStructure.CurrentWindow->State.VisualizeNormals)
|
||||
/* draw normals for each vertex as well */
|
||||
@ -207,7 +206,7 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLsizei nu
|
||||
#ifndef GL_ES_VERSION_2_0
|
||||
else
|
||||
{
|
||||
fghDrawGeometrySolid11(vertices, normals, numVertices,
|
||||
fghDrawGeometrySolid11(vertices, normals, textcs, numVertices,
|
||||
vertIdxs, numParts, numVertIdxsPerPart);
|
||||
|
||||
if (fgStructure.CurrentWindow->State.VisualizeNormals)
|
||||
@ -252,7 +251,7 @@ static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
|
||||
}
|
||||
|
||||
|
||||
static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
|
||||
{
|
||||
int i;
|
||||
@ -263,6 +262,12 @@ static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
glVertexPointer(3, GL_FLOAT, 0, vertices);
|
||||
glNormalPointer(GL_FLOAT, 0, normals);
|
||||
|
||||
if (textcs)
|
||||
{
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, textcs);
|
||||
}
|
||||
|
||||
if (!vertIdxs)
|
||||
glDrawArrays(GL_TRIANGLES, 0, numVertices);
|
||||
else
|
||||
@ -274,6 +279,8 @@ static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
glDisableClientState(GL_NORMAL_ARRAY);
|
||||
if (textcs)
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -390,11 +397,11 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei n
|
||||
|
||||
|
||||
/* Version for OpenGL (ES) >= 2.0 */
|
||||
static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart,
|
||||
GLint attribute_v_coord, GLint attribute_v_normal)
|
||||
GLint attribute_v_coord, GLint attribute_v_normal, GLint attribute_v_texture)
|
||||
{
|
||||
GLuint vbo_coords = 0, vbo_normals = 0, ibo_elements = 0;
|
||||
GLuint vbo_coords = 0, vbo_normals = 0, vbo_textcs = 0, ibo_elements = 0;
|
||||
GLsizei numVertIdxs = numParts * numVertIdxsPerPart;
|
||||
int i;
|
||||
|
||||
@ -414,6 +421,14 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
if (numVertices > 0 && attribute_v_texture != -1 && textcs) {
|
||||
fghGenBuffers(1, &vbo_textcs);
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, vbo_textcs);
|
||||
fghBufferData(FGH_ARRAY_BUFFER, numVertices * 2 * sizeof(textcs[0]),
|
||||
textcs, FGH_STATIC_DRAW);
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
if (vertIdxs != NULL) {
|
||||
fghGenBuffers(1, &ibo_elements);
|
||||
fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
|
||||
@ -450,6 +465,20 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, 0);
|
||||
};
|
||||
|
||||
if (vbo_textcs) {
|
||||
fghEnableVertexAttribArray(attribute_v_texture);
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, vbo_textcs);
|
||||
fghVertexAttribPointer(
|
||||
attribute_v_texture,/* attribute */
|
||||
2, /* number of elements per vertex, here (s,t) */
|
||||
GL_FLOAT, /* the type of each element */
|
||||
GL_FALSE, /* take our values as-is */
|
||||
0, /* no extra data between each position */
|
||||
0 /* offset of first element */
|
||||
);
|
||||
fghBindBuffer(FGH_ARRAY_BUFFER, 0);
|
||||
};
|
||||
|
||||
if (vertIdxs == NULL) {
|
||||
glDrawArrays(GL_TRIANGLES, 0, numVertices);
|
||||
} else {
|
||||
@ -470,11 +499,15 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
fghDisableVertexAttribArray(attribute_v_coord);
|
||||
if (vbo_normals != 0)
|
||||
fghDisableVertexAttribArray(attribute_v_normal);
|
||||
if (vbo_textcs != 0)
|
||||
fghDisableVertexAttribArray(attribute_v_texture);
|
||||
|
||||
if (vbo_coords != 0)
|
||||
fghDeleteBuffers(1, &vbo_coords);
|
||||
if (vbo_normals != 0)
|
||||
fghDeleteBuffers(1, &vbo_normals);
|
||||
if (vbo_textcs != 0)
|
||||
fghDeleteBuffers(1, &vbo_textcs);
|
||||
if (ibo_elements != 0)
|
||||
fghDeleteBuffers(1, &ibo_elements);
|
||||
}
|
||||
@ -483,25 +516,18 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
|
||||
|
||||
/**
|
||||
* Generate vertex indices for visualizing the normals.
|
||||
* vertices are written into verticesForNormalVisualization.
|
||||
* This must be freed by caller, we do the free at the
|
||||
* end of fghDrawNormalVisualization11/fghDrawNormalVisualization20
|
||||
*/
|
||||
static GLfloat *verticesForNormalVisualization;
|
||||
static GLushort numNormalVertices = 0;
|
||||
static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
|
||||
static GLsizei numNormalVertices = 0;
|
||||
static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices)
|
||||
{
|
||||
GLushort i,j;
|
||||
/* calc number of vertices to generate, allocate. Must be freed by caller
|
||||
* We do the free at the end of fghDrawNormalVisualization11/fghDrawNormalVisualization20
|
||||
*/
|
||||
if (!vertIdxs)
|
||||
int i,j;
|
||||
numNormalVertices = numVertices * 2;
|
||||
else
|
||||
numNormalVertices = numParts * numVertIdxsPerPart * 2;
|
||||
verticesForNormalVisualization = malloc(numNormalVertices*3 * sizeof(GLfloat));
|
||||
|
||||
/* Now generate vertices for lines to draw the normals */
|
||||
if (!vertIdxs)
|
||||
{
|
||||
for (i=0,j=0; i<numNormalVertices*3/2; i+=3, j+=6)
|
||||
{
|
||||
verticesForNormalVisualization[j+0] = vertices[i+0];
|
||||
@ -511,20 +537,6 @@ static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals,
|
||||
verticesForNormalVisualization[j+4] = vertices[i+1] + normals[i+1]/4.f;
|
||||
verticesForNormalVisualization[j+5] = vertices[i+2] + normals[i+2]/4.f;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=0,j=0; i<numNormalVertices/2; i++, j+=6)
|
||||
{
|
||||
GLushort idx = vertIdxs[i]*3;
|
||||
verticesForNormalVisualization[j+0] = vertices[idx+0];
|
||||
verticesForNormalVisualization[j+1] = vertices[idx+1];
|
||||
verticesForNormalVisualization[j+2] = vertices[idx+2];
|
||||
verticesForNormalVisualization[j+3] = vertices[idx+0] + normals[idx+0]/4.f;
|
||||
verticesForNormalVisualization[j+4] = vertices[idx+1] + normals[idx+1]/4.f;
|
||||
verticesForNormalVisualization[j+5] = vertices[idx+2] + normals[idx+2]/4.f;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Version for OpenGL (ES) 1.1 */
|
||||
@ -1507,7 +1519,7 @@ void fghGenerateTorus(
|
||||
}\
|
||||
else\
|
||||
{\
|
||||
fghDrawGeometrySolid(name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ,\
|
||||
fghDrawGeometrySolid(name##_verts,name##_norms,NULL,nameCaps##_VERT_PER_OBJ,\
|
||||
vertIdxs, 1, nameCaps##_VERT_PER_OBJ_TRI); \
|
||||
}\
|
||||
}
|
||||
@ -1549,7 +1561,7 @@ static void fghCube( GLfloat dSize, GLboolean useWireMode )
|
||||
NULL,CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
|
||||
NULL,0,0);
|
||||
else
|
||||
fghDrawGeometrySolid(vertices, cube_norms, CUBE_VERT_PER_OBJ,
|
||||
fghDrawGeometrySolid(vertices, cube_norms, NULL, CUBE_VERT_PER_OBJ,
|
||||
cube_vertIdxs, 1, CUBE_VERT_PER_OBJ_TRI);
|
||||
|
||||
if (dSize!=1.f)
|
||||
@ -1593,7 +1605,7 @@ static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale
|
||||
NULL,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
|
||||
NULL,0,0);
|
||||
else
|
||||
fghDrawGeometrySolid(vertices,normals,numVert,NULL,1,0);
|
||||
fghDrawGeometrySolid(vertices,normals,NULL,numVert,NULL,1,0);
|
||||
|
||||
free(vertices);
|
||||
free(normals );
|
||||
@ -1715,7 +1727,7 @@ static void fghSphere( GLfloat radius, GLint slices, GLint stacks, GLboolean use
|
||||
|
||||
|
||||
/* draw */
|
||||
fghDrawGeometrySolid(vertices,normals,nVert,stripIdx,stacks,(slices+1)*2);
|
||||
fghDrawGeometrySolid(vertices,normals,NULL,nVert,stripIdx,stacks,(slices+1)*2);
|
||||
|
||||
/* cleanup allocated memory */
|
||||
free(stripIdx);
|
||||
@ -1826,7 +1838,7 @@ static void fghCone( GLfloat base, GLfloat height, GLint slices, GLint stacks, G
|
||||
}
|
||||
|
||||
/* draw */
|
||||
fghDrawGeometrySolid(vertices,normals,nVert,stripIdx,stacks+1,(slices+1)*2);
|
||||
fghDrawGeometrySolid(vertices,normals,NULL,nVert,stripIdx,stacks+1,(slices+1)*2);
|
||||
|
||||
/* cleanup allocated memory */
|
||||
free(stripIdx);
|
||||
@ -1947,7 +1959,7 @@ static void fghCylinder( GLfloat radius, GLfloat height, GLint slices, GLint sta
|
||||
stripIdx[idx+1] = nVert-1; /* repeat first slice's idx for closing off shape */
|
||||
|
||||
/* draw */
|
||||
fghDrawGeometrySolid(vertices,normals,nVert,stripIdx,stacks+2,(slices+1)*2);
|
||||
fghDrawGeometrySolid(vertices,normals,NULL,nVert,stripIdx,stacks+2,(slices+1)*2);
|
||||
|
||||
/* cleanup allocated memory */
|
||||
free(stripIdx);
|
||||
@ -2041,7 +2053,7 @@ static void fghTorus( GLfloat dInnerRadius, GLfloat dOuterRadius, GLint nSides,
|
||||
}
|
||||
|
||||
/* draw */
|
||||
fghDrawGeometrySolid(vertices,normals,nVert,stripIdx,nSides,(nRings+1)*2);
|
||||
fghDrawGeometrySolid(vertices,normals,NULL,nVert,stripIdx,nSides,(nRings+1)*2);
|
||||
|
||||
/* cleanup allocated memory */
|
||||
free(stripIdx);
|
||||
|
||||
@ -25,171 +25,424 @@
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Original teapot code copyright follows:
|
||||
*/
|
||||
|
||||
/*
|
||||
* (c) Copyright 1993, Silicon Graphics, Inc.
|
||||
*
|
||||
* ALL RIGHTS RESERVED
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software
|
||||
* for any purpose and without fee is hereby granted, provided
|
||||
* that the above copyright notice appear in all copies and that
|
||||
* both the copyright notice and this permission notice appear in
|
||||
* supporting documentation, and that the name of Silicon
|
||||
* Graphics, Inc. not be used in advertising or publicity
|
||||
* pertaining to distribution of the software without specific,
|
||||
* written prior permission.
|
||||
*
|
||||
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
|
||||
* "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
|
||||
* OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
|
||||
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO
|
||||
* EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE
|
||||
* ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
|
||||
* INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
|
||||
* SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
|
||||
* NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY
|
||||
* OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* US Government Users Restricted Rights
|
||||
*
|
||||
* Use, duplication, or disclosure by the Government is subject to
|
||||
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
|
||||
* (c)(1)(ii) of the Rights in Technical Data and Computer
|
||||
* Software clause at DFARS 252.227-7013 and/or in similar or
|
||||
* successor clauses in the FAR or the DOD or NASA FAR
|
||||
* Supplement. Unpublished-- rights reserved under the copyright
|
||||
* laws of the United States. Contractor/manufacturer is Silicon
|
||||
* Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA
|
||||
* 94039-7311.
|
||||
*
|
||||
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
|
||||
/* notes:
|
||||
* the (very little) required math is found here: http://www.gamasutra.com/view/feature/131848/tessellation_of_4x4_bezier_patches_.php?print=1
|
||||
* a much more optimized version is here, didn't bother to implement that: http://www.gamasutra.com/view/feature/131794/an_indepth_look_at_bicubic_bezier_.php?print=1
|
||||
* teacup and teaspoon data: ftp://ftp.funet.fi/pub/sci/graphics/packages/objects/teaset.tar.Z (figure out this sampling scheme)
|
||||
*/
|
||||
|
||||
#include <GL/freeglut.h>
|
||||
#include "fg_internal.h"
|
||||
#include "fg_teapot_data.h"
|
||||
|
||||
/* -- STATIC VARS: CACHES ---------------------------------------------------- */
|
||||
|
||||
/* Teapot defs */
|
||||
#define GLUT_TEAPOT_N_PATCHES (6*4 + 4*2) /* 6 patches are reproduced (rotated) 4 times, 4 patches (flipped) 2 times */
|
||||
#define GLUT_SOLID_TEAPOT_N_SUBDIV 10
|
||||
#define GLUT_SOLID_TEAPOT_N_VERT GLUT_SOLID_TEAPOT_N_SUBDIV*GLUT_SOLID_TEAPOT_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
|
||||
#define GLUT_SOLID_TEAPOT_N_TRI (GLUT_SOLID_TEAPOT_N_SUBDIV-1)*(GLUT_SOLID_TEAPOT_N_SUBDIV-1) * GLUT_TEAPOT_N_PATCHES * 2 /* if e.g. 7x7 vertices for each patch, there are 6*6 squares for each patch. Each square is decomposed into 2 triangles */
|
||||
|
||||
#define GLUT_WIRE_TEAPOT_N_SUBDIV 7
|
||||
#define GLUT_WIRE_TEAPOT_N_VERT GLUT_WIRE_TEAPOT_N_SUBDIV*GLUT_WIRE_TEAPOT_N_SUBDIV * GLUT_TEAPOT_N_PATCHES /* N_SUBDIV^2 vertices per patch */
|
||||
|
||||
/* Bernstein coefficients only have to be precomputed once (number of patch subdivisions is fixed)
|
||||
* Can thus define arrays for them here, they will be filled upon first use.
|
||||
* 3rd order Bezier surfaces have 4 Bernstein coeffs.
|
||||
* Have separate caches for solid and wire as they use a different number of subdivisions
|
||||
* _0 is for Bernstein polynomials, _1 for their first derivative (which we need for normals)
|
||||
*/
|
||||
static GLfloat bernWire_0 [GLUT_WIRE_TEAPOT_N_SUBDIV] [4];
|
||||
static GLfloat bernWire_1 [GLUT_WIRE_TEAPOT_N_SUBDIV] [4];
|
||||
static GLfloat bernSolid_0[GLUT_SOLID_TEAPOT_N_SUBDIV][4];
|
||||
static GLfloat bernSolid_1[GLUT_SOLID_TEAPOT_N_SUBDIV][4];
|
||||
|
||||
/* Bit of caching:
|
||||
* vertex indices and normals only need to be generated once for
|
||||
* a given number of subdivisions as they don't change with scale.
|
||||
* Vertices can be cached and reused if scale didn't change.
|
||||
*/
|
||||
static GLushort vertIdxsSolid[GLUT_SOLID_TEAPOT_N_TRI*3];
|
||||
static GLfloat normsSolid [GLUT_SOLID_TEAPOT_N_VERT*3];
|
||||
static GLfloat vertsSolid [GLUT_SOLID_TEAPOT_N_VERT*3];
|
||||
static GLfloat texcsSolid [GLUT_SOLID_TEAPOT_N_VERT*2];
|
||||
static GLfloat lastScaleSolid = 0.f;
|
||||
static GLboolean initedSolid = GL_FALSE;
|
||||
|
||||
static GLushort vertIdxsWire [GLUT_WIRE_TEAPOT_N_VERT*2];
|
||||
static GLfloat normsWire [GLUT_WIRE_TEAPOT_N_VERT*3];
|
||||
static GLfloat vertsWire [GLUT_WIRE_TEAPOT_N_VERT*3];
|
||||
static GLfloat lastScaleWire = 0.f;
|
||||
static GLboolean initedWire = GL_FALSE;
|
||||
|
||||
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
|
||||
extern void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLfloat *textcs, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
|
||||
extern void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
|
||||
GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
|
||||
GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2);
|
||||
|
||||
|
||||
static void fghTeapot( GLint grid, GLdouble scale, GLenum type )
|
||||
/* evaluate 3rd order Bernstein polynomial and its 1st deriv */
|
||||
static void bernstein3(int i, GLfloat x, GLfloat *r0, GLfloat *r1)
|
||||
{
|
||||
#if defined(_WIN32_WCE)
|
||||
int i, numV=sizeof(strip_vertices)/4, numI=sizeof(strip_normals)/4;
|
||||
#else
|
||||
double p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
|
||||
long i, j, k, l;
|
||||
#endif
|
||||
float invx = 1.f - x;
|
||||
|
||||
glPushAttrib( GL_ENABLE_BIT | GL_EVAL_BIT );
|
||||
glEnable( GL_AUTO_NORMAL );
|
||||
glEnable( GL_NORMALIZE );
|
||||
glEnable( GL_MAP2_VERTEX_3 );
|
||||
glEnable( GL_MAP2_TEXTURE_COORD_2 );
|
||||
|
||||
glPushMatrix();
|
||||
glRotated( 270.0, 1.0, 0.0, 0.0 );
|
||||
glScaled( 0.5 * scale, 0.5 * scale, 0.5 * scale );
|
||||
glTranslated( 0.0, 0.0, -1.5 );
|
||||
|
||||
#if defined(_WIN32_WCE)
|
||||
glRotated( 90.0, 1.0, 0.0, 0.0 );
|
||||
glBegin( GL_TRIANGLE_STRIP );
|
||||
|
||||
for( i = 0; i < numV-1; i++ )
|
||||
/* r0: zero order coeff, r1: first deriv coeff */
|
||||
switch (i)
|
||||
{
|
||||
int vidx = strip_vertices[i],
|
||||
nidx = strip_normals[i];
|
||||
GLfloat temp;
|
||||
case 0:
|
||||
temp = invx*invx;
|
||||
*r0 = invx * temp; /* invx * invx * invx */
|
||||
*r1 = -3 * temp; /* -3 * invx * invx */
|
||||
break;
|
||||
case 1:
|
||||
temp = invx*invx;
|
||||
*r0 = 3 * x * temp; /* 3 * x * invx * invx */
|
||||
*r1 = 3 * temp - 6 * x * invx; /* 3 * invx * invx - 6 * x * invx */
|
||||
break;
|
||||
case 2:
|
||||
temp = x*x;
|
||||
*r0 = 3 * temp * invx; /* 3 * x * x * invx */
|
||||
*r1 = 6 * x * invx - 3 * temp; /* 6 * x * invx - 3 * x * x */
|
||||
break;
|
||||
case 3:
|
||||
temp = x*x;
|
||||
*r0 = x * temp; /* x * x * x */
|
||||
*r1 = 3 * temp; /* 3 * x * x */
|
||||
break;
|
||||
default:
|
||||
*r0 = *r1 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if( vidx != -1 )
|
||||
static void pregenBernstein(int nSubDivs, GLfloat (*bern_0)[4], GLfloat (*bern_1)[4])
|
||||
{
|
||||
int s,i;
|
||||
for (s=0; s<nSubDivs; s++)
|
||||
{
|
||||
glNormal3fv( normals[nidx] );
|
||||
glVertex3fv( vertices[vidx] );
|
||||
GLfloat x = s/(nSubDivs-1.f);
|
||||
for (i=0; i<4; i++) /* 3rd order polynomial */
|
||||
bernstein3(i,x,bern_0[s]+i,bern_1[s]+i);
|
||||
}
|
||||
}
|
||||
|
||||
/* based on flag either rotate patches around y axis to other 3 quadrants (flag=4) or reflect patch across x-y plane (flag=2) */
|
||||
static void rotOrReflect(int flag, int nVals, int nSubDivs, GLfloat *vals)
|
||||
{
|
||||
int u,i,o;
|
||||
|
||||
if (flag==4)
|
||||
{
|
||||
int i1=nVals, i2=nVals*2, i3=nVals*3;
|
||||
for (o=0; o<nVals; o+=3)
|
||||
{
|
||||
/* 90° rotation */
|
||||
vals[i1+o+0] = vals[o+2];
|
||||
vals[i1+o+1] = vals[o+1];
|
||||
vals[i1+o+2] = -vals[o+0];
|
||||
/* 180° rotation */
|
||||
vals[i2+o+0] = -vals[o+0];
|
||||
vals[i2+o+1] = vals[o+1];
|
||||
vals[i2+o+2] = -vals[o+2];
|
||||
/* 270° rotation */
|
||||
vals[i3+o+0] = -vals[o+2];
|
||||
vals[i3+o+1] = vals[o+1];
|
||||
vals[i3+o+2] = vals[o+0];
|
||||
}
|
||||
}
|
||||
else if (flag==2)
|
||||
{
|
||||
/* copy over values, reversing row order to keep winding correct, and negating z to perform the flip */
|
||||
for (u=0; u<nSubDivs; u++) /* per row */
|
||||
{
|
||||
int off = (nSubDivs-u-1)*nSubDivs*3; /* read last row first from the already existing rows */
|
||||
o = nVals + u *nSubDivs*3; /* write last row as first row to output */
|
||||
for (i=0; i<nSubDivs*3; i+=3, o+=3) /* each row has nSubDivs points consisting of three values */
|
||||
{
|
||||
vals[o+0] = vals[off+i+0];
|
||||
vals[o+1] = vals[off+i+1];
|
||||
vals[o+2] = -vals[off+i+2];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* verts array should be initialized to 0! */
|
||||
static int evalBezierWithNorm(GLfloat cp[4][4][3], int nSubDivs, float (*bern_0)[4], float (*bern_1)[4], int flag, int normalFix, GLfloat *verts, GLfloat *norms)
|
||||
{
|
||||
int nVerts = nSubDivs*nSubDivs;
|
||||
int nVertVals = nVerts*3; /* number of values output for one patch, flag (2 or 4) indicates how many times we will write this to output */
|
||||
int u,v,i,j,o;
|
||||
|
||||
/* generate vertices and coordinates for the patch */
|
||||
for (u=0,o=0; u<nSubDivs; u++)
|
||||
{
|
||||
for (v=0; v<nSubDivs; v++, o+=3)
|
||||
{
|
||||
/* for normals, get two tangents at the vertex using partial derivatives of 2D Bezier grid */
|
||||
float tan1[3]={0}, tan2[3]={0}, len;
|
||||
for (i=0; i<=3; i++)
|
||||
{
|
||||
float vert_0[3]={0}, vert_1[3]={0};
|
||||
for (j=0; j<=3; j++)
|
||||
{
|
||||
vert_0[0] += bern_0[v][j] * cp[i][j][0];
|
||||
vert_0[1] += bern_0[v][j] * cp[i][j][1];
|
||||
vert_0[2] += bern_0[v][j] * cp[i][j][2];
|
||||
|
||||
vert_1[0] += bern_1[v][j] * cp[i][j][0];
|
||||
vert_1[1] += bern_1[v][j] * cp[i][j][1];
|
||||
vert_1[2] += bern_1[v][j] * cp[i][j][2];
|
||||
}
|
||||
|
||||
verts[o+0] += bern_0[u][i]*vert_0[0];
|
||||
verts[o+1] += bern_0[u][i]*vert_0[1];
|
||||
verts[o+2] += bern_0[u][i]*vert_0[2];
|
||||
|
||||
tan1[0] += bern_0[u][i]*vert_1[0];
|
||||
tan1[1] += bern_0[u][i]*vert_1[1];
|
||||
tan1[2] += bern_0[u][i]*vert_1[2];
|
||||
tan2[0] += bern_1[u][i]*vert_0[0];
|
||||
tan2[1] += bern_1[u][i]*vert_0[1];
|
||||
tan2[2] += bern_1[u][i]*vert_0[2];
|
||||
}
|
||||
/* get normal through cross product of the two tangents of the vertex */
|
||||
norms[o+0] = tan1[1] * tan2[2] - tan1[2] * tan2[1];
|
||||
norms[o+1] = tan1[2] * tan2[0] - tan1[0] * tan2[2];
|
||||
norms[o+2] = tan1[0] * tan2[1] - tan1[1] * tan2[0];
|
||||
len = (GLfloat)sqrt(norms[o+0] * norms[o+0] + norms[o+1] * norms[o+1] + norms[o+2] * norms[o+2]);
|
||||
norms[o+0] /= len;
|
||||
norms[o+1] /= len;
|
||||
norms[o+2] /= len;
|
||||
}
|
||||
}
|
||||
|
||||
/* Fix normal vector if needed */
|
||||
if (normalFix)
|
||||
{
|
||||
for (o=0; o<nSubDivs*3; o+=3) /* whole first row (first nSubDivs normals) is broken: replace normals for the whole row */
|
||||
{
|
||||
norms[o+0] = 0.f;
|
||||
norms[o+1] = normalFix==1? 1.f:-1.f;
|
||||
norms[o+2] = 0.f;
|
||||
}
|
||||
}
|
||||
|
||||
/* now based on flag either rotate patches around y axis to other 3 quadrants (flag=4) or reflect patch across x-y plane (flag=2) */
|
||||
rotOrReflect(flag, nVertVals, nSubDivs, verts);
|
||||
rotOrReflect(flag, nVertVals, nSubDivs, norms);
|
||||
|
||||
return nVertVals*flag;
|
||||
}
|
||||
|
||||
/* verts array should be initialized to 0! */
|
||||
static int evalBezier(GLfloat cp[4][4][3], int nSubDivs, float (*bern_0)[4], int flag, GLfloat *verts)
|
||||
{
|
||||
int nVerts = nSubDivs*nSubDivs;
|
||||
int nVertVals = nVerts*3; /* number of values output for one patch, flag (2 or 4) indicates how many times we will write this to output */
|
||||
int u,v,i,j,o;
|
||||
|
||||
/* generate vertices and coordinates for the patch */
|
||||
for (u=0,o=0; u<nSubDivs; u++)
|
||||
{
|
||||
for (v=0; v<nSubDivs; v++, o+=3)
|
||||
{
|
||||
for (i=0; i<=3; i++)
|
||||
{
|
||||
float vert_0[3]={0};
|
||||
for (j=0; j<=3; j++)
|
||||
{
|
||||
vert_0[0] += bern_0[v][j] * cp[i][j][0];
|
||||
vert_0[1] += bern_0[v][j] * cp[i][j][1];
|
||||
vert_0[2] += bern_0[v][j] * cp[i][j][2];
|
||||
}
|
||||
|
||||
verts[o+0] += bern_0[u][i]*vert_0[0];
|
||||
verts[o+1] += bern_0[u][i]*vert_0[1];
|
||||
verts[o+2] += bern_0[u][i]*vert_0[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* now based on flag either rotate patches around y axis to other 3 quadrants (flag=4) or reflect patch across x-y plane (flag=2) */
|
||||
rotOrReflect(flag, nVertVals, nSubDivs, verts);
|
||||
|
||||
return nVertVals*flag;
|
||||
}
|
||||
|
||||
static void fghTeapot( GLfloat scale, GLboolean useWireMode )
|
||||
{
|
||||
/* for internal use */
|
||||
int p,o;
|
||||
GLfloat cp[4][4][3];
|
||||
/* to hold pointers to static vars/arrays */
|
||||
GLfloat (*bern_0)[4], (*bern_1)[4];
|
||||
GLfloat *verts, *norms, *lastScale;
|
||||
GLushort *vertIdxs;
|
||||
GLboolean * inited;
|
||||
int nSubDivs, nVerts;
|
||||
|
||||
/* Get relevant static arrays and variables */
|
||||
bern_0 = useWireMode ? bernWire_0 : bernSolid_0;
|
||||
bern_1 = useWireMode ? bernWire_1 : bernSolid_1;
|
||||
verts = useWireMode ? vertsWire : vertsSolid;
|
||||
norms = useWireMode ? normsWire : normsSolid;
|
||||
lastScale = useWireMode ? &lastScaleWire : &lastScaleSolid;
|
||||
vertIdxs = useWireMode ? vertIdxsWire : vertIdxsSolid;
|
||||
inited = useWireMode ? &initedWire : &initedSolid;
|
||||
nSubDivs = useWireMode ? GLUT_WIRE_TEAPOT_N_SUBDIV : GLUT_SOLID_TEAPOT_N_SUBDIV;
|
||||
nVerts = useWireMode ? GLUT_WIRE_TEAPOT_N_VERT : GLUT_SOLID_TEAPOT_N_VERT;
|
||||
|
||||
/* check if need to generate vertices */
|
||||
if (!*inited || scale != *lastScale)
|
||||
{
|
||||
printf("regen\n");
|
||||
/* set vertex array to all 0 (not necessary for normals and vertex indices) */
|
||||
memset(verts,0,nVerts*3*sizeof(GLfloat));
|
||||
|
||||
/* pregen Berstein polynomials and their first derivatives (for normals) */
|
||||
if (!*inited)
|
||||
pregenBernstein(nSubDivs,bern_0,bern_1);
|
||||
|
||||
/* generate vertices and normals */
|
||||
for (p=0, o=0; p<GLUT_TEAPOT_N_INPUT_PATCHES; p++)
|
||||
{
|
||||
/* set flags for evalBezier function */
|
||||
int flag = p<6?4:2; /* first six patches get 3 copies (rotations), last four get 2 copies (flips) */
|
||||
int normalFix = p==3?1:p==5?2:0; /* Fix normal vectors for vertices on top of lid (patch 4) and on middle of bottom (patch 6). Different flag value as different normal needed */
|
||||
|
||||
/* collect control points */
|
||||
int i;
|
||||
for (i=0; i<16; i++)
|
||||
{
|
||||
/* Original code draw with a 270° rot around X axis, a scaling and a translation along the Z-axis.
|
||||
* Incorporating these in the control points is much cheaper than transforming all the vertices.
|
||||
* Original:
|
||||
* glRotated( 270.0, 1.0, 0.0, 0.0 );
|
||||
* glScaled( 0.5 * scale, 0.5 * scale, 0.5 * scale );
|
||||
* glTranslated( 0.0, 0.0, -1.5 );
|
||||
*/
|
||||
cp[i/4][i%4][0] = cpdata[patchdata[p][i]][0] *scale/2.f;
|
||||
cp[i/4][i%4][1] = (cpdata[patchdata[p][i]][2]-1.5f)*scale/2.f;
|
||||
cp[i/4][i%4][2] = -cpdata[patchdata[p][i]][1] *scale/2.f;
|
||||
}
|
||||
|
||||
/* eval bezier patch */
|
||||
if (!*inited) /* first time, generate normals as well */
|
||||
o += evalBezierWithNorm(cp,nSubDivs,bern_0,bern_1, flag, normalFix, verts+o,norms+o);
|
||||
else /* only need to regen vertices */
|
||||
o += evalBezier(cp,nSubDivs,bern_0, flag, verts+o);
|
||||
}
|
||||
*lastScale = scale;
|
||||
|
||||
if (!*inited)
|
||||
{
|
||||
int r,c;
|
||||
/* generate texture coordinates if solid teapot */
|
||||
if (!useWireMode)
|
||||
{
|
||||
/* generate for first patch */
|
||||
for (r=0,o=0; r<nSubDivs; r++)
|
||||
{
|
||||
GLfloat u = r/(nSubDivs-1.f);
|
||||
for (c=0; c<nSubDivs; c++, o+=2)
|
||||
{
|
||||
GLfloat v = c/(nSubDivs-1.f);
|
||||
texcsSolid[o+0] = u;
|
||||
texcsSolid[o+1] = v;
|
||||
}
|
||||
}
|
||||
/* copy it over for all the other patches */
|
||||
for (p=1; p<GLUT_TEAPOT_N_PATCHES; p++)
|
||||
memcpy(texcsSolid+p*nSubDivs*nSubDivs*2,texcsSolid,nSubDivs*nSubDivs*2*sizeof(GLfloat));
|
||||
}
|
||||
|
||||
/* build vertex index array */
|
||||
if (useWireMode)
|
||||
{
|
||||
/* build vertex indices to draw teapot as line strips */
|
||||
/* first strips along increasing u, constant v */
|
||||
for (p=0, o=0; p<GLUT_TEAPOT_N_PATCHES; p++)
|
||||
{
|
||||
int idx = nSubDivs*nSubDivs*p;
|
||||
for (c=0; c<nSubDivs; c++)
|
||||
for (r=0; r<nSubDivs; r++, o++)
|
||||
vertIdxs[o] = idx+r*nSubDivs+c;
|
||||
}
|
||||
|
||||
/* then strips along increasing v, constant u */
|
||||
for (p=0; p<GLUT_TEAPOT_N_PATCHES; p++) /* don't reset o, we continue appending! */
|
||||
{
|
||||
int idx = nSubDivs*nSubDivs*p;
|
||||
for (r=0; r<nSubDivs; r++)
|
||||
{
|
||||
int loc = r*nSubDivs;
|
||||
for (c=0; c<nSubDivs; c++, o++)
|
||||
vertIdxs[o] = idx+loc+c;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
glEnd();
|
||||
glBegin( GL_TRIANGLE_STRIP );
|
||||
}
|
||||
}
|
||||
/* build vertex indices to draw teapot as triangles */
|
||||
for (p=0,o=0; p<GLUT_TEAPOT_N_PATCHES; p++)
|
||||
{
|
||||
int idx = nSubDivs*nSubDivs*p;
|
||||
for (r=0; r<nSubDivs-1; r++)
|
||||
{
|
||||
int loc = r*nSubDivs;
|
||||
for (c=0; c<nSubDivs-1; c++, o+=6)
|
||||
{
|
||||
/* ABC ACD, where B and C are one row lower */
|
||||
int row1 = idx+loc+c;
|
||||
int row2 = row1+nSubDivs;
|
||||
|
||||
glEnd();
|
||||
#else
|
||||
for (i = 0; i < 10; i++) {
|
||||
for (j = 0; j < 4; j++) {
|
||||
for (k = 0; k < 4; k++) {
|
||||
for (l = 0; l < 3; l++) {
|
||||
p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
|
||||
q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
|
||||
if (l == 1)
|
||||
q[j][k][l] *= -1.0;
|
||||
if (i < 6) {
|
||||
r[j][k][l] =
|
||||
cpdata[patchdata[i][j * 4 + (3 - k)]][l];
|
||||
if (l == 0)
|
||||
r[j][k][l] *= -1.0;
|
||||
s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
|
||||
if (l == 0)
|
||||
s[j][k][l] *= -1.0;
|
||||
if (l == 1)
|
||||
s[j][k][l] *= -1.0;
|
||||
vertIdxs[o+0] = row1+0;
|
||||
vertIdxs[o+1] = row2+0;
|
||||
vertIdxs[o+2] = row2+1;
|
||||
|
||||
vertIdxs[o+3] = row1+0;
|
||||
vertIdxs[o+4] = row2+1;
|
||||
vertIdxs[o+5] = row1+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
glMap2d(GL_MAP2_TEXTURE_COORD_2, 0.0, 1.0, 2, 2, 0.0, 1.0, 4, 2,
|
||||
&tex[0][0][0]);
|
||||
glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
|
||||
&p[0][0][0]);
|
||||
glMapGrid2d(grid, 0.0, 1.0, grid, 0.0, 1.0);
|
||||
glEvalMesh2(type, 0, grid, 0, grid);
|
||||
glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
|
||||
&q[0][0][0]);
|
||||
glEvalMesh2(type, 0, grid, 0, grid);
|
||||
if (i < 6) {
|
||||
glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
|
||||
&r[0][0][0]);
|
||||
glEvalMesh2(type, 0, grid, 0, grid);
|
||||
glMap2d(GL_MAP2_VERTEX_3, 0.0, 1.0, 3, 4, 0.0, 1.0, 12, 4,
|
||||
&s[0][0][0]);
|
||||
glEvalMesh2(type, 0, grid, 0, grid);
|
||||
*inited = GL_TRUE;
|
||||
}
|
||||
}
|
||||
#endif /* defined(_WIN32_WCE) */
|
||||
|
||||
glPopMatrix();
|
||||
glPopAttrib();
|
||||
/* draw */
|
||||
// TODO: texture coordinates
|
||||
if (useWireMode)
|
||||
fghDrawGeometryWire(verts, norms, nVerts, vertIdxs, GLUT_TEAPOT_N_PATCHES*nSubDivs*2, nSubDivs, GL_LINE_STRIP, NULL,0,0);
|
||||
else
|
||||
fghDrawGeometrySolid(verts,norms,texcsSolid,nVerts,vertIdxs,1,GLUT_SOLID_TEAPOT_N_TRI*3);
|
||||
}
|
||||
|
||||
|
||||
/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Renders a beautiful wired teapot...
|
||||
* Renders a wired teapot...
|
||||
*/
|
||||
void FGAPIENTRY glutWireTeapot( GLdouble size )
|
||||
void FGAPIENTRY glutWireTeapot( double size )
|
||||
{
|
||||
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTeapot" );
|
||||
/* We will use the general teapot rendering code */
|
||||
fghTeapot( 10, size, GL_LINE );
|
||||
fghTeapot( (GLfloat)size, GL_TRUE );
|
||||
}
|
||||
|
||||
/*
|
||||
* Renders a beautiful filled teapot...
|
||||
* Renders a filled teapot...
|
||||
*/
|
||||
void FGAPIENTRY glutSolidTeapot( GLdouble size )
|
||||
void FGAPIENTRY glutSolidTeapot( double size )
|
||||
{
|
||||
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTeapot" );
|
||||
/* We will use the general teapot rendering code */
|
||||
fghTeapot( 7, size, GL_FILL );
|
||||
fghTeapot( (GLfloat)size, GL_FALSE );
|
||||
}
|
||||
|
||||
/*** END OF FILE ***/
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user