#include <sphere.h>

Inheritance diagram for SphereMesh:

Public Member Functions
	SphereMesh ()

virtual int	MeshType () const

virtual void	SelectCullFace (int whichdrawqueue)
	Will draw all undrawn far meshes beyond the range of zbuffer (better be convex). More...

virtual void	RestoreCullFace (int whichdrawqueue)

	SphereMesh (float radius, int stacks, int slices, const char texture, const std::string &technique, const char alpha=NULL, bool insideout=false, const BLENDFUNC a=ONE, const BLENDFUNC b=ZERO, bool envMap=false, float rho_min=0.0, float rho_max=M_PI, float theta_min=0.0, float theta_max=2 *M_PI, FILTER mipmap=MIPMAP, bool reverse_normals=false)

void	Draw (float lod, bool centered=false, const Matrix &m=identity_matrix)

virtual void	ProcessDrawQueue (int whichpass, int which, bool zsort, const QVector &sortctr)

Public Member Functions inherited from Mesh
void	initTechnique (const string &technique)

TechniquePtr	getTechnique () const

void	setTechnique (TechniquePtr tech)

bool	LoadExistant (Mesh *mesh)
	Loads a mesh that has been found in the hash table into this mesh (copying original data) More...

bool	LoadExistant (const string filehash, const Vector &scale, int faction)

	Mesh ()

	Mesh (const Mesh &m)

GFXVertexList *	getVertexList () const

void	setVertexList (GFXVertexList *_vlist)

float	getFramesPerSecond () const

float	getCurrentFrame () const

void	setCurrentFrame (float)

int	getNumAnimationFrames (const string &which=string()) const

int	getNumLOD () const

int	getNumTextureFrames () const

float	getTextureFramesPerSecond () const

double	getTextureCumulativeTime () const

void	setTextureCumulativeTime (double)

bool	getConvex () const

void	setConvex (bool b)

BLENDFUNC	getBlendSrc () const

BLENDFUNC	getBlendDst () const

void	Fork (Mesh &one, Mesh &two, float a, float b, float c, float d)
	Forks the mesh across the plane a,b,c,d into two separate meshes...upon which this may be deleted. More...

virtual	~Mesh ()
	Destructor... kills orig if refcount of orig becomes zero. More...

unsigned int	numFX () const
	Gets number of specialFX. More...

void	EnableSpecialFX ()
	Turns on SpecialFX. More...

unsigned int	numTextures () const

Texture *	texture (int i) const

void	SetBlendMode (BLENDFUNC src, BLENDFUNC dst, bool lodcascade=false)

void	GetPolys (vector< mesh_polygon > &)
	Gets all polygons in this mesh for collision computation. More...

void	SetMaterial (const GFXMaterial &mat)
	Sets the material of this mesh to mat (affects original as well) More...

const GFXMaterial &	GetMaterial () const

GFXBOOL	HasBeenDrawn () const
	If it has already been drawn this frame. More...

void	UnDraw ()
	so one can query if it has or not been drawn More...

Vector const &	Position () const
	Returns center of this mesh. More...

void	Draw (float lod, const Matrix &m=identity_matrix, float toofar=1, int cloak=-1, float nebdist=0, unsigned char damage=0, bool renormalize_normals=false, const MeshFX *mfx=NULL)
	Draws lod pixel wide mesh at Transformation LATER. More...

void	DrawNow (float lod, bool centered, const Matrix &m=identity_matrix, int cloak=-1, float nebdist=0)
	Draws lod pixels wide, mesh at Transformation NOW. If centered, then will center on camera and disable cull. More...

virtual void	ProcessDrawQueue (size_t whichpass, int whichdrawqueue, bool zsort, const QVector &sortctr)
	Will draw all undrawn meshes of this type. More...

void	forceCullFace (GFXBOOL newValue)
	Sets whether or not this unit should be environment mapped. More...

GFXBOOL	getCullFaceForcedOn () const

GFXBOOL	getCullFaceForcedOff () const

void	setEnvMap (GFXBOOL newValue, bool lodcascade=false)

GFXBOOL	getEnvMap () const

void	setLighting (GFXBOOL newValue, bool lodcascade=false)

GFXBOOL	getLighting () const

Vector	corner_min ()
	Returns bounding box values. More...

Vector	corner_max ()

BoundingBox *	getBoundingBox ()
	Returns a physical boudning box in 3space instead of in current unit space. More...

