mirror of
https://github.com/overte-org/overte.git
synced 2025-04-17 04:06:43 +02:00
Merge branch 'master' of github.com:worklist/hifi
This commit is contained in:
Stephen Birarda
commit
aed0aa3034
16 changed files with 1177 additions and 465 deletions
8
interface/CMakeLists.txt
Executable file → Normal file
8
interface/CMakeLists.txt
Executable file → Normal file
|
|
@ -71,7 +71,6 @@ find_package(Qt5Core REQUIRED)
|
|||
find_package(Qt5Gui REQUIRED)
|
||||
find_package(Qt5Network REQUIRED)
|
||||
find_package(Qt5OpenGL REQUIRED)
|
||||
find_package(Qt5WebKit REQUIRED)
|
||||
find_package(Qt5Svg REQUIRED)
|
||||
|
||||
set(QUAZIP_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/quazip)
|
||||
|
|
@ -81,8 +80,6 @@ include_directories(external/fervor/)
|
|||
# create the executable, make it a bundle on OS X
|
||||
add_executable(${TARGET_NAME} MACOSX_BUNDLE ${INTERFACE_SRCS})
|
||||
|
||||
qt5_use_modules(${TARGET_NAME} Core Gui Network OpenGL WebKit Svg)
|
||||
|
||||
# link in the hifi shared library
|
||||
include(${MACRO_DIR}/LinkHifiLibrary.cmake)
|
||||
|
||||
|
|
@ -111,6 +108,8 @@ if (OPENNI_FOUND)
|
|||
target_link_libraries(${TARGET_NAME} ${OPENNI_LIBRARIES})
|
||||
endif (OPENNI_FOUND)
|
||||
|
||||
qt5_use_modules(${TARGET_NAME} Core Gui Network OpenGL Svg)
|
||||
|
||||
# include headers for interface and InterfaceConfig.
|
||||
include_directories(
|
||||
${PROJECT_SOURCE_DIR}/src
|
||||
|
|
@ -131,8 +130,7 @@ include_directories(
|
|||
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${OPENCV_INCLUDE_DIRS}")
|
||||
target_link_libraries(
|
||||
${TARGET_NAME}
|
||||
${QT_LIBRARIES}
|
||||
${TARGET_NAME}
|
||||
${LIBVPX_LIBRARIES}
|
||||
${MOTIONDRIVER_LIBRARIES}
|
||||
${OPENCV_LIBRARIES}
|
||||
|
|
|
|||
4
interface/external/fervor/CMakeLists.txt
vendored
4
interface/external/fervor/CMakeLists.txt
vendored
|
|
@ -1,7 +1,9 @@
|
|||
cmake_minimum_required(VERSION 2.8)
|
||||
project(Fervor)
|
||||
|
||||
find_package(Qt5Core REQUIRED)
|
||||
find_package(Qt5Network REQUIRED)
|
||||
find_package(Qt5WebKit REQUIRED)
|
||||
find_package(Qt5Widgets REQUIRED)
|
||||
|
||||
add_definitions(-DFV_GUI)
|
||||
|
|
@ -30,4 +32,4 @@ include_directories(
|
|||
add_library(fervor ${FERVOR_SOURCES} ${FERVOR_HEADERS} ${FERVOR_MOC_SOURCES} ${FERVOR_WRAPPED_UI})
|
||||
target_link_libraries(fervor ${QUAZIP_LIBRARIES})
|
||||
|
||||
qt5_use_modules(fervor Core Network Widgets)
|
||||
qt5_use_modules(fervor Core Network Widgets WebKit)
|
||||
|
|
@ -564,6 +564,11 @@ void Application::keyPressEvent(QKeyEvent* event) {
|
|||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//this is for switching between modes for the leap rave glove test
|
||||
if (_simulateLeapHand->isChecked() || _testRaveGlove->isChecked()) {
|
||||
_myAvatar.getHand().setRaveGloveEffectsMode((QKeyEvent*)event);
|
||||
}
|
||||
|
||||
bool shifted = event->modifiers().testFlag(Qt::ShiftModifier);
|
||||
switch (event->key()) {
|
||||
|
|
@ -2723,13 +2728,12 @@ void Application::displaySide(Camera& whichCamera) {
|
|||
_particleSystem.render();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Render the world box
|
||||
if (!_lookingInMirror->isChecked() && _renderStatsOn->isChecked()) { render_world_box(); }
|
||||
|
||||
// brad's frustum for debugging
|
||||
if (_frustumOn->isChecked()) renderViewFrustum(_viewFrustum);
|
||||
|
||||
}
|
||||
|
||||
void Application::displayOverlay() {
|
||||
|
|
@ -3652,56 +3656,57 @@ void Application::exportSettings() {
|
|||
}
|
||||
|
||||
|
||||
|
||||
void Application::updateParticleSystem(float deltaTime) {
|
||||
|
||||
if (!_particleSystemInitialized) {
|
||||
|
||||
const int LIFESPAN_IN_SECONDS = 100000.0f;
|
||||
const float EMIT_RATE_IN_SECONDS = 10000.0;
|
||||
// create a stable test emitter and spit out a bunch of particles
|
||||
_coolDemoParticleEmitter = _particleSystem.addEmitter();
|
||||
|
||||
|
||||
if (_coolDemoParticleEmitter != -1) {
|
||||
|
||||
_particleSystem.setShowingEmitter(_coolDemoParticleEmitter, true);
|
||||
glm::vec3 particleEmitterPosition = glm::vec3(5.0f, 1.0f, 5.0f);
|
||||
_particleSystem.setEmitterPosition(_coolDemoParticleEmitter, particleEmitterPosition);
|
||||
glm::vec3 velocity(0.0f, 0.1f, 0.0f);
|
||||
float lifespan = 100000.0f;
|
||||
_particleSystem.emitParticlesNow(_coolDemoParticleEmitter, 1500, velocity, lifespan);
|
||||
|
||||
_particleSystem.setEmitterPosition (_coolDemoParticleEmitter, particleEmitterPosition);
|
||||
_particleSystem.setEmitterParticleLifespan(_coolDemoParticleEmitter, LIFESPAN_IN_SECONDS);
|
||||
_particleSystem.setEmitterThrust (_coolDemoParticleEmitter, 0.0f);
|
||||
_particleSystem.setEmitterRate (_coolDemoParticleEmitter, EMIT_RATE_IN_SECONDS); // to emit a pile o particles now
|
||||
}
|
||||
|
||||
// signal that the particle system has been initialized
|
||||
_particleSystemInitialized = true;
|
||||
} else {
|
||||
// update the particle system
|
||||
|
||||
static float t = 0.0f;
|
||||
t += deltaTime;
|
||||
|
||||
static bool emitting = true;
|
||||
static float effectsTimer = 0.0f;
|
||||
effectsTimer += deltaTime;
|
||||
|
||||
if (_coolDemoParticleEmitter != -1) {
|
||||
|
||||
glm::vec3 tilt = glm::vec3
|
||||
(
|
||||
30.0f * sinf( t * 0.55f ),
|
||||
0.0f,
|
||||
30.0f * cosf( t * 0.75f )
|
||||
);
|
||||
|
||||
_particleSystem.setEmitterRotation(_coolDemoParticleEmitter, glm::quat(glm::radians(tilt)));
|
||||
_particleSystem.setEmitterDirection(_coolDemoParticleEmitter, glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
|
||||
ParticleSystem::ParticleAttributes attributes;
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
attributes.gravity = 0.0f + 0.05f * sinf( t * 0.52f );
|
||||
attributes.airFriction = 2.5 + 2.0f * sinf( t * 0.32f );
|
||||
attributes.jitter = 0.05f + 0.05f * sinf( t * 0.42f );
|
||||
attributes.emitterAttraction = 0.015f + 0.015f * cosf( t * 0.6f );
|
||||
attributes.tornadoForce = 0.0f + 0.03f * sinf( t * 0.7f );
|
||||
attributes.neighborAttraction = 0.1f + 0.1f * cosf( t * 0.8f );
|
||||
attributes.neighborRepulsion = 0.2f + 0.2f * sinf( t * 0.4f );
|
||||
attributes.gravity = 0.0f + 0.05f * sinf( effectsTimer * 0.52f );
|
||||
attributes.airFriction = 2.5 + 2.0f * sinf( effectsTimer * 0.32f );
|
||||
attributes.jitter = 0.05f + 0.05f * sinf( effectsTimer * 0.42f );
|
||||
attributes.emitterAttraction = 0.015f + 0.015f * cosf( effectsTimer * 0.6f );
|
||||
attributes.tornadoForce = 0.0f + 0.03f * sinf( effectsTimer * 0.7f );
|
||||
attributes.neighborAttraction = 0.1f + 0.1f * cosf( effectsTimer * 0.8f );
|
||||
attributes.neighborRepulsion = 0.2f + 0.2f * sinf( effectsTimer * 0.4f );
|
||||
attributes.bounce = 1.0f;
|
||||
attributes.usingCollisionSphere = true;
|
||||
attributes.collisionSpherePosition = glm::vec3( 5.0f, 0.5f, 5.0f );
|
||||
attributes.collisionSphereRadius = 0.5f;
|
||||
attributes.usingCollisionPlane = true;
|
||||
attributes.collisionPlanePosition = glm::vec3( 5.0f, 0.0f, 5.0f );
|
||||
attributes.collisionPlaneNormal = glm::vec3( 0.0f, 1.0f, 0.0f );
|
||||
|
||||
if (attributes.gravity < 0.0f) {
|
||||
attributes.gravity = 0.0f;
|
||||
|
|
@ -3712,6 +3717,15 @@ void Application::updateParticleSystem(float deltaTime) {
|
|||
|
||||
_particleSystem.setUpDirection(glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
_particleSystem.simulate(deltaTime);
|
||||
|
||||
const float EMIT_RATE_IN_SECONDS = 0.0;
|
||||
|
||||
if (_coolDemoParticleEmitter != -1) {
|
||||
if (emitting) {
|
||||
_particleSystem.setEmitterRate(_coolDemoParticleEmitter, EMIT_RATE_IN_SECONDS); // stop emitter
|
||||
emitting = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
0
interface/src/LeapManager.cpp
Executable file → Normal file
0
interface/src/LeapManager.cpp
Executable file → Normal file
|
|
@ -11,77 +11,89 @@
|
|||
#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_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;
|
||||
_numParticles = 0;
|
||||
_upDirection = glm::vec3(0.0f, 1.0f, 0.0f); // default
|
||||
|
||||
for (unsigned int emitterIndex = 0; emitterIndex < MAX_EMITTERS; emitterIndex++) {
|
||||
_emitter[emitterIndex].position = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
_emitter[emitterIndex].rotation = glm::quat();
|
||||
_emitter[emitterIndex].visible = false;
|
||||
_emitter[emitterIndex].baseParticle.alive = false;
|
||||
_emitter[emitterIndex].baseParticle.age = 0.0f;
|
||||
_emitter[emitterIndex].baseParticle.lifespan = 0.0f;
|
||||
_emitter[emitterIndex].baseParticle.radius = 0.0f;
|
||||
_emitter[emitterIndex].baseParticle.emitterIndex = 0;
|
||||
_emitter[emitterIndex].baseParticle.position = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
_emitter[emitterIndex].baseParticle.velocity = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
|
||||
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++) {
|
||||
|
||||
ParticleAttributes * a = &_emitter[emitterIndex].particleAttributes[lifeStage];
|
||||
|
||||
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;
|
||||
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].lifespan = 0.0f;
|
||||
_particle[p].radius = 0.0f;
|
||||
_particle[p].emitterIndex = 0;
|
||||
_particle[p].position = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
_particle[p].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
_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() {
|
||||
|
||||
_numEmitters ++;
|
||||
|
||||
if (_numEmitters > MAX_EMITTERS) {
|
||||
return -1;
|
||||
if (_numEmitters < MAX_EMITTERS) {
|
||||
_numEmitters ++;
|
||||
return _numEmitters - 1;
|
||||
}
|
||||
|
||||
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 (unsigned int p = 0; p < _numParticles; p++) {
|
||||
if (_particle[p].alive) {
|
||||
if (_particle[p].age > _particle[p].lifespan) {
|
||||
|
||||
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);
|
||||
|
|
@ -90,55 +102,91 @@ void ParticleSystem::simulate(float deltaTime) {
|
|||
}
|
||||
}
|
||||
|
||||
void ParticleSystem::emitParticlesNow(int e, int num, glm::vec3 velocity, float lifespan) {
|
||||
|
||||
for (unsigned int p = 0; p < num; p++) {
|
||||
createParticle(e, velocity, lifespan);
|
||||
}
|
||||
}
|
||||
|
||||
void ParticleSystem::createParticle(int e, glm::vec3 velocity, float lifespan) {
|
||||
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].lifespan = lifespan;
|
||||
_particle[p].alive = true;
|
||||
_particle[p].age = 0.0f;
|
||||
_particle[p].velocity = velocity;
|
||||
_particle[p].position = _emitter[e].position;
|
||||
_particle[p].radius = _emitter[e].particleAttributes[0].radius;
|
||||
_particle[p].color = _emitter[e].particleAttributes[0].color;
|
||||
|
||||
_numParticles ++;
|
||||
|
||||
assert(_numParticles <= MAX_PARTICLES);
|
||||
|
||||
_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;
|
||||
|
||||
return;
|
||||
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);
|
||||
assert( _numParticles > 0);
|
||||
assert(p >= 0);
|
||||
assert(p < MAX_PARTICLES);
|
||||
|
||||
_particle[p].alive = false;
|
||||
_numParticles --;
|
||||
}
|
||||
_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, lifeStage, attributes);
|
||||
for (int lifeStage = 0; lifeStage < NUM_PARTICLE_LIFE_STAGES; lifeStage ++) {
|
||||
setParticleAttributes(emitterIndex, (ParticleLifeStage)lifeStage, attributes);
|
||||
}
|
||||
}
|
||||
|
||||
void ParticleSystem::setParticleAttributes(int emitterIndex, int lifeStage, ParticleAttributes 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];
|
||||
|
||||
|
|
@ -155,155 +203,196 @@ void ParticleSystem::setParticleAttributes(int emitterIndex, int lifeStage, Part
|
|||
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) {
|
||||
|
||||
assert(_particle[p].age <= _particle[p].lifespan);
|
||||
|
||||
float ageFraction = _particle[p].age / _particle[p].lifespan;
|
||||
|
||||
int lifeStage = (int)( ageFraction * (NUM_PARTICLE_LIFE_STAGES-1) );
|
||||
|
||||
float lifeStageFraction = ageFraction * ( NUM_PARTICLE_LIFE_STAGES - 1 ) - lifeStage;
|
||||
|
||||
_particle[p].radius
|
||||
= _emitter[_particle[p].emitterIndex].particleAttributes[lifeStage ].radius * (1.0f - lifeStageFraction)
|
||||
+ _emitter[_particle[p].emitterIndex].particleAttributes[lifeStage+1].radius * lifeStageFraction;
|
||||
|
||||
_particle[p].color
|
||||
= _emitter[_particle[p].emitterIndex].particleAttributes[lifeStage ].color * (1.0f - lifeStageFraction)
|
||||
+ _emitter[_particle[p].emitterIndex].particleAttributes[lifeStage+1].color * lifeStageFraction;
|
||||
|
||||
Emitter myEmitter = _emitter[_particle[p].emitterIndex];
|
||||
|
||||
// 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 == _numParticles ) {
|
||||
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;
|
||||
assert(_particle[p].age <= myEmitter.particleLifespan);
|
||||
|
||||
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 emitterUp = myEmitter.rotation * IDENTITY_UP;
|
||||
|
||||
glm::vec3 tornadoDirection = glm::cross(vectorToHome, emitterUp);
|
||||
_particle[p].velocity += tornadoDirection * myEmitter.particleAttributes[lifeStage].tornadoForce * deltaTime;
|
||||
float ageFraction = 0.0f;
|
||||
int lifeStage = 0;
|
||||
float lifeStageFraction = 0.0f;
|
||||
|
||||
// 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 ground
|
||||
if (_particle[p].position.y < _particle[p].radius) {
|
||||
_particle[p].position.y = _particle[p].radius;
|
||||
if (_emitter[_particle[p].emitterIndex].particleLifespan > 0.0) {
|
||||
|
||||
if (_particle[p].velocity.y < 0.0f) {
|
||||
_particle[p].velocity.y *= -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) {
|
||||
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;
|
||||
|
||||
if (distanceToSphereCenter > 0.0f){
|
||||
glm::vec3 directionToSphereCenter = vectorToSphereCenter / distanceToSphereCenter;
|
||||
_particle[p].position = myEmitter.particleAttributes[lifeStage].collisionSpherePosition - directionToSphereCenter * combinedRadius;
|
||||
// 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;
|
||||
_particle[p].age += deltaTime;
|
||||
}
|
||||
|
||||
void ParticleSystem::setEmitterBaseParticle(int emitterIndex, bool showing ) {
|
||||
|
||||
_emitter[emitterIndex].baseParticle.alive = true;
|
||||
_emitter[emitterIndex].baseParticle.emitterIndex = emitterIndex;
|
||||
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::setEmitterBaseParticle(int emitterIndex, bool showing, float radius, glm::vec4 color ) {
|
||||
|
||||
_emitter[emitterIndex].baseParticle.alive = true;
|
||||
_emitter[emitterIndex].baseParticle.emitterIndex = emitterIndex;
|
||||
_emitter[emitterIndex].baseParticle.radius = radius;
|
||||
_emitter[emitterIndex].baseParticle.color = color;
|
||||
}
|
||||
|
||||
|
||||
void ParticleSystem::render() {
|
||||
|
||||
// render the emitters
|
||||
for (int e = 0; e < _numEmitters; e++) {
|
||||
|
||||
if (_emitter[e].baseParticle.alive) {
|
||||
glColor4f(_emitter[e].baseParticle.color.r, _emitter[e].baseParticle.color.g, _emitter[e].baseParticle.color.b, _emitter[e].baseParticle.color.a );
|
||||
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(_emitter[e].baseParticle.radius, 6, 6);
|
||||
glutSolidSphere(_particle[0].radius, _emitter[e].particleResolution, _emitter[e].particleResolution);
|
||||
glPopMatrix();
|
||||
}
|
||||
|
||||
if (_emitter[e].visible) {
|
||||
renderEmitter(e, 0.2f);
|
||||
renderEmitter(e, DEFAULT_EMITTER_RENDER_LENGTH);
|
||||
}
|
||||
};
|
||||
|
||||
// render the particles
|
||||
for (unsigned int p = 0; p < _numParticles; p++) {
|
||||
|
||||
// render the particles
|
||||
for (int p = 0; p < MAX_PARTICLES; p++) {
|
||||
if (_particle[p].alive) {
|
||||
renderParticle(p);
|
||||
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 );
|
||||
glColor4f(_particle[p].color.r, _particle[p].color.g, _particle[p].color.b, _particle[p].color.a);
|
||||
|
||||
if (USE_BILLBOARD_RENDERING) {
|
||||
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);
|
||||
|
|
@ -330,49 +419,89 @@ void ParticleSystem::renderParticle(int p) {
|
|||
glVertex3f(p3.x, p3.y, p3.z);
|
||||
glEnd();
|
||||
}
|
||||
} else {
|
||||
} 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, 6, 6);
|
||||
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();
|
||||
|
||||
if (SHOW_VELOCITY_TAILS) {
|
||||
glColor4f( _particle[p].color.x, _particle[p].color.y, _particle[p].color.z, 0.5f);
|
||||
glm::vec3 end = _particle[p].position - _particle[p].velocity * 2.0f;
|
||||
glBegin(GL_LINES);
|
||||
glVertex3f(_particle[p].position.x, _particle[p].position.y, _particle[p].position.z);
|
||||
glVertex3f(end.x, end.y, end.z);
|
||||
glEnd();
|
||||
} 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 r = _emitter[e].rotation * IDENTITY_FRONT * size;
|
||||
glm::vec3 u = _emitter[e].rotation * IDENTITY_RIGHT * size;
|
||||
glm::vec3 f = _emitter[e].rotation * IDENTITY_UP * size;
|
||||
|
||||
glLineWidth(2.0f);
|
||||
|
||||
glColor3f(0.8f, 0.4, 0.4);
|
||||
glBegin(GL_LINES);
|
||||
glVertex3f(_emitter[e].position.x, _emitter[e].position.y, _emitter[e].position.z);
|
||||
glVertex3f(_emitter[e].position.x + r.x, _emitter[e].position.y + r.y, _emitter[e].position.z + r.z);
|
||||
glEnd();
|
||||
|
||||
glColor3f(0.4f, 0.8, 0.4);
|
||||
glBegin(GL_LINES);
|
||||
glVertex3f(_emitter[e].position.x, _emitter[e].position.y, _emitter[e].position.z);
|
||||
glVertex3f(_emitter[e].position.x + u.x, _emitter[e].position.y + u.y, _emitter[e].position.z + u.z);
|
||||
glEnd();
|
||||
|
||||
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 + f.x, _emitter[e].position.y + f.y, _emitter[e].position.z + f.z);
|
||||
glVertex3f(_emitter[e].position.x + v.x, _emitter[e].position.y + v.y, _emitter[e].position.z + v.z);
|
||||
glEnd();
|
||||
}
|
||||
|
||||
|
|
@ -380,5 +509,3 @@ void ParticleSystem::renderEmitter(int e, float size) {
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,76 +11,121 @@
|
|||
#include <glm/gtc/quaternion.hpp>
|
||||
|
||||
const int MAX_PARTICLES = 5000;
|
||||
const int MAX_EMITTERS = 20;
|
||||
const int NUM_PARTICLE_LIFE_STAGES = 4;
|
||||
const bool USE_BILLBOARD_RENDERING = false;
|
||||
const bool SHOW_VELOCITY_TAILS = false;
|
||||
const int NULL_EMITTER = -1;
|
||||
const int NULL_PARTICLE = -1;
|
||||
const int MAX_EMITTERS = 100;
|
||||
|
||||
enum ParticleRenderStyle
|
||||
{
|
||||
PARTICLE_RENDER_STYLE_SPHERE = 0,
|
||||
PARTICLE_RENDER_STYLE_BILLBOARD,
|
||||
PARTICLE_RENDER_STYLE_RIBBON,
|
||||
NUM_PARTICLE_RENDER_STYLES
|
||||
};
|
||||
|
||||
enum ColorModulationStyle
|
||||
{
|
||||
COLOR_MODULATION_STYLE_NULL = -1,
|
||||
COLOR_MODULATION_STYLE_LIGHNTESS_PULSE,
|
||||
COLOR_MODULATION_STYLE_LIGHTNESS_WAVE,
|
||||
NUM_COLOR_MODULATION_STYLES
|
||||
};
|
||||
|
||||
enum ParticleLifeStage
|
||||
{
|
||||
PARTICLE_LIFESTAGE_0 = 0,
|
||||
PARTICLE_LIFESTAGE_1,
|
||||
PARTICLE_LIFESTAGE_2,
|
||||
PARTICLE_LIFESTAGE_3,
|
||||
NUM_PARTICLE_LIFE_STAGES
|
||||
};
|
||||
|
||||
class ParticleSystem {
|
||||
public:
|
||||
|
||||
struct ParticleAttributes {
|
||||
float radius;
|
||||
glm::vec4 color;
|
||||
float bounce;
|
||||
float gravity;
|
||||
float airFriction;
|
||||
float jitter;
|
||||
float emitterAttraction;
|
||||
float tornadoForce;
|
||||
float neighborAttraction;
|
||||
float neighborRepulsion;
|
||||
bool usingCollisionSphere;
|
||||
glm::vec3 collisionSpherePosition;
|
||||
float collisionSphereRadius;
|
||||
float radius; // radius of the particle
|
||||
glm::vec4 color; // color (rgba) of the particle
|
||||
float bounce; // how much reflection when the particle collides with floor/ground
|
||||
float gravity; // force opposite of up direction
|
||||
float airFriction; // continual dampening of velocity
|
||||
float jitter; // random forces on velocity
|
||||
float emitterAttraction; // an attraction to the emitter position
|
||||
float tornadoForce; // force perpendicular to direction axis
|
||||
float neighborAttraction; // causes particle to be pulled towards next particle in list
|
||||
float neighborRepulsion; // causes particle to be repelled by previous particle in list
|
||||
bool usingCollisionSphere; // set to true to allow collision with a sphere
|
||||
glm::vec3 collisionSpherePosition; // position of the collision sphere
|
||||
float collisionSphereRadius; // radius of the collision sphere
|
||||
bool usingCollisionPlane; // set to true to allow collision with a plane
|
||||
glm::vec3 collisionPlanePosition; // reference position of the collision plane
|
||||
glm::vec3 collisionPlaneNormal; // the surface normal of the collision plane
|
||||
float modulationAmplitude; // sets the degree (from 0 to 1) of the modulating effect
|
||||
float modulationRate; // the period of modulation, in seconds
|
||||
ColorModulationStyle modulationStyle; // to choose between color modulation styles
|
||||
};
|
||||
|
||||
// public methods...
|
||||
ParticleSystem();
|
||||
|
||||
int addEmitter(); // add (create new) emitter and get its unique id
|
||||
void emitParticlesNow(int emitterIndex, int numParticles, glm::vec3 velocity, float lifespan);
|
||||
void simulate(float deltaTime);
|
||||
void killAllParticles();
|
||||
void render();
|
||||
|
||||
void setUpDirection(glm::vec3 upDirection) {_upDirection = upDirection;} // tell particle system which direction is up
|
||||
void setEmitterBaseParticle(int emitterIndex, bool showing );
|
||||
void setEmitterBaseParticle(int emitterIndex, bool showing, float radius, glm::vec4 color );
|
||||
void setParticleAttributes (int emitterIndex, ParticleAttributes attributes);
|
||||
void setParticleAttributes (int emitterIndex, int lifeStage, ParticleAttributes attributes);
|
||||
void setEmitterPosition (int emitterIndex, glm::vec3 position) { _emitter[emitterIndex].position = position; } // set position of emitter
|
||||
void setEmitterRotation (int emitterIndex, glm::quat rotation) { _emitter[emitterIndex].rotation = rotation; } // set rotation of emitter
|
||||
void setShowingEmitter (int emitterIndex, bool showing ) { _emitter[emitterIndex].visible = showing; } // set its visibiity
|
||||
|
||||
void setUpDirection(glm::vec3 upDirection) {_upDirection = upDirection;} // tell particle system which direction is up
|
||||
void setParticleAttributesToDefault(ParticleAttributes * attributes); // set these attributes to their default values
|
||||
void setParticleAttributes (int emitterIndex, ParticleAttributes attributes); // set attributes for whole life of particles
|
||||
void setParticleAttributes (int emitterIndex, ParticleLifeStage lifeStage, ParticleAttributes attributes); // set attributes for this life stage
|
||||
void setEmitterPosition (int emitterIndex, glm::vec3 position );
|
||||
void setEmitterParticleResolution (int emitterIndex, int resolution ) {_emitter[emitterIndex].particleResolution = resolution; }
|
||||
void setEmitterDirection (int emitterIndex, glm::vec3 direction ) {_emitter[emitterIndex].direction = direction; }
|
||||
void setShowingEmitter (int emitterIndex, bool showing ) {_emitter[emitterIndex].visible = showing; }
|
||||
void setEmitterParticleLifespan (int emitterIndex, float lifespan ) {_emitter[emitterIndex].particleLifespan = lifespan; }
|
||||
void setParticleRenderStyle (int emitterIndex, ParticleRenderStyle renderStyle ) {_emitter[emitterIndex].particleRenderStyle = renderStyle; }
|
||||
void setEmitterThrust (int emitterIndex, float thrust ) {_emitter[emitterIndex].thrust = thrust; }
|
||||
void setEmitterRate (int emitterIndex, float rate ) {_emitter[emitterIndex].rate = rate; }
|
||||
void setShowingEmitterBaseParticle(int emitterIndex, bool showing ) {_emitter[emitterIndex].showingBaseParticle = showing; }
|
||||
|
||||
private:
|
||||
|
||||
struct Particle {
|
||||
bool alive; // is the particle active?
|
||||
glm::vec3 position; // position
|
||||
glm::vec3 velocity; // velocity
|
||||
glm::vec4 color; // color (rgba)
|
||||
float age; // age in seconds
|
||||
float radius; // radius
|
||||
float lifespan; // how long this particle stays alive (in seconds)
|
||||
int emitterIndex; // which emitter created this particle?
|
||||
bool alive; // is the particle active?
|
||||
glm::vec3 position; // position
|
||||
glm::vec3 velocity; // velocity
|
||||
glm::vec4 color; // color (rgba)
|
||||
float age; // age in seconds
|
||||
float radius; // radius
|
||||
int emitterIndex; // which emitter created this particle?
|
||||
int previousParticle; // the last particle that this particle's emitter emitted;
|
||||
};
|
||||
|
||||
struct Emitter {
|
||||
glm::vec3 position;
|
||||
glm::quat rotation;
|
||||
bool visible;
|
||||
Particle baseParticle; // a non-physical particle at the emitter position
|
||||
glm::vec3 position; // the position of the emitter in world coordinates
|
||||
glm::vec3 previousPosition; // the position of the emitter in the previous time step
|
||||
glm::vec3 direction; // a normalized vector used as an axis for particle emission and other effects
|
||||
bool visible; // whether or not a line is shown indicating the emitter (indicating its direction)
|
||||
float particleLifespan; // how long the particle shall live, in seconds
|
||||
int particleResolution; // for sphere-based particles
|
||||
float emitReserve; // baed on 'rate', this is the number of particles that need to be emitted at a given time step
|
||||
int numParticlesEmittedThisTime; //the integer number of particles to emit at the preent time step
|
||||
float thrust; // the initial velocity upon emitting along the emitter direction
|
||||
float rate; // currently, how many particles emitted during a simulation time step
|
||||
bool showingBaseParticle; // if true, a copy of particle 0 is shown on the emitter position
|
||||
int currentParticle; // the index of the most recently-emitted particle
|
||||
ParticleAttributes particleAttributes[NUM_PARTICLE_LIFE_STAGES]; // the attributes of particles emitted from this emitter
|
||||
};
|
||||
ParticleRenderStyle particleRenderStyle;
|
||||
};
|
||||
|
||||
glm::vec3 _upDirection;
|
||||
Emitter _emitter[MAX_EMITTERS];
|
||||
Particle _particle[MAX_PARTICLES];
|
||||
int _numParticles;
|
||||
int _numEmitters;
|
||||
float _timer;
|
||||
|
||||
// private methods
|
||||
void updateParticle(int index, float deltaTime);
|
||||
void createParticle(int e, glm::vec3 velocity, float lifespan);
|
||||
void createParticle(int e, float timeFraction);
|
||||
void killParticle(int p);
|
||||
void renderEmitter(int emitterIndex, float size);
|
||||
void renderParticle(int p);
|
||||
|
|
|
|||
|
|
@ -57,8 +57,11 @@ void Webcam::setEnabled(bool enabled) {
|
|||
}
|
||||
}
|
||||
|
||||
const float UNINITIALIZED_FACE_DEPTH = 0.0f;
|
||||
|
||||
void Webcam::reset() {
|
||||
_initialFaceRect = RotatedRect();
|
||||
_initialFaceDepth = UNINITIALIZED_FACE_DEPTH;
|
||||
|
||||
if (_enabled) {
|
||||
// send a message to the grabber
|
||||
|
|
@ -149,7 +152,10 @@ Webcam::~Webcam() {
|
|||
delete _grabber;
|
||||
}
|
||||
|
||||
void Webcam::setFrame(const Mat& color, int format, const Mat& depth, const RotatedRect& faceRect, const JointVector& joints) {
|
||||
const float METERS_PER_MM = 1.0f / 1000.0f;
|
||||
|
||||
void Webcam::setFrame(const Mat& color, int format, const Mat& depth, float meanFaceDepth,
|
||||
const RotatedRect& faceRect, const JointVector& joints) {
|
||||
IplImage colorImage = color;
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH, colorImage.widthStep / 3);
|
||||
if (_colorTextureID == 0) {
|
||||
|
|
@ -232,22 +238,28 @@ void Webcam::setFrame(const Mat& color, int format, const Mat& depth, const Rota
|
|||
const float ROTATION_SMOOTHING = 0.95f;
|
||||
_estimatedRotation.z = glm::mix(_faceRect.angle, _estimatedRotation.z, ROTATION_SMOOTHING);
|
||||
|
||||
// determine position based on translation and scaling of the face rect
|
||||
// determine position based on translation and scaling of the face rect/mean face depth
|
||||
if (_initialFaceRect.size.area() == 0) {
|
||||
_initialFaceRect = _faceRect;
|
||||
_estimatedPosition = glm::vec3();
|
||||
_initialFaceDepth = meanFaceDepth;
|
||||
|
||||
} else {
|
||||
float proportion = sqrtf(_initialFaceRect.size.area() / (float)_faceRect.size.area());
|
||||
const float DISTANCE_TO_CAMERA = 0.333f;
|
||||
float proportion, z;
|
||||
if (meanFaceDepth == UNINITIALIZED_FACE_DEPTH) {
|
||||
proportion = sqrtf(_initialFaceRect.size.area() / (float)_faceRect.size.area());
|
||||
const float INITIAL_DISTANCE_TO_CAMERA = 0.333f;
|
||||
z = INITIAL_DISTANCE_TO_CAMERA * proportion - INITIAL_DISTANCE_TO_CAMERA;
|
||||
|
||||
} else {
|
||||
z = (meanFaceDepth - _initialFaceDepth) * METERS_PER_MM;
|
||||
proportion = meanFaceDepth / _initialFaceDepth;
|
||||
}
|
||||
const float POSITION_SCALE = 0.5f;
|
||||
float z = DISTANCE_TO_CAMERA * proportion - DISTANCE_TO_CAMERA;
|
||||
glm::vec3 position = glm::vec3(
|
||||
_estimatedPosition = glm::vec3(
|
||||
(_faceRect.center.x - _initialFaceRect.center.x) * proportion * POSITION_SCALE / _textureSize.width,
|
||||
(_faceRect.center.y - _initialFaceRect.center.y) * proportion * POSITION_SCALE / _textureSize.width,
|
||||
z);
|
||||
const float POSITION_SMOOTHING = 0.95f;
|
||||
_estimatedPosition = glm::mix(position, _estimatedPosition, POSITION_SMOOTHING);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -259,7 +271,7 @@ void Webcam::setFrame(const Mat& color, int format, const Mat& depth, const Rota
|
|||
}
|
||||
|
||||
FrameGrabber::FrameGrabber() : _initialized(false), _capture(0), _searchWindow(0, 0, 0, 0),
|
||||
_depthOffset(0.0), _codec(), _frameCount(0) {
|
||||
_smoothedMeanFaceDepth(UNINITIALIZED_FACE_DEPTH), _colorCodec(), _depthCodec(), _frameCount(0) {
|
||||
}
|
||||
|
||||
FrameGrabber::~FrameGrabber() {
|
||||
|
|
@ -367,9 +379,13 @@ void FrameGrabber::shutdown() {
|
|||
cvReleaseCapture(&_capture);
|
||||
_capture = 0;
|
||||
}
|
||||
if (_codec.name != 0) {
|
||||
vpx_codec_destroy(&_codec);
|
||||
_codec.name = 0;
|
||||
if (_colorCodec.name != 0) {
|
||||
vpx_codec_destroy(&_colorCodec);
|
||||
_colorCodec.name = 0;
|
||||
}
|
||||
if (_depthCodec.name != 0) {
|
||||
vpx_codec_destroy(&_depthCodec);
|
||||
_depthCodec.name = 0;
|
||||
}
|
||||
_initialized = false;
|
||||
|
||||
|
|
@ -423,7 +439,6 @@ void FrameGrabber::grabFrame() {
|
|||
_userID, (XnSkeletonJoint)parentJoint, parentOrientation);
|
||||
rotation = glm::inverse(xnToGLM(parentOrientation.orientation)) * rotation;
|
||||
}
|
||||
const float METERS_PER_MM = 1.0f / 1000.0f;
|
||||
joints[avatarJoint] = Joint(xnToGLM(transform.position.position, true) * METERS_PER_MM,
|
||||
rotation, xnToGLM(projected));
|
||||
}
|
||||
|
|
@ -480,31 +495,23 @@ void FrameGrabber::grabFrame() {
|
|||
_searchWindow = Rect(clip(faceBounds.tl(), imageBounds), clip(faceBounds.br(), imageBounds));
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENNI
|
||||
if (_depthGenerator.IsValid()) {
|
||||
// convert from 11 to 8 bits, centered about the mean face depth (if possible)
|
||||
if (_searchWindow.area() > 0) {
|
||||
const double DEPTH_OFFSET_SMOOTHING = 0.95;
|
||||
const double EIGHT_BIT_MIDPOINT = 128.0;
|
||||
double meanOffset = EIGHT_BIT_MIDPOINT - mean(depth(_searchWindow))[0];
|
||||
_depthOffset = (_depthOffset == 0.0) ? meanOffset : glm::mix(meanOffset, _depthOffset, DEPTH_OFFSET_SMOOTHING);
|
||||
}
|
||||
depth.convertTo(_grayDepthFrame, CV_8UC1, 1.0, _depthOffset);
|
||||
}
|
||||
#endif
|
||||
|
||||
const int ENCODED_FACE_WIDTH = 128;
|
||||
const int ENCODED_FACE_HEIGHT = 128;
|
||||
int combinedFaceHeight = ENCODED_FACE_HEIGHT * (depth.empty() ? 1 : 2);
|
||||
if (_codec.name == 0) {
|
||||
// initialize encoder context
|
||||
if (_colorCodec.name == 0) {
|
||||
// initialize encoder context(s)
|
||||
vpx_codec_enc_cfg_t codecConfig;
|
||||
vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &codecConfig, 0);
|
||||
codecConfig.rc_target_bitrate = ENCODED_FACE_WIDTH * combinedFaceHeight * codecConfig.rc_target_bitrate /
|
||||
codecConfig.g_w / codecConfig.g_h;
|
||||
codecConfig.rc_target_bitrate = ENCODED_FACE_WIDTH * ENCODED_FACE_HEIGHT *
|
||||
codecConfig.rc_target_bitrate / codecConfig.g_w / codecConfig.g_h;
|
||||
codecConfig.g_w = ENCODED_FACE_WIDTH;
|
||||
codecConfig.g_h = combinedFaceHeight;
|
||||
vpx_codec_enc_init(&_codec, vpx_codec_vp8_cx(), &codecConfig, 0);
|
||||
codecConfig.g_h = ENCODED_FACE_HEIGHT;
|
||||
vpx_codec_enc_init(&_colorCodec, vpx_codec_vp8_cx(), &codecConfig, 0);
|
||||
|
||||
if (!depth.empty()) {
|
||||
int DEPTH_BITRATE_MULTIPLIER = 2;
|
||||
codecConfig.rc_target_bitrate *= 2;
|
||||
vpx_codec_enc_init(&_depthCodec, vpx_codec_vp8_cx(), &codecConfig, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// correct for 180 degree rotations
|
||||
|
|
@ -541,9 +548,9 @@ void FrameGrabber::grabFrame() {
|
|||
const int ENCODED_BITS_PER_VU = 2;
|
||||
const int ENCODED_BITS_PER_PIXEL = ENCODED_BITS_PER_Y + 2 * ENCODED_BITS_PER_VU;
|
||||
const int BITS_PER_BYTE = 8;
|
||||
_encodedFace.fill(128, ENCODED_FACE_WIDTH * combinedFaceHeight * ENCODED_BITS_PER_PIXEL / BITS_PER_BYTE);
|
||||
_encodedFace.resize(ENCODED_FACE_WIDTH * ENCODED_FACE_HEIGHT * ENCODED_BITS_PER_PIXEL / BITS_PER_BYTE);
|
||||
vpx_image_t vpxImage;
|
||||
vpx_img_wrap(&vpxImage, VPX_IMG_FMT_YV12, ENCODED_FACE_WIDTH, combinedFaceHeight, 1, (unsigned char*)_encodedFace.data());
|
||||
vpx_img_wrap(&vpxImage, VPX_IMG_FMT_YV12, ENCODED_FACE_WIDTH, ENCODED_FACE_HEIGHT, 1, (unsigned char*)_encodedFace.data());
|
||||
uchar* yline = vpxImage.planes[0];
|
||||
uchar* vline = vpxImage.planes[1];
|
||||
uchar* uline = vpxImage.planes[2];
|
||||
|
|
@ -571,9 +578,9 @@ void FrameGrabber::grabFrame() {
|
|||
|
||||
ydest[0] = (tl[redIndex] * Y_RED_WEIGHT + tl[1] * Y_GREEN_WEIGHT + tl[blueIndex] * Y_BLUE_WEIGHT) >> 8;
|
||||
ydest[1] = (tr[redIndex] * Y_RED_WEIGHT + tr[1] * Y_GREEN_WEIGHT + tr[blueIndex] * Y_BLUE_WEIGHT) >> 8;
|
||||
ydest[ENCODED_FACE_WIDTH] = (bl[redIndex] * Y_RED_WEIGHT + bl[greenIndex] *
|
||||
ydest[vpxImage.stride[0]] = (bl[redIndex] * Y_RED_WEIGHT + bl[greenIndex] *
|
||||
Y_GREEN_WEIGHT + bl[blueIndex] * Y_BLUE_WEIGHT) >> 8;
|
||||
ydest[ENCODED_FACE_WIDTH + 1] = (br[redIndex] * Y_RED_WEIGHT + br[greenIndex] *
|
||||
ydest[vpxImage.stride[0] + 1] = (br[redIndex] * Y_RED_WEIGHT + br[greenIndex] *
|
||||
Y_GREEN_WEIGHT + br[blueIndex] * Y_BLUE_WEIGHT) >> 8;
|
||||
ydest += 2;
|
||||
|
||||
|
|
@ -590,37 +597,107 @@ void FrameGrabber::grabFrame() {
|
|||
uline += vpxImage.stride[2];
|
||||
}
|
||||
|
||||
// if we have depth data, warp that and just copy it in
|
||||
if (!depth.empty()) {
|
||||
_faceDepth.create(ENCODED_FACE_WIDTH, ENCODED_FACE_HEIGHT, CV_8UC1);
|
||||
warpAffine(_grayDepthFrame, _faceDepth, transform, _faceDepth.size());
|
||||
|
||||
uchar* dest = (uchar*)_encodedFace.data() + vpxImage.stride[0] * ENCODED_FACE_HEIGHT;
|
||||
for (int i = 0; i < ENCODED_FACE_HEIGHT; i++) {
|
||||
memcpy(dest, _faceDepth.ptr(i), ENCODED_FACE_WIDTH);
|
||||
dest += vpxImage.stride[0];
|
||||
}
|
||||
}
|
||||
|
||||
// encode the frame
|
||||
vpx_codec_encode(&_codec, &vpxImage, ++_frameCount, 1, 0, VPX_DL_REALTIME);
|
||||
vpx_codec_encode(&_colorCodec, &vpxImage, ++_frameCount, 1, 0, VPX_DL_REALTIME);
|
||||
|
||||
// start the payload off with the aspect ratio
|
||||
QByteArray payload(sizeof(float), 0);
|
||||
*(float*)payload.data() = _smoothedFaceRect.size.width / _smoothedFaceRect.size.height;
|
||||
|
||||
// extract the encoded frame
|
||||
vpx_codec_iter_t iterator = 0;
|
||||
const vpx_codec_cx_pkt_t* packet;
|
||||
while ((packet = vpx_codec_get_cx_data(&_codec, &iterator)) != 0) {
|
||||
while ((packet = vpx_codec_get_cx_data(&_colorCodec, &iterator)) != 0) {
|
||||
if (packet->kind == VPX_CODEC_CX_FRAME_PKT) {
|
||||
// prepend the aspect ratio
|
||||
QByteArray payload(sizeof(float), 0);
|
||||
*(float*)payload.data() = _smoothedFaceRect.size.width / _smoothedFaceRect.size.height;
|
||||
// prepend the length, which will indicate whether there's a depth frame too
|
||||
payload.append((const char*)&packet->data.frame.sz, sizeof(packet->data.frame.sz));
|
||||
payload.append((const char*)packet->data.frame.buf, packet->data.frame.sz);
|
||||
QMetaObject::invokeMethod(Application::getInstance(), "sendAvatarFaceVideoMessage", Q_ARG(int, _frameCount),
|
||||
Q_ARG(QByteArray, payload));
|
||||
}
|
||||
}
|
||||
|
||||
if (!depth.empty()) {
|
||||
// warp the face depth without interpolation (because it will contain invalid zero values)
|
||||
_faceDepth.create(ENCODED_FACE_WIDTH, ENCODED_FACE_HEIGHT, CV_16UC1);
|
||||
warpAffine(depth, _faceDepth, transform, _faceDepth.size(), INTER_NEAREST);
|
||||
|
||||
// find the mean of the valid values
|
||||
qint64 depthTotal = 0;
|
||||
qint64 depthSamples = 0;
|
||||
ushort* src = _faceDepth.ptr<ushort>();
|
||||
const ushort ELEVEN_BIT_MINIMUM = 0;
|
||||
const ushort ELEVEN_BIT_MAXIMUM = 2047;
|
||||
for (int i = 0; i < ENCODED_FACE_HEIGHT; i++) {
|
||||
for (int j = 0; j < ENCODED_FACE_WIDTH; j++) {
|
||||
ushort depth = *src++;
|
||||
if (depth != ELEVEN_BIT_MINIMUM && depth != ELEVEN_BIT_MAXIMUM) {
|
||||
depthTotal += depth;
|
||||
depthSamples++;
|
||||
}
|
||||
}
|
||||
}
|
||||
float mean = (depthSamples == 0) ? UNINITIALIZED_FACE_DEPTH : depthTotal / (float)depthSamples;
|
||||
|
||||
// smooth the mean over time
|
||||
const float DEPTH_OFFSET_SMOOTHING = 0.95f;
|
||||
_smoothedMeanFaceDepth = (_smoothedMeanFaceDepth == UNINITIALIZED_FACE_DEPTH) ? mean :
|
||||
glm::mix(mean, _smoothedMeanFaceDepth, DEPTH_OFFSET_SMOOTHING);
|
||||
|
||||
// convert from 11 to 8 bits for preview/local display
|
||||
const uchar EIGHT_BIT_MIDPOINT = 128;
|
||||
double depthOffset = EIGHT_BIT_MIDPOINT - _smoothedMeanFaceDepth;
|
||||
depth.convertTo(_grayDepthFrame, CV_8UC1, 1.0, depthOffset);
|
||||
|
||||
// likewise for the encoded representation
|
||||
uchar* yline = vpxImage.planes[0];
|
||||
uchar* vline = vpxImage.planes[1];
|
||||
uchar* uline = vpxImage.planes[2];
|
||||
const uchar EIGHT_BIT_MAXIMUM = 255;
|
||||
for (int i = 0; i < ENCODED_FACE_HEIGHT; i += 2) {
|
||||
uchar* ydest = yline;
|
||||
uchar* vdest = vline;
|
||||
uchar* udest = uline;
|
||||
for (int j = 0; j < ENCODED_FACE_WIDTH; j += 2) {
|
||||
ushort tl = *_faceDepth.ptr<ushort>(i, j);
|
||||
ushort tr = *_faceDepth.ptr<ushort>(i, j + 1);
|
||||
ushort bl = *_faceDepth.ptr<ushort>(i + 1, j);
|
||||
ushort br = *_faceDepth.ptr<ushort>(i + 1, j + 1);
|
||||
|
||||
uchar mask = EIGHT_BIT_MAXIMUM;
|
||||
|
||||
ydest[0] = (tl == ELEVEN_BIT_MINIMUM) ? (mask = EIGHT_BIT_MIDPOINT) : saturate_cast<uchar>(tl + depthOffset);
|
||||
ydest[1] = (tr == ELEVEN_BIT_MINIMUM) ? (mask = EIGHT_BIT_MIDPOINT) : saturate_cast<uchar>(tr + depthOffset);
|
||||
ydest[vpxImage.stride[0]] = (bl == ELEVEN_BIT_MINIMUM) ?
|
||||
(mask = EIGHT_BIT_MIDPOINT) : saturate_cast<uchar>(bl + depthOffset);
|
||||
ydest[vpxImage.stride[0] + 1] = (br == ELEVEN_BIT_MINIMUM) ?
|
||||
(mask = EIGHT_BIT_MIDPOINT) : saturate_cast<uchar>(br + depthOffset);
|
||||
ydest += 2;
|
||||
|
||||
*vdest++ = mask;
|
||||
*udest++ = EIGHT_BIT_MIDPOINT;
|
||||
}
|
||||
yline += vpxImage.stride[0] * 2;
|
||||
vline += vpxImage.stride[1];
|
||||
uline += vpxImage.stride[2];
|
||||
}
|
||||
|
||||
// encode the frame
|
||||
vpx_codec_encode(&_depthCodec, &vpxImage, _frameCount, 1, 0, VPX_DL_REALTIME);
|
||||
|
||||
// extract the encoded frame
|
||||
vpx_codec_iter_t iterator = 0;
|
||||
const vpx_codec_cx_pkt_t* packet;
|
||||
while ((packet = vpx_codec_get_cx_data(&_depthCodec, &iterator)) != 0) {
|
||||
if (packet->kind == VPX_CODEC_CX_FRAME_PKT) {
|
||||
payload.append((const char*)packet->data.frame.buf, packet->data.frame.sz);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
QMetaObject::invokeMethod(Application::getInstance(), "sendAvatarFaceVideoMessage",
|
||||
Q_ARG(int, _frameCount), Q_ARG(QByteArray, payload));
|
||||
|
||||
QMetaObject::invokeMethod(Application::getInstance()->getWebcam(), "setFrame",
|
||||
Q_ARG(cv::Mat, color), Q_ARG(int, format), Q_ARG(cv::Mat, _grayDepthFrame),
|
||||
Q_ARG(cv::Mat, color), Q_ARG(int, format), Q_ARG(cv::Mat, _grayDepthFrame), Q_ARG(float, _smoothedMeanFaceDepth),
|
||||
Q_ARG(cv::RotatedRect, _smoothedFaceRect), Q_ARG(JointVector, joints));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@
|
|||
|
||||
#include <opencv2/opencv.hpp>
|
||||
|
||||
#ifdef HAVE_OPENNI
|
||||
#include <XnCppWrapper.h>
|
||||
#if defined(HAVE_OPENNI) && !defined(Q_MOC_RUN)
|
||||
#include <XnCppWrapper.h>
|
||||
#endif
|
||||
|
||||
#include <vpx_codec.h>
|
||||
|
|
@ -62,7 +62,7 @@ public:
|
|||
public slots:
|
||||
|
||||
void setEnabled(bool enabled);
|
||||
void setFrame(const cv::Mat& color, int format, const cv::Mat& depth,
|
||||
void setFrame(const cv::Mat& color, int format, const cv::Mat& depth, float meanFaceDepth,
|
||||
const cv::RotatedRect& faceRect, const JointVector& joints);
|
||||
|
||||
private:
|
||||
|
|
@ -77,6 +77,7 @@ private:
|
|||
cv::Size2f _textureSize;
|
||||
cv::RotatedRect _faceRect;
|
||||
cv::RotatedRect _initialFaceRect;
|
||||
float _initialFaceDepth;
|
||||
JointVector _joints;
|
||||
|
||||
uint64_t _startTimestamp;
|
||||
|
|
@ -117,9 +118,10 @@ private:
|
|||
cv::Mat _backProject;
|
||||
cv::Rect _searchWindow;
|
||||
cv::Mat _grayDepthFrame;
|
||||
double _depthOffset;
|
||||
float _smoothedMeanFaceDepth;
|
||||
|
||||
vpx_codec_ctx_t _codec;
|
||||
vpx_codec_ctx_t _colorCodec;
|
||||
vpx_codec_ctx_t _depthCodec;
|
||||
int _frameCount;
|
||||
cv::Mat _faceColor;
|
||||
cv::Mat _faceDepth;
|
||||
|
|
|
|||
|
|
@ -451,7 +451,7 @@ void Avatar::updateThrust(float deltaTime, Transmitter * transmitter) {
|
|||
}
|
||||
|
||||
void Avatar::simulate(float deltaTime, Transmitter* transmitter) {
|
||||
|
||||
|
||||
glm::quat orientation = getOrientation();
|
||||
glm::vec3 front = orientation * IDENTITY_FRONT;
|
||||
glm::vec3 right = orientation * IDENTITY_RIGHT;
|
||||
|
|
|
|||
|
|
@ -30,19 +30,25 @@ GLuint Face::_vboID;
|
|||
GLuint Face::_iboID;
|
||||
|
||||
Face::Face(Head* owningHead) : _owningHead(owningHead), _renderMode(MESH),
|
||||
_colorTextureID(0), _depthTextureID(0), _codec(), _frameCount(0) {
|
||||
_colorTextureID(0), _depthTextureID(0), _colorCodec(), _depthCodec(), _frameCount(0) {
|
||||
// we may have been created in the network thread, but we live in the main thread
|
||||
moveToThread(Application::getInstance()->thread());
|
||||
}
|
||||
|
||||
Face::~Face() {
|
||||
if (_codec.name != 0) {
|
||||
vpx_codec_destroy(&_codec);
|
||||
if (_colorCodec.name != 0) {
|
||||
vpx_codec_destroy(&_colorCodec);
|
||||
|
||||
// delete our textures, since we know that we own them
|
||||
// delete our texture, since we know that we own it
|
||||
if (_colorTextureID != 0) {
|
||||
glDeleteTextures(1, &_colorTextureID);
|
||||
}
|
||||
|
||||
}
|
||||
if (_depthCodec.name != 0) {
|
||||
vpx_codec_destroy(&_depthCodec);
|
||||
|
||||
// delete our texture, since we know that we own it
|
||||
if (_depthTextureID != 0) {
|
||||
glDeleteTextures(1, &_depthTextureID);
|
||||
}
|
||||
|
|
@ -55,9 +61,9 @@ void Face::setTextureRect(const cv::RotatedRect& textureRect) {
|
|||
}
|
||||
|
||||
int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
|
||||
if (_codec.name == 0) {
|
||||
if (_colorCodec.name == 0) {
|
||||
// initialize decoder context
|
||||
vpx_codec_dec_init(&_codec, vpx_codec_vp8_dx(), 0, 0);
|
||||
vpx_codec_dec_init(&_colorCodec, vpx_codec_vp8_dx(), 0, 0);
|
||||
}
|
||||
// skip the header
|
||||
unsigned char* packetPosition = packetData;
|
||||
|
|
@ -85,14 +91,14 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
|
|||
|
||||
if ((_frameBytesRemaining -= payloadSize) <= 0) {
|
||||
float aspectRatio = *(const float*)_arrivingFrame.constData();
|
||||
vpx_codec_decode(&_codec, (const uint8_t*)_arrivingFrame.constData() + sizeof(float),
|
||||
_arrivingFrame.size() - sizeof(float), 0, 0);
|
||||
size_t colorSize = *(const size_t*)(_arrivingFrame.constData() + sizeof(float));
|
||||
const uint8_t* colorData = (const uint8_t*)(_arrivingFrame.constData() + sizeof(float) + sizeof(size_t));
|
||||
vpx_codec_decode(&_colorCodec, colorData, colorSize, 0, 0);
|
||||
vpx_codec_iter_t iterator = 0;
|
||||
vpx_image_t* image;
|
||||
while ((image = vpx_codec_get_frame(&_codec, &iterator)) != 0) {
|
||||
while ((image = vpx_codec_get_frame(&_colorCodec, &iterator)) != 0) {
|
||||
// convert from YV12 to RGB
|
||||
const int imageHeight = image->d_w;
|
||||
Mat color(imageHeight, image->d_w, CV_8UC3);
|
||||
Mat color(image->d_h, image->d_w, CV_8UC3);
|
||||
uchar* yline = image->planes[0];
|
||||
uchar* vline = image->planes[1];
|
||||
uchar* uline = image->planes[2];
|
||||
|
|
@ -100,7 +106,7 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
|
|||
const int GREEN_V_WEIGHT = (int)(0.714 * 256);
|
||||
const int GREEN_U_WEIGHT = (int)(0.344 * 256);
|
||||
const int BLUE_U_WEIGHT = (int)(1.773 * 256);
|
||||
for (int i = 0; i < imageHeight; i += 2) {
|
||||
for (int i = 0; i < image->d_h; i += 2) {
|
||||
uchar* ysrc = yline;
|
||||
uchar* vsrc = vline;
|
||||
uchar* usrc = uline;
|
||||
|
|
@ -144,13 +150,44 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
|
|||
uline += image->stride[2];
|
||||
}
|
||||
Mat depth;
|
||||
if (image->d_h > imageHeight) {
|
||||
// if the height is greater than the width, we have depth data
|
||||
depth.create(imageHeight, image->d_w, CV_8UC1);
|
||||
uchar* src = image->planes[0] + image->stride[0] * imageHeight;
|
||||
for (int i = 0; i < imageHeight; i++) {
|
||||
memcpy(depth.ptr(i), src, image->d_w);
|
||||
src += image->stride[0];
|
||||
|
||||
const uint8_t* depthData = colorData + colorSize;
|
||||
int depthSize = _arrivingFrame.size() - ((const char*)depthData - _arrivingFrame.constData());
|
||||
if (depthSize > 0) {
|
||||
if (_depthCodec.name == 0) {
|
||||
// initialize decoder context
|
||||
vpx_codec_dec_init(&_depthCodec, vpx_codec_vp8_dx(), 0, 0);
|
||||
}
|
||||
vpx_codec_decode(&_depthCodec, depthData, depthSize, 0, 0);
|
||||
vpx_codec_iter_t iterator = 0;
|
||||
vpx_image_t* image;
|
||||
while ((image = vpx_codec_get_frame(&_depthCodec, &iterator)) != 0) {
|
||||
depth.create(image->d_h, image->d_w, CV_8UC1);
|
||||
uchar* yline = image->planes[0];
|
||||
uchar* vline = image->planes[1];
|
||||
const uchar EIGHT_BIT_MAXIMUM = 255;
|
||||
const uchar MASK_THRESHOLD = 192;
|
||||
for (int i = 0; i < image->d_h; i += 2) {
|
||||
uchar* ysrc = yline;
|
||||
uchar* vsrc = vline;
|
||||
for (int j = 0; j < image->d_w; j += 2) {
|
||||
if (*vsrc++ < MASK_THRESHOLD) {
|
||||
*depth.ptr(i, j) = EIGHT_BIT_MAXIMUM;
|
||||
*depth.ptr(i, j + 1) = EIGHT_BIT_MAXIMUM;
|
||||
*depth.ptr(i + 1, j) = EIGHT_BIT_MAXIMUM;
|
||||
*depth.ptr(i + 1, j + 1) = EIGHT_BIT_MAXIMUM;
|
||||
|
||||
} else {
|
||||
*depth.ptr(i, j) = ysrc[0];
|
||||
*depth.ptr(i, j + 1) = ysrc[1];
|
||||
*depth.ptr(i + 1, j) = ysrc[image->stride[0]];
|
||||
*depth.ptr(i + 1, j + 1) = ysrc[image->stride[0] + 1];
|
||||
}
|
||||
ysrc += 2;
|
||||
}
|
||||
yline += image->stride[0] * 2;
|
||||
vline += image->stride[1];
|
||||
}
|
||||
}
|
||||
}
|
||||
QMetaObject::invokeMethod(this, "setFrame", Q_ARG(cv::Mat, color),
|
||||
|
|
|
|||
|
|
@ -57,7 +57,8 @@ private:
|
|||
cv::RotatedRect _textureRect;
|
||||
float _aspectRatio;
|
||||
|
||||
vpx_codec_ctx_t _codec;
|
||||
vpx_codec_ctx_t _colorCodec;
|
||||
vpx_codec_ctx_t _depthCodec;
|
||||
|
||||
QByteArray _arrivingFrame;
|
||||
int _frameCount;
|
||||
|
|
|
|||
|
|
@ -14,19 +14,25 @@
|
|||
#include "Util.h"
|
||||
#include "renderer/ProgramObject.h"
|
||||
|
||||
const bool SHOW_LEAP_HAND = false;
|
||||
|
||||
using namespace std;
|
||||
|
||||
Hand::Hand(Avatar* owningAvatar) :
|
||||
HandData((AvatarData*)owningAvatar),
|
||||
|
||||
_raveGloveClock(0.0f),
|
||||
_raveGloveMode(RAVE_GLOVE_EFFECTS_MODE_THROBBING_COLOR),
|
||||
_raveGloveInitialized(false),
|
||||
_isRaveGloveActive(false),
|
||||
_owningAvatar(owningAvatar),
|
||||
_renderAlpha(1.0),
|
||||
_lookingInMirror(false),
|
||||
_ballColor(0.0, 0.0, 0.4),
|
||||
_particleSystemInitialized(false)
|
||||
{
|
||||
_ballColor(0.0, 0.0, 0.4)
|
||||
{
|
||||
// initialize all finger particle emitters with an invalid id as default
|
||||
for (int f = 0; f< NUM_FINGERS_PER_HAND; f ++ ) {
|
||||
_fingerParticleEmitter[f] = -1;
|
||||
for (int f = 0; f< NUM_FINGERS; f ++ ) {
|
||||
_raveGloveEmitter[f] = NULL_EMITTER;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -35,16 +41,18 @@ void Hand::init() {
|
|||
if (_owningAvatar && _owningAvatar->isMyAvatar()) {
|
||||
_ballColor = glm::vec3(0.0, 0.4, 0.0);
|
||||
}
|
||||
else
|
||||
else {
|
||||
_ballColor = glm::vec3(0.0, 0.0, 0.4);
|
||||
}
|
||||
}
|
||||
|
||||
void Hand::reset() {
|
||||
}
|
||||
|
||||
|
||||
void Hand::simulate(float deltaTime, bool isMine) {
|
||||
if (_isRaveGloveActive) {
|
||||
updateFingerParticles(deltaTime);
|
||||
updateRaveGloveParticles(deltaTime);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -76,6 +84,21 @@ void Hand::calculateGeometry() {
|
|||
}
|
||||
}
|
||||
|
||||
void Hand::setRaveGloveEffectsMode(QKeyEvent* event) {
|
||||
switch (event->key()) {
|
||||
|
||||
case Qt::Key_0: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_THROBBING_COLOR); break;
|
||||
case Qt::Key_1: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_TRAILS ); break;
|
||||
case Qt::Key_2: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_FIRE ); break;
|
||||
case Qt::Key_3: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_WATER ); break;
|
||||
case Qt::Key_4: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_FLASHY ); break;
|
||||
case Qt::Key_5: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_BOZO_SPARKLER ); break;
|
||||
case Qt::Key_6: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_LONG_SPARKLER ); break;
|
||||
case Qt::Key_7: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_SNAKE ); break;
|
||||
case Qt::Key_8: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_PULSE ); break;
|
||||
case Qt::Key_9: setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_THROB ); break;
|
||||
};
|
||||
}
|
||||
|
||||
void Hand::render(bool lookingInMirror) {
|
||||
|
||||
|
|
@ -87,16 +110,19 @@ void Hand::render(bool lookingInMirror) {
|
|||
if (_isRaveGloveActive) {
|
||||
renderRaveGloveStage();
|
||||
|
||||
if (_particleSystemInitialized) {
|
||||
_particleSystem.render();
|
||||
if (_raveGloveInitialized) {
|
||||
updateRaveGloveEmitters(); // do this after calculateGeometry
|
||||
_raveGloveParticleSystem.render();
|
||||
}
|
||||
}
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glEnable(GL_RESCALE_NORMAL);
|
||||
|
||||
renderFingerTrails();
|
||||
renderHandSpheres();
|
||||
if ( SHOW_LEAP_HAND ) {
|
||||
renderFingerTrails();
|
||||
renderHandSpheres();
|
||||
}
|
||||
}
|
||||
|
||||
void Hand::renderRaveGloveStage() {
|
||||
|
|
@ -203,69 +229,61 @@ void Hand::renderFingerTrails() {
|
|||
}
|
||||
}
|
||||
|
||||
void Hand::updateFingerParticles(float deltaTime) {
|
||||
|
||||
if (!_particleSystemInitialized) {
|
||||
|
||||
for ( int f = 0; f< NUM_FINGERS_PER_HAND; f ++ ) {
|
||||
|
||||
_particleSystem.setShowingEmitter(f, true );
|
||||
|
||||
_fingerParticleEmitter[f] = _particleSystem.addEmitter();
|
||||
|
||||
assert( _fingerParticleEmitter[f] != -1 );
|
||||
|
||||
ParticleSystem::ParticleAttributes attributes;
|
||||
|
||||
// set attributes for each life stage of the particle:
|
||||
attributes.radius = 0.0f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 0.5f, 0.5f);
|
||||
attributes.gravity = 0.0f;
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.002f;
|
||||
attributes.emitterAttraction = 0.0f;
|
||||
attributes.tornadoForce = 0.0f;
|
||||
attributes.neighborAttraction = 0.0f;
|
||||
attributes.neighborRepulsion = 0.0f;
|
||||
attributes.bounce = 1.0f;
|
||||
attributes.usingCollisionSphere = false;
|
||||
_particleSystem.setParticleAttributes(_fingerParticleEmitter[f], 0, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.jitter = 0.0f;
|
||||
attributes.gravity = -0.005f;
|
||||
attributes.color = glm::vec4( 1.0f, 0.2f, 0.0f, 0.4f);
|
||||
_particleSystem.setParticleAttributes(_fingerParticleEmitter[f], 1, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.gravity = 0.0f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.0f, 0.0f, 0.2f);
|
||||
_particleSystem.setParticleAttributes(_fingerParticleEmitter[f], 2, attributes);
|
||||
|
||||
attributes.radius = 0.02f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.0f, 0.0f, 0.0f);
|
||||
_particleSystem.setParticleAttributes(_fingerParticleEmitter[f], 3, attributes);
|
||||
void Hand::setLeapHands(const std::vector<glm::vec3>& handPositions,
|
||||
const std::vector<glm::vec3>& handNormals) {
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
if (i < handPositions.size()) {
|
||||
palm.setActive(true);
|
||||
palm.setRawPosition(handPositions[i]);
|
||||
palm.setRawNormal(handNormals[i]);
|
||||
}
|
||||
else {
|
||||
palm.setActive(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_particleSystemInitialized = true;
|
||||
} else {
|
||||
// update the particles
|
||||
// call this right after the geometry of the leap hands are set
|
||||
void Hand::updateRaveGloveEmitters() {
|
||||
|
||||
bool debug = false;
|
||||
|
||||
if (_raveGloveInitialized) {
|
||||
|
||||
static float t = 0.0f;
|
||||
t += deltaTime;
|
||||
if(debug) printf( "\n" );
|
||||
if(debug) printf( "------------------------------------\n" );
|
||||
if(debug) printf( "updating rave glove emitters:\n" );
|
||||
if(debug) printf( "------------------------------------\n" );
|
||||
|
||||
int emitterIndex = 0;
|
||||
|
||||
int fingerIndex = 0;
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
|
||||
if(debug) printf( "\n" );
|
||||
if(debug) printf( "palm %d ", (int)i );
|
||||
|
||||
if (palm.isActive()) {
|
||||
|
||||
if(debug) printf( "is active\n" );
|
||||
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
|
||||
if(debug) printf( "emitterIndex %d: ", emitterIndex );
|
||||
|
||||
if (finger.isActive()) {
|
||||
if (_fingerParticleEmitter[fingerIndex] != -1) {
|
||||
|
||||
if ((emitterIndex >=0)
|
||||
&& (emitterIndex < NUM_FINGERS)) {
|
||||
|
||||
assert(emitterIndex >=0 );
|
||||
assert(emitterIndex < NUM_FINGERS );
|
||||
|
||||
if(debug) printf( "_raveGloveEmitter[%d] = %d\n", emitterIndex, _raveGloveEmitter[emitterIndex] );
|
||||
|
||||
glm::vec3 particleEmitterPosition = finger.getTipPosition();
|
||||
|
||||
glm::vec3 fingerDirection = particleEmitterPosition - leapPositionToWorldPosition(finger.getRootPosition());
|
||||
glm::vec3 fingerDirection = finger.getTipPosition() - finger.getRootPosition();
|
||||
float fingerLength = glm::length(fingerDirection);
|
||||
|
||||
if (fingerLength > 0.0f) {
|
||||
|
|
@ -273,27 +291,391 @@ void Hand::updateFingerParticles(float deltaTime) {
|
|||
} else {
|
||||
fingerDirection = IDENTITY_UP;
|
||||
}
|
||||
|
||||
glm::quat particleEmitterRotation = rotationBetween(palm.getNormal(), fingerDirection);
|
||||
|
||||
//glm::quat particleEmitterRotation = glm::angleAxis(0.0f, fingerDirection);
|
||||
assert(_raveGloveEmitter[emitterIndex] >=0 );
|
||||
assert(_raveGloveEmitter[emitterIndex] < NUM_FINGERS );
|
||||
|
||||
_particleSystem.setEmitterPosition(_fingerParticleEmitter[f], particleEmitterPosition);
|
||||
_particleSystem.setEmitterRotation(_fingerParticleEmitter[f], particleEmitterRotation);
|
||||
|
||||
const glm::vec3 velocity = fingerDirection * 0.002f;
|
||||
const float lifespan = 1.0f;
|
||||
_particleSystem.emitParticlesNow(_fingerParticleEmitter[f], 1, velocity, lifespan);
|
||||
_raveGloveParticleSystem.setEmitterPosition (_raveGloveEmitter[emitterIndex], finger.getTipPosition());
|
||||
_raveGloveParticleSystem.setEmitterDirection(_raveGloveEmitter[emitterIndex], fingerDirection);
|
||||
}
|
||||
} else {
|
||||
if(debug) printf( "BOGUS finger\n" );
|
||||
}
|
||||
|
||||
emitterIndex ++;
|
||||
}
|
||||
} else {
|
||||
if(debug) printf( "is NOT active\n" );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// call this from within the simulate method
|
||||
void Hand::updateRaveGloveParticles(float deltaTime) {
|
||||
|
||||
if (!_raveGloveInitialized) {
|
||||
|
||||
//printf( "Initializing rave glove emitters:\n" );
|
||||
//printf( "The indices of the emitters are:\n" );
|
||||
|
||||
// start up the rave glove finger particles...
|
||||
for ( int f = 0; f< NUM_FINGERS; f ++ ) {
|
||||
_raveGloveEmitter[f] = _raveGloveParticleSystem.addEmitter();
|
||||
assert( _raveGloveEmitter[f] >= 0 );
|
||||
assert( _raveGloveEmitter[f] != NULL_EMITTER );
|
||||
|
||||
//printf( "%d\n", _raveGloveEmitter[f] );
|
||||
}
|
||||
|
||||
setRaveGloveMode(RAVE_GLOVE_EFFECTS_MODE_FIRE);
|
||||
_raveGloveParticleSystem.setUpDirection(glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
_raveGloveInitialized = true;
|
||||
} else {
|
||||
|
||||
_particleSystem.setUpDirection(glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
_particleSystem.simulate(deltaTime);
|
||||
_raveGloveClock += deltaTime;
|
||||
|
||||
// this rave glove effect oscillates though various colors and radii that are meant to show off some effects
|
||||
if (_raveGloveMode == RAVE_GLOVE_EFFECTS_MODE_THROBBING_COLOR) {
|
||||
ParticleSystem::ParticleAttributes attributes;
|
||||
float red = 0.5f + 0.5f * sinf(_raveGloveClock * 1.4f);
|
||||
float green = 0.5f + 0.5f * cosf(_raveGloveClock * 1.7f);
|
||||
float blue = 0.5f + 0.5f * sinf(_raveGloveClock * 2.0f);
|
||||
float alpha = 1.0f;
|
||||
|
||||
attributes.color = glm::vec4(red, green, blue, alpha);
|
||||
attributes.radius = 0.01f + 0.005f * sinf(_raveGloveClock * 2.2f);
|
||||
attributes.modulationAmplitude = 0.0f;
|
||||
|
||||
for ( int f = 0; f< NUM_FINGERS; f ++ ) {
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
}
|
||||
}
|
||||
|
||||
_raveGloveParticleSystem.simulate(deltaTime);
|
||||
}
|
||||
}
|
||||
|
||||
void Hand::setRaveGloveMode(int mode) {
|
||||
|
||||
_raveGloveMode = mode;
|
||||
|
||||
_raveGloveParticleSystem.killAllParticles();
|
||||
|
||||
for ( int f = 0; f< NUM_FINGERS; f ++ ) {
|
||||
|
||||
ParticleSystem::ParticleAttributes attributes;
|
||||
|
||||
//-----------------------------------------
|
||||
// throbbing color cycle
|
||||
//-----------------------------------------
|
||||
if (mode == RAVE_GLOVE_EFFECTS_MODE_THROBBING_COLOR) {
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.0f );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.0f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 30.0f );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 20 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.02f;
|
||||
attributes.gravity = 0.0f;
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.0f;
|
||||
attributes.bounce = 0.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// trails
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_TRAILS) {
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_RIBBON );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], false );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 1.0f );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.0f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 50.0f );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 5 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.001f;
|
||||
attributes.color = glm::vec4( 1.0f, 0.5f, 0.2f, 1.0f);
|
||||
attributes.gravity = 0.005f;
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.0f;
|
||||
attributes.bounce = 0.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.002f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.color = glm::vec4( 1.0f, 0.2f, 0.2f, 0.5f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.color = glm::vec4( 1.0f, 0.2f, 0.2f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
}
|
||||
|
||||
//-----------------------------------------
|
||||
// Fire!
|
||||
//-----------------------------------------
|
||||
if (mode == RAVE_GLOVE_EFFECTS_MODE_FIRE) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], false );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 1.0f );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.002f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 120.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 6 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.005f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 0.5f, 0.5f);
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.003f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.jitter = 0.0f;
|
||||
attributes.gravity = -0.005f;
|
||||
attributes.color = glm::vec4( 1.0f, 0.2f, 0.0f, 0.4f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.gravity = 0.0f;
|
||||
attributes.color = glm::vec4( 0.4f, 0.4f, 0.4f, 0.2f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.radius = 0.02f;
|
||||
attributes.color = glm::vec4( 0.4f, 0.6f, 0.9f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// water
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_WATER) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.6f );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.001f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 100.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 5 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.001f;
|
||||
attributes.color = glm::vec4( 0.8f, 0.9f, 1.0f, 0.5f);
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.004f;
|
||||
attributes.bounce = 1.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.gravity = 0.01f;
|
||||
attributes.jitter = 0.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.color = glm::vec4( 0.8f, 0.9f, 1.0f, 0.2f);
|
||||
attributes.radius = 0.002f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.color = glm::vec4( 0.8f, 0.9f, 1.0f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// flashy
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_FLASHY) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.1 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.002f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 100.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 12 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.0f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.05f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 0.0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 1.0f, 0.0f, 1.0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.0f, 0.0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// Bozo sparkler
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_BOZO_SPARKLER) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_RIBBON );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], false );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.2 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.002f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 100.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 12 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.0f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.01f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 0.0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 1.0f, 0.0f, .0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.radius = 0.0f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// long sparkler
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_LONG_SPARKLER) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_RIBBON );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], false );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 1.0 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.002f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 100.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 7 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.color = glm::vec4( 0.3f, 0.3f, 0.3f, 0.4f);
|
||||
attributes.radius = 0.0f;
|
||||
attributes.airFriction = 0.0f;
|
||||
attributes.jitter = 0.0001f;
|
||||
attributes.bounce = 1.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.005f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.5f, 0.5f, 0.8f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.radius = 0.007f;
|
||||
attributes.color = glm::vec4( 0.5f, 0.0f, 0.5f, 0.5f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.radius = 0.02f;
|
||||
attributes.color = glm::vec4( 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// bubble snake
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_SNAKE) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 1.0 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.002f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 100.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 7 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.001f;
|
||||
attributes.color = glm::vec4( 0.5f, 1.0f, 0.5f, 1.0f);
|
||||
attributes.airFriction = 0.01f;
|
||||
attributes.jitter = 0.0f;
|
||||
attributes.emitterAttraction = 0.0f;
|
||||
attributes.tornadoForce = 1.1f;
|
||||
attributes.neighborAttraction = 1.1f;
|
||||
attributes.neighborRepulsion = 1.1f;
|
||||
attributes.bounce = 0.0f;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
|
||||
attributes.radius = 0.002f;
|
||||
attributes.color = glm::vec4( 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
|
||||
attributes.radius = 0.003f;
|
||||
attributes.color = glm::vec4( 0.3f, 0.3f, 0.3f, 0.5f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
|
||||
attributes.radius = 0.004f;
|
||||
attributes.color = glm::vec4( 0.3f, 0.3f, 0.3f, 0.0f);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// pulse
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_PULSE) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.0 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.0f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 30.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 20 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 0.1f, 0.2f, 0.4f, 0.5f);
|
||||
attributes.modulationAmplitude = 0.9;
|
||||
attributes.modulationRate = 7.0;
|
||||
attributes.modulationStyle = COLOR_MODULATION_STYLE_LIGHNTESS_PULSE;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
|
||||
//-----------------------------------------
|
||||
// throb
|
||||
//-----------------------------------------
|
||||
} else if (mode == RAVE_GLOVE_EFFECTS_MODE_LONG_SPARKLER) {
|
||||
|
||||
_raveGloveParticleSystem.setParticleRenderStyle (_raveGloveEmitter[f], PARTICLE_RENDER_STYLE_SPHERE );
|
||||
_raveGloveParticleSystem.setShowingEmitterBaseParticle(_raveGloveEmitter[f], true );
|
||||
_raveGloveParticleSystem.setEmitterParticleLifespan (_raveGloveEmitter[f], 0.0 );
|
||||
_raveGloveParticleSystem.setEmitterThrust (_raveGloveEmitter[f], 0.0f );
|
||||
_raveGloveParticleSystem.setEmitterRate (_raveGloveEmitter[f], 30.0 );
|
||||
_raveGloveParticleSystem.setEmitterParticleResolution (_raveGloveEmitter[f], 20 );
|
||||
|
||||
_raveGloveParticleSystem.setParticleAttributesToDefault(&attributes);
|
||||
|
||||
attributes.radius = 0.01f;
|
||||
attributes.color = glm::vec4( 0.5f, 0.4f, 0.3f, 0.5f);
|
||||
attributes.modulationAmplitude = 0.3;
|
||||
attributes.modulationRate = 1.0;
|
||||
attributes.modulationStyle = COLOR_MODULATION_STYLE_LIGHTNESS_WAVE;
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_0, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_1, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_2, attributes);
|
||||
_raveGloveParticleSystem.setParticleAttributes(_raveGloveEmitter[f], PARTICLE_LIFESTAGE_3, attributes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#ifndef hifi_Hand_h
|
||||
#define hifi_Hand_h
|
||||
|
||||
#include <QAction>
|
||||
#include <glm/glm.hpp>
|
||||
#include <AvatarData.h>
|
||||
#include <HandData.h>
|
||||
|
|
@ -22,6 +23,22 @@
|
|||
class Avatar;
|
||||
class ProgramObject;
|
||||
|
||||
enum RaveGloveEffectsMode
|
||||
{
|
||||
RAVE_GLOVE_EFFECTS_MODE_NULL = -1,
|
||||
RAVE_GLOVE_EFFECTS_MODE_THROBBING_COLOR,
|
||||
RAVE_GLOVE_EFFECTS_MODE_TRAILS,
|
||||
RAVE_GLOVE_EFFECTS_MODE_FIRE,
|
||||
RAVE_GLOVE_EFFECTS_MODE_WATER,
|
||||
RAVE_GLOVE_EFFECTS_MODE_FLASHY,
|
||||
RAVE_GLOVE_EFFECTS_MODE_BOZO_SPARKLER,
|
||||
RAVE_GLOVE_EFFECTS_MODE_LONG_SPARKLER,
|
||||
RAVE_GLOVE_EFFECTS_MODE_SNAKE,
|
||||
RAVE_GLOVE_EFFECTS_MODE_PULSE,
|
||||
RAVE_GLOVE_EFFECTS_MODE_THROB,
|
||||
NUM_RAVE_GLOVE_EFFECTS_MODES
|
||||
};
|
||||
|
||||
class Hand : public HandData {
|
||||
public:
|
||||
Hand(Avatar* owningAvatar);
|
||||
|
|
@ -42,9 +59,10 @@ public:
|
|||
void render(bool lookingInMirror);
|
||||
|
||||
void setBallColor (glm::vec3 ballColor ) { _ballColor = ballColor; }
|
||||
void updateFingerParticles(float deltaTime);
|
||||
void updateRaveGloveParticles(float deltaTime);
|
||||
void updateRaveGloveEmitters();
|
||||
void setRaveGloveActive(bool active) { _isRaveGloveActive = active; }
|
||||
|
||||
void setRaveGloveEffectsMode(QKeyEvent* event);
|
||||
|
||||
// getters
|
||||
const glm::vec3& getLeapBallPosition (int ball) const { return _leapBalls[ball].position;}
|
||||
|
|
@ -55,20 +73,25 @@ private:
|
|||
Hand(const Hand&);
|
||||
Hand& operator= (const Hand&);
|
||||
|
||||
ParticleSystem _particleSystem;
|
||||
ParticleSystem _raveGloveParticleSystem;
|
||||
float _raveGloveClock;
|
||||
int _raveGloveMode;
|
||||
bool _raveGloveInitialized;
|
||||
int _raveGloveEmitter[NUM_FINGERS];
|
||||
bool _isRaveGloveActive;
|
||||
|
||||
Avatar* _owningAvatar;
|
||||
float _renderAlpha;
|
||||
bool _lookingInMirror;
|
||||
bool _isRaveGloveActive;
|
||||
glm::vec3 _ballColor;
|
||||
std::vector<HandBall> _leapBalls;
|
||||
|
||||
bool _particleSystemInitialized;
|
||||
int _fingerParticleEmitter[NUM_FINGERS_PER_HAND];
|
||||
Avatar* _owningAvatar;
|
||||
float _renderAlpha;
|
||||
bool _lookingInMirror;
|
||||
glm::vec3 _ballColor;
|
||||
std::vector<HandBall> _leapBalls;
|
||||
|
||||
// private methods
|
||||
void setLeapHands(const std::vector<glm::vec3>& handPositions,
|
||||
const std::vector<glm::vec3>& handNormals);
|
||||
|
||||
void renderRaveGloveStage();
|
||||
void setRaveGloveMode(int mode);
|
||||
void renderHandSpheres();
|
||||
void renderFingerTrails();
|
||||
void calculateGeometry();
|
||||
|
|
|
|||
|
|
@ -81,12 +81,12 @@ def hifiJob(String targetName, Boolean deploy) {
|
|||
static Closure cmakeBuild(srcDir, instCommand) {
|
||||
return { project ->
|
||||
project / 'builders' / 'hudson.plugins.cmake.CmakeBuilder' {
|
||||
sourceDir srcDir
|
||||
sourceDir '.'
|
||||
buildDir 'build'
|
||||
installDir ''
|
||||
buildType 'RelWithDebInfo'
|
||||
generator 'Unix Makefiles'
|
||||
makeCommand 'make'
|
||||
makeCommand "make ${srcDir}"
|
||||
installCommand instCommand
|
||||
preloadScript ''
|
||||
cmakeArgs ''
|
||||
|
|
|
|||
|
|
@ -19,7 +19,10 @@ class AvatarData;
|
|||
class FingerData;
|
||||
class PalmData;
|
||||
|
||||
const int NUM_HANDS = 2;
|
||||
const int NUM_FINGERS_PER_HAND = 5;
|
||||
const int NUM_FINGERS = NUM_HANDS * NUM_FINGERS_PER_HAND;
|
||||
|
||||
const int LEAPID_INVALID = -1;
|
||||
|
||||
class HandData {
|
||||
|
|
|
|||
|
|
@ -18,14 +18,15 @@ PACKET_VERSION versionForPacketType(PACKET_TYPE type) {
|
|||
case PACKET_TYPE_MICROPHONE_AUDIO_NO_ECHO:
|
||||
case PACKET_TYPE_MICROPHONE_AUDIO_WITH_ECHO:
|
||||
return 1;
|
||||
break;
|
||||
|
||||
case PACKET_TYPE_HEAD_DATA:
|
||||
return 2;
|
||||
break;
|
||||
|
||||
case PACKET_TYPE_AVATAR_FACE_VIDEO:
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue