DustEntity Class Reference

#include <DustEntity.h>

Inheritance diagram for DustEntity:

Collaboration diagram for DustEntity:

Instance Methods
(void)	- setDustColor:
(OOColor *)	- dustColor
(id)	- init [implementation]
(void)	- dealloc [implementation]
(BOOL)	- canCollide [implementation]
(void)	- updateCameraRelativePosition [implementation]
(void)	- update: [implementation]
(Vector)	- warpVector [implementation]
(void)	- drawImmediate:translucent: [implementation]
(void)	- resetGraphicsState [implementation]
(NSString *)	- descriptionForObjDump [implementation]
(void)	- checkShaderMode [implementation]
Instance Methods inherited from Entity
(NSUInteger)	- sessionID
(BOOL)	- isShip
(BOOL)	- isDock
(BOOL)	- isStation
(BOOL)	- isSubEntity
(BOOL)	- isPlayer
(BOOL)	- isPlanet
(BOOL)	- isSun
(BOOL)	- isSunlit
(BOOL)	- isStellarObject
(BOOL)	- isSky
(BOOL)	- isWormhole
(BOOL)	- isEffect
(BOOL)	- isVisualEffect
(BOOL)	- isWaypoint
(BOOL)	- validForAddToUniverse
(void)	- addToLinkedLists
(void)	- removeFromLinkedLists
(void)	- updateLinkedLists
(void)	- wasAddedToUniverse
(void)	- wasRemovedFromUniverse
(void)	- warnAboutHostiles
(CollisionRegion *)	- collisionRegion
(void)	- setCollisionRegion:
(void)	- setUniversalID:
(OOUniversalID)	- universalID
(BOOL)	- throwingSparks
(void)	- setThrowSparks:
(void)	- throwSparks
(void)	- setOwner:
(id)	- owner
(ShipEntity *)	- parentEntity
(ShipEntity *)	- rootShipEntity
(void)	- setPosition:
(void)	- setPositionX:y:z:
(HPVector)	- position
(Vector)	- cameraRelativePosition
(GLfloat)	- cameraRangeFront
(GLfloat)	- cameraRangeBack
(Vector)	- vectorTo:
(HPVector)	- absolutePositionForSubentity
(HPVector)	- absolutePositionForSubentityOffset:
(double)	- zeroDistance
(double)	- camZeroDistance
(NSComparisonResult)	- compareZeroDistance:
(BoundingBox)	- boundingBox
(GLfloat)	- mass
(Quaternion)	- orientation
(void)	- setOrientation:
(Quaternion)	- normalOrientation
(void)	- setNormalOrientation:
(void)	- orientationChanged
(void)	- setVelocity:
(Vector)	- velocity
(double)	- speed
(GLfloat)	- distanceTravelled
(void)	- setDistanceTravelled:
(void)	- setStatus:
(OOEntityStatus)	- status
(void)	- setScanClass:
(OOScanClass)	- scanClass
(void)	- setEnergy:
(GLfloat)	- energy
(void)	- setMaxEnergy:
(GLfloat)	- maxEnergy
(void)	- applyRoll:andClimb:
(void)	- applyRoll:climb:andYaw:
(void)	- moveForward:
(OOMatrix)	- rotationMatrix
(OOMatrix)	- drawRotationMatrix
(OOMatrix)	- transformationMatrix
(OOMatrix)	- drawTransformationMatrix
(GLfloat)	- collisionRadius
(GLfloat)	- frustumRadius
(void)	- setCollisionRadius:
(NSMutableArray *)	- collisionArray
(void)	- applyVelocity:
(BOOL)	- checkCloseCollisionWith:
(void)	- takeEnergyDamage:from:becauseOf:weaponIdentifier:
(void)	- dumpState
(void)	- dumpSelfState
(NSUInteger)	- lastDrawCounter
(void)	- setLastDrawCounter:
(double)	- findCollisionRadius
(BOOL)	- isVisible
(BOOL)	- isInSpace
(BOOL)	- isImmuneToBreakPatternHide
(GLfloat)	- universalTime
(GLfloat)	- spawnTime
(GLfloat)	- timeElapsedSinceSpawn
(void)	- setAtmosphereFogging:
(OOColor *)	- fogUniform
(NSString *)	- descriptionForObjDumpBasic
(NSSet *)	- allTextures
(NSString *)	- descriptionComponents [implementation]
(BOOL)	- checkLinkedLists [implementation]
(id< OOWeakReferenceSupport >)	- superShaderBindingTarget [implementation]
(Vector)	- relativePosition [implementation]
(void)	- subEntityReallyDied: [implementation]
(BOOL)	- isBreakPattern
(void)	- inspect [implementation]
(BOOL)	- isECMBlast
(BOOL)	- isExhaust
(BOOL)	- isFlasher
(BOOL)	- isVisibleToScripts
(NSString *)	- oo_jsClassName
(void)	- getJSClass:andPrototype:
(void)	- deleteJSSelf
(jsval)	- oo_jsValueInContext: [implementation]
(BOOL)	- isCascadeWeapon
(BOOL)	- isPlayerLikeShip
(GLfloat)	- clock [implementation]
(unsigned)	- pseudoFixedD100 [implementation]
(unsigned)	- pseudoFixedD256 [implementation]
(unsigned)	- systemGovernment [implementation]
(unsigned)	- systemEconomy [implementation]
(unsigned)	- systemTechLevel [implementation]
(unsigned)	- systemPopulation [implementation]
(unsigned)	- systemProductivity [implementation]
(BOOL)	- isShipWithSubEntityShip:
(void)	- drawSubEntityImmediate:translucent: [implementation]
Instance Methods inherited from OOWeakRefObject
(id)	- weakSelf
(id)	- weakRetain [implementation]
(void)	- weakRefDied: [implementation]
Instance Methods inherited from <OOWeakReferenceSupport>
(id)	- OO_RETURNS_RETAINED

