mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-25 22:55:06 +02:00
511 lines
21 KiB
C++
511 lines
21 KiB
C++
//
|
|
// ParticleSystem.cpp
|
|
// hifi
|
|
//
|
|
// Created by Jeffrey on July 10, 2013
|
|
//
|
|
|
|
#include <glm/glm.hpp>
|
|
#include "InterfaceConfig.h"
|
|
#include <SharedUtil.h>
|
|
#include "ParticleSystem.h"
|
|
#include "Application.h"
|
|
|
|
const float DEFAULT_PARTICLE_RADIUS = 0.01f;
|
|
const float DEFAULT_PARTICLE_BOUNCE = 1.0f;
|
|
const float DEFAULT_PARTICLE_AIR_FRICTION = 2.0f;
|
|
const float DEFAULT_PARTICLE_LIFESPAN = 1.0f;
|
|
const int DEFAULT_PARTICLE_SPHERE_RESOLUTION = 6;
|
|
const float DEFAULT_EMITTER_RENDER_LENGTH = 0.2f;
|
|
|
|
ParticleSystem::ParticleSystem() {
|
|
|
|
_timer = 0.0f;
|
|
_numEmitters = 0;
|
|
_upDirection = glm::vec3(0.0f, 1.0f, 0.0f); // default
|
|
|
|
for (unsigned int emitterIndex = 0; emitterIndex < MAX_EMITTERS; emitterIndex++) {
|
|
|
|
Emitter * e = &_emitter[emitterIndex];
|
|
e->position = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
e->previousPosition = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
e->direction = glm::vec3(0.0f, 1.0f, 0.0f);
|
|
e->visible = false;
|
|
e->particleResolution = DEFAULT_PARTICLE_SPHERE_RESOLUTION;
|
|
e->particleLifespan = DEFAULT_PARTICLE_LIFESPAN;
|
|
e->showingBaseParticle = false;
|
|
e->emitReserve = 0.0;
|
|
e->thrust = 0.0f;
|
|
e->rate = 0.0f;
|
|
e->currentParticle = 0;
|
|
e->particleRenderStyle = PARTICLE_RENDER_STYLE_SPHERE;
|
|
e->numParticlesEmittedThisTime = 0;
|
|
|
|
for (int lifeStage = 0; lifeStage < NUM_PARTICLE_LIFE_STAGES; lifeStage++) {
|
|
setParticleAttributesToDefault(&_emitter[emitterIndex].particleAttributes[lifeStage]);
|
|
}
|
|
};
|
|
|
|
for (unsigned int p = 0; p < MAX_PARTICLES; p++) {
|
|
_particle[p].alive = false;
|
|
_particle[p].age = 0.0f;
|
|
_particle[p].radius = 0.0f;
|
|
_particle[p].emitterIndex = 0;
|
|
_particle[p].previousParticle = NULL_PARTICLE;
|
|
_particle[p].position = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
_particle[p].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
}
|
|
}
|
|
|
|
int ParticleSystem::addEmitter() {
|
|
|
|
if (_numEmitters < MAX_EMITTERS) {
|
|
_numEmitters ++;
|
|
return _numEmitters - 1;
|
|
}
|
|
|
|
return NULL_EMITTER;
|
|
}
|
|
|
|
|
|
void ParticleSystem::simulate(float deltaTime) {
|
|
|
|
_timer += deltaTime;
|
|
|
|
// emit particles
|
|
for (int e = 0; e < _numEmitters; e++) {
|
|
|
|
assert(e >= 0);
|
|
assert(e <= MAX_EMITTERS);
|
|
assert(_emitter[e].rate >= 0);
|
|
|
|
_emitter[e].emitReserve += _emitter[e].rate * deltaTime;
|
|
_emitter[e].numParticlesEmittedThisTime = (int)_emitter[e].emitReserve;
|
|
_emitter[e].emitReserve -= _emitter[e].numParticlesEmittedThisTime;
|
|
|
|
for (int p = 0; p < _emitter[e].numParticlesEmittedThisTime; p++) {
|
|
float timeFraction = (float)p / (float)_emitter[e].numParticlesEmittedThisTime;
|
|
createParticle(e, timeFraction);
|
|
}
|
|
}
|
|
|
|
// update particles
|
|
|
|
for (int p = 0; p < MAX_PARTICLES; p++) {
|
|
if (_particle[p].alive) {
|
|
if (_particle[p].age > _emitter[_particle[p].emitterIndex].particleLifespan) {
|
|
killParticle(p);
|
|
} else {
|
|
updateParticle(p, deltaTime);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::createParticle(int e, float timeFraction) {
|
|
|
|
for (unsigned int p = 0; p < MAX_PARTICLES; p++) {
|
|
if (!_particle[p].alive) {
|
|
|
|
_particle[p].emitterIndex = e;
|
|
_particle[p].alive = true;
|
|
_particle[p].age = 0.0f;
|
|
_particle[p].velocity = _emitter[e].direction * _emitter[e].thrust;
|
|
_particle[p].position = _emitter[e].previousPosition + timeFraction * (_emitter[e].position - _emitter[e].previousPosition);
|
|
_particle[p].radius = _emitter[e].particleAttributes[PARTICLE_LIFESTAGE_0].radius;
|
|
_particle[p].color = _emitter[e].particleAttributes[PARTICLE_LIFESTAGE_0].color;
|
|
_particle[p].previousParticle = NULL_PARTICLE;
|
|
|
|
if (_particle[_emitter[e].currentParticle].alive) {
|
|
if (_particle[_emitter[e].currentParticle].emitterIndex == e) {
|
|
_particle[p].previousParticle = _emitter[e].currentParticle;
|
|
}
|
|
}
|
|
|
|
_emitter[e].currentParticle = p;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::killParticle(int p) {
|
|
|
|
assert(p >= 0);
|
|
assert(p < MAX_PARTICLES);
|
|
|
|
_particle[p].alive = false;
|
|
_particle[p].previousParticle = NULL_PARTICLE;
|
|
_particle[p].position = _emitter[_particle[p].emitterIndex].position;
|
|
_particle[p].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
_particle[p].age = 0.0f;
|
|
_particle[p].emitterIndex = NULL_PARTICLE;
|
|
_particle[p].color = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
_particle[p].radius = 0.0f;
|
|
}
|
|
|
|
|
|
void ParticleSystem::setEmitterPosition(int emitterIndex, glm::vec3 position) {
|
|
_emitter[emitterIndex].previousPosition = _emitter[emitterIndex].position;
|
|
_emitter[emitterIndex].position = position;
|
|
}
|
|
|
|
|
|
void ParticleSystem::setParticleAttributes(int emitterIndex, ParticleAttributes attributes) {
|
|
|
|
for (int lifeStage = 0; lifeStage < NUM_PARTICLE_LIFE_STAGES; lifeStage ++) {
|
|
setParticleAttributes(emitterIndex, (ParticleLifeStage)lifeStage, attributes);
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::setParticleAttributesToDefault(ParticleAttributes * a) {
|
|
|
|
a->radius = DEFAULT_PARTICLE_RADIUS;
|
|
a->color = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
a->bounce = DEFAULT_PARTICLE_BOUNCE;
|
|
a->airFriction = DEFAULT_PARTICLE_AIR_FRICTION;
|
|
a->gravity = 0.0f;
|
|
a->jitter = 0.0f;
|
|
a->emitterAttraction = 0.0f;
|
|
a->tornadoForce = 0.0f;
|
|
a->neighborAttraction = 0.0f;
|
|
a->neighborRepulsion = 0.0f;
|
|
a->collisionSphereRadius = 0.0f;
|
|
a->collisionSpherePosition = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
a->usingCollisionSphere = false;
|
|
a->collisionPlaneNormal = _upDirection;
|
|
a->collisionPlanePosition = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
a->usingCollisionPlane = false;
|
|
a->modulationAmplitude = 0.0f;
|
|
a->modulationRate = 0.0;
|
|
a->modulationStyle = COLOR_MODULATION_STYLE_NULL;
|
|
|
|
}
|
|
|
|
|
|
void ParticleSystem::setParticleAttributes(int emitterIndex, ParticleLifeStage lifeStage, ParticleAttributes attributes) {
|
|
|
|
assert(lifeStage >= 0);
|
|
assert(lifeStage < NUM_PARTICLE_LIFE_STAGES);
|
|
|
|
ParticleAttributes * a = &_emitter[emitterIndex].particleAttributes[lifeStage];
|
|
|
|
a->radius = attributes.radius;
|
|
a->color = attributes.color;
|
|
a->bounce = attributes.bounce;
|
|
a->gravity = attributes.gravity;
|
|
a->airFriction = attributes.airFriction;
|
|
a->jitter = attributes.jitter;
|
|
a->emitterAttraction = attributes.emitterAttraction;
|
|
a->tornadoForce = attributes.tornadoForce;
|
|
a->neighborAttraction = attributes.neighborAttraction;
|
|
a->neighborRepulsion = attributes.neighborRepulsion;
|
|
a->usingCollisionSphere = attributes.usingCollisionSphere;
|
|
a->collisionSpherePosition = attributes.collisionSpherePosition;
|
|
a->collisionSphereRadius = attributes.collisionSphereRadius;
|
|
a->usingCollisionPlane = attributes.usingCollisionPlane;
|
|
a->collisionPlanePosition = attributes.collisionPlanePosition;
|
|
a->collisionPlaneNormal = attributes.collisionPlaneNormal;
|
|
a->modulationAmplitude = attributes.modulationAmplitude;
|
|
a->modulationRate = attributes.modulationRate;
|
|
a->modulationStyle = attributes.modulationStyle;
|
|
}
|
|
|
|
|
|
|
|
void ParticleSystem::updateParticle(int p, float deltaTime) {
|
|
|
|
Emitter myEmitter = _emitter[_particle[p].emitterIndex];
|
|
|
|
assert(_particle[p].age <= myEmitter.particleLifespan);
|
|
|
|
float ageFraction = 0.0f;
|
|
int lifeStage = 0;
|
|
float lifeStageFraction = 0.0f;
|
|
|
|
if (_emitter[_particle[p].emitterIndex].particleLifespan > 0.0) {
|
|
|
|
ageFraction = _particle[p].age / myEmitter.particleLifespan;
|
|
lifeStage = (int)(ageFraction * (NUM_PARTICLE_LIFE_STAGES - 1));
|
|
lifeStageFraction = ageFraction * (NUM_PARTICLE_LIFE_STAGES - 1) - lifeStage;
|
|
|
|
// adjust radius
|
|
_particle[p].radius
|
|
= myEmitter.particleAttributes[lifeStage ].radius * (1.0f - lifeStageFraction)
|
|
+ myEmitter.particleAttributes[lifeStage+1].radius * lifeStageFraction;
|
|
|
|
// apply random jitter
|
|
float j = myEmitter.particleAttributes[lifeStage].jitter;
|
|
_particle[p].velocity +=
|
|
glm::vec3
|
|
(
|
|
-j * ONE_HALF + j * randFloat(),
|
|
-j * ONE_HALF + j * randFloat(),
|
|
-j * ONE_HALF + j * randFloat()
|
|
) * deltaTime;
|
|
|
|
// apply attraction to home position
|
|
glm::vec3 vectorToHome = myEmitter.position - _particle[p].position;
|
|
_particle[p].velocity += vectorToHome * myEmitter.particleAttributes[lifeStage].emitterAttraction * deltaTime;
|
|
|
|
// apply neighbor attraction
|
|
int neighbor = p + 1;
|
|
if (neighbor == MAX_PARTICLES) {
|
|
neighbor = 0;
|
|
}
|
|
|
|
if (_particle[neighbor].emitterIndex == _particle[p].emitterIndex) {
|
|
glm::vec3 vectorToNeighbor = _particle[p].position - _particle[neighbor].position;
|
|
|
|
_particle[p].velocity -= vectorToNeighbor * myEmitter.particleAttributes[lifeStage].neighborAttraction * deltaTime;
|
|
|
|
float distanceToNeighbor = glm::length(vectorToNeighbor);
|
|
if (distanceToNeighbor > 0.0f) {
|
|
_particle[neighbor].velocity += (vectorToNeighbor / (1.0f + distanceToNeighbor * distanceToNeighbor)) * myEmitter.particleAttributes[lifeStage].neighborRepulsion * deltaTime;
|
|
}
|
|
}
|
|
|
|
// apply tornado force
|
|
glm::vec3 tornadoDirection = glm::cross(vectorToHome, myEmitter.direction);
|
|
_particle[p].velocity += tornadoDirection * myEmitter.particleAttributes[lifeStage].tornadoForce * deltaTime;
|
|
|
|
// apply air friction
|
|
float drag = 1.0 - myEmitter.particleAttributes[lifeStage].airFriction * deltaTime;
|
|
if (drag < 0.0f) {
|
|
_particle[p].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
|
|
} else {
|
|
_particle[p].velocity *= drag;
|
|
}
|
|
|
|
// apply gravity
|
|
_particle[p].velocity -= _upDirection * myEmitter.particleAttributes[lifeStage].gravity * deltaTime;
|
|
|
|
// update position by velocity
|
|
_particle[p].position += _particle[p].velocity;
|
|
|
|
// collision with the plane surface
|
|
if (myEmitter.particleAttributes[lifeStage].usingCollisionPlane) {
|
|
glm::vec3 vectorFromParticleToPlanePosition = _particle[p].position - myEmitter.particleAttributes[lifeStage].collisionPlanePosition;
|
|
glm::vec3 normal = myEmitter.particleAttributes[lifeStage].collisionPlaneNormal;
|
|
float dot = glm::dot(vectorFromParticleToPlanePosition, normal);
|
|
if (dot < _particle[p].radius) {
|
|
_particle[p].position += normal * (_particle[p].radius - dot);
|
|
float planeNormalComponentOfVelocity = glm::dot(_particle[p].velocity, normal);
|
|
_particle[p].velocity -= normal * planeNormalComponentOfVelocity * (1.0f + myEmitter.particleAttributes[lifeStage].bounce);
|
|
}
|
|
}
|
|
|
|
// collision with sphere
|
|
if (myEmitter.particleAttributes[lifeStage].usingCollisionSphere) {
|
|
glm::vec3 vectorToSphereCenter = myEmitter.particleAttributes[lifeStage].collisionSpherePosition - _particle[p].position;
|
|
float distanceToSphereCenter = glm::length(vectorToSphereCenter);
|
|
float combinedRadius = myEmitter.particleAttributes[lifeStage].collisionSphereRadius + _particle[p].radius;
|
|
if (distanceToSphereCenter < combinedRadius) {
|
|
|
|
if (distanceToSphereCenter > 0.0f){
|
|
glm::vec3 directionToSphereCenter = vectorToSphereCenter / distanceToSphereCenter;
|
|
_particle[p].position = myEmitter.particleAttributes[lifeStage].collisionSpherePosition - directionToSphereCenter * combinedRadius;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// adjust color
|
|
_particle[p].color
|
|
= myEmitter.particleAttributes[lifeStage ].color * (1.0f - lifeStageFraction)
|
|
+ myEmitter.particleAttributes[lifeStage+1].color * lifeStageFraction;
|
|
|
|
// apply color modulation
|
|
if (myEmitter.particleAttributes[lifeStage ].modulationAmplitude > 0.0f) {
|
|
float modulation = 0.0f;
|
|
float radian = _timer * myEmitter.particleAttributes[lifeStage ].modulationRate * PI_TIMES_TWO;
|
|
if (myEmitter.particleAttributes[lifeStage ].modulationStyle == COLOR_MODULATION_STYLE_LIGHNTESS_PULSE) {
|
|
if (sinf(radian) > 0.0f) {
|
|
modulation = myEmitter.particleAttributes[lifeStage].modulationAmplitude;
|
|
}
|
|
} else if (myEmitter.particleAttributes[lifeStage].modulationStyle == COLOR_MODULATION_STYLE_LIGHTNESS_WAVE) {
|
|
float a = myEmitter.particleAttributes[lifeStage].modulationAmplitude;
|
|
modulation = a * ONE_HALF + sinf(radian) * a * ONE_HALF;
|
|
}
|
|
|
|
_particle[p].color.r += modulation;
|
|
_particle[p].color.g += modulation;
|
|
_particle[p].color.b += modulation;
|
|
_particle[p].color.a += modulation;
|
|
|
|
if (_particle[p].color.r > 1.0f) {_particle[p].color.r = 1.0f;}
|
|
if (_particle[p].color.g > 1.0f) {_particle[p].color.g = 1.0f;}
|
|
if (_particle[p].color.b > 1.0f) {_particle[p].color.b = 1.0f;}
|
|
if (_particle[p].color.a > 1.0f) {_particle[p].color.a = 1.0f;}
|
|
}
|
|
|
|
// do this at the end...
|
|
_particle[p].age += deltaTime;
|
|
}
|
|
|
|
|
|
void ParticleSystem::killAllParticles() {
|
|
|
|
for (int e = 0; e < _numEmitters; e++) {
|
|
_emitter[e].currentParticle = NULL_PARTICLE;
|
|
_emitter[e].emitReserve = 0.0f;
|
|
_emitter[e].previousPosition = _emitter[e].position;
|
|
_emitter[e].rate = 0.0f;
|
|
_emitter[e].currentParticle = 0;
|
|
_emitter[e].numParticlesEmittedThisTime = 0;
|
|
}
|
|
|
|
for (int p = 0; p < MAX_PARTICLES; p++) {
|
|
killParticle(p);
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::render() {
|
|
|
|
// render the emitters
|
|
for (int e = 0; e < _numEmitters; e++) {
|
|
|
|
if (_emitter[e].showingBaseParticle) {
|
|
glColor4f(_particle[0].color.r, _particle[0].color.g, _particle[0].color.b, _particle[0].color.a);
|
|
glPushMatrix();
|
|
glTranslatef(_emitter[e].position.x, _emitter[e].position.y, _emitter[e].position.z);
|
|
glutSolidSphere(_particle[0].radius, _emitter[e].particleResolution, _emitter[e].particleResolution);
|
|
glPopMatrix();
|
|
}
|
|
|
|
if (_emitter[e].visible) {
|
|
renderEmitter(e, DEFAULT_EMITTER_RENDER_LENGTH);
|
|
}
|
|
};
|
|
|
|
// render the particles
|
|
for (int p = 0; p < MAX_PARTICLES; p++) {
|
|
if (_particle[p].alive) {
|
|
if (_emitter[_particle[p].emitterIndex].particleLifespan > 0.0) {
|
|
renderParticle(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::renderParticle(int p) {
|
|
|
|
glColor4f(_particle[p].color.r, _particle[p].color.g, _particle[p].color.b, _particle[p].color.a);
|
|
|
|
if (_emitter[_particle[p].emitterIndex].particleRenderStyle == PARTICLE_RENDER_STYLE_BILLBOARD) {
|
|
glm::vec3 cameraPosition = Application::getInstance()->getCamera()->getPosition();
|
|
glm::vec3 viewVector = _particle[p].position - cameraPosition;
|
|
float distance = glm::length(viewVector);
|
|
|
|
if (distance >= 0.0f) {
|
|
viewVector /= distance;
|
|
glm::vec3 up = glm::vec3(viewVector.y, viewVector.z, viewVector.x);
|
|
glm::vec3 right = glm::vec3(viewVector.z, viewVector.x, viewVector.y);
|
|
|
|
glm::vec3 p0 = _particle[p].position - right * _particle[p].radius - up * _particle[p].radius;
|
|
glm::vec3 p1 = _particle[p].position + right * _particle[p].radius - up * _particle[p].radius;
|
|
glm::vec3 p2 = _particle[p].position + right * _particle[p].radius + up * _particle[p].radius;
|
|
glm::vec3 p3 = _particle[p].position - right * _particle[p].radius + up * _particle[p].radius;
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
glVertex3f(p0.x, p0.y, p0.z);
|
|
glVertex3f(p1.x, p1.y, p1.z);
|
|
glVertex3f(p2.x, p2.y, p2.z);
|
|
glEnd();
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
glVertex3f(p0.x, p0.y, p0.z);
|
|
glVertex3f(p2.x, p2.y, p2.z);
|
|
glVertex3f(p3.x, p3.y, p3.z);
|
|
glEnd();
|
|
}
|
|
} else if (_emitter[_particle[p].emitterIndex].particleRenderStyle == PARTICLE_RENDER_STYLE_SPHERE) {
|
|
|
|
glPushMatrix();
|
|
glTranslatef(_particle[p].position.x, _particle[p].position.y, _particle[p].position.z);
|
|
glutSolidSphere(_particle[p].radius, _emitter[_particle[p].emitterIndex].particleResolution, _emitter[_particle[p].emitterIndex].particleResolution);
|
|
glPopMatrix();
|
|
|
|
} else if (_emitter[_particle[p].emitterIndex].particleRenderStyle == PARTICLE_RENDER_STYLE_RIBBON) {
|
|
|
|
if (_particle[p].previousParticle != NULL_PARTICLE) {
|
|
if ((_particle[p].alive)
|
|
&& (_particle[_particle[p].previousParticle].alive)
|
|
&& (_particle[_particle[p].previousParticle].emitterIndex == _particle[p].emitterIndex)) {
|
|
|
|
glm::vec3 vectorFromPreviousParticle = _particle[p].position - _particle[_particle[p].previousParticle].position;
|
|
float distance = glm::length(vectorFromPreviousParticle);
|
|
|
|
if (distance > 0.0f) {
|
|
|
|
vectorFromPreviousParticle /= distance;
|
|
|
|
glm::vec3 up = glm::normalize(glm::cross(vectorFromPreviousParticle, _upDirection)) * _particle[p].radius;
|
|
glm::vec3 right = glm::normalize(glm::cross(up, vectorFromPreviousParticle )) * _particle[p].radius;
|
|
|
|
glm::vec3 p0Left = _particle[p ].position - right;
|
|
glm::vec3 p0Right = _particle[p ].position + right;
|
|
glm::vec3 p0Down = _particle[p ].position - up;
|
|
glm::vec3 p0Up = _particle[p ].position + up;
|
|
|
|
glm::vec3 ppLeft = _particle[_particle[p].previousParticle].position - right;
|
|
glm::vec3 ppRight = _particle[_particle[p].previousParticle].position + right;
|
|
glm::vec3 ppDown = _particle[_particle[p].previousParticle].position - up;
|
|
glm::vec3 ppUp = _particle[_particle[p].previousParticle].position + up;
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glVertex3f(p0Left.x, p0Left.y, p0Left.z );
|
|
glVertex3f(p0Right.x, p0Right.y, p0Right.z);
|
|
glVertex3f(ppLeft.x, ppLeft.y, ppLeft.z );
|
|
|
|
glVertex3f(p0Right.x, p0Right.y, p0Right.z);
|
|
glVertex3f(ppLeft.x, ppLeft.y, ppLeft.z );
|
|
glVertex3f(ppRight.x, ppRight.y, ppRight.z);
|
|
|
|
glVertex3f(p0Up.x, p0Up.y, p0Up.z );
|
|
glVertex3f(p0Down.x, p0Down.y, p0Down.z );
|
|
glVertex3f(ppDown.x, ppDown.y, ppDown.z );
|
|
|
|
glVertex3f(p0Up.x, p0Up.y, p0Up.z );
|
|
glVertex3f(ppUp.x, ppUp.y, ppUp.z );
|
|
glVertex3f(ppDown.x, ppDown.y, ppDown.z );
|
|
|
|
glVertex3f(p0Up.x, p0Up.y, p0Left.z );
|
|
glVertex3f(p0Right.x, p0Right.y, p0Right.z);
|
|
glVertex3f(p0Down.x, p0Down.y, p0Down.z );
|
|
|
|
glVertex3f(p0Up.x, p0Up.y, p0Left.z );
|
|
glVertex3f(p0Left.x, p0Left.y, p0Left.z );
|
|
glVertex3f(p0Down.x, p0Down.y, p0Down.z );
|
|
|
|
glVertex3f(ppUp.x, ppUp.y, ppLeft.z );
|
|
glVertex3f(ppRight.x, ppRight.y, ppRight.z);
|
|
glVertex3f(ppDown.x, ppDown.y, ppDown.z );
|
|
|
|
glVertex3f(ppUp.x, ppUp.y, ppLeft.z );
|
|
glVertex3f(ppLeft.x, ppLeft.y, ppLeft.z );
|
|
glVertex3f(ppDown.x, ppDown.y, ppDown.z );
|
|
|
|
glEnd();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParticleSystem::renderEmitter(int e, float size) {
|
|
|
|
glm::vec3 v = _emitter[e].direction * size;
|
|
|
|
glColor3f(0.4f, 0.4, 0.8);
|
|
glBegin(GL_LINES);
|
|
glVertex3f(_emitter[e].position.x, _emitter[e].position.y, _emitter[e].position.z);
|
|
glVertex3f(_emitter[e].position.x + v.x, _emitter[e].position.y + v.y, _emitter[e].position.z + v.z);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
|
|
|
|
|