Renderer Class Reference

#include <render.h>

Collaboration diagram for Renderer:

List of all members.

Public Types
enum	{   NoLabels = 0x000, StarLabels = 0x001, PlanetLabels = 0x002, MoonLabels = 0x004,   ConstellationLabels = 0x008, GalaxyLabels = 0x010, AsteroidLabels = 0x020, SpacecraftLabels = 0x040,   LocationLabels = 0x080, CometLabels = 0x100, NebulaLabels = 0x200, OpenClusterLabels = 0x400,   I18nConstellationLabels = 0x800, BodyLabelMask = (PlanetLabels | MoonLabels | AsteroidLabels | SpacecraftLabels | CometLabels) }
enum	{   ShowNothing = 0x0000, ShowStars = 0x0001, ShowPlanets = 0x0002, ShowGalaxies = 0x0004,   ShowDiagrams = 0x0008, ShowCloudMaps = 0x0010, ShowOrbits = 0x0020, ShowCelestialSphere = 0x0040,   ShowNightMaps = 0x0080, ShowAtmospheres = 0x0100, ShowSmoothLines = 0x0200, ShowEclipseShadows = 0x0400,   ShowStarsAsPoints = 0x0800, ShowRingShadows = 0x1000, ShowBoundaries = 0x2000, ShowAutoMag = 0x4000,   ShowCometTails = 0x8000, ShowMarkers = 0x10000, ShowPartialTrajectories = 0x20000, ShowNebulae = 0x40000,   ShowOpenClusters = 0x80000 }
enum	StarStyle { FuzzyPointStars = 0, PointStars = 1, ScaledDiscStars = 2, StarStyleCount = 3 }
Public Member Functions
void	addLabel (std::string, Color, const Point3f &, float depth=-1)
void	addLabelledStar (Star *, const std::string &)
void	addSortedLabel (std::string, Color, const Point3f &)
void	autoMag (float &faintestMag)
float	calcPixelSize (float fov, float windowHeight)
void	clearLabelledStars ()
void	clearLabels ()
bool	fragmentShaderSupported () const
float	getAmbientLightLevel () const
float	getBrightnessBias () const
float	getDistanceLimit () const
float	getFaintestAM45deg ()
TextureFont *	getFont () const
bool	getFragmentShaderEnabled () const
GLContext *	getGLContext ()
int	getLabelMode () const
float	getMinimumFeatureSize () const
float	getMinimumOrbitSize () const
int	getOrbitMask () const
int	getRenderFlags () const
unsigned int	getResolution ()
float	getSaturationMagnitude () const
int	getScreenDpi () const
const ColorTemperatureTable *	getStarColorTable () const
StarStyle	getStarStyle () const
bool	getVertexShaderEnabled () const
bool	init (GLContext *, int, int, DetailOptions &)
void	loadTextures (Body *)
void	render (const Observer &, const Universe &, float faintestVisible, const Selection &sel)
	Renderer ()
void	resize (int, int)
void	setAmbientLightLevel (float)
void	setBrightnessBias (float)
void	setDistanceLimit (float)
void	setFaintestAM45deg (float)
void	setFont (TextureFont *)
void	setFragmentShaderEnabled (bool)
void	setLabelMode (int)
void	setMinimumFeatureSize (float)
void	setMinimumOrbitSize (float)
void	setOrbitMask (int)
void	setRenderFlags (int)
void	setRenderMode (int)
void	setResolution (unsigned int resolution)
void	setSaturationMagnitude (float)
void	setScreenDpi (int)
void	setStarColorTable (const ColorTemperatureTable *)
void	setStarStyle (StarStyle)
void	setVertexShaderEnabled (bool)
void	shutdown ()
bool	vertexShaderSupported () const
	~Renderer ()
Private Types
typedef ObjectLabel< DeepSkyObject >	DSOLabel
typedef ObjectLabel< Star >	StarLabel
Private Member Functions
void	labelConstellations (const AsterismList &asterisms, const Observer &observer)
void	labelStars (const std::vector< StarLabel > &labelledStars, const StarDatabase &, const Observer &)
void	renderBodyAsParticle (Point3f center, float appMag, float _faintestMag, float discSizeInPixels, Color color, const Quatf &orientation, float renderDistance, bool useHaloes)
void	renderCelestialSphere (const Observer &observer)
void	renderCometTail (const Body &body, Point3f pos, float distance, float appMag, double now, Quatf orientation, const vector< LightSource > &lightSources, float, float)
void	renderDeepSkyObjects (const Universe &, const Observer &, float faintestMagNight)
void	renderEllipsoidAtmosphere (const Atmosphere &atmosphere, Point3f center, const Quatf &orientation, Vec3f semiAxes, const Vec3f &sunDirection, Color ambientColor, float fade, bool lit)
void	renderForegroundOrbits (const PlanetarySystem *system, const Point3f &center, float distance, float discSizeInPixels, const Selection &sel, double t)
void	renderLabels ()
void	renderLocations (const vector< Location * > &locations, const Quatf &cameraOrientation, const Point3f &position, const Quatf &orientation, float scale)
void	renderMarkers (const MarkerList &, const UniversalCoord &position, const Quatf &orientation, double jd)
void	renderObject (Point3f pos, float distance, double now, Quatf cameraOrientation, float nearPlaneDistance, float farPlaneDistance, RenderProperties &obj, const LightingState &)
void	renderOrbit (Body *, double)
void	renderOrbits (PlanetarySystem *, const Selection &, double, const Point3d &, const Point3d &)
void	renderParticles (const std::vector< Particle > &particles, Quatf orientation)
void	renderPlanet (Body &body, Point3f pos, float distance, float appMag, double now, Quatf orientation, const vector< LightSource > &lightSources, float, float)
void	renderPlanetarySystem (const Star &sun, const PlanetarySystem &solSystem, const Observer &observer, double now, unsigned int solarSysIndex, bool showLabels=false)
std::vector< Label >::iterator	renderSortedLabels (std::vector< Label >::iterator, float depth)
void	renderStar (const Star &star, Point3f pos, float distance, float appMag, Quatf orientation, double now, float, float)
void	renderStars (const StarDatabase &starDB, float faintestVisible, const Observer &observer)
void	setFieldOfView (float)
bool	testEclipse (const Body &receiver, const Body &caster, const DirectionalLight &light, double now, vector< EclipseShadow > &shadows)
Private Attributes
Color	ambientColor
float	ambientLightLevel
float	brightnessBias
float	brightnessScale
const ColorTemperatureTable *	colorTemp
GLContext *	context
float	corrFac
std::vector< Label >	depthSortedLabels
DetailOptions	detailOptions
std::string	displayedSurface
float	distanceLimit
std::vector< EclipseShadow >	eclipseShadows [MaxLights]
float	faintestAutoMag45deg
float	faintestMag
float	faintestPlanetMag
TextureFont *	font
float	fov
bool	fragmentShaderEnabled
std::vector< Particle >	glareParticles
std::vector< DSOLabel >	labelledDSOs
std::vector< StarLabel >	labelledStars
int	labelMode
std::vector< Label >	labels
std::vector< LightSource >	lightSourceLists [MaxSolarSystems]
uint32	locationFilter
float	minFeatureSize
float	minOrbitSize
double	modelMatrix [16]
std::vector< const Star * >	nearStars
std::vector< CachedOrbit * >	orbitCache
int	orbitMask
float	pixelSize
double	projMatrix [16]
int	renderFlags
std::vector< RenderListEntry >	renderList
int	renderMode
float	saturationMag
float	saturationMagNight
int	screenDpi
SkyContourPoint *	skyContour
uint32 *	skyIndices
SkyVertex *	skyVertices
StarStyle	starStyle
StarVertexBuffer *	starVertexBuffer
unsigned int	textureResolution
bool	useClampToBorder
bool	useCompressedTextures
bool	usePointSprite
bool	useRescaleNormal
bool	useVertexPrograms
bool	vertexShaderEnabled
int	windowHeight
int	windowWidth
Classes
struct	CachedOrbit
struct	DetailOptions
struct	Label
struct	LightSource
struct	ObjectLabel
struct	OrbitSample
struct	Particle
class	PointStarVertexBuffer
struct	RenderProperties
struct	SkyContourPoint
struct	SkyVertex
class	StarVertexBuffer

---

Member Typedef Documentation

typedef ObjectLabel<DeepSkyObject> Renderer::DSOLabel [private]

Definition at line 313 of file render.h.

typedef ObjectLabel<Star> Renderer::StarLabel [private]

Definition at line 312 of file render.h.

---

Member Enumeration Documentation

anonymous enum

Enumeration values: NoLabels  StarLabels  PlanetLabels  MoonLabels  ConstellationLabels  GalaxyLabels  AsteroidLabels  SpacecraftLabels  LocationLabels  CometLabels  NebulaLabels  OpenClusterLabels  I18nConstellationLabels  BodyLabelMask  Definition at line 74 of file render.h. { NoLabels = 0x000, StarLabels = 0x001, PlanetLabels = 0x002, MoonLabels = 0x004, ConstellationLabels = 0x008, GalaxyLabels = 0x010, AsteroidLabels = 0x020, SpacecraftLabels = 0x040, LocationLabels = 0x080, CometLabels = 0x100, NebulaLabels = 0x200, OpenClusterLabels = 0x400, I18nConstellationLabels = 0x800, BodyLabelMask = (PlanetLabels | MoonLabels | AsteroidLabels | SpacecraftLabels | CometLabels), };

anonymous enum

Enumeration values: ShowNothing  ShowStars  ShowPlanets  ShowGalaxies  ShowDiagrams  ShowCloudMaps  ShowOrbits  ShowCelestialSphere  ShowNightMaps  ShowAtmospheres  ShowSmoothLines  ShowEclipseShadows  ShowStarsAsPoints  ShowRingShadows  ShowBoundaries  ShowAutoMag  ShowCometTails  ShowMarkers  ShowPartialTrajectories  ShowNebulae  ShowOpenClusters  Definition at line 91 of file render.h. { ShowNothing = 0x0000, ShowStars = 0x0001, ShowPlanets = 0x0002, ShowGalaxies = 0x0004, ShowDiagrams = 0x0008, ShowCloudMaps = 0x0010, ShowOrbits = 0x0020, ShowCelestialSphere = 0x0040, ShowNightMaps = 0x0080, ShowAtmospheres = 0x0100, ShowSmoothLines = 0x0200, ShowEclipseShadows = 0x0400, ShowStarsAsPoints = 0x0800, ShowRingShadows = 0x1000, ShowBoundaries = 0x2000, ShowAutoMag = 0x4000, ShowCometTails = 0x8000, ShowMarkers = 0x10000, ShowPartialTrajectories = 0x20000, ShowNebulae = 0x40000, ShowOpenClusters = 0x80000, };

enum Renderer::StarStyle

Enumeration values: FuzzyPointStars  PointStars  ScaledDiscStars  StarStyleCount  Definition at line 115 of file render.h. { FuzzyPointStars = 0, PointStars = 1, ScaledDiscStars = 2, StarStyleCount = 3, };

---

Constructor & Destructor Documentation

Renderer::Renderer (   )

Definition at line 132 of file render.cpp. References ColorTable_Enhanced, colorTemp, FOV, GetStarColorTable(), MaxSkyRings, MaxSkySlices, medres, MinFeatureSizeForLabel, MinOrbitSizeForLabel, skyContour, skyIndices, skyVertices, and starVertexBuffer. : context(0), windowWidth(0), windowHeight(0), fov(FOV), screenDpi(96), corrFac(1.12f), faintestAutoMag45deg(7.0f), renderMode(GL_FILL), labelMode(NoLabels), renderFlags(ShowStars | ShowPlanets), orbitMask(Body::Planet | Body::Moon), ambientLightLevel(0.1f), fragmentShaderEnabled(false), vertexShaderEnabled(false), brightnessBias(0.0f), saturationMagNight(1.0f), saturationMag(1.0f), starStyle(FuzzyPointStars), starVertexBuffer(NULL), useVertexPrograms(false), useRescaleNormal(false), usePointSprite(false), textureResolution(medres), minOrbitSize(MinOrbitSizeForLabel), distanceLimit(1.0e6f), minFeatureSize(MinFeatureSizeForLabel), locationFilter(~0), colorTemp(NULL) { starVertexBuffer = new StarVertexBuffer(2048); skyVertices = new SkyVertex[MaxSkySlices * (MaxSkyRings + 1)]; skyIndices = new uint32[(MaxSkySlices + 1) * 2 * MaxSkyRings]; skyContour = new SkyContourPoint[MaxSkySlices + 1]; colorTemp = GetStarColorTable(ColorTable_Enhanced); }

Renderer::~Renderer (   )

Definition at line 170 of file render.cpp. References skyContour, skyIndices, skyVertices, and starVertexBuffer. { if (starVertexBuffer != NULL) delete starVertexBuffer; delete[] skyVertices; delete[] skyIndices; delete[] skyContour; }

---

Member Function Documentation

void Renderer::addLabel (  std::string  , Color  , const Point3f &  , float  depth = -1 )

Definition at line 773 of file render.cpp. References Renderer::Label::color, labels, modelMatrix, Renderer::Label::position, projMatrix, ReplaceGreekLetterAbbr(), Renderer::Label::text, windowHeight, and windowWidth. Referenced by labelConstellations(), labelStars(), DSORenderer::process(), and renderCelestialSphere(). { double winX, winY, winZ; int view[4] = { 0, 0, 0, 0 }; view[0] = -windowWidth / 2; view[1] = -windowHeight / 2; view[2] = windowWidth; view[3] = windowHeight; depth = (float) (pos.x * modelMatrix[2] + pos.y * modelMatrix[6] + pos.z * modelMatrix[10]); if (gluProject(pos.x, pos.y, pos.z, modelMatrix, projMatrix, (const GLint*) view, &winX, &winY, &winZ) != GL_FALSE) { Label l; l.text = ReplaceGreekLetterAbbr(text.c_str()); l.color = color; l.position = Point3f((float) winX, (float) winY, -depth); labels.insert(labels.end(), l); } }

void Renderer::addLabelledStar (  Star *  , const std::string &  )

Definition at line 681 of file render.cpp. References labelledStars. Referenced by CelestiaCore::initRenderer(). { labelledStars.push_back(StarLabel(star, label)); }

void Renderer::addSortedLabel (  std::string  , Color  , const Point3f &  )

Definition at line 802 of file render.cpp. References _, Renderer::Label::color, depthSortedLabels, modelMatrix, Renderer::Label::position, projMatrix, ReplaceGreekLetterAbbr(), Renderer::Label::text, windowHeight, and windowWidth. Referenced by renderPlanetarySystem(). { double winX, winY, winZ; int view[4] = { 0, 0, 0, 0 }; view[0] = -windowWidth / 2; view[1] = -windowHeight / 2; view[2] = windowWidth; view[3] = windowHeight; float depth = (float) (pos.x * modelMatrix[2] + pos.y * modelMatrix[6] + pos.z * modelMatrix[10]); if (gluProject(pos.x, pos.y, pos.z, modelMatrix, projMatrix, (const GLint*) view, &winX, &winY, &winZ) != GL_FALSE) { Label l; l.text = ReplaceGreekLetterAbbr(_(text.c_str())); l.color = color; l.position = Point3f((float) winX, (float) winY, -depth); depthSortedLabels.insert(depthSortedLabels.end(), l); } }

void Renderer::autoMag (  float &  faintestMag  )

Definition at line 1188 of file render.cpp. References faintestAutoMag45deg, faintestMag, fov, FOV, saturationMag, saturationMagNight, and sqrt(). Referenced by render(), and CelestiaCore::setFaintestAutoMag(). { float fieldCorr = 2.0f * FOV/(fov + FOV); faintestMag = (float) (faintestAutoMag45deg * sqrt(fieldCorr)); saturationMag = saturationMagNight * (1.0f + fieldCorr * fieldCorr); }

float Renderer::calcPixelSize (  float  fov, float  windowHeight )

Definition at line 577 of file render.cpp. References degToRad(). Referenced by render(). { return 2 * (float) tan(degToRad(fovY / 2.0)) / (float) windowHeight; }

void Renderer::clearLabelledStars (   )

Definition at line 687 of file render.cpp. References labelledStars. { labelledStars.clear(); }

void Renderer::clearLabels (   )

Definition at line 828 of file render.cpp. References depthSortedLabels, and labels. Referenced by render(). { labels.clear(); depthSortedLabels.clear(); }

bool Renderer::fragmentShaderSupported (   )  const

Definition at line 752 of file render.cpp. References GLContext::bumpMappingSupported(), and context. Referenced by setFragmentShaderEnabled(). { return context->bumpMappingSupported(); }

float Renderer::getAmbientLightLevel (   )  const

Definition at line 693 of file render.cpp. References ambientLightLevel. Referenced by celestia_getambient(), CelestiaCore::charEntered(), GetCurrentPreferences(), KdePreferencesDialog::KdePreferencesDialog(), KdeApp::queryExit(), KdePreferencesDialog::slotApply(), and syncMenusWithRendererState(). { return ambientLightLevel; }

float Renderer::getBrightnessBias (   )  const

Definition at line 7023 of file render.cpp. References brightnessBias. { return brightnessBias; }

float Renderer::getDistanceLimit (   )  const

Definition at line 730 of file render.cpp. References distanceLimit. Referenced by celestia_getstardistancelimit(), and ViewOptionsDialog::SetControls(). { return distanceLimit; }

float Renderer::getFaintestAM45deg (   )

Definition at line 603 of file render.cpp. References faintestAutoMag45deg. Referenced by celestia_getfaintestvisible(), CelestiaCore::charEntered(), CelestiaCore::initRenderer(), and DSORenderer::process(). { return faintestAutoMag45deg; }

TextureFont * Renderer::getFont (   )  const

Definition at line 621 of file render.cpp. References font. { return font; }

bool Renderer::getFragmentShaderEnabled (   )  const

Definition at line 742 of file render.cpp. References fragmentShaderEnabled. { return fragmentShaderEnabled; }

GLContext* Renderer::getGLContext (   )  [inline]