Private Attributes
OOColor *	dust_color
Vector	vertices [DUST_N_PARTICLES *2]
GLushort	indices [DUST_N_PARTICLES *2]
GLfloat	color_fv [4]
OOTexture *	texture
bool	hasPointSprites
bool	drawDust

Additional Inherited Members
Public Attributes inherited from Entity
OOUniversalID	universalID
unsigned	isShip: 1
unsigned	isStation: 1
unsigned	isPlayer: 1
unsigned	isWormhole: 1
unsigned	isSubEntity: 1
unsigned	hasMoved: 1
unsigned	hasRotated: 1
unsigned	hasCollided: 1
unsigned	isSunlit: 1
unsigned	collisionTestFilter: 2
unsigned	throw_sparks: 1
unsigned	isImmuneToBreakPatternHide: 1
unsigned	isExplicitlyNotMainStation: 1
unsigned	isVisualEffect: 1
OOScanClass	scanClass
GLfloat	zero_distance
GLfloat	cam_zero_distance
GLfloat	no_draw_distance
GLfloat	collision_radius
HPVector	position
Vector	cameraRelativePosition
Quaternion	orientation
OOColor *	atmosphereFogging
int	zero_index
Entity *	x_previous
Entity *	x_next
Entity *	y_previous
Entity *	y_next
Entity *	z_previous
Entity *	z_next
Entity *	collision_chain
OOUniversalID	shadingEntityID
Entity *	collider
CollisionRegion *	collisionRegion
Protected Attributes inherited from Entity
HPVector	lastPosition
Quaternion	lastOrientation
GLfloat	distanceTravelled
OOMatrix	rotMatrix
Vector	velocity
GLfloat	energy
GLfloat	maxEnergy
BoundingBox	boundingBox
GLfloat	mass
NSMutableArray *	collidingEntities
OOTimeAbsolute	spawnTime
struct JSObject *	_jsSelf
NSUInteger	lastDrawCounter
Protected Attributes inherited from OOWeakRefObject
OOWeakReference *	weakSelf

Detailed Description

Definition at line 37 of file DustEntity.h.

Method Documentation

canCollide

- (BOOL) canCollide

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

{
    return NO;
}

checkShaderMode

- (void) checkShaderMode

implementation

Provided by category DustEntity(Private).

dealloc