bool	queryBoundingBox (const QVector &start, const float err) const
	queries this bounding box with a vector and radius More...

bool	queryBoundingBox (const QVector &start, const QVector &end, const float err) const
	Queries bounding box with a ray. More...

float	rSize () const
	returns the radial size of this More...

virtual float	clipRadialSize () const

void	UpdateFX (float ttime)
	based on TTL, etc, updates shield effects More...

void	AddDamageFX (const Vector &LocalPos, const Vector &LocalNorm, const float percentage, const GFXColor &color=GFXColor(1, 1, 1, 1))
	Adds a new damage effect with age damage to the part of the unit. Color specifies the shield oclor. More...

void	setVirtualBoundingBox (const Vector &mn, const Vector &mx, float rsize)

Protected Member Functions
virtual float	GetT (float rho, float rho_min, float rho_max) const

virtual float	GetS (float theta, float theta_min, float theta_max) const

virtual Mesh *	AllocNewMeshesEachInSizeofMeshSpace (int num)

void	InitSphere (float radius, int stacks, int slices, const char texture, const std::string &technique, const char alpha=NULL, bool insideout=false, const BLENDFUNC a=ONE, const BLENDFUNC b=ZERO, bool envMap=false, float rho_min=0.0, float rho_max=M_PI, float theta_min=0.0, float theta_max=2 *M_PI, FILTER mipmap=MIPMAP, bool reverse_normals=false, bool subclass=false)

Protected Member Functions inherited from Mesh
void	PostProcessLoading (struct MeshXML *xml, const vector< string > &overrideTexture)

	Mesh (std::string filename, const Vector &scalex, int faction, class Flightgroup *fg, bool orig=false)

void	InitUnit ()
	Setting all values to defaults (good for mesh copying and stuff) More...

Mesh *	getLOD (float lod, bool bBypassDamping=true)
	Returing the mesh relevant to "size" pixels LOD of this mesh. More...

Additional Inherited Members
Static Public Member Functions inherited from Mesh
static Mesh *	LoadMesh (const char filename, const Vector &scalex, int faction, class Flightgroup fg, const std::vector< std::string > &textureOverride=std::vector< std::string >())
	Loading a mesh from an XML file. faction specifies the logos. Orig is for internal (LOD) use only! More...

static vector< Mesh * >	LoadMeshes (const char filename, const Vector &scalex, int faction, class Flightgroup fg, const std::vector< std::string > &textureOverride=std::vector< std::string >())

static vector< Mesh * >	LoadMeshes (VSFileSystem::VSFile &f, const Vector &scalex, int faction, class Flightgroup *fg, std::string hash_name, const std::vector< std::string > &textureOverride=std::vector< std::string >())

static void	ProcessZFarMeshes (bool nocamerasetup=false)

static void	ProcessUndrawnMeshes (bool pushSpecialEffects=false, bool nocamerasetup=false)
	Will draw all undrawn meshes in total If pushSpclFX, the last series of meshes will be drawn with other lighting off. More...

Protected Attributes inherited from Mesh
Vector	local_pos
	the position of the center of this mesh for collision detection More...

int	refcount
	The refcount:: how many meshes are referencing the appropriate original. More...

Vector	mx
	bounding box More...

Vector	mn

float	radialSize
	The radial size of this mesh. More...

int	numlods
	num lods contained in the array of Mesh "orig" More...

float	framespersecond

Mesh *	orig

float	lodsize
	The size that this LOD (if original) comes into effect. More...

Logo *	forcelogos
	The number of force logos on this mesh (original) More...

int	numforcelogo

Logo *	squadlogos
	The number of squad logos on this mesh (original) More...

int	numsquadlogo

GFXVertexList *	vlist
	tri,quad,line, strips, etc More...

unsigned int	myMatNum
	The number of the appropriate material for this mesh (default 0) More...

TechniquePtr	technique
	The technique used to render this mesh. More...

vector< Texture * >	Decal
	The decal relevant to this mesh. More...

Texture *	detailTexture

vector< Vector >	detailPlanes

float	polygon_offset

char	envMapAndLit
	whether this should be environment mapped 0x1 and 0x2 for if it should be lit (ored together) More...

GFXBOOL	will_be_drawn
	Whether this original will be drawn this frame. More...

bool	convex
	The blend functions. More...

unsigned char	alphatest

enum BLENDFUNC	blendSrc

enum BLENDFUNC	blendDst