Definition at line 151 of file render.h. References context. Referenced by CelestiaCore::charEntered(), GetCurrentPreferences(), KdeGlWidget::initializeGL(), KdePreferencesDialog::KdePreferencesDialog(), CommandRenderPath::process(), KdeApp::queryExit(), KdeApp::resyncMenus(), KdePreferencesDialog::setRenderPathLabel(), KdePreferencesDialog::slotApply(), KdePreferencesDialog::slotCancel(), KdePreferencesDialog::slotRenderPath(), KdeApp::slotSetRenderPathARBFPARBVP(), KdeApp::slotSetRenderPathBasic(), KdeApp::slotSetRenderPathDOT3ARBVP(), KdeApp::slotSetRenderPathGLSL(), KdeApp::slotSetRenderPathMultitexture(), KdeApp::slotSetRenderPathNV30(), KdeApp::slotSetRenderPathNvCombiner(), KdeApp::slotSetRenderPathNvCombinerARBVP(), KdeApp::slotSetRenderPathNvCombinerNvVP(), and WinMain(). { return context; }

int Renderer::getLabelMode (   )  const

Definition at line 646 of file render.cpp. References labelMode. Referenced by celestia_getlabelflags(), celestia_hidelabel(), celestia_setlabelflags(), celestia_showlabel(), CelestiaCore::charEntered(), GetCurrentPreferences(), KdeApp::initActions(), KdePreferencesDialog::KdePreferencesDialog(), LocationsProc(), MainWindowProc(), CommandLabels::process(), KdeApp::queryExit(), KdeApp::resyncMenus(), ViewOptionsDialog::SetControls(), LocationsDialog::SetControls(), KdePreferencesDialog::slotApply(), KdeApp::slotShowAsteroidLabels(), KdeApp::slotShowCometLabels(), KdeApp::slotShowConstellationLabels(), KdeApp::slotShowGalaxyLabels(), KdeApp::slotShowI18nConstellationLabels(), KdeApp::slotShowLocationLabels(), KdeApp::slotShowMoonLabels(), KdeApp::slotShowNebulaLabels(), KdeApp::slotShowOpenClusterLabels(), KdeApp::slotShowPlanetLabels(), KdeApp::slotShowSpacecraftLabels(), KdeApp::slotShowStarLabels(), syncMenusWithRendererState(), Url::Url(), and ViewOptionsProc(). { return labelMode; }

float Renderer::getMinimumFeatureSize (   )  const

Definition at line 705 of file render.cpp. References minFeatureSize. Referenced by celestia_getminfeaturesize(), KdePreferencesDialog::KdePreferencesDialog(), LocationsProc(), KdeApp::queryExit(), LocationsDialog::SetControls(), and KdePreferencesDialog::slotApply(). { return minFeatureSize; }

float Renderer::getMinimumOrbitSize (   )  const

Definition at line 717 of file render.cpp. References minOrbitSize. Referenced by celestia_getminorbitsize(). { return minOrbitSize; }

int Renderer::getOrbitMask (   )  const

Definition at line 656 of file render.cpp. References orbitMask. Referenced by celestia_getorbitflags(), celestia_setorbitflags(), GetCurrentPreferences(), KdeApp::initActions(), KdePreferencesDialog::KdePreferencesDialog(), CommandOrbitFlags::process(), KdeApp::queryExit(), KdeApp::resyncMenus(), ViewOptionsDialog::SetControls(), KdeApp::slotShowAsteroidOrbits(), KdeApp::slotShowCometOrbits(), KdeApp::slotShowMoonOrbits(), KdeApp::slotShowPlanetOrbits(), KdeApp::slotShowSpacecraftOrbits(), and ViewOptionsProc(). { return orbitMask; }

int Renderer::getRenderFlags (   )  const

Definition at line 636 of file render.cpp. References renderFlags. Referenced by celestia_getfaintestvisible(), celestia_getrenderflags(), celestia_hide(), celestia_setfaintestvisible(), celestia_setrenderflags(), celestia_show(), CelestiaCore::charEntered(), GetCurrentPreferences(), KdeApp::initActions(), CelestiaCore::initRenderer(), CelestiaCore::initSimulation(), KdePreferencesDialog::KdePreferencesDialog(), MainWindowProc(), CelestiaCore::mouseButtonUp(), CelestiaCore::mouseMove(), CommandRenderFlags::process(), KdeApp::queryClose(), KdeApp::queryExit(), KdeApp::resyncMenus(), ViewOptionsDialog::SetControls(), KdePreferencesDialog::slotApply(), KdeApp::slotShowAtmospheres(), KdeApp::slotShowAutoMag(), KdeApp::slotShowBoundaries(), KdeApp::slotShowCelestialSphere(), KdeApp::slotShowCloudMaps(), KdeApp::slotShowCometTails(), KdeApp::slotShowDiagrams(), KdeApp::slotShowEclipseShadows(), KdeApp::slotShowGalaxies(), KdeApp::slotShowNebulae(), KdeApp::slotShowNightMaps(), KdeApp::slotShowOpenClusters(), KdeApp::slotShowOrbits(), KdeApp::slotShowPartialTrajectories(), KdeApp::slotShowPlanets(), KdeApp::slotShowRingShadows(), KdeApp::slotShowSmoothLines(), KdeApp::slotShowStars(), syncMenusWithRendererState(), LuaState::tick(), Url::Url(), and ViewOptionsProc(). { return renderFlags; }

unsigned int Renderer::getResolution (   )

Definition at line 608 of file render.cpp. References textureResolution. Referenced by CelestiaCore::charEntered(), and GetCurrentPreferences(). { return textureResolution; }

float Renderer::getSaturationMagnitude (   )  const

Definition at line 7011 of file render.cpp. References saturationMag. { return saturationMag; }

int Renderer::getScreenDpi (   )  const

Definition at line 588 of file render.cpp. References screenDpi. Referenced by DSORenderer::process(). { return screenDpi; }

const ColorTemperatureTable * Renderer::getStarColorTable (   )  const

Definition at line 668 of file render.cpp. References colorTemp. Referenced by CelestiaCore::charEntered(). { return colorTemp; }

Renderer::StarStyle Renderer::getStarStyle (   )  const

Definition at line 7041 of file render.cpp. References starStyle. Referenced by celestia_getstarstyle(), CelestiaCore::charEntered(), GetCurrentPreferences(), MainWindowProc(), and syncMenusWithRendererState(). { return starStyle; }

bool Renderer::getVertexShaderEnabled (   )  const

Definition at line 757 of file render.cpp. References vertexShaderEnabled. { return vertexShaderEnabled; }

bool Renderer::init (  GLContext *  , int  , int  , DetailOptions &  )

