diff --git a/interface/CMakeLists.txt b/interface/CMakeLists.txt old mode 100755 new mode 100644 index e5a2880cfd..17967c5f42 --- a/interface/CMakeLists.txt +++ b/interface/CMakeLists.txt @@ -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} diff --git a/interface/external/fervor/CMakeLists.txt b/interface/external/fervor/CMakeLists.txt index 62968d8833..a8b37ba9d0 100644 --- a/interface/external/fervor/CMakeLists.txt +++ b/interface/external/fervor/CMakeLists.txt @@ -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) \ No newline at end of file +qt5_use_modules(fervor Core Network Widgets WebKit) \ No newline at end of file diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 737dae8d0f..a4279a7e58 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -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; + } + } } } diff --git a/interface/src/LeapManager.cpp b/interface/src/LeapManager.cpp old mode 100755 new mode 100644 diff --git a/interface/src/ParticleSystem.cpp b/interface/src/ParticleSystem.cpp index 9dcdbe5f06..5e2b92bb64 100644 --- a/interface/src/ParticleSystem.cpp +++ b/interface/src/ParticleSystem.cpp @@ -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; lifeStageradius = 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) { - - diff --git a/interface/src/ParticleSystem.h b/interface/src/ParticleSystem.h index 764800f23e..d79f621f69 100644 --- a/interface/src/ParticleSystem.h +++ b/interface/src/ParticleSystem.h @@ -11,76 +11,121 @@ #include 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); diff --git a/interface/src/Webcam.cpp b/interface/src/Webcam.cpp index e37ca6c70e..d4fa015ba0 100644 --- a/interface/src/Webcam.cpp +++ b/interface/src/Webcam.cpp @@ -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(); + 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(i, j); + ushort tr = *_faceDepth.ptr(i, j + 1); + ushort bl = *_faceDepth.ptr(i + 1, j); + ushort br = *_faceDepth.ptr(i + 1, j + 1); + + uchar mask = EIGHT_BIT_MAXIMUM; + + ydest[0] = (tl == ELEVEN_BIT_MINIMUM) ? (mask = EIGHT_BIT_MIDPOINT) : saturate_cast(tl + depthOffset); + ydest[1] = (tr == ELEVEN_BIT_MINIMUM) ? (mask = EIGHT_BIT_MIDPOINT) : saturate_cast(tr + depthOffset); + ydest[vpxImage.stride[0]] = (bl == ELEVEN_BIT_MINIMUM) ? + (mask = EIGHT_BIT_MIDPOINT) : saturate_cast(bl + depthOffset); + ydest[vpxImage.stride[0] + 1] = (br == ELEVEN_BIT_MINIMUM) ? + (mask = EIGHT_BIT_MIDPOINT) : saturate_cast(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)); } diff --git a/interface/src/Webcam.h b/interface/src/Webcam.h index 260eda0897..3910bb4a19 100644 --- a/interface/src/Webcam.h +++ b/interface/src/Webcam.h @@ -19,8 +19,8 @@ #include -#ifdef HAVE_OPENNI - #include +#if defined(HAVE_OPENNI) && !defined(Q_MOC_RUN) +#include #endif #include @@ -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; diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp index 0bf2c94b10..1af82083ae 100755 --- a/interface/src/avatar/Avatar.cpp +++ b/interface/src/avatar/Avatar.cpp @@ -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; diff --git a/interface/src/avatar/Face.cpp b/interface/src/avatar/Face.cpp index d8a8d6c2a6..ff31241c54 100644 --- a/interface/src/avatar/Face.cpp +++ b/interface/src/avatar/Face.cpp @@ -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), diff --git a/interface/src/avatar/Face.h b/interface/src/avatar/Face.h index 1f9d41a1b3..d4812fecfb 100644 --- a/interface/src/avatar/Face.h +++ b/interface/src/avatar/Face.h @@ -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; diff --git a/interface/src/avatar/Hand.cpp b/interface/src/avatar/Hand.cpp index 97594d0f50..28b1af0603 100755 --- a/interface/src/avatar/Hand.cpp +++ b/interface/src/avatar/Hand.cpp @@ -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& handPositions, + const std::vector& 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); + } } } + diff --git a/interface/src/avatar/Hand.h b/interface/src/avatar/Hand.h index f37046ed3a..a3a00beb96 100755 --- a/interface/src/avatar/Hand.h +++ b/interface/src/avatar/Hand.h @@ -8,6 +8,7 @@ #ifndef hifi_Hand_h #define hifi_Hand_h +#include #include #include #include @@ -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 _leapBalls; - - bool _particleSystemInitialized; - int _fingerParticleEmitter[NUM_FINGERS_PER_HAND]; + Avatar* _owningAvatar; + float _renderAlpha; + bool _lookingInMirror; + glm::vec3 _ballColor; + std::vector _leapBalls; // private methods + void setLeapHands(const std::vector& handPositions, + const std::vector& handNormals); + void renderRaveGloveStage(); + void setRaveGloveMode(int mode); void renderHandSpheres(); void renderFingerTrails(); void calculateGeometry(); diff --git a/jenkins/jobs.groovy b/jenkins/jobs.groovy index 5acf313a9a..a7be662df6 100644 --- a/jenkins/jobs.groovy +++ b/jenkins/jobs.groovy @@ -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 '' diff --git a/libraries/avatars/src/HandData.h b/libraries/avatars/src/HandData.h index d2b5cae90d..1a7a99f2db 100755 --- a/libraries/avatars/src/HandData.h +++ b/libraries/avatars/src/HandData.h @@ -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 { diff --git a/libraries/shared/src/PacketHeaders.cpp b/libraries/shared/src/PacketHeaders.cpp index 292c4bbc0a..2e7b95c7f7 100644 --- a/libraries/shared/src/PacketHeaders.cpp +++ b/libraries/shared/src/PacketHeaders.cpp @@ -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; } }