vector< MeshDrawContext > *	draw_queue
	Support for reorganized rendering. More...

int	draw_sequence
	How transparent this mesh is (in what order should it be rendered in. More...

string	hash_name
	The name of this unit. More...

vector< MeshFX >	LocalFX
	The enabled light effects on this mesh. More...

Static Protected Attributes inherited from Mesh
static Hashtable< std::string, Mesh, MESH_HASTHABLE_SIZE >	meshHashTable
	The hash table of all meshes. More...

static Hashtable< std::string, std::vector< int > , MESH_HASTHABLE_SIZE >	animationSequences

Detailed Description

Definition at line 13 of file sphere.h.

Constructor & Destructor Documentation

SphereMesh::SphereMesh ( )

inline

Definition at line 41 of file sphere.h.

References Mesh::setConvex().

       : SphereMesh() : Mesh()
     {
         setConvex( true );
     }

SphereMesh::SphereMesh	(	float	radius,
		int	stacks,
		int	slices,
		const char *	texture,
		const std::string &	technique,
		const char *	alpha = `NULL`,
		bool	insideout = `false`,
		const BLENDFUNC	a = `ONE`,
		const BLENDFUNC	b = `ZERO`,
		bool	envMap = `false`,
		float	rho_min = `0.0`,
		float	rho_max = `M_PI`,
		float	theta_min = `0.0`,
		float	theta_max = `2 *M_PI`,
		FILTER	mipmap = `MIPMAP`,
		bool	reverse_normals = `false`
	)

inline

Definition at line 51 of file sphere.h.

References a, b, and InitSphere().

     {
         InitSphere( radius,
                     stacks,
                     slices,
                     texture,
                     technique,
                     alpha,
                     insideout,
                     a,
                     b,
                     envMap,
                     rho_min,
                     rho_max,
                     theta_min,
                     theta_max,
                     mipmap,
                     reverse_normals );
     }

Member Function Documentation

virtual Mesh* SphereMesh::AllocNewMeshesEachInSizeofMeshSpace ( int num)

inlineprotectedvirtual

Reimplemented in CityLights.

Definition at line 19 of file sphere.h.

Referenced by InitSphere().

     {
         assert( sizeof (Mesh) == sizeof (*this) );
         return new SphereMesh[num];
     }

void SphereMesh::Draw	(	float	lod,
		bool	centered = `false`,
		const Matrix &	m = `identity_matrix`
	)

Definition at line 244 of file sphere_generic.cpp.

References _Universe, Universe::AccessCamera(), Mesh::Draw(), Camera::GetPosition(), m1, Matrix::p, and QVector.

 {
     if (centered) {
         Matrix m1( m );
         m1.p = QVector( _Universe->AccessCamera()->GetPosition().Transform( m1 ) );
         Mesh::Draw( lod, m1 );
     } else {
         Mesh::Draw( lod, m );
     }
 }

float SphereMesh::GetS	(	float	theta,
		float	theta_min,
		float	theta_max
	)		const

protectedvirtual

Reimplemented in CityLights.

Definition at line 40 of file sphere_generic.cpp.

Referenced by CityLights::GetS(), and InitSphere().

 {
     return 1-(theta-theta_min)/(theta_max-theta_min);
 }

float SphereMesh::GetT	(	float	rho,
		float	rho_min,
		float	rho_max
	)		const

protectedvirtual

Reimplemented in CityLights.

Definition at line 35 of file sphere_generic.cpp.

Referenced by CityLights::GetT(), and InitSphere().

 {
     return 1-(rho-rho_min)/(rho_max-rho_min);
 }

void SphereMesh::InitSphere	(	float	radius,
		int	stacks,
		int	slices,
		const char *	texture,
		const std::string &	technique,
		const char *	alpha = `NULL`,
		bool	insideout = `false`,
		const BLENDFUNC	a = `ONE`,
		const BLENDFUNC	b = `ZERO`,
		bool	envMap = `false`,
		float	rho_min = `0.0`,
		float	rho_max = `M_PI`,
		float	theta_min = `0.0`,
		float	theta_max = `2 *M_PI`,
		FILTER	mipmap = `MIPMAP`,
		bool	reverse_normals = `false`,
		bool	subclass = `false`
	)

protected

Definition at line 68 of file sphere_generic.cpp.

References AllocNewMeshesEachInSizeofMeshSpace(), UniverseUtil::cos(), createAnimatedTexture(), FactionUtil::createTexture(), Mesh::Decal, Mesh::draw_queue, Mesh::draw_sequence, g_game, g_rho, g_theta, GetS(), GetT(), GFXFALSE, GFXQUADSTRIP, GFXTRUE, Mesh::hash_name, GFXVertex::i, i, Mesh::initTechnique(), GFXVertex::j, j, GFXVertex::k, Mesh::LoadExistant(), Mesh::lodsize, M_PI, Mesh::meshHashTable, Mesh::mn, Mesh::mx, NUM_ZBUF_SEQ, Mesh::numlods, Mesh::orig, pixelscalesize, Hashtable< KEY, VALUE, SIZ >::Put(), Mesh::radialSize, Mesh::refcount, GFXVertex::s, Mesh::SetBlendMode(), Mesh::setConvex(), Mesh::setEnvMap(), UniverseUtil::sin(), GFXVertex::t, Mesh::texture(), TEXTURE2D, TEXTURE_2D, XMLSupport::tostring(), truncateByPipe(), game_data_t::use_planet_textures, Vector, Mesh::vlist, GFXVertex::x, x, GFXVertex::y, y, GFXVertex::z, and z.

Referenced by CityLights::CityLights(), and SphereMesh().

 {
     setConvex( true );
     int   numspheres = (stacks+slices)/8;
     if (numspheres < 1)
         numspheres = 1;
     Mesh *oldmesh;
     char  ab[3];
     ab[2]     = '\0';
     ab[1]     = b+'0';
     ab[0]     = a+'0';
     hash_name = string( "@@Sphere" )+"#"+texture+"#"+technique+"#"+XMLSupport::tostring( stacks )+"#"+XMLSupport::tostring( slices )+ab+"#"
                 +XMLSupport::tostring( rho_min )+"#"+XMLSupport::tostring( rho_max );
     if ( LoadExistant( hash_name, Vector( radius, radius, radius ), 0 ) ) {
         return;
     } else {}
     this->orig = AllocNewMeshesEachInSizeofMeshSpace( numspheres ); //FIXME::RISKY::MIGHT HAVE...
     //... DIFFERENT SIZES!!  DON"T YOU DARE ADD XTRA VARS TO SphereMesh calsshave to!
     oldmesh    = this->orig;
     numlods    = numspheres;
     meshHashTable.Put( hash_name, oldmesh );
     radialSize = radius; //MAKE SURE FRUSTUM CLIPPING IS DONE CORRECTLY!!!!!
     mn = Vector( -radialSize, -radialSize, -radialSize );
     mx = Vector( radialSize, radialSize, radialSize );
     vector< MeshDrawContext > *odq = NULL;
     for (int l = 0; l < numspheres; l++) {
         draw_queue = new vector< MeshDrawContext >[NUM_ZBUF_SEQ+1];
         if (subclass || rho_max != M_PI || rho_min != 0.0 || theta_min != 0.0 || theta_max != 2*M_PI)
             odq = draw_queue;
         vlist = NULL;
         if (subclass) {
             if (stacks > 12) {
                 stacks -= 4;
                 slices -= 4;
             } else {
                 stacks -= 2;
                 slices -= 2;
             }
             float drho, dtheta;
             float x, y, z;
             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.0/slices;
             dt     = 1.0/stacks;
             t = 1.0;  /* 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];
             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;
                 s = 0.0;
                 g_theta( 0 ) = 0;
                 for (j = 0; j <= slices; j++) {
                     g_theta( j+1 ) = (j+1)*dtheta;
                     x = -sin( g_theta( j ) )*sin( g_rho( i ) );
                     y = cos( g_theta( j ) )*sin( g_rho( i ) );
                     z = nsign*cos( g_rho( i ) );
                     vertexlist[j*2+fir].i = x*normalscale;
                     vertexlist[j*2+fir].k = -y*normalscale;
                     vertexlist[j*2+fir].j = z*normalscale;
                     vertexlist[j*2+fir].s = GetS( g_theta( j ), theta_min, theta_max ); //1-s;//insideout?1-s:s;
                     vertexlist[j*2+fir].t = GetT( g_rho( i ), rho_min, rho_max ); //t;
                     vertexlist[j*2+fir].x = x*radius;
                     vertexlist[j*2+fir].z = -y*radius;
                     vertexlist[j*2+fir].y = z*radius;
                     x = -sin( g_theta( j ) )*sin( g_rho( i+1 ) );
                     y = cos( g_theta( j ) )*sin( g_rho( i+1 ) );
                     z = nsign*cos( g_rho( i+1 ) );
                     vertexlist[j*2+sec].i = x*normalscale;
                     vertexlist[j*2+sec].k = -y*normalscale;
                     vertexlist[j*2+sec].j = z*normalscale; //double negative
                     vertexlist[j*2+sec].s = GetS( g_theta( j ), theta_min, theta_max ); //1-s;//insideout?1-s:s;
                     vertexlist[j*2+sec].t = GetT( g_rho( i+1 ), rho_min, rho_max ); //t - dt;
                     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
             vlist = new GFXVertexList( modes, numvertex, vertexlist, numQuadstrips, QSOffsets );
             delete[] vertexlist;
             delete[] modes;
             delete[] QSOffsets;
         } else {
             vlist = new GFXSphereVertexList( radius, stacks > slices ? stacks : slices, Insideout, reverse_normals );
         }
         SetBlendMode( a, b );
         string inputtex    = texture;
         unsigned int count = 0;
         if ( Decal.empty() )
             Decal.push_back( NULL );
         while ( inputtex.length() ) {
             string thistex = truncateByPipe( inputtex );
             while (Decal.size() <= count)
                 Decal.push_back( NULL );
             if (thistex.find( ".ani" ) != string::npos) {
                 Decal[count] = createAnimatedTexture( thistex.c_str(), 0, mipmap );
             } else {
                 if (alpha) {
                     Decal[count] =
                         createTexture( thistex.c_str(), alpha, 0, mipmap, TEXTURE2D, TEXTURE_2D, 1, 0,
                                        (Insideout || g_game.use_planet_textures) ? GFXTRUE : GFXFALSE );
                 } else {
                     Decal[count] =
                         createTexture(
                             thistex.c_str(), 0, mipmap, TEXTURE2D, TEXTURE_2D,
                             (Insideout || g_game.use_planet_textures) ? GFXTRUE : GFXFALSE );
                 }
             }
             count++;
         }
         Insideout ? setEnvMap( GFXFALSE ) : setEnvMap( envMapping );
         if (Insideout)
             draw_sequence = 0;
         Mesh *oldorig = orig;
         refcount = 1;
         orig     = NULL;
         if (l >= 1) {
             lodsize = (numspheres+1-l)*pixelscalesize;
             if (l == 1)
                 lodsize *= 2;
             else if (l == 2)
                 lodsize *= 1.75;
             else if (l == 3)
                 lodsize *= 1.5;
         }
         initTechnique( technique );
         oldmesh[l] = *this;
         refcount   = 0;
         orig = oldorig;
         lodsize    = FLT_MAX;
     }
     draw_queue     = odq;
 }

virtual int SphereMesh::MeshType ( ) const

inlinevirtual

Reimplemented from Mesh.

Definition at line 45 of file sphere.h.

     {
         return 1;
     }

void SphereMesh::ProcessDrawQueue	(	int	whichpass,
		int	which,
		bool	zsort,
		const QVector &	sortctr
	)

virtual

Reimplemented in CityLights.

Definition at line 23 of file sphere.cpp.

References getSphereColor(), GFXGetLightContextAmbient(), GFXLightContextAmbient(), GFXPolygonOffset(), and Mesh::ProcessDrawQueue().

 {
     static GFXColor spherecol( getSphereColor() );
     GFXColor tmpcol( 0, 0, 0, 1 );
     GFXGetLightContextAmbient( tmpcol );
     GFXLightContextAmbient( spherecol );
     Mesh::ProcessDrawQueue( whichpass, whichdrawqueue, zsort, sortctr );
     GFXLightContextAmbient( tmpcol );
     GFXPolygonOffset( 0, 0 );
 }

void SphereMesh::RestoreCullFace ( int whichdrawqueue)

virtual

Reimplemented from Mesh.

Definition at line 255 of file sphere_generic.cpp.

 {
     //always right
 }

void SphereMesh::SelectCullFace ( int whichdrawqueue)

virtual

Will draw all undrawn far meshes beyond the range of zbuffer (better be convex).

Reimplemented from Mesh.

Definition at line 34 of file sphere.cpp.

References CULLFACE, and GFXEnable().

 {
     GFXEnable( CULLFACE );
 }

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

src/gfx/sphere.h
src/gfx/sphere.cpp
src/gfx/sphere_generic.cpp
src/gfx/sphere_server.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation