#include <gfxlib_struct.h>

Inheritance diagram for GFXSphereVertexList:

Public Member Functions
	GFXSphereVertexList (float radius, int detail, bool insideout, bool reverse_normals)
	creates a vertex list with 1 polytype and a given number of vertices More...

	~GFXSphereVertexList ()

virtual VDAT *	BeginMutate (int offset)
	Returns the array of vertices to be mutated. More...

virtual void	EndMutate (int newsize=0)
	Ends mutation and refreshes display list. More...

virtual void	BeginDrawState (GFXBOOL lock=GFXTRUE)

virtual void	Draw ()
	Draws a single copy of the mass-loaded vlist. More...

virtual void	EndDrawState (GFXBOOL lock=GFXTRUE)

virtual void	GetPolys (GFXVertex *vert, int numPolys, int *numTris)
	returns a packed vertex list with number of polys and number of tries to passed in arguments. Useful for getting vertex info from a mesh More...

virtual void	ProceduralModification ()
	generates procedural planetdata to the actual detaillevel with the "plasma method" More...

Public Member Functions inherited from GFXVertexList
void	RefreshDisplayList ()
	Propagates modifications to the display list. More...

	GFXVertexList (enum POLYTYPE poly, int numVertices, const GFXVertex vertices, int numindices, bool Mutable=false, unsigned int index=0)
	creates a vertex list with 1 polytype and a given number of vertices More...

	GFXVertexList (enum POLYTYPE poly, int numVertices, const GFXVertex vertices, int numlists, int offsets, bool Mutable=false, unsigned int index=0)
	Creates a vertex list with an arbitrary number of poly types and given vertices, num list and offsets (see above) More...

	GFXVertexList (enum POLYTYPE poly, int numVertices, const GFXColorVertex colors, int numindices, bool Mutable=false, unsigned int index=0)
	Creates a vertex list with 1 poly type and color information to boot. More...

	GFXVertexList (enum POLYTYPE poly, int numVertices, const GFXColorVertex colors, int numlists, int offsets, bool Mutable=false, unsigned int index=0)
	Creates a vertex list with an arbitrary number of poly types and color. More...

virtual	~GFXVertexList ()

virtual int	numTris () const
	Returns number of Triangles in vertex list (counts tri strips) More...

virtual int	numQuads () const
	Returns number of Quads in vertex list (counts quad strips) More...

unsigned int	GetIndex (int offset) const
	Looks up the index in the appropriate short, char or int array. More...

POLYTYPE *	GetPolyType () const

int *	GetOffsets () const

int	GetNumLists () const

bool	hasColor () const

int	GetNumVertices () const

virtual VDAT *	Map (bool read, bool write)

void	UnMap ()

void	LoadDrawState ()
	Loads the draw state (what is active) of a given vlist for mass drawing. More...

void	Draw (enum POLYTYPE poly, int numV)

void	Draw (enum POLYTYPE poly, int numV, unsigned char *index)

void	Draw (enum POLYTYPE poly, int numV, unsigned short *index)

void	Draw (enum POLYTYPE poly, int numV, unsigned int *index)

void	DrawOnce ()
	Loads draw state and prepares to draw only once. More...

Protected Member Functions
virtual void	Draw (enum POLYTYPE poly, const INDEX index, const int numLists, const int offsets)

Protected Member Functions inherited from GFXVertexList
const GFXVertex *	GetVertex (int index) const
	Num vertices allocated. More...

const GFXColorVertex *	GetColorVertex (int index) const

void	Init (enum POLYTYPE poly, int numVertices, const GFXVertex vert, const GFXColorVertex colors, int numlists, int offsets, bool Mutable, unsigned int *indices)
	Init function (call from construtor) More...

void	RenormalizeNormals ()

	GFXVertexList ()

Protected Attributes
float	radius
	Num vertices allocated. More...

GFXVertexList *	sphere

Protected Attributes inherited from GFXVertexList
int	numVertices