- (void) dealloc

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

{
    DESTROY(dust_color);
    [[OOGraphicsResetManager sharedManager] unregisterClient:self];
 
    DESTROY(texture);
#if OO_SHADERS
    DESTROY(shader);
    DESTROY(uniforms);
#endif
    
    [super dealloc];
}

descriptionForObjDump

- (NSString *) descriptionForObjDump

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

{
    // Don't include range and visibility flag as they're irrelevant.
    return [self descriptionForObjDumpBasic];
}

drawImmediate:translucent:

- (void) drawImmediate: (bool)  immediate translucent: (bool)  translucent

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

                      :(bool)immediate translucent:(bool)translucent
{
    if (!drawDust || [UNIVERSE breakPatternHide] || !translucent)  return;  // DON'T DRAW
    
    PlayerEntity* player = PLAYER;
    assert(player != nil);
    
#ifndef NDEBUG
    if (gDebugFlags & DEBUG_NO_DUST)  return;
#endif
    
#if OO_SHADERS
    if (EXPECT_NOT(shaderMode == kShaderModeUnknown))  [self checkShaderMode];
    BOOL useShader = (shaderMode == kShaderModeOn);
#endif
    
 
    GLfloat *fogcolor = [UNIVERSE skyClearColor];
    float   idealDustSize = [[UNIVERSE gameView] viewSize].width / 800.0f;
    
    BOOL    warp_stars = [player atHyperspeed];
    float   dustIntensity;
    
    OO_ENTER_OPENGL();
    OOSetOpenGLState(OPENGL_STATE_OPAQUE);
    OOGL(glDisableClientState(GL_NORMAL_ARRAY));
 
    if (!warp_stars)
    {
        // Draw points.
        float dustPointSize = ceil(idealDustSize);
        if (dustPointSize < 1.0f)  dustPointSize = 1.0f;
        OOGL(GLScaledPointSize(dustPointSize));
        dustIntensity = OOClamp_0_1_f(idealDustSize / dustPointSize);
    }
    else
    {
        // Draw lines.
        float idealLineSize = idealDustSize * 0.5f;
        float dustLineSize = ceil(idealLineSize);
        if (dustLineSize < 1.0f)  dustLineSize = 1.0f;
        GLScaledLineWidth(dustLineSize);
        dustIntensity = OOClamp_0_1_f(idealLineSize / dustLineSize);
    }
    if (fogcolor[3] > 0.0)
    {
        // fade out dust when entering atmosphere (issue #100)
        dustIntensity = OOClamp_0_1_f(dustIntensity-(fogcolor[3]*3.0));
    }
 
 
    if (dustIntensity > 0.0)
    {
 
        float   *color = NULL;
        if (player->isSunlit)  color = color_fv;
        else  color = UNIVERSE->stars_ambient;
        OOGL(glColor4f(color[0], color[1], color[2], dustIntensity));
    
#if OO_SHADERS
        if (useShader)
        {
            [[self shader] apply];
            [uniforms makeObjectsPerformSelector:@selector(apply)];
        }
        else
#endif
        {
            OOGL(glEnable(GL_FOG));
            OOGL(glFogi(GL_FOG_MODE, GL_LINEAR));
            OOGL(glFogfv(GL_FOG_COLOR, fogcolor));
            OOGL(glHint(GL_FOG_HINT, GL_NICEST));
            OOGL(glFogf(GL_FOG_START, NEAR_PLANE));
            OOGL(glFogf(GL_FOG_END, FAR_PLANE));
        }
 
        OOGL(glEnable(GL_BLEND));
        OOGL(glDepthMask(GL_FALSE));
    
        if (warp_stars)
        {
            OOGL(glDisable(GL_TEXTURE_2D));
#if OO_SHADERS
            if (useShader)
            {
                OOGL(glEnableVertexAttribArrayARB(kTangentAttributeIndex));
                OOGL(glVertexAttribPointerARB(kTangentAttributeIndex, 1, GL_FLOAT, GL_FALSE, 0, warpinessAttr));
            }
            else
#endif
            {
                Vector  warpVector = [self warpVector];
                unsigned vi;
                for (vi = 0; vi < DUST_N_PARTICLES; vi++)
                {
                    vertices[vi + DUST_N_PARTICLES] = vector_subtract(vertices[vi], warpVector);
                }
            }
        
            OOGL(glVertexPointer(3, GL_FLOAT, 0, vertices));
            OOGL(glDrawElements(GL_LINES, DUST_N_PARTICLES * 2, GL_UNSIGNED_SHORT, indices));
        
#if OO_SHADERS
            if (useShader)
            {
                OOGL(glDisableVertexAttribArrayARB(kTangentAttributeIndex));
            }
#endif
            OOGL(glEnable(GL_TEXTURE_2D));
    
        }
        else
        {
            if (hasPointSprites)
            {
#if OO_SHADERS
                if (!useShader)
#endif
                {
                    OOGL(glBlendFunc(GL_SRC_ALPHA, GL_ONE));
                }
                OOGL(glEnable(GL_POINT_SPRITE_ARB));
                [texture apply];
                OOGL(glVertexPointer(3, GL_FLOAT, 0, vertices));
                OOGL(glDrawArrays(GL_POINTS, 0, DUST_N_PARTICLES));
                OOGL(glDisable(GL_POINT_SPRITE_ARB));
            }
            else
            {
                OOGL(glDisable(GL_TEXTURE_2D));
                OOGL(glVertexPointer(3, GL_FLOAT, 0, vertices));
                OOGL(glDrawArrays(GL_POINTS, 0, DUST_N_PARTICLES));
                OOGL(glEnable(GL_TEXTURE_2D));
            }
        }
    
        // reapply normal conditions
#if OO_SHADERS
        if (useShader)
        {
            [OOShaderProgram applyNone];
        }
        else
#endif
        {
            OOGL(glDisable(GL_FOG));
            OOGL(glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA));
        }
    
        OOGL(glDisable(GL_BLEND));
        OOGL(glDepthMask(GL_TRUE));
 
    }
    OOGL(glEnableClientState(GL_NORMAL_ARRAY));
    
    OOVerifyOpenGLState();
    OOCheckOpenGLErrors(@"DustEntity after drawing %@", self);
}