Definition at line 379 of file render.cpp. References buggyVertexProgramEmulation, commonDataInitialized, context, coordLabels, CreateProceduralCubeMap(), CreateProceduralTexture(), SphericalCoordLabel::dec, detailOptions, DPRINTF, eclipseShadowTextures, Renderer::DetailOptions::eclipseTextureSize, GLContext::extensionSupported(), GL_RESCALE_NORMAL_EXT, glareTex, GlareTextureEval(), IllumMapEval(), SphericalCoordLabel::label, LoadTextureFromFile(), lodSphere, nCoordLabels, normalizationTex, PenumbraFunctionEval(), penumbraFunctionTexture, SphericalCoordLabel::ra, resize(), Texture::setBorderColor(), shadowMaskTexture, shadowTex, ShadowTextureEval(), Renderer::DetailOptions::shadowTextureSize, starTex, StarTextureEval(), useClampToBorder, usePointSprite, and useRescaleNormal. Referenced by CelestiaCore::initRenderer(). { context = _context; detailOptions = _detailOptions; // Initialize static meshes and textures common to all instances of Renderer if (!commonDataInitialized) { lodSphere = new LODSphereMesh(); starTex = CreateProceduralTexture(64, 64, GL_RGB, StarTextureEval); glareTex = LoadTextureFromFile("textures/flare.jpg"); if (glareTex == NULL) glareTex = CreateProceduralTexture(64, 64, GL_RGB, GlareTextureEval); // Max mipmap level doesn't work reliably on all graphics // cards. In particular, Rage 128 and TNT cards resort to software // rendering when this feature is enabled. The only workaround is to // disable mipmapping completely unless texture border clamping is // supported, which solves the problem much more elegantly than all // the mipmap level nonsense. // shadowTex->setMaxMipMapLevel(3); Texture::AddressMode shadowTexAddress = Texture::EdgeClamp; Texture::MipMapMode shadowTexMip = Texture::NoMipMaps; useClampToBorder = context->extensionSupported("GL_ARB_texture_border_clamp"); if (useClampToBorder) { shadowTexAddress = Texture::BorderClamp; shadowTexMip = Texture::DefaultMipMaps; } shadowTex = CreateProceduralTexture(detailOptions.shadowTextureSize, detailOptions.shadowTextureSize, GL_RGB, ShadowTextureEval, shadowTexAddress, shadowTexMip); shadowTex->setBorderColor(Color::White); // Create the eclipse shadow textures { for (int i = 0; i < 4; i++) { ShadowTextureFunction func(i * 0.25f); eclipseShadowTextures[i] = CreateProceduralTexture(detailOptions.eclipseTextureSize, detailOptions.eclipseTextureSize, GL_RGB, func, shadowTexAddress, shadowTexMip); if (eclipseShadowTextures[i] != NULL) { // eclipseShadowTextures[i]->setMaxMipMapLevel(2); eclipseShadowTextures[i]->setBorderColor(Color::White); } } } // Create the shadow mask texture { ShadowMaskTextureFunction func; shadowMaskTexture = CreateProceduralTexture(128, 2, GL_RGBA, func); //shadowMaskTexture->bindName(); } // Create a function lookup table in a texture for use with // fragment program eclipse shadows. penumbraFunctionTexture = CreateProceduralTexture(512, 1, GL_LUMINANCE, PenumbraFunctionEval, Texture::EdgeClamp); if (context->extensionSupported("GL_EXT_texture_cube_map")) { // normalizationTex = CreateNormalizationCubeMap(64); normalizationTex = CreateProceduralCubeMap(64, GL_RGB, IllumMapEval); } // Create labels for celestial sphere { char buf[10]; int i; coordLabels = new SphericalCoordLabel[nCoordLabels]; for (i = 0; i < 12; i++) { coordLabels[i].ra = float(i * 2); coordLabels[i].dec = 0; sprintf(buf, "%dh", i * 2); coordLabels[i].label = string(buf); } coordLabels[12] = SphericalCoordLabel(0, -75); coordLabels[13] = SphericalCoordLabel(0, -60); coordLabels[14] = SphericalCoordLabel(0, -45); coordLabels[15] = SphericalCoordLabel(0, -30); coordLabels[16] = SphericalCoordLabel(0, -15); coordLabels[17] = SphericalCoordLabel(0, 15); coordLabels[18] = SphericalCoordLabel(0, 30); coordLabels[19] = SphericalCoordLabel(0, 45); coordLabels[20] = SphericalCoordLabel(0, 60); coordLabels[21] = SphericalCoordLabel(0, 75); for (i = 22; i < nCoordLabels; i++) { coordLabels[i].ra = 12; coordLabels[i].dec = coordLabels[i - 10].dec; } for (i = 12; i < nCoordLabels; i++) { char buf[10]; sprintf(buf, "%d", (int) coordLabels[i].dec); coordLabels[i].label = string(buf); } } commonDataInitialized = true; } if (context->extensionSupported("GL_EXT_rescale_normal")) { // We need this enabled because we use glScale, but only // with uniform scale factors. DPRINTF(1, "Renderer: EXT_rescale_normal supported.\n"); useRescaleNormal = true; glEnable(GL_RESCALE_NORMAL_EXT); } if (context->extensionSupported("GL_ARB_point_sprite")) { DPRINTF(1, "Renderer: point sprites supported.\n"); usePointSprite = true; } // Ugly renderer-specific bug workarounds follow . . . char* glRenderer = (char*) glGetString(GL_RENDERER); if (glRenderer != NULL) { // Fog is broken with vertex program emulation in most versions of // the GF 1 and 2 drivers; we need to detect this and disable // vertex programs which output fog coordinates if (strstr(glRenderer, "GeForce3") != NULL || strstr(glRenderer, "GeForce4") != NULL) { buggyVertexProgramEmulation = false; } if (strstr(glRenderer, "Savage4") != NULL || strstr(glRenderer, "ProSavage") != NULL) { // S3 Savage4 drivers appear to rescale normals without reporting // EXT_rescale_normal. Lighting will be messed up unless // we set the useRescaleNormal flag. useRescaleNormal = true; } } // More ugly hacks; according to Matt Craighead at NVIDIA, an NVIDIA // OpenGL driver that reports version 1.3.1 or greater will have working // fog in emulated vertex programs. char* glVersion = (char*) glGetString(GL_VERSION); if (glVersion != NULL) { int major = 0, minor = 0, extra = 0; int nScanned = sscanf(glVersion, "%d.%d.%d", &major, &minor, &extra); if (nScanned >= 2) { if (major > 1 || minor > 3 || (minor == 3 && extra >= 1)) buggyVertexProgramEmulation = false; } } glLoadIdentity(); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_COLOR_MATERIAL); glEnable(GL_LIGHTING); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); // LEQUAL rather than LESS required for multipass rendering glDepthFunc(GL_LEQUAL); resize(winWidth, winHeight); return true; }

void Renderer::labelConstellations (  const AsterismList &  asterisms, const Observer &  observer )  [private]

Definition at line 6787 of file render.cpp. References addLabel(), conjugate(), Asterism::getChain(), Asterism::getChainCount(), Asterism::getName(), I18nConstellationLabels, labelMode, Vector3< T >::x, Vector3< T >::y, and Vector3< T >::z. Referenced by render(). { Point3f observerPos = (Point3f) observer.getPosition(); for (AsterismList::const_iterator iter = asterisms.begin(); iter != asterisms.end(); iter++) { Asterism* ast = *iter; if (ast->getChainCount() > 0) { const Asterism::Chain& chain = ast->getChain(0); if (chain.size() > 0) { // The constellation label is positioned at the average // position of all stars in the first chain. This usually // gives reasonable results. Vec3f avg(0, 0, 0); for (Asterism::Chain::const_iterator iter = chain.begin(); iter != chain.end(); iter++) avg += (*iter - Point3f(0, 0, 0)); avg = avg / (float) chain.size(); avg = avg * 1e6f; Vec3f rpos = Point3f(avg.x, avg.y, avg.z) - observerPos; if ((rpos * conjugate(observer.getOrientation()).toMatrix3()).z < 0) { addLabel(ast->getName(labelMode & I18nConstellationLabels), Color(0.5f, 0.0f, 1.0f, 1.0f), Point3f(rpos.x, rpos.y, rpos.z)); } } } } }

void Renderer::labelStars (  const std::vector< StarLabel > &  labelledStars, const StarDatabase &  , const Observer &  )  [private]

Definition at line 6748 of file render.cpp. References astro::absToAppMag(), addLabel(), conjugate(), distance(), distanceLimit, Point3< T >::distanceTo(), faintestMag, Star::getAbsoluteMagnitude(), Star::getPosition(), astro::heliocentricPosition(), labelledStars, Vector3< T >::x, Point3< T >::x, Vector3< T >::y, Point3< T >::y, Vector3< T >::z, and Point3< T >::z. Referenced by render(). { Point3f observerPos_ly = (Point3f) observer.getPosition() * 1e-6f; for (vector<StarLabel>::const_iterator iter = labelledStars.begin(); iter != labelledStars.end(); ++iter) { Star* star = iter->obj; Point3f pos = star->getPosition(); float distance = pos.distanceTo(observerPos_ly); float appMag = (distance > 0.0f) ? astro::absToAppMag(star->getAbsoluteMagnitude(), distance) : -100.0f; if (appMag < faintestMag && distance <= distanceLimit) { Vec3f rpos = pos - observerPos_ly; // Use a more accurate and expensive calculation if the // distance to the star is less than a light year. Single // precision arithmetic isn't good enough when we're very close // to the star. if (distance < 1.0f) { Point3d hpos = astro::heliocentricPosition(observer.getPosition(), pos); rpos = Vec3f((float) -hpos.x, (float) -hpos.y, (float) -hpos.z); } if ((rpos * conjugate(observer.getOrientation()).toMatrix3()).z < 0) { addLabel(iter->label, Color(0.3f, 0.3f, 1.0f), Point3f(rpos.x, rpos.y, rpos.z)); } } } }

void Renderer::loadTextures (  Body *   )

Definition at line 7378 of file render.cpp. References Surface::appearanceFlags, Surface::baseTexture, GLContext::bumpMappingSupported(), Surface::bumpTexture, context, MultiResTexture::find(), InvalidResource, Surface::nightTexture, renderFlags, ShowCloudMaps, ShowNightMaps, Surface::specularTexture, MultiResTexture::tex, and textureResolution. Referenced by object_preloadtexture(), and CommandPreloadTextures::process(). { Surface& surface = body->getSurface(); if (surface.baseTexture.tex[textureResolution] != InvalidResource) surface.baseTexture.find(textureResolution); if ((surface.appearanceFlags & Surface::ApplyBumpMap) != 0 && context->bumpMappingSupported() && surface.bumpTexture.tex[textureResolution] != InvalidResource) surface.bumpTexture.find(textureResolution); if ((surface.appearanceFlags & Surface::ApplyNightMap) != 0 && (renderFlags & ShowNightMaps) != 0) surface.nightTexture.find(textureResolution); if ((surface.appearanceFlags & Surface::SeparateSpecularMap) != 0 && surface.specularTexture.tex[textureResolution] != InvalidResource) surface.specularTexture.find(textureResolution); if ((renderFlags & ShowCloudMaps) != 0 && body->getAtmosphere() != NULL && body->getAtmosphere()->cloudTexture.tex[textureResolution] != InvalidResource) { body->getAtmosphere()->cloudTexture.find(textureResolution); } if (body->getRings() != NULL && body->getRings()->texture.tex[textureResolution] != InvalidResource) { body->getRings()->texture.find(textureResolution); } }

void Renderer::render (  const Observer &  , const Universe &  , float  faintestVisible, const Selection &  sel )

Definition at line 1248 of file render.cpp. References ambientColor, ambientLightLevel, astrocentricPosition(), autoMag(), Texture::bind(), Color::blue(), BodyLabelMask, brightnessScale, calcPixelSize(), Math< T >::clamp(), clearLabels(), conjugate(), ConstellationLabels, CoronaHeight, cos(), degToRad(), depthSortedLabels, disableSmoothLines(), displayedSurface, distance(), Point3< T >::distanceFromOrigin(), enableSmoothLines(), faintestMag, faintestPlanetMag, FAR_DIST, fov, Asterism::getChain(), SolarSystem::getPlanets(), glAmbientLightColor(), glRotate(), glVertex(), Color::green(), Atmosphere::height, InvalidResource, labelConstellations(), labelledStars, labelMode, labels, labelStars(), lightSourceLists, locationFilter, max, MaxFarNearRatio, min, MinNearPlaneDistance, modelMatrix, NEAR_DIST, nearStars, Vector3< T >::normalize(), orbitCache, orbitMask, pixelSize, projMatrix, radToDeg(), Color::red(), renderCelestialSphere(), renderCometTail(), renderDeepSkyObjects(), renderFlags, renderForegroundOrbits(), renderLabels(), renderList, renderMarkers(), renderMode, renderOrbits(), renderPlanet(), renderPlanetarySystem(), renderSortedLabels(), renderStar(), renderStars(), saturationMag, saturationMagNight, Matrix3< float >::scaling(), setFieldOfView(), setupLightSources(), ShowAtmospheres, ShowAutoMag, ShowBoundaries, ShowCelestialSphere, ShowDiagrams, ShowMarkers, ShowOrbits, ShowPlanets, ShowSmoothLines, ShowStars, sqrt(), square(), StarLabels, starTex, Frustum::testSphere(), Quaternion< T >::w, windowHeight, windowWidth, Quaternion< T >::x, Point3< T >::x, Quaternion< T >::y, Point3< T >::y, Quaternion< T >::z, and Point3< T >::z. Referenced by DSORenderer::process(). { // Get the observer's time double now = observer.getTime(); // Compute the size of a pixel setFieldOfView(radToDeg(observer.getFOV())); pixelSize = calcPixelSize(fov, (float) windowHeight); // Set up the projection we'll use for rendering stars. glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(fov, (float) windowWidth / (float) windowHeight, NEAR_DIST, FAR_DIST); // Set the modelview matrix glMatrixMode(GL_MODELVIEW); // Get the displayed surface texture set to use from the observer displayedSurface = observer.getDisplayedSurface(); locationFilter = observer.getLocationFilter(); // Set up the camera Point3f observerPos = (Point3f) observer.getPosition(); observerPos.x *= 1e-6f; observerPos.y *= 1e-6f; observerPos.z *= 1e-6f; glPushMatrix(); glRotate(observer.getOrientation()); // Get the model matrix *before* translation. We'll use this for // positioning star and planet labels. glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); glGetDoublev(GL_PROJECTION_MATRIX, projMatrix); clearLabels(); // Put all solar system bodies into the render list. Stars close and // large enough to have discernible surface detail are also placed in // renderList. renderList.clear(); // See if we want to use AutoMag. if ((renderFlags & ShowAutoMag) != 0) { autoMag(faintestMag); } else { faintestMag = faintestMagNight; saturationMag = saturationMagNight; } // Automatic FOV-based adjustment of limiting magnitude for solar system // objects. Now that we have the automag feature, this hack should no // longer be required. // faintestPlanetMag = faintestMag + (2.5f * (float) log10((double) square(45.0f / fov))); faintestPlanetMag = faintestMag; if (renderFlags & ShowPlanets) { nearStars.clear(); universe.getNearStars(observer.getPosition(), 1.0f, nearStars); unsigned int solarSysIndex = 0; for (vector<const Star*>::const_iterator iter = nearStars.begin(); iter != nearStars.end(); iter++) { const Star* sun = *iter; SolarSystem* solarSystem = universe.getSolarSystem(sun); if (solarSystem != NULL) { setupLightSources(nearStars, *sun, now, lightSourceLists[solarSysIndex]); renderPlanetarySystem(*sun, *solarSystem->getPlanets(), observer, now, solarSysIndex, (labelMode & (BodyLabelMask)) != 0); solarSysIndex++; } } starTex->bind(); } Color skyColor(0.0f, 0.0f, 0.0f); // Scan through the render list to see if we're inside a planetary // atmosphere. If so, we need to adjust the sky color as well as the // limiting magnitude of stars (so stars aren't visible in the daytime // on planets with thick atmospheres.) if ((renderFlags & ShowAtmospheres) != 0) { for (vector<RenderListEntry>::iterator iter = renderList.begin(); iter != renderList.end(); iter++) { if (iter->body != NULL && iter->body->getAtmosphere() != NULL) { // Compute the density of the atmosphere, and from that // the amount light scattering. It's complicated by the // possibility that the planet is oblate and a simple distance // to sphere calculation will not suffice. const Atmosphere* atmosphere = iter->body->getAtmosphere(); float radius = iter->body->getRadius(); float oblateness = iter->body->getOblateness(); Vec3f recipSemiAxes(1.0f, 1.0f / (1.0f - oblateness), 1.0f); Mat3f A = Mat3f::scaling(recipSemiAxes); Vec3f eyeVec = iter->position - Point3f(0.0f, 0.0f, 0.0f); eyeVec *= (1.0f / radius); // Compute the orientation of the planet before axial rotation Quatd qd = iter->body->getEclipticalToEquatorial(now); Quatf q((float) qd.w, (float) qd.x, (float) qd.y, (float) qd.z); eyeVec = eyeVec * conjugate(q).toMatrix3(); // ellipDist is not the true distance from the surface unless // the planet is spherical. The quantity that we do compute // is the distance to the surface along a line from the eye // position to the center of the ellipsoid. float ellipDist = (float) sqrt((eyeVec * A) * (eyeVec * A)) - 1.0f; if (ellipDist < atmosphere->height / radius && atmosphere->height > 0.0f) { float density = 1.0f - ellipDist / (atmosphere->height / radius); if (density > 1.0f) density = 1.0f; Vec3f sunDir = iter->sun; Vec3f normal = Point3f(0.0f, 0.0f, 0.0f) - iter->position; sunDir.normalize(); normal.normalize(); float illumination = Math<float>::clamp((sunDir * normal) + 0.2f); float lightness = illumination * density; faintestMag = faintestMag - 15.0f * lightness; saturationMag = saturationMag - 15.0f * lightness; } } } } // Now we need to determine how to scale the brightness of stars. The // brightness will be proportional to the apparent magnitude, i.e. // a logarithmic function of the stars apparent brightness. This mimics // the response of the human eye. We sort of fudge things here and // maintain a minimum range of four magnitudes between faintest visible // and saturation; this keeps stars from popping in or out as the sun // sets or rises. if (faintestMag - saturationMag >= 4.0f) brightnessScale = 1.0f / (faintestMag - saturationMag); else brightnessScale = 0.25f; ambientColor = Color(ambientLightLevel, ambientLightLevel, ambientLightLevel); // Create the ambient light source. For realistic scenes in space, this // should be black. glAmbientLightColor(ambientColor); glClearColor(skyColor.red(), skyColor.green(), skyColor.blue(), 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glDisable(GL_LIGHTING); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); if ((renderFlags & ShowCelestialSphere) != 0) { glColor4f(0.3f, 0.7f, 0.7f, 0.55f); glDisable(GL_TEXTURE_2D); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); renderCelestialSphere(observer); if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); } if (universe.getDSOCatalog() != NULL) renderDeepSkyObjects(universe, observer, faintestMag); // Translate the camera before rendering the stars glPushMatrix(); glTranslatef(-observerPos.x, -observerPos.y, -observerPos.z); // Render stars glBlendFunc(GL_SRC_ALPHA, GL_ONE); if ((renderFlags & ShowStars) != 0 && universe.getStarCatalog() != NULL) renderStars(*universe.getStarCatalog(), faintestMag, observer); // Render asterisms if ((renderFlags & ShowDiagrams) != 0 && universe.getAsterisms() != NULL) { glColor4f(0.28f, 0.0f, 0.66f, 0.96f); glDisable(GL_TEXTURE_2D); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); AsterismList* asterisms = universe.getAsterisms(); for (AsterismList::const_iterator iter = asterisms->begin(); iter != asterisms->end(); iter++) { Asterism* ast = *iter; for (int i = 0; i < ast->getChainCount(); i++) { const Asterism::Chain& chain = ast->getChain(i); glBegin(GL_LINE_STRIP); for (Asterism::Chain::const_iterator iter = chain.begin(); iter != chain.end(); iter++) glVertex(*iter); glEnd(); } } if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); } if ((renderFlags & ShowBoundaries) != 0) { glColor4f(0.8f, 0.33f, 0.63f, 0.35f); glDisable(GL_TEXTURE_2D); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); if (universe.getBoundaries() != NULL) universe.getBoundaries()->render(); if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); } if ((labelMode & StarLabels) != 0 && universe.getStarCatalog() != NULL) labelStars(labelledStars, *universe.getStarCatalog(), observer); if ((labelMode & ConstellationLabels) != 0 && universe.getAsterisms() != NULL) labelConstellations(*universe.getAsterisms(), observer); glPopMatrix(); // Render orbit paths if ((renderFlags & ShowOrbits) != 0 && orbitMask != 0) { // Clear the keep flag for all orbits in the cache; if they're not // used when rendering this frame, they'll get marked for // recycling. vector<CachedOrbit*>::const_iterator iter; for (iter = orbitCache.begin(); iter != orbitCache.end(); iter++) (*iter)->keep = false; glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); for (vector<const Star*>::const_iterator starIter = nearStars.begin(); starIter != nearStars.end(); starIter++) { const Star* sun = *starIter; SolarSystem* solarSystem = universe.getSolarSystem(sun); if (solarSystem != NULL) { Point3d obsPos = astrocentricPosition(observer.getPosition(), *sun, observer.getTime()); glPushMatrix(); glTranslatef((float) astro::kilometersToAU(-obsPos.x), (float) astro::kilometersToAU(-obsPos.y), (float) astro::kilometersToAU(-obsPos.z)); renderOrbits(solarSystem->getPlanets(), sel, now, obsPos, Point3d(0.0, 0.0, 0.0)); glPopMatrix(); } } if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); // Mark for recycling all unused orbits in the cache for (iter = orbitCache.begin(); iter != orbitCache.end(); iter++) { if (!(*iter)->keep) (*iter)->body = NULL; } } renderLabels(); glPolygonMode(GL_FRONT, (GLenum) renderMode); glPolygonMode(GL_BACK, (GLenum) renderMode); { Frustum frustum(degToRad(fov), (float) windowWidth / (float) windowHeight, MinNearPlaneDistance); Mat3f viewMat = conjugate(observer.getOrientation()).toMatrix3(); // Remove objects from the render list that lie completely outside the // view frustum. vector<RenderListEntry>::iterator notCulled = renderList.begin(); for (vector<RenderListEntry>::iterator iter = renderList.begin(); iter != renderList.end(); iter++) { Point3f center = iter->position * viewMat; bool convex = true; float radius = 1.0f; float cullRadius = 1.0f; float cloudHeight = 0.0f; if (iter->body != NULL) { radius = iter->body->getBoundingRadius(); if (iter->body->getRings() != NULL) { radius = iter->body->getRings()->outerRadius; convex = false; } if (iter->body->getModel() != InvalidResource) convex = false; cullRadius = radius; if (iter->body->getAtmosphere() != NULL) { cullRadius += iter->body->getAtmosphere()->height; cloudHeight = iter->body->getAtmosphere()->cloudHeight; } } else if (iter->star != NULL) { radius = iter->star->getRadius(); cullRadius = radius * (1.0f + CoronaHeight); } // Test the object's bounding sphere against the view frustum if (frustum.testSphere(center, cullRadius) != Frustum::Outside) { float nearZ = center.distanceFromOrigin() - radius; float maxSpan = (float) sqrt(square((float) windowWidth) + square((float) windowHeight)); nearZ = -nearZ * (float) cos(degToRad(fov / 2)) * ((float) windowHeight / maxSpan); if (nearZ > -MinNearPlaneDistance) iter->nearZ = -MinNearPlaneDistance; else iter->nearZ = nearZ; if (!convex) { iter->farZ = center.z - radius; if (iter->farZ / iter->nearZ > MaxFarNearRatio) iter->nearZ = iter->farZ / MaxFarNearRatio; } else { // Make the far plane as close as possible float d = center.distanceFromOrigin(); // Account for the oblateness float eradius = radius; if (iter->body != NULL) eradius *= 1.0f - iter->body->getOblateness(); if (d > eradius) { // Multiply by a factor to eliminate overaggressive // clipping due to limited floating point precision iter->farZ = (float) (sqrt(square(d) - square(eradius)) * -1.1); } else { // We're inside the bounding sphere (and, if the planet // is spherical, inside the planet.) iter->farZ = iter->nearZ * 2.0f; } if (cloudHeight > 0.0f && d < eradius + cloudHeight) { // If there's a cloud layer, we need to move the // far plane out so that the clouds aren't clipped float cloudLayerRadius = eradius + cloudHeight; iter->farZ -= (float) sqrt(square(cloudLayerRadius) - square(eradius)); } } *notCulled = *iter; notCulled++; } } renderList.resize(notCulled - renderList.begin()); // The calls to renderSolarSystem/renderStars filled renderList // with visible planetary bodies. Sort it by distance, then // render each entry. stable_sort(renderList.begin(), renderList.end()); // Sort the labels sort(depthSortedLabels.begin(), depthSortedLabels.end()); int nEntries = renderList.size(); // Determine how to split up the depth buffer. Typically, each body // with an apparent size greater than one pixel is allocated its own // depth buffer range. However, this will not correctly handle // overlapping objects. If two objects overlap in depth, we attempt // to coalesce their depth buckets. Coalescing will succeed as long // as the far / near plane ratio is not too large. If it does exceed // the limit, coaslescing fails and the objects may not be rendered // correctly, though the result should be superior to throwing away // depth buffer precision by allowing the far / near ratio to get too // large. int nDepthBuckets = 1; int i; { float lastNear = 0.0f; float lastFar = 0.0f; int firstCoalesced = 0; for (i = 0; i < nEntries; i++) { // Don't worry about objects that are smaller than a pixel, // as they'll just be rendered as points. if (renderList[i].discSizeInPixels > 1) { if (nDepthBuckets == 1 || renderList[i].nearZ <= lastFar) { // This object doesn't overlap any others in depth, // no need to coaslesce. nDepthBuckets++; firstCoalesced = i; lastNear = renderList[i].nearZ; lastFar = renderList[i].farZ; } else { // Consider coalescing this object with the previous // one. float farthest = min(lastFar, renderList[i].farZ); float nearest = max(lastNear, renderList[i].nearZ); static int blah = 0; // Need just a bit of slack in the farthest/nearest // ratio test. if (farthest / nearest < MaxFarNearRatio * 1.01f) { // Far/near ratio is acceptable, so coalesce // this object's depth bucket with the previous // one. for (int j = firstCoalesced; j <= i; j++) { renderList[j].farZ = farthest; renderList[j].nearZ = nearest; } #if DEBUG_COALESCE clog << "Coalesce #" << i << ": " << renderList[i].body->getName() << ", " << nearest << ", " << farthest << " -- " << blah++ << '\n'; #endif lastNear = nearest; lastFar = farthest; } else { // Coalesce failed, so create a new depth bucket // for this object. nDepthBuckets++; firstCoalesced = i; lastNear = renderList[i].nearZ; lastFar = renderList[i].farZ; #if DEBUG_COALESCE clog << "Coalesce #" << i << ": " << renderList[i].body->getName() << " failed! " << nearest << ", " << farthest << " -- " << blah++ << '\n'; #endif } } renderList[i].depthBucket = nDepthBuckets - 1; } } } float depthRange = 1.0f / (float) nDepthBuckets; int depthBucket = nDepthBuckets - 1; i = nEntries - 1; // Set up the depth bucket. glDepthRange(depthBucket * depthRange, (depthBucket + 1) * depthRange); // Set the initial near and far plane distance; any reasonable choice // for these will do, since different values will be chosen as soon // as we need to render a body as a mesh. float nearPlaneDistance = 1.0f; float farPlaneDistance = 10.0f; glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(fov, (float) windowWidth / (float) windowHeight, nearPlaneDistance, farPlaneDistance); glMatrixMode(GL_MODELVIEW); vector<Label>::iterator label = depthSortedLabels.begin(); // Render all the bodies in the render list. for (i = nEntries - 1; i >= 0; i--) { label = renderSortedLabels(label, -renderList[i].farZ); if (renderList[i].discSizeInPixels > 1) { depthBucket = renderList[i].depthBucket; glDepthRange(depthBucket * depthRange, (depthBucket + 1) * depthRange); nearPlaneDistance = renderList[i].nearZ * -0.9f; farPlaneDistance = renderList[i].farZ * -1.5f; if (nearPlaneDistance < MinNearPlaneDistance) nearPlaneDistance = MinNearPlaneDistance; if (farPlaneDistance / nearPlaneDistance > MaxFarNearRatio) farPlaneDistance = nearPlaneDistance * MaxFarNearRatio; glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(fov, (float) windowWidth / (float) windowHeight, nearPlaneDistance, farPlaneDistance); glMatrixMode(GL_MODELVIEW); } if (renderList[i].body != NULL) { if (renderList[i].isCometTail) { renderCometTail(*renderList[i].body, renderList[i].position, renderList[i].distance, renderList[i].appMag, now, observer.getOrientation(), lightSourceLists[renderList[i].solarSysIndex], nearPlaneDistance, farPlaneDistance); } else { renderPlanet(*renderList[i].body, renderList[i].position, renderList[i].distance, renderList[i].appMag, now, observer.getOrientation(), lightSourceLists[renderList[i].solarSysIndex], nearPlaneDistance, farPlaneDistance); renderForegroundOrbits(renderList[i].body->getSatellites(), renderList[i].position, renderList[i].distance, renderList[i].discSizeInPixels, sel, now); } } else if (renderList[i].star != NULL) { renderStar(*renderList[i].star, renderList[i].position, renderList[i].distance, renderList[i].appMag, observer.getOrientation(), now, nearPlaneDistance, farPlaneDistance); } // If this body is larger than a pixel, we rendered it as a mesh // instead of just a particle. We move to the next depth buffer // bucket before proceeding with further rendering. if (renderList[i].discSizeInPixels > 1) { depthBucket--; glDepthRange(depthBucket * depthRange, (depthBucket + 1) * depthRange); } } renderSortedLabels(label, 0.0f); // reset the depth range glDepthRange(0, 1); } glPopMatrix(); glEnable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glPolygonMode(GL_FRONT, GL_FILL); glPolygonMode(GL_BACK, GL_FILL); { Mat3f m = observer.getOrientation().toMatrix3(); for (int i = 0; i < (int) labels.size(); i++) { } } if ((renderFlags & ShowMarkers) != 0) { renderMarkers(*universe.getMarkers(), observer.getPosition(), observer.getOrientation(), now); } glDisable(GL_BLEND); glDepthMask(GL_TRUE); glEnable(GL_LIGHTING); #if 0 int errCode = glGetError(); if (errCode != GL_NO_ERROR) { cout << "glError: " << (char*) gluErrorString(errCode) << '\n'; } #endif }

void Renderer::renderBodyAsParticle (  Point3f  center, float  appMag, float  _faintestMag, float  discSizeInPixels, Color  color, const Quatf &  orientation, float  renderDistance, bool  useHaloes )  [private]

Definition at line 1915 of file render.cpp. References abs(), Texture::bind(), brightnessBias, brightnessScale, clamp(), conjugate(), corrFac, fov, FOV, glareTex, glColor(), glVertex(), MaxScaledDiscStarSize, min, pixelSize, saturationMag, ScaledDiscStars, starStyle, starTex, Point3< T >::x, Point3< T >::y, and Point3< T >::z. Referenced by renderPlanet(), and renderStar(). { float maxDiscSize = (starStyle == ScaledDiscStars) ? MaxScaledDiscStarSize : 1.0f; float maxBlendDiscSize = maxDiscSize + 3.0f; float discSize = 1.0f; if (discSizeInPixels < maxBlendDiscSize || useHaloes) { float a = 1; float fade = 1.0f; if (discSizeInPixels > maxDiscSize) { fade = (maxBlendDiscSize - discSizeInPixels) / (maxBlendDiscSize - maxDiscSize - 1.0f); if (fade > 1) fade = 1; } a = (_faintestMag - appMag) * brightnessScale + brightnessBias; if (starStyle == ScaledDiscStars && a > 1.0f) discSize = min(discSize * (2.0f * a - 1.0f), maxDiscSize); a = clamp(a) * fade; // We scale up the particle by a factor of 1.6 (at fov = 45deg) // so that it's more // visible--the texture we use has fuzzy edges, and if we render it // in just one pixel, it's likely to disappear. Also, the render // distance is scaled by a factor of 0.1 so that we're rendering in // front of any mesh that happens to be sharing this depth bucket. // What we really want is to render the particle with the frontmost // z value in this depth bucket, and scaling the render distance is // just hack to accomplish this. There are cases where it will fail // and a more robust method should be implemented. float size = discSize * pixelSize * 1.6f * renderZ / corrFac; float posScale = abs(renderZ / (position * conjugate(orientation).toMatrix3()).z); Point3f center(position.x * posScale, position.y * posScale, position.z * posScale); Mat3f m = orientation.toMatrix3(); Vec3f v0 = Vec3f(-1, -1, 0) * m; Vec3f v1 = Vec3f( 1, -1, 0) * m; Vec3f v2 = Vec3f( 1, 1, 0) * m; Vec3f v3 = Vec3f(-1, 1, 0) * m; starTex->bind(); glColor(color, a); glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex(center + (v0 * size)); glTexCoord2f(1, 0); glVertex(center + (v1 * size)); glTexCoord2f(1, 1); glVertex(center + (v2 * size)); glTexCoord2f(0, 1); glVertex(center + (v3 * size)); glEnd(); // If the object is brighter than magnitude 1, add a halo around it to // make it appear more brilliant. This is a hack to compensate for the // limited dynamic range of monitors. // // TODO: Currently, this is extremely broken. Stars look fine, // but planets look ridiculous with bright haloes. if (useHaloes && appMag < saturationMag) { a = 0.4f * clamp((appMag - saturationMag) * -0.8f); float s = renderZ * 0.001f * (3 - (appMag - saturationMag)) * 2; if (s > size * 3) size = s * 2.0f/(1.0f +FOV/fov); else size = size * 3; float realSize = discSizeInPixels * pixelSize * renderZ; if (size < realSize * 10) size = realSize * 10; glareTex->bind(); glColor(color, a); glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex(center + (v0 * size)); glTexCoord2f(1, 0); glVertex(center + (v1 * size)); glTexCoord2f(1, 1); glVertex(center + (v2 * size)); glTexCoord2f(0, 1); glVertex(center + (v3 * size)); glEnd(); } } }

void Renderer::renderCelestialSphere (  const Observer &  observer  )  [private]

Definition at line 6702 of file render.cpp. References addLabel(), conjugate(), coordLabels, astro::equatorialToCelestialCart(), glVertex(), and nCoordLabels. Referenced by render(). { int raDivisions = 12; int decDivisions = 12; int nSections = 60; float radius = 10.0f; int i; for (i = 0; i < raDivisions; i++) { float ra = (float) i / (float) raDivisions * 24.0f; glBegin(GL_LINE_STRIP); for (int j = 0; j <= nSections; j++) { float dec = ((float) j / (float) nSections) * 180 - 90; glVertex(astro::equatorialToCelestialCart(ra, dec, radius)); } glEnd(); } for (i = 1; i < decDivisions; i++) { float dec = (float) i / (float) decDivisions * 180 - 90; glBegin(GL_LINE_LOOP); for (int j = 0; j < nSections; j++) { float ra = (float) j / (float) nSections * 24.0f; glVertex(astro::equatorialToCelestialCart(ra, dec, radius)); } glEnd(); } for (i = 0; i < nCoordLabels; i++) { Point3f pos = astro::equatorialToCelestialCart(coordLabels[i].ra, coordLabels[i].dec, radius); if ((pos * conjugate(observer.getOrientation()).toMatrix3()).z < 0) { addLabel(coordLabels[i].label, Color(0.3f, 0.7f, 0.7f, 0.85f), pos); } } }

void Renderer::renderCometTail (  const Body &  body, Point3f  pos, float  distance, float  appMag, double  now, Quatf  orientation, const vector< LightSource > &  lightSources, float  , float  )  [private]

Definition at line 5863 of file render.cpp. References abs(), CometTailVertex::brightness, CometTailSlices, cometTailVertices, cos(), distance(), glTranslate(), glVertex(), Vector3< T >::length(), MaxCometTailPoints, CometTailVertex::normal, Vector3< T >::normalize(), CometTailVertex::paraboloidPoint, PI, CometTailVertex::point, ProcessCometTailVertex(), sin(), sqrt(), square(), Quaternion< T >::w, Quaternion< T >::x, Point3< T >::x, Vector3< T >::x, X0_SOL, Quaternion< T >::y, Point3< T >::y, Vector3< T >::y, Quaternion< T >::z, Point3< T >::z, and Vector3< T >::z. Referenced by render(). { Point3f cometPoints[MaxCometTailPoints]; Point3d pos0 = body.getOrbit()->positionAtTime(now); Point3d pos1 = body.getOrbit()->positionAtTime(now - 0.01); Vec3d vd = pos1 - pos0; double t = now; float f = 1.0e15f; int nSteps = MaxCometTailPoints; float dt = 10000000.0f / (nSteps * (float) vd.length() * 100.0f); float distanceFromSun, irradiance_max = 0.0f; unsigned int li_eff; // Find the sun with the largest irrradiance of light onto the comet // as function of the comet's position; // irradiance = sun's luminosity / square(distanceFromSun); for (unsigned int li = 0; li < lightSources.size(); li++) { distanceFromSun = (float)(body.getHeliocentricPosition(now) - lightSources[li].position).length(); float irradiance = lightSources[li].luminosity / square(distanceFromSun); if (irradiance > irradiance_max ) { li_eff = li; irradiance_max = irradiance; } } float fadeDistance = 1.0f / (X0_SOL * sqrt(irradiance_max)); // direction to sun with dominant light irradiance: Vec3d sd = body.getHeliocentricPosition(now) - lightSources[li_eff].position; Vec3f sunDir = Vec3f((float) sd.x, (float) sd.y, (float) sd.z); sunDir.normalize(); // cout<<astro::kilometersToAU(X0_SOL*sqrt(lightSources[li_eff].luminosity))<<" "<<fadeDistance<<" "<<astro::kilometersToAU(sd.length())<<endl; int i; #if 0 for (i = 0; i < MaxCometTailPoints; i++) { Vec3d pd = body.getOrbit()->positionAtTime(t) - pos0; Point3f p = Point3f((float) pd.x, (float) pd.y, (float) pd.z); Vec3f r(p.x + (float) pos0.x, p.y + (float) pos0.y, p.z + (float) pos0.z); float distance = r.length(); Vec3f a = r * ((1 / square(distance)) * f * dt); Vec3f dx = a * (square(i * dt) * 0.5f); cometPoints[i] = p + dx; t -= dt; } #endif // Compute a rough estimate of the visible length of the dust tail float dustTailLength = (1.0e8f / (float) pos0.distanceFromOrigin()) * (body.getRadius() / 5.0f) * 1.0e7f; float dustTailRadius = dustTailLength * 0.1f; float comaRadius = dustTailRadius * 0.5f; Point3f origin(0, 0, 0); origin -= sunDir * (body.getRadius() * 100); for (i = 0; i < MaxCometTailPoints; i++) { float alpha = (float) i / (float) MaxCometTailPoints; alpha = alpha * alpha; cometPoints[i] = origin + sunDir * (dustTailLength * alpha); } // We need three axes to define the coordinate system for rendering the // comet. The first axis is the velocity. We choose the second one // based on the orientation of the comet. And the third is just the cross // product of the first and second axes. Quatd qd = body.getEclipticalToEquatorial(t); Quatf q((float) qd.w, (float) qd.x, (float) qd.y, (float) qd.z); Vec3f v = cometPoints[1] - cometPoints[0]; v.normalize(); Vec3f u0 = Vec3f(0, 1, 0) * q.toMatrix3(); Vec3f u1 = Vec3f(1, 0, 0) * q.toMatrix3(); Vec3f u; if (abs(u0 * v) < abs(u1 * v)) u = v ^ u0; else u = v ^ u1; u.normalize(); Vec3f w = u ^ v; glColor4f(0.0f, 1.0f, 1.0f, 0.5f); glPushMatrix(); glTranslate(pos); // glx::glActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); for (i = 0; i < MaxCometTailPoints; i++) { float brightness = 1.0f - (float) i / (float) (MaxCometTailPoints - 1); Vec3f v0, v1; float sectionLength; if (i != 0 && i != MaxCometTailPoints - 1) { v0 = cometPoints[i] - cometPoints[i - 1]; v1 = cometPoints[i + 1] - cometPoints[i]; sectionLength = v0.length(); v0.normalize(); v1.normalize(); Vec3f axis = v1 ^ v0; float axisLength = axis.length(); if (axisLength > 1e-5f) { axis *= 1.0f / axisLength; q.setAxisAngle(axis, (float) asin(axisLength)); Mat3f m = q.toMatrix3(); u = u * m; v = v * m; w = w * m; } } else if (i == 0) { v0 = cometPoints[i + 1] - cometPoints[i]; sectionLength = v0.length(); v0.normalize(); v1 = v0; } else { v0 = v1 = cometPoints[i] - cometPoints[i - 1]; sectionLength = v0.length(); v0.normalize(); v1 = v0; } float radius = (float) i / (float) MaxCometTailPoints * dustTailRadius; float dr = (dustTailRadius / (float) MaxCometTailPoints) / sectionLength; float w0 = (float) atan(dr); float w1 = (float) sqrt(1.0f - square(w0)); for (int j = 0; j < CometTailSlices; j++) { float theta = (float) (2 * PI * (float) j / CometTailSlices); float s = (float) sin(theta); float c = (float) cos(theta); CometTailVertex* vtx = &cometTailVertices[i * CometTailSlices + j]; vtx->normal = u * (s * w1) + w * (c * w1) + v * w0; s *= radius; c *= radius; vtx->point = Point3f(cometPoints[i].x + u.x * s + w.x * c, cometPoints[i].y + u.y * s + w.y * c, cometPoints[i].z + u.z * s + w.z * c); vtx->brightness = brightness; vtx->paraboloidPoint = Point3f(c, s, square((float) i / (float) MaxCometTailPoints)); } } Vec3f viewDir = pos - Point3f(0.0f, 0.0f, 0.0f); viewDir.normalize(); glDisable(GL_CULL_FACE); for (i = 0; i < MaxCometTailPoints - 1; i++) { glBegin(GL_QUAD_STRIP); int n = i * CometTailSlices; for (int j = 0; j < CometTailSlices; j++) { ProcessCometTailVertex(cometTailVertices[n + j], viewDir, fadeDistance); ProcessCometTailVertex(cometTailVertices[n + j + CometTailSlices], viewDir, fadeDistance); } ProcessCometTailVertex(cometTailVertices[n], viewDir, fadeDistance); ProcessCometTailVertex(cometTailVertices[n + CometTailSlices], viewDir, fadeDistance); glEnd(); } glEnable(GL_CULL_FACE); glBegin(GL_LINE_STRIP); for (i = 0; i < MaxCometTailPoints; i++) { glVertex(cometPoints[i]); } glEnd(); glDepthMask(GL_TRUE); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glPopMatrix(); }

void Renderer::renderDeepSkyObjects (  const Universe &  , const Observer &  , float  faintestMagNight )  [private]

Definition at line 6644 of file render.cpp. References DSORenderer::avgAbsMag, brightnessBias, ObjectRenderer< OBJ, PREC >::brightnessBias, brightnessScale, ObjectRenderer< OBJ, PREC >::brightnessScale, conjugate(), context, ObjectRenderer< OBJ, PREC >::context, corrFac, degToRad(), disableSmoothLines(), DSORenderer::dsoDB, enableSmoothLines(), faintestMag, ObjectRenderer< OBJ, PREC >::faintestMag, ObjectRenderer< OBJ, PREC >::faintestMagNight, DSODatabase::findVisibleDSOs(), fov, ObjectRenderer< OBJ, PREC >::fov, DSORenderer::frustum, DSODatabase::getAverageAbsoluteMagnitude(), labelMode, ObjectRenderer< OBJ, PREC >::labelMode, MinNearPlaneDistance, ObjectRenderer< OBJ, PREC >::observer, DSORenderer::obsPos, DSORenderer::orientationMatrix, ObjectRenderer< OBJ, PREC >::pixelSize, pixelSize, ObjectRenderer< OBJ, PREC >::renderer, renderFlags, ObjectRenderer< OBJ, PREC >::renderFlags, saturationMag, ObjectRenderer< OBJ, PREC >::saturationMag, ShowSmoothLines, ObjectRenderer< OBJ, PREC >::size, ObjectRenderer< OBJ, PREC >::viewNormal, DSORenderer::wHeight, windowHeight, windowWidth, DSORenderer::wWidth, Point3< T >::x, Point3< T >::y, and Point3< T >::z. Referenced by render(). { DSORenderer dsoRenderer; Point3d obsPos = (Point3d) observer.getPosition(); obsPos.x *= 1e-6; obsPos.y *= 1e-6; obsPos.z *= 1e-6; DSODatabase* dsoDB = universe.getDSOCatalog(); dsoRenderer.context = context; dsoRenderer.renderer = this; dsoRenderer.dsoDB = dsoDB; dsoRenderer.orientationMatrix = conjugate(observer.getOrientation()).toMatrix3(); dsoRenderer.observer = &observer; dsoRenderer.obsPos = obsPos; dsoRenderer.viewNormal = Vec3f(0, 0, -1) * observer.getOrientation().toMatrix3(); dsoRenderer.fov = fov; // size/pixelSize =0.86 at 120deg, 1.43 at 45deg and 1.6 at 0deg. dsoRenderer.size = pixelSize * 1.6f / corrFac; dsoRenderer.pixelSize = pixelSize; dsoRenderer.brightnessScale = brightnessScale * corrFac; dsoRenderer.brightnessBias = brightnessBias; dsoRenderer.avgAbsMag = dsoDB->getAverageAbsoluteMagnitude(); dsoRenderer.faintestMag = faintestMag; dsoRenderer.faintestMagNight = faintestMagNight; dsoRenderer.saturationMag = saturationMag; dsoRenderer.renderFlags = renderFlags; dsoRenderer.labelMode = labelMode; dsoRenderer.wWidth = windowWidth; dsoRenderer.wHeight = windowHeight; dsoRenderer.frustum = Frustum(degToRad(fov), (float) windowWidth / (float) windowHeight, MinNearPlaneDistance); // Render any line primitives with smooth lines // (mostly to make graticules look good.) if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); glBlendFunc(GL_SRC_ALPHA, GL_ONE); dsoDB->findVisibleDSOs(dsoRenderer, obsPos, observer.getOrientation(), degToRad(fov), (float) windowWidth / (float) windowHeight, 2*faintestMagNight); if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); }

void Renderer::renderEllipsoidAtmosphere (  const Atmosphere &  atmosphere, Point3f  center, const Quatf &  orientation, Vec3f  semiAxes, const Vec3f &  sunDirection, Color  ambientColor, float  fade, bool  lit )  [private]

Definition at line 2405 of file render.cpp. References abs(), Renderer::SkyContourPoint::centerDist, clamp(), Renderer::SkyVertex::color, conjugate(), cos(), Renderer::SkyContourPoint::cosSkyCapAltitude, ellipsoidTangent(), Renderer::SkyContourPoint::eyeDir, Renderer::SkyContourPoint::eyeDist, Vector3< T >::length(), Math< T >::lerp(), max, MaxSkySlices, min, MinSkySlices, Vector3< T >::normalize(), PI, pow(), Matrix3< float >::scaling(), sin(), skyContour, skyIndices, skyVertices, sqrt(), square(), Renderer::SkyContourPoint::v, Renderer::SkyVertex::x, Point3< T >::x, Vector3< T >::x, Renderer::SkyVertex::y, Point3< T >::y, Vector3< T >::y, Renderer::SkyVertex::z, Point3< T >::z, and Vector3< T >::z. Referenced by renderObject(). { if (atmosphere.height == 0.0f) return; glDepthMask(GL_FALSE); // Gradually fade in the atmosphere if it's thickness on screen is just // over one pixel. float fade = clamp(pixSize - 2); Mat3f rot = orientation.toMatrix3(); Mat3f irot = conjugate(orientation).toMatrix3(); Point3f eyePos(0.0f, 0.0f, 0.0f); float radius = max(semiAxes.x, max(semiAxes.y, semiAxes.z)); Vec3f eyeVec = center - eyePos; eyeVec = eyeVec * irot; double centerDist = eyeVec.length(); float height = atmosphere.height / radius; Vec3f recipSemiAxes(1.0f / semiAxes.x, 1.0f / semiAxes.y, 1.0f / semiAxes.z); Vec3f recipAtmSemiAxes = recipSemiAxes / (1.0f + height); Mat3f A = Mat3f::scaling(recipAtmSemiAxes); Mat3f A1 = Mat3f::scaling(recipSemiAxes); // ellipDist is not the true distance from the surface unless the // planet is spherical. Computing the true distance requires finding // the roots of a sixth degree polynomial, and isn't actually what we // want anyhow since the atmosphere region is just the planet ellipsoid // multiplied by a uniform scale factor. The value that we do compute // is the distance to the surface along a line from the eye position to // the center of the ellipsoid. float ellipDist = (float) sqrt((eyeVec * A1) * (eyeVec * A1)) - 1.0f; bool within = ellipDist < height; // Adjust the tesselation of the sky dome/ring based on distance from the // planet surface. int nSlices = MaxSkySlices; if (ellipDist < 0.25f) { nSlices = MinSkySlices + max(0, (int) ((ellipDist / 0.25f) * (MaxSkySlices - MinSkySlices))); nSlices &= ~1; } int nRings = min(1 + (int) pixSize / 5, 6); int nHorizonRings = nRings; if (within) nRings += 12; float horizonHeight = height; if (within) { if (ellipDist <= 0.0f) horizonHeight = 0.0f; else horizonHeight *= max((float) pow(ellipDist / height, 0.33f), 0.001f); } Vec3f e = -eyeVec; Vec3f e_(e.x * recipSemiAxes.x, e.y * recipSemiAxes.y, e.z * recipSemiAxes.z); float ee = e_ * e_; // Compute the cosine of the altitude of the sun. This is used to compute // the degree of sunset/sunrise coloration. float cosSunAltitude = 0.0f; { // Check for a sun either directly behind or in front of the viewer float cosSunAngle = (float) ((sunDirection * e) / centerDist); if (cosSunAngle < -1.0f + 1.0e-6f) { cosSunAltitude = 0.0f; } else if (cosSunAngle > 1.0f - 1.0e-6f) { cosSunAltitude = 0.0f; } else { Point3f tangentPoint = center + ellipsoidTangent(recipSemiAxes, (-sunDirection * irot) * (float) centerDist, e, e_, ee) * rot; Vec3f tangentDir = tangentPoint - eyePos; tangentDir.normalize(); cosSunAltitude = sunDirection * tangentDir; } } Vec3f normal = eyeVec; normal = normal / (float) centerDist; Vec3f uAxis, vAxis; if (abs(normal.x) < abs(normal.y) && abs(normal.x) < abs(normal.z)) { uAxis = Vec3f(1, 0, 0) ^ normal; uAxis.normalize(); } else if (abs(eyeVec.y) < abs(normal.z)) { uAxis = Vec3f(0, 1, 0) ^ normal; uAxis.normalize(); } else { uAxis = Vec3f(0, 0, 1) ^ normal; uAxis.normalize(); } vAxis = uAxis ^ normal; // Compute the contour of the ellipsoid int i; for (i = 0; i <= nSlices; i++) { // We want rays with an origin at the eye point and tangent to the the // ellipsoid. float theta = (float) i / (float) nSlices * 2 * (float) PI; Vec3f w = (float) cos(theta) * uAxis + (float) sin(theta) * vAxis; w = w * (float) centerDist; Vec3f toCenter = ellipsoidTangent(recipSemiAxes, w, e, e_, ee); skyContour[i].v = toCenter * rot; skyContour[i].centerDist = skyContour[i].v.length(); skyContour[i].eyeDir = skyContour[i].v + (center - eyePos); skyContour[i].eyeDist = skyContour[i].eyeDir.length(); skyContour[i].eyeDir.normalize(); float skyCapDist = (float) sqrt(square(skyContour[i].eyeDist) + square(horizonHeight * radius)); skyContour[i].cosSkyCapAltitude = skyContour[i].eyeDist / skyCapDist; } Vec3f botColor(atmosphere.lowerColor.red(), atmosphere.lowerColor.green(), atmosphere.lowerColor.blue()); Vec3f topColor(atmosphere.upperColor.red(), atmosphere.upperColor.green(), atmosphere.upperColor.blue()); Vec3f sunsetColor(atmosphere.sunsetColor.red(), atmosphere.sunsetColor.green(), atmosphere.sunsetColor.blue()); if (within) { Vec3f skyColor(atmosphere.skyColor.red(), atmosphere.skyColor.green(), atmosphere.skyColor.blue()); if (ellipDist < 0.0f) topColor = skyColor; else topColor = skyColor + (topColor - skyColor) * (ellipDist / height); } Vec3f zenith = (skyContour[0].v + skyContour[nSlices / 2].v); zenith.normalize(); zenith *= skyContour[0].centerDist * (1.0f + horizonHeight * 2.0f); float minOpacity = within ? (1.0f - ellipDist / height) * 0.75f : 0.0f; float sunset = cosSunAltitude < 0.9f ? 0.0f : (cosSunAltitude - 0.9f) * 10.0f; // Build the list of vertices SkyVertex* vtx = skyVertices; for (i = 0; i <= nRings; i++) { float h = min(1.0f, (float) i / (float) nHorizonRings); float hh = (float) sqrt(h); float u = i <= nHorizonRings ? 0.0f : (float) (i - nHorizonRings) / (float) (nRings - nHorizonRings); float r = Mathf::lerp(h, 1.0f - (horizonHeight * 0.05f), 1.0f + horizonHeight); float atten = 1.0f - hh; for (int j = 0; j < nSlices; j++) { Vec3f v; if (i <= nHorizonRings) v = skyContour[j].v * r; else v = (skyContour[j].v * (1.0f - u) + zenith * u) * r; Point3f p = center + v; Vec3f viewDir(p.x, p.y, p.z); viewDir.normalize(); float cosSunAngle = viewDir * sunDirection; float cosAltitude = viewDir * skyContour[j].eyeDir; float brightness = 1.0f; float coloration = 0.0f; if (lit) { if (sunset > 0.0f && cosSunAngle > 0.7f && cosAltitude > 0.98f) { coloration = (1.0f / 0.30f) * (cosSunAngle - 0.70f); coloration *= 50.0f * (cosAltitude - 0.98f); coloration *= sunset; } cosSunAngle = (skyContour[j].v * sunDirection) / skyContour[j].centerDist; if (cosSunAngle > -0.2f) { if (cosSunAngle < 0.3f) brightness = (cosSunAngle + 0.2f) * 2.0f; else brightness = 1.0f; } else { brightness = 0.0f; } } vtx->x = p.x; vtx->y = p.y; vtx->z = p.z; #if 0 // Better way of generating sky color gradients--based on // altitude angle. if (!within) { hh = (1.0f - cosAltitude) / (1.0f - skyContour[j].cosSkyCapAltitude); } else { float top = pow((ellipDist / height), 0.125f) * skyContour[j].cosSkyCapAltitude; if (cosAltitude < top) hh = 1.0f; else hh = (1.0f - cosAltitude) / (1.0f - top); } hh = sqrt(hh); //hh = (float) pow(hh, 0.25f); #endif atten = 1.0f - hh; Vec3f color = (1.0f - hh) * botColor + hh * topColor; brightness *= minOpacity + (1.0f - minOpacity) * fade * atten; if (coloration != 0.0f) color = (1.0f - coloration) * color + coloration * sunsetColor; Color(brightness * color.x, brightness * color.y, brightness * color.z, fade * (minOpacity + (1.0f - minOpacity)) * atten).get(vtx->color); vtx++; } } // Create the index list int index = 0; for (i = 0; i < nRings; i++) { int baseVertex = i * nSlices; for (int j = 0; j < nSlices; j++) { skyIndices[index++] = baseVertex + j; skyIndices[index++] = baseVertex + nSlices + j; } skyIndices[index++] = baseVertex; skyIndices[index++] = baseVertex + nSlices; } glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(SkyVertex), &skyVertices[0].x); glEnableClientState(GL_COLOR_ARRAY); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(SkyVertex), static_cast<void*>(&skyVertices[0].color)); for (i = 0; i < nRings; i++) { glDrawElements(GL_QUAD_STRIP, (nSlices + 1) * 2, GL_UNSIGNED_INT, &skyIndices[(nSlices + 1) * 2 * i]); } glDisableClientState(GL_COLOR_ARRAY); }

void Renderer::renderForegroundOrbits (  const PlanetarySystem *  system, const Point3f &  center, float  distance, float  discSizeInPixels, const Selection &  sel, double  t )  [private]

Definition at line 1115 of file render.cpp. References disableSmoothLines(), distance(), enableSmoothLines(), fov, Body::getClassification(), astro::kilometersToAU(), max, minOrbitSize, orbitMask, renderFlags, renderOrbit(), renderOrbitColor(), ShowOrbits, ShowSmoothLines, transformOrbits(), windowHeight, and windowWidth. Referenced by render(). { // Render orbit paths if ((renderFlags & ShowOrbits) == 0 || orbitMask == 0) return; if (system == NULL) return; if (discSizeInPixels < minOrbitSize) return; distance = astro::kilometersToAU(distance); double scale = astro::kilometersToAU(1.0); glPushMatrix(); glTranslated(center.x * scale, center.y * scale, center.z * scale); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); transformOrbits(system); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(fov, (float) windowWidth / (float) windowHeight, max( distance * 1e-6f, (float)(1e-5/2./tan(fov*3.14159/360.0)) ), distance); glMatrixMode(GL_MODELVIEW); int nBodies = system->getSystemSize(); for (int i = 0; i < nBodies; i++) { Body* body = system->getBody(i); // Only show orbits for major bodies or selected objects if ((body->getClassification() & orbitMask) == 0 && body != sel.body()) continue; renderOrbitColor(body, body == sel.body()); renderOrbit(body, t); } if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); glPopMatrix(); }

void Renderer::renderLabels (   )  [private]

Definition at line 6856 of file render.cpp. References TextureFont::bind(), font, glColor(), labels, PixelOffset, TextureFont::render(), windowHeight, and windowWidth. Referenced by render(). { if (font == NULL) return; //glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); font->bind(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluOrtho2D(0, windowWidth, 0, windowHeight); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslatef(GLfloat((int) (windowWidth / 2)), GLfloat((int) (windowHeight / 2)), 0); for (int i = 0; i < (int) labels.size(); i++) { glColor(labels[i].color); glPushMatrix(); glTranslatef((int) labels[i].position.x + PixelOffset + 2.0f, (int) labels[i].position.y + PixelOffset, 0.0f); // EK TODO: Check where to replace (see '_(' above) font->render(labels[i].text.c_str()); glPopMatrix(); } glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glDisable(GL_DEPTH_TEST); }

void Renderer::renderLocations (  const vector< Location * > &  locations, const Quatf &  cameraOrientation, const Point3f &  position, const Quatf &  orientation, float  scale )  [private]

Definition at line 4729 of file render.cpp. References TextureFont::bind(), Point3< T >::distanceFromOrigin(), font, locationFilter, minFeatureSize, PixelOffset, pixelSize, TextureFont::render(), testIntersection(), windowHeight, windowWidth, Vector3< T >::x, Vector3< T >::y, and Vector3< T >::z. Referenced by renderObject(). { if (font == NULL) return; double winX, winY, winZ; int view[4] = { 0, 0, 0, 0 }; view[0] = -windowWidth / 2; view[1] = -windowHeight / 2; view[2] = windowWidth; view[3] = windowHeight; Vec3f viewNormal = Vec3f(0.0f, 0.0f, -1.0f) * cameraOrientation.toMatrix3(); Vec3d viewNormald = Vec3d(viewNormal.x, viewNormal.y, viewNormal.z); double modelview[16]; double projection[16]; glGetDoublev(GL_MODELVIEW_MATRIX, modelview); glGetDoublev(GL_PROJECTION_MATRIX, projection); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); font->bind(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_LIGHTING); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, windowWidth, 0, windowHeight, 1.0f, -1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Render the labels very close to the near plane with z=-0.999f. In fact, // z=-1.0f should work, but I'm concerned that some OpenGL implementations // might clip things placed right on the near plane. glTranslatef(GLfloat((int) (windowWidth / 2)), GLfloat((int) (windowHeight / 2)), -0.999f); Point3d position(positionf.x, positionf.y, positionf.z); Point3d origin(0.0, 0.0, 0.0); Ellipsoidd ellipsoid(position, Vec3d(scale, scale, scale)); float iScale = 1.0f / scale; Mat3f mat = orientation.toMatrix3(); for (vector<Location*>::const_iterator iter = locations.begin(); iter != locations.end(); iter++) { if ((*iter)->getFeatureType() & locationFilter) { // Get the position of the label with respect to the planet center Vec3f ppos = (*iter)->getPosition(); // Get the rotated position Vec3f pposRotated = ppos * mat; // Double precision required for stable intersection calculations Vec3d pposd(pposRotated.x, pposRotated.y, pposRotated.z); // Get the position in camera space. Add a slight scale factor // to keep the point from being exactly on the surface. Point3d cpos(position + pposd * 1.0001); float effSize = (*iter)->getImportance(); if (effSize < 0.0f) effSize = (*iter)->getSize(); float pixSize = effSize / (float) (cpos.distanceFromOrigin() * pixelSize); if (pixSize > minFeatureSize && (cpos - origin) * viewNormald > 0.0) { double r = pposd.length(); if (r < scale * 0.99) cpos = position + pposd * (scale * 1.01 / r); double t = 0.0f; // Test for a intersection of the eye-to-location ray with // the planet ellipsoid. If we hit the planet first, then // the label is obscured by the planet. An exact calculation // for irregular objects would be too expensive, and the // ellipsoid approximation works reasonably well for them. bool hit = testIntersection(Ray3d(origin, cpos - origin), ellipsoid, t); if (!hit || t >= 1.0) { if (gluProject(ppos.x * iScale, ppos.y * iScale, ppos.z * iScale, modelview, projection, (const GLint*) view, &winX, &winY, &winZ) != GL_FALSE) { glColor4f(0.0f, 1.0f, 0.0f, 1.0f); glPushMatrix(); glTranslatef((int) winX + PixelOffset, (int) winY + PixelOffset, 0.0f); font->render((*iter)->getName(true)); glPopMatrix(); } } } } } glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); }

void Renderer::renderMarkers (  const MarkerList &  , const UniversalCoord &  position, const Quatf &  orientation, double  jd )  [private]

Definition at line 6940 of file render.cpp. References conjugate(), glColor(), Vector3< T >::normalize(), projMatrix, windowHeight, windowWidth, Vector3< T >::x, Vector3< T >::y, and Vector3< T >::z. Referenced by render(). { double identity4x4[16] = { 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 }; int view[4] = { 0, 0, 0, 0 }; view[0] = -windowWidth / 2; view[1] = -windowHeight / 2; view[2] = windowWidth; view[3] = windowHeight; glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glDisable(GL_LIGHTING); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_TEXTURE_2D); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluOrtho2D(0, windowWidth, 0, windowHeight); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslatef(GLfloat((int) (windowWidth / 2)), GLfloat((int) (windowHeight / 2)), 0); Mat3f rot = conjugate(orientation).toMatrix3(); for (MarkerList::const_iterator iter = markers.begin(); iter != markers.end(); iter++) { UniversalCoord uc = iter->getPosition(jd); Vec3d offset = uc - position; Vec3f eyepos = Vec3f((float) offset.x, (float) offset.y, (float) offset.z) * rot; eyepos.normalize(); eyepos *= 1000.0f; double winX, winY, winZ; if (gluProject(eyepos.x, eyepos.y, eyepos.z, identity4x4, projMatrix, (const GLint*) view, &winX, &winY, &winZ) != GL_FALSE) { if (eyepos.z < 0.0f) { glPushMatrix(); glTranslatef((GLfloat) winX, (GLfloat) winY, 0.0f); glColor(iter->getColor()); iter->render(); glPopMatrix(); } } } glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glDisable(GL_DEPTH_TEST); }

void Renderer::renderObject (  Point3f  pos, float  distance, double  now, Quatf  cameraOrientation, float  nearPlaneDistance, float  farPlaneDistance, RenderProperties &  obj, const LightingState &  )  [private]

Definition at line 4961 of file render.cpp. References ambientColor, RenderInfo::ambientColor, RenderInfo::baseTex, Texture::bind(), Color::blue(), GLContext::bumpMappingSupported(), RenderInfo::bumpTex, clamp(), Atmosphere::cloudHeight, Atmosphere::cloudSpeed, Atmosphere::cloudTexture, DirectionalLight::color, RenderInfo::color, context, degToRad(), detailOptions, VertexProcessor::disable(), distance(), VertexProcessor::enable(), RenderInfo::eyeDir_obj, RenderInfo::eyePos_obj, MultiResTexture::find(), ResourceManager< T >::find(), fov, GLContext::getFragmentProcessor(), GLContext::getMaxTextures(), GetModelManager(), GLContext::getRenderPath(), GLContext::getVertexPath(), GLContext::getVertexProcessor(), glLightColor(), glLightDirection(), RenderInfo::glossTex, glRotate(), glScale(), glTranslate(), Color::green(), GLContext::hasMultitexture(), RenderInfo::hazeColor, Atmosphere::height, InvalidResource, DirectionalLight::irradiance, labelMode, LocationLabels, lodSphere, max, RenderInfo::nightTex, Vector3< T >::normalize(), RenderInfo::orientation, RenderInfo::overlayTex, VertexProcessor::parameter(), pfmod(), PI, pixelSize, RenderInfo::pixWidth, Color::red(), LODSphereMesh::render(), renderAtmosphere(), renderClouds_GLSL(), renderEclipseShadows(), renderEclipseShadows_Shaders(), renderEllipsoidAtmosphere(), renderFlags, renderLocations(), renderModelDefault(), renderRings(), renderRings_GLSL(), renderRingShadowsVS(), renderSphere_Combiners(), renderSphere_Combiners_VP(), renderSphere_DOT3_VP(), renderSphere_FP_VP(), renderSphere_GLSL(), renderSphereDefault(), Renderer::DetailOptions::ringSystemSections, Matrix4< float >::scaling(), setLightParameters_VP(), ShowAtmospheres, ShowCloudMaps, ShowNightMaps, ShowRingShadows, RenderInfo::specularColor, RenderInfo::specularPower, RenderInfo::sunColor, RenderInfo::sunDir_eye, RenderInfo::sunDir_obj, MultiResTexture::tex, textureResolution, Quaternion< T >::toMatrix4(), Frustum::transform(), Matrix4< float >::translation(), VertexProcessor::use(), useClampToBorder, useRescaleNormal, RenderInfo::useTexEnvCombine, windowHeight, windowWidth, Vector3< T >::x, Point3< T >::x, Vector3< T >::y, Point3< T >::y, Vector3< T >::z, and Point3< T >::z. Referenced by renderPlanet(), and renderStar(). { RenderInfo ri; float altitude = distance - obj.radius; float discSizeInPixels = obj.radius / (max(nearPlaneDistance, altitude) * pixelSize); ri.sunDir_eye = Vec3f(0.0f, 1.0f, 0.0f); ri.sunDir_obj = Vec3f(0.0f, 1.0f, 0.0f); ri.sunColor = Color(0.0f, 0.0f, 0.0f); if (ls.nLights > 0) { ri.sunDir_eye = ls.lights[0].direction_eye; ri.sunDir_obj = ls.lights[0].direction_obj; ri.sunColor = ls.lights[0].color;// * ls.lights[0].intensity; } // Enable depth buffering glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDisable(GL_BLEND); // Get the textures . . . if (obj.surface->baseTexture.tex[textureResolution] != InvalidResource) ri.baseTex = obj.surface->baseTexture.find(textureResolution); if ((obj.surface->appearanceFlags & Surface::ApplyBumpMap) != 0 && context->bumpMappingSupported() && obj.surface->bumpTexture.tex[textureResolution] != InvalidResource) ri.bumpTex = obj.surface->bumpTexture.find(textureResolution); if ((obj.surface->appearanceFlags & Surface::ApplyNightMap) != 0 && (renderFlags & ShowNightMaps) != 0) ri.nightTex = obj.surface->nightTexture.find(textureResolution); if ((obj.surface->appearanceFlags & Surface::SeparateSpecularMap) != 0) ri.glossTex = obj.surface->specularTexture.find(textureResolution); if ((obj.surface->appearanceFlags & Surface::ApplyOverlay) != 0) ri.overlayTex = obj.surface->overlayTexture.find(textureResolution); // Apply the modelview transform for the object glPushMatrix(); glTranslate(pos); glRotate(~obj.orientation); // Apply a scale factor which depends on the size of the planet and // its oblateness. Since the oblateness is usually quite // small, the potentially nonuniform scale factor shouldn't mess up // the lighting calculations enough to be noticeable. // TODO: Figure out a better way to render ellipsoids than applying // a nonunifom scale factor to a sphere. float radius = obj.radius; Vec3f semiAxes = obj.radius * obj.semiAxes; glScale(semiAxes); Mat4f planetMat = (~obj.orientation).toMatrix4(); ri.eyeDir_obj = (Point3f(0, 0, 0) - pos) * planetMat; ri.eyeDir_obj.normalize(); ri.eyePos_obj = Point3f(-pos.x / semiAxes.x, -pos.y / semiAxes.y, -pos.z / semiAxes.z) * planetMat; ri.orientation = cameraOrientation; ri.pixWidth = discSizeInPixels; // Set up the colors if (ri.baseTex == NULL || (obj.surface->appearanceFlags & Surface::BlendTexture) != 0) { ri.color = obj.surface->color; } ri.ambientColor = ambientColor; ri.hazeColor = obj.surface->hazeColor; ri.specularColor = obj.surface->specularColor; ri.specularPower = obj.surface->specularPower; ri.useTexEnvCombine = context->getRenderPath() != GLContext::GLPath_Basic; // See if the surface should be lit bool lit = (obj.surface->appearanceFlags & Surface::Emissive) == 0; // Set the OpenGL light state unsigned int i; for (i = 0; i < ls.nLights; i++) { const DirectionalLight& light = ls.lights[i]; glLightDirection(GL_LIGHT0 + i, ls.lights[i].direction_obj); // RANT ALERT! // This sucks, but it's necessary. glScale is used to scale a unit // sphere up to planet size. Since normals are transformed by the // inverse transpose of the model matrix, this means they end up // getting scaled by a factor of 1.0 / planet radius (in km). This // has terrible effects on lighting: the planet appears almost // completely dark. To get around this, the GL_rescale_normal // extension was introduced and eventually incorporated into into the // OpenGL 1.2 standard. Of course, not everyone implemented this // incredibly simple and essential little extension. Microsoft is // notorious for half-assed support of OpenGL, but 3dfx should have // known better: no Voodoo 1/2/3 drivers seem to support this // extension. The following is an attempt to get around the problem by // scaling the light brightness by the planet radius. According to the // OpenGL spec, this should work fine, as clamping of colors to [0, 1] // occurs *after* lighting. It works fine on my GeForce3 when I // disable EXT_rescale_normal, but I'm not certain whether other // drivers are as well behaved as nVidia's. // // Addendum: Unsurprisingly, using color values outside [0, 1] produces // problems on Savage4 cards. Vec3f lightColor = Vec3f(light.color.red(), light.color.green(), light.color.blue()) * light.irradiance; if (useRescaleNormal) { glLightColor(GL_LIGHT0 + i, GL_DIFFUSE, lightColor); glLightColor(GL_LIGHT0 + i, GL_SPECULAR, lightColor); } else { glLightColor(GL_LIGHT0 + i, GL_DIFFUSE, lightColor * radius); } glEnable(GL_LIGHT0 + i); } // Compute the inverse model/view matrix Mat4f invMV = (cameraOrientation.toMatrix4() * Mat4f::translation(Point3f(-pos.x, -pos.y, -pos.z)) * planetMat * Mat4f::scaling(1.0f / radius)); // Transform the frustum into object coordinates using the // inverse model/view matrix. Frustum viewFrustum(degToRad(fov), (float) windowWidth / (float) windowHeight, nearPlaneDistance, farPlaneDistance); viewFrustum.transform(invMV); // Temporary hack until we fix culling for ringed planets if (obj.rings != NULL) { if (ri.pixWidth > 5000) ri.pixWidth = 5000; } Model* model = NULL; if (obj.model == InvalidResource) { // A null model indicates that this body is a sphere if (lit) { switch (context->getRenderPath()) { case GLContext::GLPath_GLSL: renderSphere_GLSL(ri, ls, obj.rings, obj.radius, planetMat, viewFrustum, *context); break; case GLContext::GLPath_NV30: renderSphere_FP_VP(ri, viewFrustum, *context); break; case GLContext::GLPath_NvCombiner_ARBVP: case GLContext::GLPath_NvCombiner_NvVP: renderSphere_Combiners_VP(ri, ls, viewFrustum, *context); break; case GLContext::GLPath_NvCombiner: renderSphere_Combiners(ri, viewFrustum, *context); break; case GLContext::GLPath_DOT3_ARBVP: renderSphere_DOT3_VP(ri, ls, viewFrustum, *context); break; default: renderSphereDefault(ri, viewFrustum, true, *context); } } else { renderSphereDefault(ri, viewFrustum, false, *context); } } else { // This is a model loaded from a file model = GetModelManager()->find(obj.model); if (model != NULL) renderModelDefault(model, ri, lit); } if (obj.rings != NULL && distance <= obj.rings->innerRadius) { if (context->getRenderPath() == GLContext::GLPath_GLSL) { renderRings_GLSL(*obj.rings, ri, ls, radius, 1.0f - obj.semiAxes.y, textureResolution, (renderFlags & ShowRingShadows) != 0 && lit, detailOptions.ringSystemSections); } else { renderRings(*obj.rings, ri, radius, 1.0f - obj.semiAxes.y, textureResolution, context->getMaxTextures() > 1 && (renderFlags & ShowRingShadows) != 0 && lit, *context, detailOptions.ringSystemSections); } } if (obj.atmosphere != NULL) { Atmosphere* atmosphere = const_cast<Atmosphere *>(obj.atmosphere); // Compute the apparent thickness in pixels of the atmosphere. // If it's only one pixel thick, it can look quite unsightly // due to aliasing. To avoid popping, we gradually fade in the // atmosphere as it grows from two to three pixels thick. float fade; float thicknessInPixels = 0.0f; if (distance - radius > 0.0f) { thicknessInPixels = atmosphere->height / ((distance - radius) * pixelSize); fade = clamp(thicknessInPixels - 2); } else { fade = 1.0f; } if (fade > 0 && (renderFlags & ShowAtmospheres) != 0) { glPushMatrix(); glLoadIdentity(); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); #ifdef OLD_ATMOSPHERE renderAtmosphere(*atmosphere, pos * (~cameraOrientation).toMatrix3(), radius, ri.sunDir_eye * (~cameraOrientation).toMatrix3(), ri.ambientColor, fade, lit); #else glRotate(cameraOrientation); renderEllipsoidAtmosphere(*atmosphere, pos, obj.orientation, semiAxes, ri.sunDir_eye, ri.ambientColor, thicknessInPixels, lit); #endif // OLD_ATMOSPHERE glEnable(GL_TEXTURE_2D); glPopMatrix(); } // If there's a cloud layer, we'll render it now. Texture* cloudTex = NULL; if ((renderFlags & ShowCloudMaps) != 0 && atmosphere->cloudTexture.tex[textureResolution] != InvalidResource) cloudTex = atmosphere->cloudTexture.find(textureResolution); if (cloudTex != NULL) { glPushMatrix(); float cloudScale = 1.0f + atmosphere->cloudHeight / radius; glScalef(cloudScale, cloudScale, cloudScale); // If we're beneath the cloud level, render the interior of // the cloud sphere. if (distance - radius < atmosphere->cloudHeight) glFrontFace(GL_CW); float texOffset = (float) (-pfmod(now * atmosphere->cloudSpeed / (2 * PI), 1.0)); if (atmosphere->cloudSpeed != 0.0f) { // Make the clouds appear to rotate above the surface of // the planet. This is easier to do with the texture // matrix than the model matrix because changing the // texture matrix doesn't require us to compute a second // set of model space rendering parameters. glMatrixMode(GL_TEXTURE); glTranslatef(texOffset, 0.0f, 0.0f); glMatrixMode(GL_MODELVIEW); } glEnable(GL_LIGHTING); glDepthMask(GL_FALSE); cloudTex->bind(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1, 1, 1, 1); if (lit) { if (context->getRenderPath() == GLContext::GLPath_GLSL) { renderClouds_GLSL(ri, ls, cloudTex, texOffset, obj.rings, radius * cloudScale, planetMat, viewFrustum, *context); } else { VertexProcessor* vproc = context->getVertexProcessor(); if (vproc != NULL) { vproc->enable(); vproc->parameter(vp::AmbientColor, ri.ambientColor * ri.color); vproc->parameter(vp::TextureTranslation, texOffset, 0.0f, 0.0f, 0.0f); if (ls.nLights > 1) vproc->use(vp::diffuseTexOffset_2light); else vproc->use(vp::diffuseTexOffset); setLightParameters_VP(*vproc, ls, ri.color, Color::Black); } lodSphere->render(*context, LODSphereMesh::Normals | LODSphereMesh::TexCoords0, viewFrustum, ri.pixWidth, cloudTex); if (vproc != NULL) vproc->disable(); } } else { glDisable(GL_LIGHTING); lodSphere->render(*context, LODSphereMesh::Normals | LODSphereMesh::TexCoords0, viewFrustum, ri.pixWidth, cloudTex); glEnable(GL_LIGHTING); } // Reset the texture matrix glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glDepthMask(GL_TRUE); glFrontFace(GL_CCW); glPopMatrix(); } } // No separate shadow rendering pass required for GLSL path if (ls.shadows[0] != NULL && ls.shadows[0]->size() != 0 && (obj.surface->appearanceFlags & Surface::Emissive) == 0 && context->getRenderPath() != GLContext::GLPath_GLSL) { #if 1 // renderEclipseShadows_Shaders() still needs some more work. if (context->getVertexProcessor() != NULL && context->getFragmentProcessor() != NULL) { renderEclipseShadows_Shaders(model, *ls.shadows[0], ri, radius, planetMat, viewFrustum, *context); } else #endif { renderEclipseShadows(model, *ls.shadows[0], ri, radius, planetMat, viewFrustum, *context); } } if (obj.rings != NULL && (obj.surface->appearanceFlags & Surface::Emissive) == 0 && (renderFlags & ShowRingShadows) != 0) { Texture* ringsTex = obj.rings->texture.find(textureResolution); if (ringsTex != NULL) { Vec3f sunDir = pos - Point3f(0, 0, 0); sunDir.normalize(); ringsTex->bind(); if (useClampToBorder && context->getVertexPath() != GLContext::VPath_Basic && context->getRenderPath() != GLContext::GLPath_GLSL) { renderRingShadowsVS(model, *obj.rings, sunDir, ri, radius, 1.0f - obj.semiAxes.y, planetMat, viewFrustum, *context); } } } if (obj.rings != NULL && distance > obj.rings->innerRadius) { glDepthMask(GL_FALSE); if (context->getRenderPath() == GLContext::GLPath_GLSL) { renderRings_GLSL(*obj.rings, ri, ls, radius, 1.0f - obj.semiAxes.y, textureResolution, (renderFlags & ShowRingShadows) != 0 && lit, detailOptions.ringSystemSections); } else { renderRings(*obj.rings, ri, radius, 1.0f - obj.semiAxes.y, textureResolution, (context->hasMultitexture() && (renderFlags & ShowRingShadows) != 0 && lit), *context, detailOptions.ringSystemSections); } } // Disable all light sources other than the first for (i = 0; i < ls.nLights; i++) glDisable(GL_LIGHT0 + i); if (obj.locations != NULL && (labelMode & LocationLabels) != 0) renderLocations(*obj.locations, cameraOrientation, pos, obj.orientation, radius); glPopMatrix(); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); }

void Renderer::renderOrbit (  Body *  , double  )  [private]

Definition at line 918 of file render.cpp. References Renderer::CachedOrbit::body, detailOptions, Renderer::CachedOrbit::keep, max, min, orbitCache, Renderer::DetailOptions::orbitPathSamplePoints, renderFlags, ShowPartialTrajectories, Renderer::CachedOrbit::trajectory, Point3< T >::x, Point3< T >::y, and Point3< T >::z. Referenced by renderForegroundOrbits(), and renderOrbits(). { vector<OrbitSample>* trajectory = NULL; for (vector<CachedOrbit*>::const_iterator iter = orbitCache.begin(); iter != orbitCache.end(); iter++) { if ((*iter)->body == body) { (*iter)->keep = true; trajectory = &((*iter)->trajectory); break; } } // If it's not in the cache already if (trajectory == NULL) { CachedOrbit* orbit = NULL; // Search the cache an see if we can reuse an old orbit for (vector<CachedOrbit*>::const_iterator iter = orbitCache.begin(); iter != orbitCache.end(); iter++) { if ((*iter)->body == NULL) { orbit = *iter; orbit->trajectory.clear(); break; } } // If we can't reuse an old orbit, allocate a new one. bool reuse = true; if (orbit == NULL) { orbit = new CachedOrbit(); reuse = false; } double startTime = t; int nSamples = detailOptions.orbitPathSamplePoints; // Adjust the number of samples used for aperiodic orbits--these aren't // true orbits, but are sampled trajectories, generally of spacecraft. // Better control is really needed--some sort of adaptive sampling would // be ideal. if (!body->getOrbit()->isPeriodic()) { double begin = 0.0, end = 0.0; body->getOrbit()->getValidRange(begin, end); if (begin != end) { startTime = begin; nSamples = (int) (body->getOrbit()->getPeriod() * 100.0); nSamples = max(min(nSamples, 1000), 100); } } orbit->body = body; orbit->keep = true; OrbitSampler sampler(&orbit->trajectory); body->getOrbit()->sample(startTime, body->getOrbit()->getPeriod(), nSamples, sampler); trajectory = &orbit->trajectory; // If the orbit is new, put it back in the cache if (!reuse) orbitCache.insert(orbitCache.end(), orbit); } // Actually render the orbit if (body->getOrbit()->isPeriodic()) glBegin(GL_LINE_LOOP); else glBegin(GL_LINE_STRIP); if ((renderFlags & ShowPartialTrajectories) == 0 || body->getOrbit()->isPeriodic()) { // Show the complete trajectory for (vector<OrbitSample>::const_iterator p = trajectory->begin(); p != trajectory->end(); p++) { glVertex3f(astro::kilometersToAU(p->pos.x), astro::kilometersToAU(p->pos.y), astro::kilometersToAU(p->pos.z)); } } else { vector<OrbitSample>::const_iterator p; // Show the portion of the trajectory travelled up to this point for (p = trajectory->begin(); p != trajectory->end() && p->t < t; p++) { glVertex3f(astro::kilometersToAU(p->pos.x), astro::kilometersToAU(p->pos.y), astro::kilometersToAU(p->pos.z)); } // If we're midway through a non-periodic trajectory, we will need // to render a partial orbit segment. if (p != trajectory->end()) { Point3d pos = body->getOrbit()->positionAtTime(t); glVertex3f((float) astro::kilometersToAU(pos.x), (float) astro::kilometersToAU(pos.y), (float) astro::kilometersToAU(pos.z)); } } glEnd(); }

void Renderer::renderOrbits (  PlanetarySystem *  , const Selection &  , double  , const Point3d &  , const Point3d &  )  [private]

Definition at line 1037 of file render.cpp. References RotationElements::ascendingNode, distance(), fov, Orbit::getBoundingRadius(), Body::getClassification(), Body::getHeliocentricPosition(), Body::getOrbit(), Body::getRotationElements(), Body::getSatellites(), glRotate(), astro::kilometersToAU(), max, minOrbitSize, RotationElements::obliquity, orbitMask, pixelSize, Orbit::positionAtTime(), renderOrbit(), renderOrbitColor(), windowHeight, windowWidth, Point3< T >::x, Quaternion< double >::xrotation(), Point3< T >::y, Quaternion< double >::yrotation(), and Point3< T >::z. Referenced by render(). { if (planets == NULL) return; double distance = (center - observerPos).length(); int nBodies = planets->getSystemSize(); for (int i = 0; i < nBodies; i++) { Body* body = planets->getBody(i); // Only show orbits for major bodies or selected objects if ((body->getClassification() & orbitMask) != 0 || body == sel.body()) { renderOrbitColor(body, body == sel.body()); float orbitRadiusInPixels = (float) (body->getOrbit()->getBoundingRadius() / (distance * pixelSize)); if (orbitRadiusInPixels > minOrbitSize) { float farDistance = (float) (body->getOrbit()->getBoundingRadius() + distance); farDistance = astro::kilometersToAU(farDistance); // Set up the projection matrix so that the far plane is // distant enough that the orbit won't be clipped. glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(fov, (float) windowWidth / (float) windowHeight, max( farDistance * 1e-6f, (float)(1e-5/2./tan(fov*3.14159/360.0)) ), farDistance * 1.1f ); glMatrixMode(GL_MODELVIEW); renderOrbit(body, t); if (body->getSatellites() != NULL) { Point3d localPos = body->getOrbit()->positionAtTime(t); Quatd rotation = Quatd::yrotation(body->getRotationElements().ascendingNode) * Quatd::xrotation(body->getRotationElements().obliquity); double scale = astro::kilometersToAU(1.0); glPushMatrix(); glTranslated(localPos.x * scale, localPos.y * scale, localPos.z * scale); glRotate(rotation); renderOrbits(body->getSatellites(), sel, t, observerPos, body->getHeliocentricPosition(t)); glPopMatrix(); } } } } }

void Renderer::renderParticles (  const std::vector< Particle > &  particles, Quatf  orientation )  [private]

Definition at line 6825 of file render.cpp. References glColor(), glVertex(), and Quaternion< T >::toMatrix3(). Referenced by renderStars(). { int nParticles = particles.size(); Mat3f m = orientation.toMatrix3(); Vec3f v0 = Vec3f(-1, -1, 0) * m; Vec3f v1 = Vec3f( 1, -1, 0) * m; Vec3f v2 = Vec3f( 1, 1, 0) * m; Vec3f v3 = Vec3f(-1, 1, 0) * m; glBegin(GL_QUADS); for (int i = 0; i < nParticles; i++) { Point3f center = particles[i].center; float size = particles[i].size; glColor(particles[i].color); glTexCoord2f(0, 0); glVertex(center + (v0 * size)); glTexCoord2f(1, 0); glVertex(center + (v1 * size)); glTexCoord2f(1, 1); glVertex(center + (v2 * size)); glTexCoord2f(0, 1); glVertex(center + (v3 * size)); } glEnd(); }

void Renderer::renderPlanet (  Body &  body, Point3f  pos, float  distance, float  appMag, double  now, Quatf  orientation, const vector< LightSource > &  lightSources, float  , float  )  [private]

Definition at line 5511 of file render.cpp. References Renderer::RenderProperties::atmosphere, disableSmoothLines(), displayedSurface, distance(), eclipseShadows, enableSmoothLines(), RotationElements::epoch, faintestPlanetMag, PlanetarySystem::getBody(), PlanetarySystem::getPrimaryBody(), Body::getSatellites(), PlanetarySystem::getSystemSize(), glRotate(), InvalidResource, labelMode, LightingState::lights, LocationLabels, Renderer::RenderProperties::locations, max, Renderer::RenderProperties::model, LightingState::nLights, RotationElements::offset, Renderer::RenderProperties::orientation, RotationElements::period, PI, pixelSize, Renderer::RenderProperties::radius, renderBodyAsParticle(), renderCompass(), renderFlags, renderObject(), Renderer::RenderProperties::rings, Renderer::RenderProperties::semiAxes, setupObjectLighting(), LightingState::shadows, ShowCelestialSphere, ShowEclipseShadows, ShowSmoothLines, Renderer::RenderProperties::surface, testEclipse(), Quaternion< T >::w, Quaternion< T >::x, Quaternion< T >::y, Quaternion< T >::yrotate(), and Quaternion< T >::z. Referenced by render(). { float altitude = distance - body.getRadius(); float discSizeInPixels = body.getRadius() / (max(nearPlaneDistance, altitude) * pixelSize); if (discSizeInPixels > 1) { RenderProperties rp; if (displayedSurface.empty()) { rp.surface = const_cast<Surface*>(&body.getSurface()); } else { rp.surface = body.getAlternateSurface(displayedSurface); if (rp.surface == NULL) rp.surface = const_cast<Surface*>(&body.getSurface()); } rp.atmosphere = body.getAtmosphere(); rp.rings = body.getRings(); rp.radius = body.getRadius(); rp.semiAxes = Vec3f(1.0f, 1.0f - body.getOblateness(), 1.0f); rp.model = body.getModel(); // Compute the orientation of the planet before axial rotation Quatd q = body.getEclipticalToEquatorial(now); double rotation = 0.0; // Watch out for the precision limits of floats when computing // rotation . . . { RotationElements re = body.getRotationElements(); double rotations = (now - re.epoch) / (double) re.period; double wholeRotations = floor(rotations); double remainder = rotations - wholeRotations; // Add an extra half rotation because of the convention in all // planet texture maps where zero deg long. is in the middle of // the texture. remainder += 0.5; rotation = remainder * 2 * PI + re.offset; } q.yrotate(-rotation); rp.orientation = body.getOrientation() * Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z); rp.locations = body.getLocations(); if (rp.locations != NULL && (labelMode & LocationLabels) != 0) body.computeLocations(); LightingState lights; setupObjectLighting(lightSources, body.getHeliocentricPosition(now), rp.orientation, rp.semiAxes, pos, lights); assert(lights.nLights < MaxLights); { // Clear out the list of eclipse shadows for (unsigned int li = 0; li < lights.nLights; li++) { eclipseShadows[li].clear(); lights.shadows[li] = &eclipseShadows[li]; } } // Calculate eclipse circumstances if ((renderFlags & ShowEclipseShadows) != 0 && body.getClassification() != Body::Invisible && body.getSystem() != NULL) { PlanetarySystem* system = body.getSystem(); if (system->getPrimaryBody() == NULL && body.getSatellites() != NULL) { // The body is a planet. Check for eclipse shadows // from all of its satellites. PlanetarySystem* satellites = body.getSatellites(); if (satellites != NULL) { int nSatellites = satellites->getSystemSize(); for (unsigned int li = 0; li < lights.nLights; li++) { for (int i = 0; i < nSatellites; i++) testEclipse(body, *satellites->getBody(i), lights.lights[li], now, *lights.shadows[li]); } } } else if (system->getPrimaryBody() != NULL) { for (unsigned int li = 0; li < lights.nLights; li++) { // The body is a moon. Check for eclipse shadows from // the parent planet and all satellites in the system. Body* planet = system->getPrimaryBody(); testEclipse(body, *planet, lights.lights[li], now, *lights.shadows[li]); int nSatellites = system->getSystemSize(); for (int i = 0; i < nSatellites; i++) { if (system->getBody(i) != &body) { testEclipse(body, *system->getBody(i), lights.lights[li], now, *lights.shadows[li]); } } } } } renderObject(pos, distance, now, orientation, nearPlaneDistance, farPlaneDistance, rp, lights); // Render the horizon compass for spherical and ellipsoidal bodies if ((renderFlags & ShowCelestialSphere) != 0 && rp.model == InvalidResource && discSizeInPixels > 100.0f) { glPushMatrix(); glLoadIdentity(); glDisable(GL_TEXTURE_2D); glRotate(orientation); Vec3f semiAxes = rp.semiAxes * rp.radius; // Compute the orientation of the planet before axial rotation Quatd q = body.getEclipticalToEquatorial(now); Quatf qf = Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z); if ((renderFlags & ShowSmoothLines) != 0) enableSmoothLines(); renderCompass(pos, qf, semiAxes, pixelSize / rp.radius); if ((renderFlags & ShowSmoothLines) != 0) disableSmoothLines(); glEnable(GL_TEXTURE_2D); glPopMatrix(); } } glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); renderBodyAsParticle(pos, appMag, faintestPlanetMag, discSizeInPixels, body.getSurface().color, orientation, (nearPlaneDistance + farPlaneDistance) / 2.0f, false); }

void Renderer::renderPlanetarySystem (  const Star &  sun, const PlanetarySystem &  solSystem, const Observer &  observer, double  now, unsigned int  solarSysIndex, bool  showLabels = false )  [private]

Definition at line 6075 of file render.cpp. References addSortedLabel(), RenderListEntry::appMag, AsteroidLabels, astrocentricPosition(), RenderListEntry::body, CometLabels, conjugate(), RenderListEntry::discSizeInPixels, RenderListEntry::distance, Body::extant(), faintestPlanetMag, Body::getApparentMagnitude(), Orbit::getBoundingRadius(), Body::getClassification(), Body::getHeliocentricPosition(), Body::getName(), Body::getOrbit(), Body::getRadius(), Body::getSatellites(), RenderListEntry::isCometTail, labelMode, Vector3< T >::length(), lightSourceLists, min, minOrbitSize, MoonLabels, pixelSize, PlanetLabels, RenderListEntry::position, Orbit::positionAtTime(), RenderListEntry::radius, renderFlags, renderList, ShowCometTails, RenderListEntry::solarSysIndex, SpacecraftLabels, RenderListEntry::star, RenderListEntry::sun, Point3< T >::x, Vector3< T >::x, Point3< T >::y, Vector3< T >::y, Point3< T >::z, and Vector3< T >::z. Referenced by render(). { Point3f starPos = sun.getPosition(); Point3d observerPos = astrocentricPosition(observer.getPosition(), sun, now); int nBodies = solSystem.getSystemSize(); for (int i = 0; i < nBodies; i++) { Body* body = solSystem.getBody(i); if (!body->extant(now)) continue; Point3d localPos = body->getOrbit()->positionAtTime(now); Point3d bodyPos = body->getHeliocentricPosition(now); // We now have the positions of the observer and the planet relative // to the sun. From these, compute the position of the planet // relative to the observer. Vec3d posd = bodyPos - observerPos; vector<LightSource>& lightSources = lightSourceLists[solarSysIndex]; // Compute the apparent magnitude; instead of summing the reflected // light from all nearby stars, we just consider the one with the // highest apparent brightness. float appMag = 100.0f; for (unsigned int li = 0; li < lightSources.size(); li++) { Vec3d sunPos = bodyPos - lightSources[li].position; appMag = min(appMag, body->getApparentMagnitude(lightSources[li].luminosity, sunPos, posd)); } Vec3f pos((float) posd.x, (float) posd.y, (float) posd.z); // Compute the size of the planet/moon disc in pixels double distanceFromObserver = posd.length(); float discSize = (body->getRadius() / (float) distanceFromObserver) / pixelSize; // if (discSize > 1 || appMag < 1.0f / brightnessScale) if ((discSize > 1 || appMag < faintestPlanetMag) && body->getClassification() != Body::Invisible) { RenderListEntry rle; rle.body = body; rle.star = NULL; rle.isCometTail = false; rle.position = Point3f(pos.x, pos.y, pos.z); rle.sun = Vec3f((float) -bodyPos.x, (float) -bodyPos.y, (float) -bodyPos.z); rle.distance = (float) distanceFromObserver; rle.radius = body->getRadius(); rle.discSizeInPixels = discSize; rle.appMag = appMag; rle.solarSysIndex = solarSysIndex; renderList.insert(renderList.end(), rle); } if (body->getClassification() == Body::Comet && (renderFlags & ShowCometTails) != 0) { float radius = 10000000.0f; // body->getRadius() * 1000000.0f; discSize = (radius / (float) distanceFromObserver) / pixelSize; if (discSize > 1) { RenderListEntry rle; rle.body = body; rle.star = NULL; rle.isCometTail = true; rle.position = Point3f(pos.x, pos.y, pos.z); rle.radius = radius; rle.sun = Vec3f((float) -bodyPos.x, (float) -bodyPos.y, (float) -bodyPos.z); rle.distance = (float) distanceFromObserver; rle.radius = radius; rle.discSizeInPixels = discSize; rle.appMag = appMag; rle.solarSysIndex = solarSysIndex; renderList.insert(renderList.end(), rle); } } if (showLabels && (pos * conjugate(observer.getOrientation()).toMatrix3()).z < 0) { float boundingRadiusSize = (float) (body->getOrbit()->getBoundingRadius() / distanceFromObserver) / pixelSize; if (boundingRadiusSize > minOrbitSize) { Color labelColor; bool showLabel = false; switch (body->getClassification()) { case Body::Planet: if ((labelMode & PlanetLabels) != 0) { labelColor = Color(0.0f, 1.0f, 0.0f); showLabel = true; } break; case Body::Moon: if ((labelMode & MoonLabels) != 0) { labelColor = Color(0.0f, 0.65f, 0.0f); showLabel = true; } break; case Body::Asteroid: if ((labelMode & AsteroidLabels) != 0) { labelColor = Color(0.7f, 0.4f, 0.0f); showLabel = true; } break; case Body::Comet: if ((labelMode & CometLabels) != 0) { labelColor = Color(0.0f, 1.0f, 1.0f); showLabel = true; } break; case Body::Spacecraft: if ((labelMode & SpacecraftLabels) != 0) { labelColor = Color(0.6f, 0.6f, 0.6f); showLabel = true; } break; } if (showLabel) { addSortedLabel(body->getName(), labelColor, Point3f(pos.x, pos.y, pos.z)); } } } if (appMag < faintestPlanetMag) { const PlanetarySystem* satellites = body->getSatellites(); if (satellites != NULL) { renderPlanetarySystem(sun, *satellites, observer, now, solarSysIndex, showLabels); } } } }

vector< Renderer::Label >::iterator Renderer::renderSortedLabels (  std::vector< Label >::iterator  , float  depth )  [private]

Definition at line 6898 of file render.cpp. References TextureFont::bind(), depthSortedLabels, font, glColor(), PixelOffset, TextureFont::render(), windowHeight, and windowWidth. Referenced by render(). { if (font == NULL) return iter; glDisable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); font->bind(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluOrtho2D(0, windowWidth, 0, windowHeight); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslatef(GLfloat((int) (windowWidth / 2)), GLfloat((int) (windowHeight / 2)), 0); for (; iter != depthSortedLabels.end() && iter->position.z > depth; iter++) { glColor(iter->color); glPushMatrix(); glTranslatef((int) iter->position.x + PixelOffset + 2.0f, (int) iter->position.y + PixelOffset, 0.0f); font->render(iter->text); glPopMatrix(); } glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glDisable(GL_DEPTH_TEST); return iter; }

void Renderer::renderStar (  const Star &  star, Point3f  pos, float  distance, float  appMag, Quatf  orientation, double  now, float  , float  )  [private]

Definition at line 5686 of file render.cpp. References Surface::appearanceFlags, Renderer::RenderProperties::atmosphere, Surface::baseTexture, Surface::color, colorTemp, CoronaHeight, distance(), RotationElements::eclipticalToEquatorial(), RotationElements::epoch, faintestMag, Atmosphere::height, InvalidResource, ColorTemperatureTable::lookupColor(), Atmosphere::lowerColor, Renderer::RenderProperties::model, RotationElements::offset, Renderer::RenderProperties::orientation, RotationElements::period, PI, pixelSize, Renderer::RenderProperties::radius, renderBodyAsParticle(), renderObject(), Renderer::RenderProperties::rings, Renderer::RenderProperties::semiAxes, Atmosphere::skyColor, Renderer::RenderProperties::surface, MultiResTexture::tex, textureResolution, Atmosphere::upperColor, Quaternion< T >::w, Quaternion< T >::x, Quaternion< T >::y, Quaternion< T >::yrotate(), and Quaternion< T >::z. Referenced by render(). { if (!star.getVisibility()) return; //Color color = star.getStellarClass().getApparentColor(); Color color = colorTemp->lookupColor(star.getTemperature()); float radius = star.getRadius(); float discSizeInPixels = radius / (distance * pixelSize); if (discSizeInPixels > 1) { Surface surface; RenderProperties rp; surface.color = color; MultiResTexture mtex = star.getTexture(); if (mtex.tex[textureResolution] != InvalidResource) { surface.baseTexture = mtex; } else { surface.baseTexture = InvalidResource; } surface.appearanceFlags |= Surface::ApplyBaseTexture; surface.appearanceFlags |= Surface::Emissive; rp.surface = &surface; rp.rings = NULL; rp.radius = star.getRadius(); rp.semiAxes = star.getEllipsoidSemiAxes(); rp.model = star.getModel(); Atmosphere atmosphere; atmosphere.height = radius * CoronaHeight; atmosphere.lowerColor = color; atmosphere.upperColor = color; atmosphere.skyColor = color; if (rp.model == InvalidResource) rp.atmosphere = &atmosphere; else rp.atmosphere = NULL; const RotationElements& re = star.getRotationElements(); Quatd q = re.eclipticalToEquatorial(now); double rotation = 0.0; // Watch out for the precision limits of floats when computing // rotation . . . { const RotationElements& re = star.getRotationElements(); double rotations = (now - re.epoch) / (double) re.period; double wholeRotations = floor(rotations); double remainder = rotations - wholeRotations; // Add an extra half rotation because of the convention in all // planet texture maps where zero deg long. is in the middle of // the texture. remainder += 0.5; rotation = remainder * 2 * PI + re.offset; } q.yrotate(-rotation); rp.orientation = Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z); renderObject(pos, distance, now, orientation, nearPlaneDistance, farPlaneDistance, rp, LightingState()); glEnable(GL_TEXTURE_2D); } glBlendFunc(GL_SRC_ALPHA, GL_ONE); renderBodyAsParticle(pos, appMag, faintestMag, discSizeInPixels, color, orientation, (nearPlaneDistance + farPlaneDistance) / 2.0f, true); }

void Renderer::renderStars (  const StarDatabase &  starDB, float  faintestVisible, const Observer &  observer )  [private]

Definition at line 6445 of file render.cpp. References Texture::bind(), brightnessBias, ObjectRenderer< OBJ, PREC >::brightnessBias, brightnessScale, ObjectRenderer< OBJ, PREC >::brightnessScale, colorTemp, StarRenderer::colorTemp, context, ObjectRenderer< OBJ, PREC >::context, corrFac, degToRad(), distanceLimit, ObjectRenderer< OBJ, PREC >::distanceLimit, faintestMag, ObjectRenderer< OBJ, PREC >::faintestMag, ObjectRenderer< OBJ, PREC >::faintestMagNight, Renderer::StarVertexBuffer::finish(), fov, ObjectRenderer< OBJ, PREC >::fov, glareParticles, StarRenderer::glareParticles, glareTex, StarRenderer::maxDiscSize, MaxScaledDiscStarSize, ObjectRenderer< OBJ, PREC >::observer, StarRenderer::obsPos, ObjectRenderer< OBJ, PREC >::pixelSize, pixelSize, PointStars, renderList, StarRenderer::renderList, renderParticles(), saturationMag, ObjectRenderer< OBJ, PREC >::saturationMag, ScaledDiscStars, Renderer::StarVertexBuffer::setBillboardOrientation(), ObjectRenderer< OBJ, PREC >::size, starStyle, Renderer::StarVertexBuffer::start(), starTex, starVertexBuffer, StarRenderer::starVertexBuffer, StarRenderer::useDiscs, ObjectRenderer< OBJ, PREC >::viewNormal, windowHeight, windowWidth, Point3< T >::x, Point3< T >::y, and Point3< T >::z. Referenced by render(). { StarRenderer starRenderer; Point3f obsPos = (Point3f) observer.getPosition(); obsPos.x *= 1e-6f; obsPos.y *= 1e-6f; obsPos.z *= 1e-6f; starRenderer.context = context; starRenderer.observer = &observer; starRenderer.obsPos = obsPos; starRenderer.viewNormal = Vec3f(0, 0, -1) * observer.getOrientation().toMatrix3(); starRenderer.glareParticles = &glareParticles; starRenderer.renderList = &renderList; starRenderer.starVertexBuffer = starVertexBuffer; starRenderer.fov = fov; // size/pixelSize =0.86 at 120deg, 1.43 at 45deg and 1.6 at 0deg. starRenderer.size = pixelSize * 1.6f / corrFac; starRenderer.pixelSize = pixelSize; starRenderer.brightnessScale = brightnessScale * corrFac; starRenderer.brightnessBias = brightnessBias; starRenderer.faintestMag = faintestMag; starRenderer.faintestMagNight = faintestMagNight; starRenderer.saturationMag = saturationMag; starRenderer.distanceLimit = distanceLimit; if (starStyle == ScaledDiscStars) { starRenderer.useDiscs = true; starRenderer.brightnessScale *= 2.0f; starRenderer.maxDiscSize = starRenderer.size * MaxScaledDiscStarSize; } starRenderer.colorTemp = colorTemp; glareParticles.clear(); starVertexBuffer->setBillboardOrientation(observer.getOrientation()); glEnable(GL_TEXTURE_2D); starTex->bind(); starRenderer.starVertexBuffer->start(starStyle == PointStars); starDB.findVisibleStars(starRenderer, obsPos, observer.getOrientation(), degToRad(fov), (float) windowWidth / (float) windowHeight, faintestMagNight); starRenderer.starVertexBuffer->finish(); glareTex->bind(); renderParticles(glareParticles, observer.getOrientation()); }

void Renderer::resize (  int  , int  )

Definition at line 570 of file render.cpp. References windowHeight, and windowWidth. Referenced by CelestiaCore::draw(), init(), and CelestiaCore::resize(). { windowWidth = width; windowHeight = height; // glViewport(windowWidth, windowHeight); }

void Renderer::setAmbientLightLevel (  float   )

Definition at line 699 of file render.cpp. References ambientLightLevel. Referenced by celestia_setambient(), CelestiaCore::charEntered(), KdeGlWidget::initializeGL(), MainWindowProc(), CommandSet::process(), CommandSetAmbientLight::process(), KdeApp::slotAmbientLightLevel(), KdePreferencesDialog::slotCancel(), and WinMain(). { ambientLightLevel = level; }

void Renderer::setBrightnessBias (  float   )

Definition at line 7029 of file render.cpp. References brightnessBias. Referenced by CelestiaCore::initRenderer(), CommandSetVisibilityLimit::process(), CelestiaCore::setFaintest(), and CelestiaCore::setFaintestAutoMag(). { brightnessBias = bias; }

void Renderer::setDistanceLimit (  float   )

Definition at line 736 of file render.cpp. References distanceLimit. Referenced by celestia_setstardistancelimit(), CommandSet::process(), and ViewOptionsProc(). { distanceLimit = distanceLimit_; }

void Renderer::setFaintestAM45deg (  float   )

Definition at line 598 of file render.cpp. References faintestAutoMag45deg. Referenced by celestia_setfaintestvisible(), CelestiaCore::charEntered(), CelestiaCore::initRenderer(), and CommandSetFaintestAutoMag45deg::process(). { faintestAutoMag45deg = _faintestAutoMag45deg; }

void Renderer::setFieldOfView (  float   )  [private]

Definition at line 582 of file render.cpp. References corrFac, FOV, and fov. Referenced by render(). { fov = _fov; corrFac = (0.12f * fov/FOV * fov/FOV + 1.0f); }

void Renderer::setFont (  TextureFont *   )

Definition at line 626 of file render.cpp. References font. Referenced by CelestiaCore::initRenderer(). { font = txf; }

void Renderer::setFragmentShaderEnabled (  bool   )

Definition at line 747 of file render.cpp. References fragmentShaderEnabled, and fragmentShaderSupported(). { fragmentShaderEnabled = enable && fragmentShaderSupported(); }

void Renderer::setLabelMode (  int   )

Definition at line 651 of file render.cpp. References labelMode. Referenced by celestia_hidelabel(), celestia_setlabelflags(), celestia_showlabel(), CelestiaCore::charEntered(), Url::goTo(), KdeGlWidget::initializeGL(), LocationsProc(), CommandLabels::process(), ViewOptionsDialog::RestoreSettings(), KdePreferencesDialog::slotCancel(), KdeApp::slotShowAsteroidLabels(), KdeApp::slotShowCometLabels(), KdeApp::slotShowConstellationLabels(), KdeApp::slotShowGalaxyLabels(), KdeApp::slotShowI18nConstellationLabels(), KdeApp::slotShowLocationLabels(), KdeApp::slotShowMoonLabels(), KdeApp::slotShowNebulaLabels(), KdeApp::slotShowOpenClusterLabels(), KdeApp::slotShowPlanetLabels(), KdeApp::slotShowSpacecraftLabels(), KdeApp::slotShowStarLabels(), ViewOptionsProc(), and WinMain(). { labelMode = _labelMode; }

void Renderer::setMinimumFeatureSize (  float   )

Definition at line 711 of file render.cpp. References minFeatureSize. Referenced by celestia_setminfeaturesize(), KdeGlWidget::initializeGL(), LocationsProc(), KdePreferencesDialog::slotCancel(), and KdeApp::slotMinFeatureSize(). { minFeatureSize = pixels; }

void Renderer::setMinimumOrbitSize (  float   )

Definition at line 724 of file render.cpp. References minOrbitSize. Referenced by celestia_setminorbitsize(), and CommandSet::process(). { minOrbitSize = pixels; }

void Renderer::setOrbitMask (  int   )

Definition at line 661 of file render.cpp. References orbitMask. Referenced by celestia_setorbitflags(), KdeGlWidget::initializeGL(), CommandOrbitFlags::process(), KdePreferencesDialog::slotCancel(), KdeApp::slotShowAsteroidOrbits(), KdeApp::slotShowCometOrbits(), KdeApp::slotShowMoonOrbits(), KdeApp::slotShowPlanetOrbits(), KdeApp::slotShowSpacecraftOrbits(), ViewOptionsProc(), and WinMain(). { orbitMask = mask; }

void Renderer::setRenderFlags (  int   )

Definition at line 641 of file render.cpp. References renderFlags. Referenced by celestia_hide(), celestia_setrenderflags(), celestia_show(), LuaState::charEntered(), CelestiaCore::charEntered(), LuaState::cleanup(), Url::goTo(), KdeGlWidget::initializeGL(), CelestiaCore::initRenderer(), CommandRenderFlags::process(), ViewOptionsDialog::RestoreSettings(), KdePreferencesDialog::slotCancel(), KdeApp::slotShowAtmospheres(), KdeApp::slotShowAutoMag(), KdeApp::slotShowBoundaries(), KdeApp::slotShowCelestialSphere(), KdeApp::slotShowCloudMaps(), KdeApp::slotShowCometTails(), KdeApp::slotShowDiagrams(), KdeApp::slotShowEclipseShadows(), KdeApp::slotShowGalaxies(), KdeApp::slotShowNebulae(), KdeApp::slotShowNightMaps(), KdeApp::slotShowOpenClusters(), KdeApp::slotShowOrbits(), KdeApp::slotShowPartialTrajectories(), KdeApp::slotShowPlanets(), KdeApp::slotShowRingShadows(), KdeApp::slotShowSmoothLines(), KdeApp::slotShowStars(), LuaState::tick(), ViewOptionsProc(), and WinMain(). { renderFlags = _renderFlags; }

void Renderer::setRenderMode (  int   )

Definition at line 631 of file render.cpp. References renderMode. Referenced by CelestiaCore::charEntered(), and KdeApp::slotWireframeMode(). { renderMode = _renderMode; }

void Renderer::setResolution (  unsigned int  resolution  )

Definition at line 614 of file render.cpp. References TEXTURE_RESOLUTION, and textureResolution. Referenced by CelestiaCore::charEntered(), and WinMain(). { if (resolution < TEXTURE_RESOLUTION) textureResolution = resolution; }

void Renderer::setSaturationMagnitude (  float   )

Definition at line 7017 of file render.cpp. References saturationMag. Referenced by CelestiaCore::initRenderer(), CommandSetVisibilityLimit::process(), and CelestiaCore::setFaintest(). { saturationMag = mag; }

void Renderer::setScreenDpi (  int   )

Definition at line 593 of file render.cpp. References screenDpi. Referenced by CelestiaCore::setScreenDpi(). { screenDpi = _dpi; }

void Renderer::setStarColorTable (  const ColorTemperatureTable *   )

Definition at line 675 of file render.cpp. References colorTemp. Referenced by CelestiaCore::charEntered(). { colorTemp = ct; }

void Renderer::setStarStyle (  StarStyle   )

Definition at line 7035 of file render.cpp. References starStyle. Referenced by celestia_setstarstyle(), CelestiaCore::charEntered(), MainWindowProc(), CommandSet::process(), and WinMain(). { starStyle = style; }

void Renderer::setVertexShaderEnabled (  bool   )

Definition at line 762 of file render.cpp. References vertexShaderEnabled, and vertexShaderSupported(). { vertexShaderEnabled = enable && vertexShaderSupported(); }

void Renderer::shutdown (   )  [inline]

Definition at line 60 of file render.h. {};

bool Renderer::testEclipse (  const Body &  receiver, const Body &  caster, const DirectionalLight &  light, double  now, vector< EclipseShadow > &  shadows )  [private]

Definition at line 5430 of file render.cpp. References EclipseShadow::direction, distance(), InvalidResource, Vector3< T >::length(), Vector3< T >::normalize(), EclipseShadow::origin, EclipseShadow::penumbraRadius, EclipseShadow::umbraRadius, Vector3< T >::x, Vector3< T >::y, and Vector3< T >::z. Referenced by renderPlanet(). { // Ignore situations where the shadow casting body is much smaller than // the receiver, as these shadows aren't likely to be relevant. Also, // ignore eclipses where the caster is not an ellipsoid, since we can't // generate correct shadows in this case. if (caster.getRadius() * 100 >= receiver.getRadius() && caster.getClassification() != Body::Invisible && caster.extant(now) && caster.getModel() == InvalidResource) { // All of the eclipse related code assumes that both the caster // and receiver are spherical. Irregular receivers will work more // or less correctly, but casters that are sufficiently non-spherical // will produce obviously incorrect shadows. Another assumption we // make is that the distance between the caster and receiver is much // less than the distance between the sun and the receiver. This // approximation works everywhere in the solar system, and likely // works for any orbitally stable pair of objects orbiting a star. Point3d posReceiver = receiver.getHeliocentricPosition(now); Point3d posCaster = caster.getHeliocentricPosition(now); //const Star* sun = receiver.getSystem()->getStar(); //assert(sun != NULL); //double distToSun = posReceiver.distanceFromOrigin(); //float appSunRadius = (float) (sun->getRadius() / distToSun); float appSunRadius = light.apparentSize; Vec3d dir = posCaster - posReceiver; double distToCaster = dir.length() - receiver.getRadius(); float appOccluderRadius = (float) (caster.getRadius() / distToCaster); // The shadow radius is the radius of the occluder plus some additional // amount that depends upon the apparent radius of the sun. For // a sun that's distant/small and effectively a point, the shadow // radius will be the same as the radius of the occluder. float shadowRadius = (1 + appSunRadius / appOccluderRadius) * caster.getRadius(); // Test whether a shadow is cast on the receiver. We want to know // if the receiver lies within the shadow volume of the caster. Since // we're assuming that everything is a sphere and the sun is far // away relative to the caster, the shadow volume is a // cylinder capped at one end. Testing for the intersection of a // singly capped cylinder is as simple as checking the distance // from the center of the receiver to the axis of the shadow cylinder. // If the distance is less than the sum of the caster's and receiver's // radii, then we have an eclipse. float R = receiver.getRadius() + shadowRadius; double dist = distance(posReceiver, Ray3d(posCaster, posCaster - light.position)); if (dist < R) { Vec3d sunDir = posCaster - light.position; sunDir.normalize(); EclipseShadow shadow; shadow.origin = Point3f((float) dir.x, (float) dir.y, (float) dir.z); shadow.direction = Vec3f((float) sunDir.x, (float) sunDir.y, (float) sunDir.z); shadow.penumbraRadius = shadowRadius; shadow.umbraRadius = caster.getRadius() * (appOccluderRadius - appSunRadius) / appOccluderRadius; shadows.push_back(shadow); return true; } } return false; }

bool Renderer::vertexShaderSupported (   )  const

Definition at line 767 of file render.cpp. References useVertexPrograms. Referenced by setVertexShaderEnabled(). { return useVertexPrograms; }

---

Member Data Documentation

Color Renderer::ambientColor [private]

Definition at line 449 of file render.h. Referenced by render(), and renderObject().

float Renderer::ambientLightLevel [private]

Definition at line 437 of file render.h. Referenced by getAmbientLightLevel(), render(), and setAmbientLightLevel().

float Renderer::brightnessBias [private]

Definition at line 440 of file render.h. Referenced by getBrightnessBias(), renderBodyAsParticle(), renderDeepSkyObjects(), renderStars(), and setBrightnessBias().

float Renderer::brightnessScale [private]

Definition at line 442 of file render.h. Referenced by render(), renderBodyAsParticle(), renderDeepSkyObjects(), and renderStars().

const ColorTemperatureTable* Renderer::colorTemp [private]

Definition at line 502 of file render.h. Referenced by getStarColorTable(), Renderer(), renderStar(), renderStars(), and setStarColorTable().

GLContext* Renderer::context [private]

Definition at line 422 of file render.h. Referenced by fragmentShaderSupported(), getGLContext(), init(), loadTextures(), renderDeepSkyObjects(), renderObject(), and renderStars().

float Renderer::corrFac [private]

Definition at line 428 of file render.h. Referenced by renderBodyAsParticle(), renderDeepSkyObjects(), renderStars(), and setFieldOfView().

std::vector<Label> Renderer::depthSortedLabels [private]

Definition at line 456 of file render.h. Referenced by addSortedLabel(), clearLabels(), render(), and renderSortedLabels().

DetailOptions Renderer::detailOptions [private]

Definition at line 475 of file render.h. Referenced by init(), renderObject(), and renderOrbit().

std::string Renderer::displayedSurface [private]

Definition at line 450 of file render.h. Referenced by render(), and renderPlanet().

float Renderer::distanceLimit [private]

Definition at line 494 of file render.h. Referenced by getDistanceLimit(), labelStars(), renderStars(), and setDistanceLimit().

std::vector<EclipseShadow> Renderer::eclipseShadows[MaxLights] [private]

Definition at line 457 of file render.h. Referenced by renderPlanet().

float Renderer::faintestAutoMag45deg [private]

Definition at line 430 of file render.h. Referenced by autoMag(), getFaintestAM45deg(), and setFaintestAM45deg().

float Renderer::faintestMag [private]

Definition at line 443 of file render.h. Referenced by autoMag(), labelStars(), render(), renderDeepSkyObjects(), renderStar(), and renderStars().

float Renderer::faintestPlanetMag [private]

Definition at line 444 of file render.h. Referenced by render(), renderPlanet(), and renderPlanetarySystem().

TextureFont* Renderer::font [private]

Definition at line 431 of file render.h. Referenced by getFont(), renderLabels(), renderLocations(), renderSortedLabels(), and setFont().

float Renderer::fov [private]

Definition at line 426 of file render.h. Referenced by autoMag(), render(), renderBodyAsParticle(), renderDeepSkyObjects(), renderForegroundOrbits(), renderObject(), renderOrbits(), renderStars(), and setFieldOfView().

bool Renderer::fragmentShaderEnabled [private]

Definition at line 438 of file render.h. Referenced by getFragmentShaderEnabled(), and setFragmentShaderEnabled().

std::vector<Particle> Renderer::glareParticles [private]

Definition at line 454 of file render.h. Referenced by renderStars().

std::vector<DSOLabel> Renderer::labelledDSOs [private]

Definition at line 463 of file render.h.

std::vector<StarLabel> Renderer::labelledStars [private]

Definition at line 462 of file render.h. Referenced by addLabelledStar(), clearLabelledStars(), labelStars(), and render().

int Renderer::labelMode [private]

Definition at line 434 of file render.h. Referenced by GetCurrentPreferences(), getLabelMode(), labelConstellations(), render(), renderDeepSkyObjects(), renderObject(), renderPlanet(), renderPlanetarySystem(), and setLabelMode().

std::vector<Label> Renderer::labels [private]

Definition at line 455 of file render.h. Referenced by addLabel(), clearLabels(), render(), and renderLabels().

std::vector<LightSource> Renderer::lightSourceLists[MaxSolarSystems] [private]

Definition at line 460 of file render.h. Referenced by render(), and renderPlanetarySystem().

uint32 Renderer::locationFilter [private]

Definition at line 496 of file render.h. Referenced by render(), and renderLocations().

float Renderer::minFeatureSize [private]

Definition at line 495 of file render.h. Referenced by getMinimumFeatureSize(), renderLocations(), and setMinimumFeatureSize().

float Renderer::minOrbitSize [private]

Definition at line 493 of file render.h. Referenced by getMinimumOrbitSize(), renderForegroundOrbits(), renderOrbits(), renderPlanetarySystem(), and setMinimumOrbitSize().

double Renderer::modelMatrix[16] [private]

Definition at line 465 of file render.h. Referenced by addLabel(), addSortedLabel(), and render().

std::vector<const Star*> Renderer::nearStars [private]

Definition at line 458 of file render.h. Referenced by render().

std::vector<CachedOrbit*> Renderer::orbitCache [private]

Definition at line 491 of file render.h. Referenced by render(), and renderOrbit().

int Renderer::orbitMask [private]

Definition at line 436 of file render.h. Referenced by GetCurrentPreferences(), getOrbitMask(), render(), renderForegroundOrbits(), renderOrbits(), and setOrbitMask().

float Renderer::pixelSize [private]

Definition at line 429 of file render.h. Referenced by render(), renderBodyAsParticle(), renderDeepSkyObjects(), renderLocations(), renderObject(), renderOrbits(), renderPlanet(), renderPlanetarySystem(), renderStar(), and renderStars().

double Renderer::projMatrix[16] [private]

Definition at line 466 of file render.h. Referenced by addLabel(), addSortedLabel(), render(), and renderMarkers().

int Renderer::renderFlags [private]

Definition at line 435 of file render.