union GFXVertexList::VDAT	data

union GFXVertexList::INDEX	index

enum POLYTYPE *	mode
	Array of modes that vertices will be drawn with. More...

bool	unique_mode

int	display_list
	Display list number if list is indeed active. 0 otherwise. More...

int	vbo_data

int	numlists
	number of different mode, drawn lists More...

int *	offsets

char	changed
	If vertex list has been mutated since last draw. Low 3 bits store the stride of the index list (if avail). another bit for if color is presnet. More...

Additional Inherited Members
Static Protected Member Functions inherited from GFXVertexList
static void	VtxCopy (GFXVertexList thus, GFXVertex dst, int offset, int howmany)
	copies nonindexed vertices to dst vertex array More...

static void	ColVtxCopy (GFXVertexList thus, GFXVertex dst, int offset, int howmany)
	Copies nonindex colored vertices to dst vertex array. More...

static void	ColIndVtxCopy (GFXVertexList thus, GFXVertex dst, int offset, int howmany)
	Copies indexed colored vertices to dst vertex array. More...

static void	IndVtxCopy (GFXVertexList thus, GFXVertex dst, int offset, int howmany)
	Copies indexed vertices to dst vertex array. More...

Detailed Description

Definition at line 638 of file gfxlib_struct.h.

Constructor & Destructor Documentation

GFXSphereVertexList::GFXSphereVertexList	(	float	radius,
		int	detail,
		bool	insideout,
		bool	reverse_normals
	)

creates a vertex list with 1 polytype and a given number of vertices

Definition at line 59 of file gl_sphere_list.cpp.