dustColor

- (OOColor *) dustColor

Definition at line 1 of file DustEntity.m.

{
    return dust_color;
}

init

- (id) init

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

{
    int vi;
    
// this should be unnecessary
//  ranrot_srand((uint32_t)[[NSDate date] timeIntervalSince1970]);  // seed randomiser by time
    
    self = [super init];
    
    for (vi = 0; vi < DUST_N_PARTICLES; vi++)
    {
        vertices[vi].x = (ranrot_rand() % DUST_SCALE) - DUST_SCALE / 2;
        vertices[vi].y = (ranrot_rand() % DUST_SCALE) - DUST_SCALE / 2;
        vertices[vi].z = (ranrot_rand() % DUST_SCALE) - DUST_SCALE / 2;
        
        // Set up element index array for warp mode.
        indices[vi * 2] = vi;
        indices[vi * 2 + 1] = vi + DUST_N_PARTICLES;
        
#if OO_SHADERS
        vertices[vi + DUST_N_PARTICLES] = vertices[vi];
        warpinessAttr[vi] = 0.0f;
        warpinessAttr[vi + DUST_N_PARTICLES] = 1.0f;
#endif
    }
    
#if OO_SHADERS
    shaderMode = kShaderModeUnknown;
#endif
    
    drawDust = ![[[NSProcessInfo processInfo] arguments] containsObject:@"-nodust"];
    
    dust_color = [[OOColor colorWithRed:0.5 green:1.0 blue:1.0 alpha:1.0] retain];
    [self setStatus:STATUS_ACTIVE];
 
    hasPointSprites = [[OOOpenGLExtensionManager sharedManager] haveExtension:@"GL_ARB_point_sprite"];
    
    if (hasPointSprites)
    {
        texture = [[OOTexture textureWithName:@"oolite-particle-dust.png"
                                                                 inFolder:@"Textures"
                                                                    options:kOOTextureMinFilterMipMap | kOOTextureMagFilterLinear | kOOTextureAlphaMask
                                                             anisotropy:kOOTextureDefaultAnisotropy / 2.0
                                                                    lodBias:0.0] retain];
    }   
 
    collision_radius = DUST_SCALE; // for draw pass calculations
 
    [[OOGraphicsResetManager sharedManager] registerClient:self];
 
    return self;
}