References UniverseUtil::cos(), GFXVertexList::data, GFXVertexList::display_list, g_rho, g_theta, GetS, GetT, GFXQUADSTRIP, GFXVertexList::GFXVertexList(), GFXVertex::i, i, GFXVertexList::INDEX::i, GFXVertexList::index, GFXVertex::j, j, GFXVertex::k, GFXVertexList::mode, GFXVertexList::numlists, GFXVertexList::numVertices, GFXVertexList::offsets, radius, GFXVertex::s, UniverseUtil::sin(), size, sphere, GFXVertex::t, GFXVertex::tw, GFXVertex::tx, GFXVertex::ty, GFXVertex::tz, GFXVertexList::vbo_data, GFXVertexList::VDAT::vertices, GFXVertex::x, x, GFXVertex::y, y, GFXVertex::z, and z.

 {
     this->radius = radius;
     radius = 100000.0f;
     static vector< GFXVertexList* >vlists[4];
     int which = (Insideout ? 1 : 0)+(reverse_normals ? 2 : 0);
     while ( detail >= static_cast<int>(vlists[which].size()) )
         vlists[which].insert( vlists[which].end(), 1+detail-vlists[which].size(), NULL );
     if (vlists[which][detail] == 0) {
         int slices;
         int stacks = slices = detail;
         if (stacks > 12) {
             stacks -= 4;
             slices -= 4;
         } else {
             stacks -= 2;
             slices -= 2;
         }
         float rho_max   = 3.1415926536f;
         float rho_min   = 0.0f;
         float theta_min = 0.0f;
         float theta_max = 2.0f*3.1415926536f;
         float drho, dtheta;
         float x, y, z, tx, ty;
         float s, t, ds, dt;
         int   i, j, imin, imax;
         float nsign = Insideout ? -1.0 : 1.0;
         float normalscale = reverse_normals ? -1.0 : 1.0;
         int   fir   = 0;       //Insideout?1:0;
         int   sec   = 1;       //Insideout?0:1;
         /* Code below adapted from gluSphere */
         drho   = (rho_max-rho_min)/(float) stacks;
         dtheta = (theta_max-theta_min)/(float) slices;
 
         ds     = 1.0f/slices;
         dt     = 1.0f/stacks;
         t = 1.0f;               /* because loop now runs from 0 */
 
         imin   = 0;
         imax   = stacks;
 
         int  numQuadstrips   = stacks;
         //numQuadstrips = 0;
         int *QSOffsets       = new int[numQuadstrips];
 
         //draw intermediate stacks as quad strips
         int  numvertex       = stacks*(slices+1)*2;
         GFXVertex     *vertexlist = new GFXVertex[numvertex];
 
         GFXVertex     *vl    = vertexlist;
         enum POLYTYPE *modes = new enum POLYTYPE[numQuadstrips];
         /*   SetOrientation(Vector(1,0,0),
          *    Vector(0,0,-1),
          *    Vector(0,1,0));//that's the way prop*/                                                                          //taken care of in loading
 
         float rhol[2];
         float thetal[2];
 #define g_rho( i ) ((rhol[((i))&1]))
 #define g_theta( i ) ((thetal[((i))&1]))
 
         g_rho( 0 ) = rho_min;
         for (i = imin; i < imax; i++) {
             GFXVertex *vertexlist = vl+(i*(slices+1)*2);
             g_rho( i+1 ) = (i+1)*drho+rho_min; //FIXME These macros are horrible
 
             s = 0.0;
             g_theta( 0 ) = 0;
             for (j = 0; j <= slices; j++) {
                 g_theta( j+1 ) = (j+1)*dtheta;
 
                 tx = -sin( g_theta( j ) );
                 ty = cos( g_theta( j ) );
                 z  = sin( g_rho( i ) );
                 x  = tx*z;
                 y  = ty*z;
                 z  = nsign*cos( g_rho( i ) );
 
                 //normal
                 vertexlist[j*2+fir].i  = x*normalscale;
                 vertexlist[j*2+fir].k  = -y*normalscale;
                 vertexlist[j*2+fir].j  = z*normalscale;
 
                 //tangent
                 vertexlist[j*2+fir].tx = -ty*normalscale;
                 vertexlist[j*2+fir].tz = -tx*normalscale;
                 vertexlist[j*2+fir].ty = 0;
                 vertexlist[j*2+fir].tw = nsign*normalscale;
 #define GetS( theta, theta_min, theta_max ) ( 1-(theta-theta_min)/(theta_max-theta_min) )
 #define GetT( rho, rho_min, rho_max ) ( 1-(rho-rho_min)/(rho_max-rho_min) )
 
                 //texcoords
                 vertexlist[j*2+fir].s = GetS( g_theta( j ), theta_min, theta_max );                 //1-s;
                 vertexlist[j*2+fir].t = GetT( g_rho( i ), rho_min, rho_max );                 //t;
 
                 //position
                 vertexlist[j*2+fir].x = x*radius;
                 vertexlist[j*2+fir].z = -y*radius;
                 vertexlist[j*2+fir].y = z*radius;
 
                 z = sin( g_rho( i+1 ) );
                 x = tx*z;
                 y = ty*z;
                 z = nsign*cos( g_rho( i+1 ) );
 
                 //normal
                 vertexlist[j*2+sec].i  = x*normalscale;
                 vertexlist[j*2+sec].k  = -y*normalscale;
                 vertexlist[j*2+sec].j  = z*normalscale;
 
                 //tangent
                 vertexlist[j*2+sec].tx = -ty*normalscale;
                 vertexlist[j*2+sec].tz = -tx*normalscale;
                 vertexlist[j*2+sec].ty = 0;
                 vertexlist[j*2+sec].tw = nsign*normalscale;
 
                 //texcoords
                 vertexlist[j*2+sec].s  = GetS( g_theta( j ), theta_min, theta_max );                 //1-s;
                 vertexlist[j*2+sec].t  = GetT( g_rho( i+1 ), rho_min, rho_max );                 //t - dt;
 
                 //position
                 vertexlist[j*2+sec].x  = x*radius;
                 vertexlist[j*2+sec].z  = -y*radius;
                 vertexlist[j*2+sec].y  = z*radius;
 
                 s       += ds;
             }
 
             t           -= dt;
             QSOffsets[i] = (slices+1)*2;
             modes[i]     = GFXQUADSTRIP;
         }
 
 #undef g_rho
 #undef g_theta
 
         vlists[which][detail] = new GFXVertexList( modes, numvertex, vertexlist, numQuadstrips, QSOffsets );
     }
     sphere        = vlists[which][detail];
     numVertices   = sphere->numVertices;
     numlists      = sphere->numlists;
     data.vertices = sphere->data.vertices;
     index.i       = sphere->index.i;
     display_list  = sphere->display_list;
     vbo_data      = sphere->vbo_data;
     mode          = sphere->mode;
     offsets       = sphere->offsets;
 }