resetGraphicsState

- (void) resetGraphicsState

implementation

Definition at line 1 of file DustEntity.m.

{
#if OO_SHADERS
    DESTROY(shader);
    DESTROY(uniforms);
    
    shaderMode = kShaderModeUnknown;
    
    /*  Duplicate vertex data. This is only required if we're switching from
        non-shader mode to a shader mode, but let's KISS.
    */
    memcpy(vertices + DUST_N_PARTICLES, vertices, sizeof *vertices * DUST_N_PARTICLES);
#endif
}

setDustColor:

- (void) setDustColor:

(OOColor *)

color

Definition at line 1 of file DustEntity.m.

                     :(OOColor *) color
{
    if (dust_color) [dust_color release];
    dust_color = [color retain];
    [dust_color getRed:&color_fv[0] green:&color_fv[1] blue:&color_fv[2] alpha:&color_fv[3]];
}

update:

- (void) update: (OOTimeDelta)  delta_t

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

               :(OOTimeDelta) delta_t
{
    // [self setPosition:position];
    zero_distance = 0.0;
            
#if OO_SHADERS
    if (EXPECT_NOT(shaderMode == kShaderModeUnknown))  [self checkShaderMode];
    
    // Shader takes care of repositioning.
    if (shaderMode == kShaderModeOn)  return;
#endif
    
    Vector offset = vector_flip(cameraRelativePosition);
    GLfloat  half_scale = DUST_SCALE * 0.50;
    int vi;
    for (vi = 0; vi < DUST_N_PARTICLES; vi++)
    {
        while (vertices[vi].x - offset.x < -half_scale)
            vertices[vi].x += DUST_SCALE;
        while (vertices[vi].x - offset.x > half_scale)
            vertices[vi].x -= DUST_SCALE;
        
        while (vertices[vi].y - offset.y < -half_scale)
            vertices[vi].y += DUST_SCALE;
        while (vertices[vi].y - offset.y > half_scale)
            vertices[vi].y -= DUST_SCALE;
        
        while (vertices[vi].z - offset.z < -half_scale)
            vertices[vi].z += DUST_SCALE;
        while (vertices[vi].z - offset.z > half_scale)
            vertices[vi].z -= DUST_SCALE;
    }
}

updateCameraRelativePosition

- (void) updateCameraRelativePosition

implementation

Reimplemented from Entity.

Definition at line 1 of file DustEntity.m.

{
    HPVector c_pos = [PLAYER viewpointPosition];
    cameraRelativePosition = make_vector((OOScalar)-fmod(c_pos.x,DUST_SCALE),(OOScalar)-fmod(c_pos.y,DUST_SCALE),(OOScalar)-fmod(c_pos.z,DUST_SCALE));
}

warpVector

- (Vector) warpVector

implementation

Definition at line 1 of file DustEntity.m.

{
    return vector_multiply_scalar([PLAYER velocity], 1.0f / HYPERSPEED_FACTOR);
}

Member Data Documentation

color_fv

- (GLfloat color_fv[4])

private

Definition at line 43 of file DustEntity.h.

drawDust

- (bool) drawDust

private

Definition at line 46 of file DustEntity.h.

dust_color

- (OOColor*) dust_color

private

Definition at line 40 of file DustEntity.h.

hasPointSprites

- (bool) hasPointSprites

private

Definition at line 45 of file DustEntity.h.

indices

- (GLushort indices[DUST_N_PARTICLES *2])

private

Definition at line 42 of file DustEntity.h.

texture

- (OOTexture*) texture

private

Definition at line 44 of file DustEntity.h.

vertices

- (Vector vertices[DUST_N_PARTICLES *2])

private

Definition at line 41 of file DustEntity.h.

---

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

• src/Core/Entities/DustEntity.h
• src/Core/Entities/DustEntity.m