GFXSphereVertexList::~GFXSphereVertexList ( )

Definition at line 207 of file gl_sphere_list.cpp.

References GFXVertexList::VDAT::colors, GFXVertexList::data, GFXVertexList::display_list, GFXVertexList::INDEX::i, GFXVertexList::index, GFXVertexList::mode, GFXVertexList::numlists, GFXVertexList::numVertices, GFXVertexList::offsets, GFXVertexList::vbo_data, and GFXVertexList::VDAT::vertices.

 {
     numVertices   = 0;
     data.vertices = 0;
     data.colors   = 0;
     index.i      = 0;
     mode         = 0;
     numlists     = 0;
     display_list = 0;
     offsets      = 0;
     vbo_data     = 0;
 }

Member Function Documentation

void GFXSphereVertexList::BeginDrawState ( GFXBOOL lock = GFXTRUE)

virtual

Loads the draw state (what is active) of a given vlist for mass drawing Specifies array pointers and loads the draw state of a given vlist for mass drawing

Reimplemented from GFXVertexList.

Definition at line 28 of file gl_sphere_list.cpp.

References GFXVertexList::BeginDrawState(), and sphere.

 {
     //
 
     sphere->BeginDrawState( lock );
 }

GFXVertexList::VDAT * GFXSphereVertexList::BeginMutate ( int offset)

virtual

Returns the array of vertices to be mutated.

Reimplemented from GFXVertexList.

Definition at line 51 of file gl_sphere_list.cpp.

 {
     return NULL;
 }

void GFXSphereVertexList::Draw	(	enum POLYTYPE *	poly,
		const INDEX	index,
		const int	numLists,
		const int *	offsets
	)

protectedvirtual

Reimplemented from GFXVertexList.

Definition at line 18 of file gl_sphere_list.cpp.

References GFXVertexList::Draw(), f, radius, and sphere.

 {
     glEnable( GL_NORMALIZE );
     glMatrixMode( GL_MODELVIEW );
     glPushMatrix();
     glScalef( radius/100000.0f, radius/100000.0f, radius/100000.0f );
     sphere->Draw( poly, index, numLists, offsets );
     glPopMatrix();
     glDisable( GL_NORMALIZE );
 }

void GFXSphereVertexList::Draw ( )

virtual

Draws a single copy of the mass-loaded vlist.

Reimplemented from GFXVertexList.

Definition at line 7 of file gl_sphere_list.cpp.

References GFXVertexList::Draw(), f, radius, and sphere.

 {
     glEnable( GL_NORMALIZE );
     glMatrixMode( GL_MODELVIEW );
     glPushMatrix();
     glScalef( radius/100000.0f, radius/100000.0f, radius/100000.0f );
     sphere->Draw();
     glPopMatrix();
     glDisable( GL_NORMALIZE );
 }

void GFXSphereVertexList::EndDrawState ( GFXBOOL lock = GFXTRUE)

virtual

Reimplemented from GFXVertexList.

Definition at line 46 of file gl_sphere_list.cpp.

References GFXVertexList::EndDrawState(), and sphere.

 {
     //
     sphere->EndDrawState( lock );
 }

void GFXSphereVertexList::EndMutate ( int newsize = 0)

virtual

Ends mutation and refreshes display list.

Reimplemented from GFXVertexList.

Definition at line 55 of file gl_sphere_list.cpp.

 {
     assert( 0 );
 }

void GFXSphereVertexList::GetPolys	(	GFXVertex **	vert,
		int *	numPolys,
		int *	numTris
	)

virtual

returns a packed vertex list with number of polys and number of tries to passed in arguments. Useful for getting vertex info from a mesh

Reimplemented from GFXVertexList.

Definition at line 34 of file gl_sphere_list.cpp.

References GFXVertexList::GetPolys(), i, GFXVertexList::numTris(), radius, and sphere.

 {
     sphere->GetPolys( vert, numPolys, numTris );
     int numt  = *numTris;
     int numq  = *numPolys-numt;
     int verts = numt*3+numq*4;
     for (int i = 0; i < verts; ++i) {
         (*vert)[i].x *= radius;
         (*vert)[i].y *= radius;
         (*vert)[i].z *= radius;
     }
 }

void GFXSphereVertexList::ProceduralModification ( )

virtual

generates procedural planetdata to the actual detaillevel with the "plasma method"

Definition at line 637 of file gfxlib_struct.cpp.

References GFXVertexList::BeginMutate(), GFXVertexList::EndMutate(), GFXVertex::GetPosition(), i, j, GFXVertexList::numVertices, CockpitXML::ROWS, SetVector(), GFXVertex::SetVertex(), sphere, VSRandom::uniformInc(), v, Vector, vert, GFXVertexList::VDAT::vertices, and vsrandom.

 {
     GFXVertex* v = sphere->BeginMutate( 0 )->vertices;
         const int ROWS = 28;
         int row[ROWS];
         for(int i=0; i < ROWS; i++) {
             row[i] = numVertices/ROWS*i;
         }
 
         Vector vert[ROWS];
         int direction[ROWS/2];
 
         int last_row_set[ROWS];
         for(int i=0; i < ROWS; i++) {
             last_row_set[i] = 0;
         }
 
         for(int i=0; i < numVertices; i++) {
             for(int j=0; j < ROWS; j++)
                 if(row[j] < numVertices/ROWS*(j+1))
                     vert[j] = v[row[j]].GetPosition();
 
             for(int j=0; j < ROWS/2; j++)
                 direction[j] = (int)vsrandom.uniformInc( 0.0, 5.0 );
             if(i % 4 == 1) {
                 for(int j=0; j < ROWS; j+=2) { 
                     if(direction[j/2] > 2) {
                         SetVector( 1.003, &vert[j] );
                         last_row_set[j] = 1;
                     } else {
                         last_row_set[j] = -1;
                     }
                 }
 
             }
 
             if(i % 4 == 0 ) {
                 for(int j=1; j < ROWS; j+=2) {
                     if(direction[(j-1)/2] > 2) {
                         SetVector( 1.003, &vert[j] );
                         last_row_set[j] = 1;
                     } else {
                         last_row_set[j] = -1;
                     }
                 }
             }
 
             for(int j=0; j < ROWS; j++)
                 if(row[j] < numVertices/ROWS*(j+1))
                     v[row[j]].SetVertex( vert[j] );
 
             for(int j=0; j < ROWS; j++)
                 row[j]++;
         }
 
     sphere->EndMutate( /*numVertices*/ );
 }

Member Data Documentation

float GFXSphereVertexList::radius

protected

Num vertices allocated.

Definition at line 642 of file gfxlib_struct.h.

Referenced by Draw(), GetPolys(), and GFXSphereVertexList().

GFXVertexList* GFXSphereVertexList::sphere

protected

Definition at line 643 of file gfxlib_struct.h.

Referenced by BeginDrawState(), Draw(), EndDrawState(), GetPolys(), GFXSphereVertexList(), and ProceduralModification().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation