From d51cab3e3d58cec59be452ece77d2d8ae3034f50 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Wed, 16 Sep 2015 14:51:08 -0700 Subject: [PATCH 01/11] Replace particle velocity with speed and orientation --- examples/example/entities/particlesTest.js | 23 ++-- .../entities/src/EntityItemProperties.cpp | 35 +++--- libraries/entities/src/EntityItemProperties.h | 9 +- .../entities/src/EntityItemPropertiesMacros.h | 8 ++ libraries/entities/src/EntityPropertyFlags.h | 3 + .../entities/src/ParticleEffectEntityItem.cpp | 106 +++++++++--------- .../entities/src/ParticleEffectEntityItem.h | 23 ++-- .../networking/src/udt/PacketHeaders.cpp | 2 +- libraries/networking/src/udt/PacketHeaders.h | 1 + 9 files changed, 125 insertions(+), 85 deletions(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index 0d1ea60005..b9d046e3a0 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -26,22 +26,22 @@ case 0: print("Simple emitter"); Entities.editEntity(particles, { - velocitySpread: { x: 0.0, y: 0.0, z: 0.0 }, + speedSpread: 0.0, accelerationSpread: { x: 0.0, y: 0.0, z: 0.0 }, radiusSpread: 0.0, animationIsPlaying: true }); break; case 1: - print("Velocity spread"); + print("Speed spread"); Entities.editEntity(particles, { - velocitySpread: { x: 0.1, y: 0.0, z: 0.1 } + speedSpread: 0.1 }); break; case 2: print("Acceleration spread"); Entities.editEntity(particles, { - velocitySpread: { x: 0.0, y: 0.0, z: 0.0 }, + speedSpread: 0.0, accelerationSpread: { x: 0.0, y: 0.1, z: 0.0 } }); break; @@ -116,7 +116,8 @@ } function setUp() { - var spawnPoint = Vec3.sum(MyAvatar.position, Vec3.multiply(4.0, Quat.getFront(Camera.getOrientation()))), + var spawnPoint, + boxPoint, animation = { fps: 30, frameIndex: 0, @@ -126,9 +127,14 @@ loop: true }; + boxPoint = Vec3.sum(MyAvatar.position, Vec3.multiply(4.0, Quat.getFront(Camera.getOrientation()))); + boxPoint = Vec3.sum(boxPoint, { x: 0.0, y: -0.5, z: 0.0 }); + spawnPoint = Vec3.sum(boxPoint, { x: 0.0, y: 0.75, z: 0.0 }); + box = Entities.addEntity({ type: "Box", - position: spawnPoint, + name: "ParticlesTest Box", + position: boxPoint, dimensions: { x: 0.3, y: 0.3, z: 0.3 }, color: { red: 128, green: 128, blue: 128 }, lifetime: 3600 // 1 hour; just in case @@ -136,12 +142,13 @@ particles = Entities.addEntity({ type: "ParticleEffect", + name: "ParticlesTest Effect", position: spawnPoint, particleRadius: PARTICLE_RADIUS, radiusSpread: 0.0, emitRate: 2.0, - emitVelocity: { x: 0.0, y: 1.0, z: 0.0 }, - velocitySpread: { x: 0.0, y: 0.0, z: 0.0 }, + emitSpeed: 1.0, + speedSpread: 0.0, emitAcceleration: { x: 0.0, y: -0.3, z: 0.0 }, accelerationSpread: { x: 0.0, y: 0.0, z: 0.0 }, textures: "https://hifi-public.s3.amazonaws.com/alan/Particles/Particle-Sprite-Smoke-1.png", diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp index dbcad8a328..af228d92de 100644 --- a/libraries/entities/src/EntityItemProperties.cpp +++ b/libraries/entities/src/EntityItemProperties.cpp @@ -91,8 +91,9 @@ CONSTRUCT_PROPERTY(shapeType, SHAPE_TYPE_NONE), CONSTRUCT_PROPERTY(maxParticles, ParticleEffectEntityItem::DEFAULT_MAX_PARTICLES), CONSTRUCT_PROPERTY(lifespan, ParticleEffectEntityItem::DEFAULT_LIFESPAN), CONSTRUCT_PROPERTY(emitRate, ParticleEffectEntityItem::DEFAULT_EMIT_RATE), -CONSTRUCT_PROPERTY(emitVelocity, ParticleEffectEntityItem::DEFAULT_EMIT_VELOCITY), -CONSTRUCT_PROPERTY(velocitySpread, ParticleEffectEntityItem::DEFAULT_VELOCITY_SPREAD), +CONSTRUCT_PROPERTY(emitSpeed, ParticleEffectEntityItem::DEFAULT_EMIT_SPEED), +CONSTRUCT_PROPERTY(speedSpread, ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD), +CONSTRUCT_PROPERTY(emitOrientation, ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION), CONSTRUCT_PROPERTY(emitAcceleration, ParticleEffectEntityItem::DEFAULT_EMIT_ACCELERATION), CONSTRUCT_PROPERTY(accelerationSpread, ParticleEffectEntityItem::DEFAULT_ACCELERATION_SPREAD), CONSTRUCT_PROPERTY(particleRadius, ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS), @@ -374,8 +375,9 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const { CHECK_PROPERTY_CHANGE(PROP_MAX_PARTICLES, maxParticles); CHECK_PROPERTY_CHANGE(PROP_LIFESPAN, lifespan); CHECK_PROPERTY_CHANGE(PROP_EMIT_RATE, emitRate); - CHECK_PROPERTY_CHANGE(PROP_EMIT_VELOCITY, emitVelocity); - CHECK_PROPERTY_CHANGE(PROP_VELOCITY_SPREAD, velocitySpread); + CHECK_PROPERTY_CHANGE(PROP_EMIT_SPEED, emitSpeed); + CHECK_PROPERTY_CHANGE(PROP_SPEED_SPREAD, speedSpread); + CHECK_PROPERTY_CHANGE(PROP_EMIT_ORIENTATION, emitOrientation); CHECK_PROPERTY_CHANGE(PROP_EMIT_ACCELERATION, emitAcceleration); CHECK_PROPERTY_CHANGE(PROP_ACCELERATION_SPREAD, accelerationSpread); CHECK_PROPERTY_CHANGE(PROP_PARTICLE_RADIUS, particleRadius); @@ -493,8 +495,9 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool COPY_PROPERTY_TO_QSCRIPTVALUE(maxParticles); COPY_PROPERTY_TO_QSCRIPTVALUE(lifespan); COPY_PROPERTY_TO_QSCRIPTVALUE(emitRate); - COPY_PROPERTY_TO_QSCRIPTVALUE(emitVelocity); - COPY_PROPERTY_TO_QSCRIPTVALUE(velocitySpread); + COPY_PROPERTY_TO_QSCRIPTVALUE(emitSpeed); + COPY_PROPERTY_TO_QSCRIPTVALUE(speedSpread); + COPY_PROPERTY_TO_QSCRIPTVALUE(emitOrientation); COPY_PROPERTY_TO_QSCRIPTVALUE(emitAcceleration); COPY_PROPERTY_TO_QSCRIPTVALUE(accelerationSpread); COPY_PROPERTY_TO_QSCRIPTVALUE(particleRadius); @@ -632,8 +635,9 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool COPY_PROPERTY_FROM_QSCRIPTVALUE(maxParticles, float, setMaxParticles); COPY_PROPERTY_FROM_QSCRIPTVALUE(lifespan, float, setLifespan); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRate, float, setEmitRate); - COPY_PROPERTY_FROM_QSCRIPTVALUE(emitVelocity, glmVec3, setEmitVelocity); - COPY_PROPERTY_FROM_QSCRIPTVALUE(velocitySpread, glmVec3, setVelocitySpread); + COPY_PROPERTY_FROM_QSCRIPTVALUE(emitSpeed, float, setEmitSpeed); + COPY_PROPERTY_FROM_QSCRIPTVALUE(speedSpread, float, setSpeedSpread); + COPY_PROPERTY_FROM_QSCRIPTVALUE(emitOrientation, glmQuat, setEmitOrientation); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitAcceleration, glmVec3, setEmitAcceleration); COPY_PROPERTY_FROM_QSCRIPTVALUE(accelerationSpread, glmVec3, setAccelerationSpread); COPY_PROPERTY_FROM_QSCRIPTVALUE(particleRadius, float, setParticleRadius); @@ -885,8 +889,9 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem APPEND_ENTITY_PROPERTY(PROP_MAX_PARTICLES, properties.getMaxParticles()); APPEND_ENTITY_PROPERTY(PROP_LIFESPAN, properties.getLifespan()); APPEND_ENTITY_PROPERTY(PROP_EMIT_RATE, properties.getEmitRate()); - APPEND_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, properties.getEmitVelocity()); - APPEND_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, properties.getVelocitySpread()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, properties.getEmitSpeed()); + APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, properties.getSpeedSpread()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, properties.getEmitOrientation()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, properties.getEmitAcceleration()); APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, properties.getAccelerationSpread()); APPEND_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, properties.getParticleRadius()); @@ -1169,8 +1174,9 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MAX_PARTICLES, float, setMaxParticles); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LIFESPAN, float, setLifespan); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RATE, float, setEmitRate); - READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_VELOCITY, glm::vec3, setEmitVelocity); - READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VELOCITY_SPREAD, glm::vec3, setVelocitySpread); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_SPEED, float, setEmitSpeed); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SPEED_SPREAD, float, setSpeedSpread); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARTICLE_RADIUS, float, setParticleRadius); @@ -1318,8 +1324,9 @@ void EntityItemProperties::markAllChanged() { _maxParticlesChanged = true; _lifespanChanged = true; _emitRateChanged = true; - _emitVelocityChanged = true; - _velocitySpreadChanged = true; + _emitSpeedChanged = true; + _speedSpreadChanged = true; + _emitOrientationChanged = true; _emitAccelerationChanged = true; _accelerationSpreadChanged = true; _particleRadiusChanged = true; diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h index cec6b456a7..10ef4164ab 100644 --- a/libraries/entities/src/EntityItemProperties.h +++ b/libraries/entities/src/EntityItemProperties.h @@ -138,8 +138,9 @@ public: DEFINE_PROPERTY(PROP_MAX_PARTICLES, MaxParticles, maxParticles, quint32); DEFINE_PROPERTY(PROP_LIFESPAN, Lifespan, lifespan, float); DEFINE_PROPERTY(PROP_EMIT_RATE, EmitRate, emitRate, float); - DEFINE_PROPERTY_REF(PROP_EMIT_VELOCITY, EmitVelocity, emitVelocity, glm::vec3); - DEFINE_PROPERTY_REF(PROP_VELOCITY_SPREAD, VelocitySpread, velocitySpread, glm::vec3); + DEFINE_PROPERTY(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, float); + DEFINE_PROPERTY(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, float); + DEFINE_PROPERTY_REF(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat); DEFINE_PROPERTY(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, glm::vec3); DEFINE_PROPERTY(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, glm::vec3); DEFINE_PROPERTY(PROP_PARTICLE_RADIUS, ParticleRadius, particleRadius, float); @@ -335,7 +336,9 @@ inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) { DEBUG_PROPERTY_IF_CHANGED(debug, properties, MaxParticles, maxParticles, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, Lifespan, lifespan, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitRate, emitRate, ""); - DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitVelocity, emitVelocity, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitSpeed, emitSpeed, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, SpeedSpread, speedSpread, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitOrientation, emitOrientation, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitAcceleration, emitAcceleration, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, AccelerationSpread, accelerationSpread, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, ParticleRadius, particleRadius, ""); diff --git a/libraries/entities/src/EntityItemPropertiesMacros.h b/libraries/entities/src/EntityItemPropertiesMacros.h index a3e31024d1..e7ff53026e 100644 --- a/libraries/entities/src/EntityItemPropertiesMacros.h +++ b/libraries/entities/src/EntityItemPropertiesMacros.h @@ -44,6 +44,14 @@ } \ } +#define SKIP_ENTITY_PROPERTY(P,T) \ + if (propertyFlags.getHasProperty(P)) { \ + T fromBuffer; \ + int bytes = OctreePacketData::unpackDataFromBytes(dataAt, fromBuffer); \ + dataAt += bytes; \ + bytesRead += bytes; \ + } + #define DECODE_GROUP_PROPERTY_HAS_CHANGED(P,N) \ if (propertyFlags.getHasProperty(P)) { \ set##N##Changed(true); \ diff --git a/libraries/entities/src/EntityPropertyFlags.h b/libraries/entities/src/EntityPropertyFlags.h index d4f880ed8f..3de8541984 100644 --- a/libraries/entities/src/EntityPropertyFlags.h +++ b/libraries/entities/src/EntityPropertyFlags.h @@ -160,6 +160,9 @@ enum EntityPropertyList { PROP_ALPHA_SPREAD, PROP_ALPHA_START, PROP_ALPHA_FINISH, + PROP_EMIT_SPEED, + PROP_SPEED_SPREAD, + PROP_EMIT_ORIENTATION, //////////////////////////////////////////////////////////////////////////////////////////////////// // ATTENTION: add new properties to end of list just ABOVE this line diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index b1229b8bb6..25de20166c 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -43,6 +43,9 @@ #include "EntityScriptingInterface.h" #include "ParticleEffectEntityItem.h" +const glm::vec3 X_AXIS = glm::vec3(1.0f, 0.0f, 0.0f); +const glm::vec3 Z_AXIS = glm::vec3(0.0f, 0.0f, 1.0f); + const xColor ParticleEffectEntityItem::DEFAULT_COLOR = { 255, 255, 255 }; const xColor ParticleEffectEntityItem::DEFAULT_COLOR_SPREAD = { 0, 0, 0 }; const float ParticleEffectEntityItem::DEFAULT_ALPHA = 1.0f; @@ -55,8 +58,9 @@ const float ParticleEffectEntityItem::DEFAULT_ANIMATION_FPS = 30.0f; const quint32 ParticleEffectEntityItem::DEFAULT_MAX_PARTICLES = 1000; const float ParticleEffectEntityItem::DEFAULT_LIFESPAN = 3.0f; const float ParticleEffectEntityItem::DEFAULT_EMIT_RATE = 15.0f; -const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_VELOCITY(0.0f, 5.0f, 0.0f); -const glm::vec3 ParticleEffectEntityItem::DEFAULT_VELOCITY_SPREAD(3.0f, 0.0f, 3.0f); +const float ParticleEffectEntityItem::DEFAULT_EMIT_SPEED = 5.0f; +const float ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD = 1.0f; +const glm::quat ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, X_AXIS); const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f); const glm::vec3 ParticleEffectEntityItem::DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f); const float ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS = 0.025f; @@ -104,13 +108,18 @@ ParticleEffectEntityItem::~ParticleEffectEntityItem() { } -void ParticleEffectEntityItem::setEmitVelocity(const glm::vec3& emitVelocity) { - _emitVelocity = emitVelocity; +void ParticleEffectEntityItem::setEmitSpeed(float emitSpeed) { + _emitSpeed = emitSpeed; computeAndUpdateDimensions(); } -void ParticleEffectEntityItem::setVelocitySpread(const glm::vec3& velocitySpread) { - _velocitySpread = velocitySpread; +void ParticleEffectEntityItem::setSpeedSpread(float speedSpread) { + _speedSpread = speedSpread; + computeAndUpdateDimensions(); +} + +void ParticleEffectEntityItem::setEmitOrientation(const glm::quat& emitOrientation) { + _emitOrientation = emitOrientation; computeAndUpdateDimensions(); } @@ -126,23 +135,18 @@ void ParticleEffectEntityItem::setAccelerationSpread(const glm::vec3& accelerati void ParticleEffectEntityItem::computeAndUpdateDimensions() { const float time = _lifespan * 1.1f; // add 10% extra time to account for incremental timer accumulation error - - float maxVelocityX = fabsf(_velocity.x) + _velocitySpread.x; - float maxAccelerationX = fabsf(_acceleration.x) + _accelerationSpread.x; - float maxXDistance = (maxVelocityX * time) + (0.5f * maxAccelerationX * time * time); - - float maxVelocityY = fabsf(_velocity.y) + _velocitySpread.y; - float maxAccelerationY = fabsf(_acceleration.y) + _accelerationSpread.y; - float maxYDistance = (maxVelocityY * time) + (0.5f * maxAccelerationY * time * time); - - float maxVelocityZ = fabsf(_velocity.z) + _velocitySpread.z; - float maxAccelerationZ = fabsf(_acceleration.z) + _accelerationSpread.z; - float maxZDistance = (maxVelocityZ * time) + (0.5f * maxAccelerationZ * time * time); - - float maxDistance = std::max(maxXDistance, std::max(maxYDistance, maxZDistance)); - + + glm::vec3 velocity = _emitSpeed * (_emitOrientation * Z_AXIS); + glm::vec3 velocitySpread = _speedSpread * (_emitOrientation * Z_AXIS); + + glm::vec3 maxVelocity = glm::abs(velocity) + velocitySpread; + glm::vec3 maxAccleration = glm::abs(_acceleration) + _accelerationSpread; + glm::vec3 maxDistance = time * maxVelocity + (0.5f * time * time) * maxAccleration; + + float maxDistanceValue = std::max(maxDistance.x, std::max(maxDistance.y, maxDistance.z)); + //times 2 because dimensions are diameters not radii - glm::vec3 dims(2.0f * maxDistance); + glm::vec3 dims(2.0f * maxDistanceValue); EntityItem::setDimensions(dims); } @@ -161,8 +165,9 @@ EntityItemProperties ParticleEffectEntityItem::getProperties() const { COPY_ENTITY_PROPERTY_TO_PROPERTIES(maxParticles, getMaxParticles); COPY_ENTITY_PROPERTY_TO_PROPERTIES(lifespan, getLifespan); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitRate, getEmitRate); - COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitVelocity, getEmitVelocity); - COPY_ENTITY_PROPERTY_TO_PROPERTIES(velocitySpread, getVelocitySpread); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitSpeed, getEmitSpeed); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(speedSpread, getSpeedSpread); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitOrientation, getEmitOrientation); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitAcceleration, getEmitAcceleration); COPY_ENTITY_PROPERTY_TO_PROPERTIES(accelerationSpread, getAccelerationSpread); COPY_ENTITY_PROPERTY_TO_PROPERTIES(particleRadius, getParticleRadius); @@ -194,8 +199,9 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert SET_ENTITY_PROPERTY_FROM_PROPERTIES(maxParticles, setMaxParticles); SET_ENTITY_PROPERTY_FROM_PROPERTIES(lifespan, setLifespan); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitRate, setEmitRate); - SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitVelocity, setEmitVelocity); - SET_ENTITY_PROPERTY_FROM_PROPERTIES(velocitySpread, setVelocitySpread); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitSpeed, setEmitSpeed); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(speedSpread, setSpeedSpread); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitOrientation, setEmitOrientation); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitAcceleration, setEmitAcceleration); SET_ENTITY_PROPERTY_FROM_PROPERTIES(accelerationSpread, setAccelerationSpread); SET_ENTITY_PROPERTY_FROM_PROPERTIES(particleRadius, setParticleRadius); @@ -258,20 +264,24 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_MAX_PARTICLES, quint32, setMaxParticles); READ_ENTITY_PROPERTY(PROP_LIFESPAN, float, setLifespan); READ_ENTITY_PROPERTY(PROP_EMIT_RATE, float, setEmitRate); - READ_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, glm::vec3, setEmitVelocity); + if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + SKIP_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, glm::vec3); + } if (args.bitstreamVersion >= VERSION_ENTITIES_PARTICLE_MODIFICATIONS) { READ_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration); READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread); READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures); - READ_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, glm::vec3, setVelocitySpread); + if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + SKIP_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, glm::vec3); + } } else { - // EMIT_STRENGTH FAKEOUT + // EMIT_ACCELERATION FAKEOUT READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); - // LOCAL_GRAVITY FAKEOUT + // ACCELERATION_SPREAD FAKEOUT READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); - // ACTUALLY PARTICLE RADIUS + // ACTUAL PARTICLE_RADIUS READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures); } @@ -292,6 +302,12 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_ALPHA_FINISH, float, setAlphaFinish); } + if (args.bitstreamVersion >= VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed); + READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread); + READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); + } + return bytesRead; } @@ -309,12 +325,10 @@ EntityPropertyFlags ParticleEffectEntityItem::getEntityProperties(EncodeBitstrea requestedProperties += PROP_MAX_PARTICLES; requestedProperties += PROP_LIFESPAN; requestedProperties += PROP_EMIT_RATE; - requestedProperties += PROP_EMIT_VELOCITY; requestedProperties += PROP_EMIT_ACCELERATION; requestedProperties += PROP_ACCELERATION_SPREAD; requestedProperties += PROP_PARTICLE_RADIUS; requestedProperties += PROP_TEXTURES; - requestedProperties += PROP_VELOCITY_SPREAD; requestedProperties += PROP_RADIUS_SPREAD; requestedProperties += PROP_RADIUS_START; requestedProperties += PROP_RADIUS_FINISH; @@ -325,6 +339,9 @@ EntityPropertyFlags ParticleEffectEntityItem::getEntityProperties(EncodeBitstrea requestedProperties += PROP_ALPHA_SPREAD; requestedProperties += PROP_ALPHA_START; requestedProperties += PROP_ALPHA_FINISH; + requestedProperties += PROP_EMIT_SPEED; + requestedProperties += PROP_SPEED_SPREAD; + requestedProperties += PROP_EMIT_ORIENTATION; return requestedProperties; } @@ -347,12 +364,10 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData, APPEND_ENTITY_PROPERTY(PROP_MAX_PARTICLES, getMaxParticles()); APPEND_ENTITY_PROPERTY(PROP_LIFESPAN, getLifespan()); APPEND_ENTITY_PROPERTY(PROP_EMIT_RATE, getEmitRate()); - APPEND_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, getEmitVelocity()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, getEmitAcceleration()); APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, getAccelerationSpread()); APPEND_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, getParticleRadius()); APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures()); - APPEND_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, getVelocitySpread()); APPEND_ENTITY_PROPERTY(PROP_RADIUS_SPREAD, getRadiusSpread()); APPEND_ENTITY_PROPERTY(PROP_RADIUS_START, getRadiusStart()); APPEND_ENTITY_PROPERTY(PROP_RADIUS_FINISH, getRadiusFinish()); @@ -363,6 +378,9 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData, APPEND_ENTITY_PROPERTY(PROP_ALPHA_SPREAD, getAlphaSpread()); APPEND_ENTITY_PROPERTY(PROP_ALPHA_START, getAlphaStart()); APPEND_ENTITY_PROPERTY(PROP_ALPHA_FINISH, getAlphaFinish()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, getEmitSpeed()); + APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, getSpeedSpread()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, getEmitOrientation()); } bool ParticleEffectEntityItem::isAnimatingSomething() const { @@ -614,7 +632,7 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { _radiusMiddles[i] =_particleRadius; _radiusFinishes[i] = getRadiusFinish(); } else { - float spreadMultiplier = 1.0f + (2.0f * randFloat() - 1) * _radiusSpread / _particleRadius; + float spreadMultiplier = 1.0f + (2.0f * randFloat() - 1.0f) * _radiusSpread / _particleRadius; _radiusStarts[i] = spreadMultiplier * getRadiusStart(); _radiusMiddles[i] = spreadMultiplier * _particleRadius; _radiusFinishes[i] = spreadMultiplier * getRadiusFinish(); @@ -622,21 +640,9 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { updateRadius(i, 0.0f); // Velocity and acceleration - glm::vec3 spreadOffset; - spreadOffset.x = -_velocitySpread.x + randFloat() * (_velocitySpread.x * 2.0f); - spreadOffset.y = -_velocitySpread.y + randFloat() * (_velocitySpread.y * 2.0f); - spreadOffset.z = -_velocitySpread.z + randFloat() * (_velocitySpread.z * 2.0f); - - // set initial conditions _particlePositions[i] = getPosition(); - _particleVelocities[i] = _emitVelocity + spreadOffset; - - spreadOffset.x = -_accelerationSpread.x + randFloat() * (_accelerationSpread.x * 2.0f); - spreadOffset.y = -_accelerationSpread.y + randFloat() * (_accelerationSpread.y * 2.0f); - spreadOffset.z = -_accelerationSpread.z + randFloat() * (_accelerationSpread.z * 2.0f); - - _particleAccelerations[i] = _emitAcceleration + spreadOffset; - + _particleVelocities[i] = (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS); + _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; integrateParticle(i, timeLeftInFrame); extendBounds(_particlePositions[i]); diff --git a/libraries/entities/src/ParticleEffectEntityItem.h b/libraries/entities/src/ParticleEffectEntityItem.h index 802ff25af3..429f6e02ba 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.h +++ b/libraries/entities/src/ParticleEffectEntityItem.h @@ -128,13 +128,17 @@ public: void setEmitRate(float emitRate) { _emitRate = emitRate; } float getEmitRate() const { return _emitRate; } - static const glm::vec3 DEFAULT_EMIT_VELOCITY; - void setEmitVelocity(const glm::vec3& emitVelocity); - const glm::vec3& getEmitVelocity() const { return _emitVelocity; } - - static const glm::vec3 DEFAULT_VELOCITY_SPREAD; - void setVelocitySpread(const glm::vec3& velocitySpread); - const glm::vec3& getVelocitySpread() const { return _velocitySpread; } + static const float DEFAULT_EMIT_SPEED; + void setEmitSpeed(float emitSpeed); + float getEmitSpeed() const { return _emitSpeed; } + + static const float DEFAULT_SPEED_SPREAD; + void setSpeedSpread(float speedSpread); + float getSpeedSpread() const { return _speedSpread; } + + static const glm::quat DEFAULT_EMIT_ORIENTATION; + void setEmitOrientation(const glm::quat& emitOrientation); + const glm::quat& getEmitOrientation() const { return _emitOrientation; } static const glm::vec3 DEFAULT_EMIT_ACCELERATION; void setEmitAcceleration(const glm::vec3& emitAcceleration); @@ -202,8 +206,9 @@ protected: quint32 _maxParticles = DEFAULT_MAX_PARTICLES; float _lifespan = DEFAULT_LIFESPAN; float _emitRate = DEFAULT_EMIT_RATE; - glm::vec3 _emitVelocity = DEFAULT_EMIT_VELOCITY; - glm::vec3 _velocitySpread = DEFAULT_VELOCITY_SPREAD; + float _emitSpeed = DEFAULT_EMIT_SPEED; + float _speedSpread = DEFAULT_SPEED_SPREAD; + glm::quat _emitOrientation = DEFAULT_EMIT_ORIENTATION; glm::vec3 _emitAcceleration = DEFAULT_EMIT_ACCELERATION; glm::vec3 _accelerationSpread = DEFAULT_ACCELERATION_SPREAD; float _particleRadius = DEFAULT_PARTICLE_RADIUS; diff --git a/libraries/networking/src/udt/PacketHeaders.cpp b/libraries/networking/src/udt/PacketHeaders.cpp index 7e00acfdc0..5552836a9a 100644 --- a/libraries/networking/src/udt/PacketHeaders.cpp +++ b/libraries/networking/src/udt/PacketHeaders.cpp @@ -38,7 +38,7 @@ PacketVersion versionForPacketType(PacketType packetType) { case PacketType::EntityAdd: case PacketType::EntityEdit: case PacketType::EntityData: - return VERSION_ENTITIES_PROTOCOL_HEADER_SWAP; + return VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER; default: return 14; } diff --git a/libraries/networking/src/udt/PacketHeaders.h b/libraries/networking/src/udt/PacketHeaders.h index da702358a1..5f6fb18814 100644 --- a/libraries/networking/src/udt/PacketHeaders.h +++ b/libraries/networking/src/udt/PacketHeaders.h @@ -140,5 +140,6 @@ const PacketVersion VERSION_ENTITIES_POLYVOX_NEIGHBORS = 40; const PacketVersion VERSION_ENTITIES_PARTICLE_RADIUS_PROPERTIES = 41; const PacketVersion VERSION_ENTITIES_PARTICLE_COLOR_PROPERTIES = 42; const PacketVersion VERSION_ENTITIES_PROTOCOL_HEADER_SWAP = 43; +const PacketVersion VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER = 44; #endif // hifi_PacketHeaders_h From c99210736389e9fddda618b06cb86d5387957783 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Wed, 16 Sep 2015 18:07:18 -0700 Subject: [PATCH 02/11] Add particle properties ready to use for emitting from a spheroid --- .../entities/src/EntityItemProperties.cpp | 42 +++++++++++++++++ libraries/entities/src/EntityItemProperties.h | 16 ++++++- libraries/entities/src/EntityPropertyFlags.h | 6 +++ .../entities/src/ParticleEffectEntityItem.cpp | 46 ++++++++++++++++++- .../entities/src/ParticleEffectEntityItem.h | 30 ++++++++++++ 5 files changed, 136 insertions(+), 4 deletions(-) diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp index af228d92de..7702657790 100644 --- a/libraries/entities/src/EntityItemProperties.cpp +++ b/libraries/entities/src/EntityItemProperties.cpp @@ -94,6 +94,12 @@ CONSTRUCT_PROPERTY(emitRate, ParticleEffectEntityItem::DEFAULT_EMIT_RATE), CONSTRUCT_PROPERTY(emitSpeed, ParticleEffectEntityItem::DEFAULT_EMIT_SPEED), CONSTRUCT_PROPERTY(speedSpread, ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD), CONSTRUCT_PROPERTY(emitOrientation, ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION), +CONSTRUCT_PROPERTY(emitRadius, ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS), +CONSTRUCT_PROPERTY(emitRadiusStart, ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START), +CONSTRUCT_PROPERTY(polarStart, ParticleEffectEntityItem::DEFAULT_POLAR_START), +CONSTRUCT_PROPERTY(polarFinish, ParticleEffectEntityItem::DEFAULT_POLAR_FINISH), +CONSTRUCT_PROPERTY(azimuthStart, ParticleEffectEntityItem::DEFAULT_AZIMUTH_START), +CONSTRUCT_PROPERTY(azimuthFinish, ParticleEffectEntityItem::DEFAULT_AZIMUTH_FINISH), CONSTRUCT_PROPERTY(emitAcceleration, ParticleEffectEntityItem::DEFAULT_EMIT_ACCELERATION), CONSTRUCT_PROPERTY(accelerationSpread, ParticleEffectEntityItem::DEFAULT_ACCELERATION_SPREAD), CONSTRUCT_PROPERTY(particleRadius, ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS), @@ -378,6 +384,12 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const { CHECK_PROPERTY_CHANGE(PROP_EMIT_SPEED, emitSpeed); CHECK_PROPERTY_CHANGE(PROP_SPEED_SPREAD, speedSpread); CHECK_PROPERTY_CHANGE(PROP_EMIT_ORIENTATION, emitOrientation); + CHECK_PROPERTY_CHANGE(PROP_EMIT_RADIUS, emitRadius); + CHECK_PROPERTY_CHANGE(PROP_EMIT_RADIUS_START, emitRadiusStart); + CHECK_PROPERTY_CHANGE(PROP_POLAR_START, polarStart); + CHECK_PROPERTY_CHANGE(PROP_POLAR_FINISH, polarFinish); + CHECK_PROPERTY_CHANGE(PROP_AZIMUTH_START, azimuthStart); + CHECK_PROPERTY_CHANGE(PROP_AZIMUTH_FINISH, azimuthFinish); CHECK_PROPERTY_CHANGE(PROP_EMIT_ACCELERATION, emitAcceleration); CHECK_PROPERTY_CHANGE(PROP_ACCELERATION_SPREAD, accelerationSpread); CHECK_PROPERTY_CHANGE(PROP_PARTICLE_RADIUS, particleRadius); @@ -498,6 +510,12 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool COPY_PROPERTY_TO_QSCRIPTVALUE(emitSpeed); COPY_PROPERTY_TO_QSCRIPTVALUE(speedSpread); COPY_PROPERTY_TO_QSCRIPTVALUE(emitOrientation); + COPY_PROPERTY_TO_QSCRIPTVALUE(emitRadius); + COPY_PROPERTY_TO_QSCRIPTVALUE(emitRadiusStart); + COPY_PROPERTY_TO_QSCRIPTVALUE(polarStart); + COPY_PROPERTY_TO_QSCRIPTVALUE(polarFinish); + COPY_PROPERTY_TO_QSCRIPTVALUE(azimuthStart); + COPY_PROPERTY_TO_QSCRIPTVALUE(azimuthFinish); COPY_PROPERTY_TO_QSCRIPTVALUE(emitAcceleration); COPY_PROPERTY_TO_QSCRIPTVALUE(accelerationSpread); COPY_PROPERTY_TO_QSCRIPTVALUE(particleRadius); @@ -638,6 +656,12 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool COPY_PROPERTY_FROM_QSCRIPTVALUE(emitSpeed, float, setEmitSpeed); COPY_PROPERTY_FROM_QSCRIPTVALUE(speedSpread, float, setSpeedSpread); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitOrientation, glmQuat, setEmitOrientation); + COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRadius, glmVec3, setEmitRadius); + COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRadiusStart, float, setEmitRadiusStart); + COPY_PROPERTY_FROM_QSCRIPTVALUE(polarStart, float, setPolarStart); + COPY_PROPERTY_FROM_QSCRIPTVALUE(polarFinish, float, setPolarFinish); + COPY_PROPERTY_FROM_QSCRIPTVALUE(azimuthStart, float, setAzimuthStart); + COPY_PROPERTY_FROM_QSCRIPTVALUE(azimuthFinish, float, setAzimuthFinish); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitAcceleration, glmVec3, setEmitAcceleration); COPY_PROPERTY_FROM_QSCRIPTVALUE(accelerationSpread, glmVec3, setAccelerationSpread); COPY_PROPERTY_FROM_QSCRIPTVALUE(particleRadius, float, setParticleRadius); @@ -892,6 +916,12 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, properties.getEmitSpeed()); APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, properties.getSpeedSpread()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, properties.getEmitOrientation()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS, properties.getEmitRadius()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, properties.getEmitRadiusStart()); + APPEND_ENTITY_PROPERTY(PROP_POLAR_START, properties.getPolarStart()); + APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, properties.getPolarFinish()); + APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_START, properties.getAzimuthStart()); + APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_FINISH, properties.getAzimuthFinish()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, properties.getEmitAcceleration()); APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, properties.getAccelerationSpread()); APPEND_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, properties.getParticleRadius()); @@ -1177,6 +1207,12 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_SPEED, float, setEmitSpeed); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SPEED_SPREAD, float, setSpeedSpread); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS, glm::vec3, setEmitRadius); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_START, float, setPolarStart); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_FINISH, float, setPolarFinish); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_START, float, setAzimuthStart); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_FINISH, float, setAzimuthFinish); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARTICLE_RADIUS, float, setParticleRadius); @@ -1327,6 +1363,12 @@ void EntityItemProperties::markAllChanged() { _emitSpeedChanged = true; _speedSpreadChanged = true; _emitOrientationChanged = true; + _emitRadiusChanged = true; + _emitRadiusStartChanged = true; + _polarStartChanged = true; + _polarFinishChanged = true; + _azimuthStartChanged = true; + _azimuthFinishChanged = true; _emitAccelerationChanged = true; _accelerationSpreadChanged = true; _particleRadiusChanged = true; diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h index 10ef4164ab..8e899d7651 100644 --- a/libraries/entities/src/EntityItemProperties.h +++ b/libraries/entities/src/EntityItemProperties.h @@ -141,8 +141,14 @@ public: DEFINE_PROPERTY(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, float); DEFINE_PROPERTY(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, float); DEFINE_PROPERTY_REF(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat); - DEFINE_PROPERTY(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, glm::vec3); - DEFINE_PROPERTY(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, glm::vec3); + DEFINE_PROPERTY_REF(PROP_EMIT_RADIUS, EmitRadius, emitRadius, glm::vec3); + DEFINE_PROPERTY(PROP_EMIT_RADIUS_START, EmitRadiusStart, emitRadiusStart, float); + DEFINE_PROPERTY(PROP_POLAR_START, PolarStart, polarStart, float); + DEFINE_PROPERTY(PROP_POLAR_FINISH, PolarFinish, polarFinish, float); + DEFINE_PROPERTY(PROP_AZIMUTH_START, AzimuthStart, azimuthStart, float); + DEFINE_PROPERTY(PROP_AZIMUTH_FINISH, AzimuthFinish, azimuthFinish, float); + DEFINE_PROPERTY_REF(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, glm::vec3); + DEFINE_PROPERTY_REF(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, glm::vec3); DEFINE_PROPERTY(PROP_PARTICLE_RADIUS, ParticleRadius, particleRadius, float); DEFINE_PROPERTY(PROP_RADIUS_SPREAD, RadiusSpread, radiusSpread, float); DEFINE_PROPERTY(PROP_RADIUS_START, RadiusStart, radiusStart, float); @@ -339,6 +345,12 @@ inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) { DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitSpeed, emitSpeed, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, SpeedSpread, speedSpread, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitOrientation, emitOrientation, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitRadius, emitRadius, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitRadiusStart, emitRadiusStart, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, PolarStart, polarStart, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, PolarFinish, polarFinish, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, AzimuthStart, azimuthStart, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, AzimuthFinish, azimuthFinish, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitAcceleration, emitAcceleration, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, AccelerationSpread, accelerationSpread, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, ParticleRadius, particleRadius, ""); diff --git a/libraries/entities/src/EntityPropertyFlags.h b/libraries/entities/src/EntityPropertyFlags.h index 3de8541984..741cfabf92 100644 --- a/libraries/entities/src/EntityPropertyFlags.h +++ b/libraries/entities/src/EntityPropertyFlags.h @@ -163,6 +163,12 @@ enum EntityPropertyList { PROP_EMIT_SPEED, PROP_SPEED_SPREAD, PROP_EMIT_ORIENTATION, + PROP_EMIT_RADIUS, + PROP_EMIT_RADIUS_START, + PROP_POLAR_START, + PROP_POLAR_FINISH, + PROP_AZIMUTH_START, + PROP_AZIMUTH_FINISH, //////////////////////////////////////////////////////////////////////////////////////////////////// // ATTENTION: add new properties to end of list just ABOVE this line diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 25de20166c..2e5ce09aa0 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -60,7 +60,13 @@ const float ParticleEffectEntityItem::DEFAULT_LIFESPAN = 3.0f; const float ParticleEffectEntityItem::DEFAULT_EMIT_RATE = 15.0f; const float ParticleEffectEntityItem::DEFAULT_EMIT_SPEED = 5.0f; const float ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD = 1.0f; -const glm::quat ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, X_AXIS); +const glm::quat ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, X_AXIS); // Vertical +const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS = glm::vec3(0.0f, 0.0f, 0.0f); // Emit from point +const float ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START = 1.0f; // Emit from surface (when emitRadius > 0) +const float ParticleEffectEntityItem::DEFAULT_POLAR_START = 0.0f; // Emit along z-axis +const float ParticleEffectEntityItem::DEFAULT_POLAR_FINISH = 0.0f; // "" +const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_START = -PI; // Emit full circumference (when polarFinish > 0) +const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_FINISH = -PI; // "" const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f); const glm::vec3 ParticleEffectEntityItem::DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f); const float ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS = 0.025f; @@ -123,6 +129,12 @@ void ParticleEffectEntityItem::setEmitOrientation(const glm::quat& emitOrientati computeAndUpdateDimensions(); } + +void ParticleEffectEntityItem::setEmitRadius(const glm::vec3& emitRadius) { + _emitRadius = emitRadius; + computeAndUpdateDimensions(); +} + void ParticleEffectEntityItem::setEmitAcceleration(const glm::vec3& emitAcceleration) { _emitAcceleration = emitAcceleration; computeAndUpdateDimensions(); @@ -141,7 +153,7 @@ void ParticleEffectEntityItem::computeAndUpdateDimensions() { glm::vec3 maxVelocity = glm::abs(velocity) + velocitySpread; glm::vec3 maxAccleration = glm::abs(_acceleration) + _accelerationSpread; - glm::vec3 maxDistance = time * maxVelocity + (0.5f * time * time) * maxAccleration; + glm::vec3 maxDistance = _emitRadius + time * maxVelocity + (0.5f * time * time) * maxAccleration; float maxDistanceValue = std::max(maxDistance.x, std::max(maxDistance.y, maxDistance.z)); @@ -168,6 +180,12 @@ EntityItemProperties ParticleEffectEntityItem::getProperties() const { COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitSpeed, getEmitSpeed); COPY_ENTITY_PROPERTY_TO_PROPERTIES(speedSpread, getSpeedSpread); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitOrientation, getEmitOrientation); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitRadius, getEmitRadius); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitRadiusStart, getEmitRadiusStart); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(polarStart, getPolarStart); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(polarFinish, getPolarFinish); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(azimuthStart, getAzimuthStart); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(azimuthFinish, getAzimuthFinish); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitAcceleration, getEmitAcceleration); COPY_ENTITY_PROPERTY_TO_PROPERTIES(accelerationSpread, getAccelerationSpread); COPY_ENTITY_PROPERTY_TO_PROPERTIES(particleRadius, getParticleRadius); @@ -202,6 +220,12 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitSpeed, setEmitSpeed); SET_ENTITY_PROPERTY_FROM_PROPERTIES(speedSpread, setSpeedSpread); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitOrientation, setEmitOrientation); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitRadius, setEmitRadius); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitRadiusStart, setEmitRadiusStart); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(polarStart, setPolarStart); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(polarFinish, setPolarFinish); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(azimuthStart, setAzimuthStart); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(azimuthFinish, setAzimuthFinish); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitAcceleration, setEmitAcceleration); SET_ENTITY_PROPERTY_FROM_PROPERTIES(accelerationSpread, setAccelerationSpread); SET_ENTITY_PROPERTY_FROM_PROPERTIES(particleRadius, setParticleRadius); @@ -306,6 +330,12 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed); READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread); READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); + READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS, glm::vec3, setEmitRadius); + READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart); + READ_ENTITY_PROPERTY(PROP_POLAR_START, float, setPolarStart); + READ_ENTITY_PROPERTY(PROP_POLAR_FINISH, float, setPolarFinish); + READ_ENTITY_PROPERTY(PROP_AZIMUTH_START, float, setAzimuthStart); + READ_ENTITY_PROPERTY(PROP_AZIMUTH_FINISH, float, setAzimuthFinish); } return bytesRead; @@ -342,6 +372,12 @@ EntityPropertyFlags ParticleEffectEntityItem::getEntityProperties(EncodeBitstrea requestedProperties += PROP_EMIT_SPEED; requestedProperties += PROP_SPEED_SPREAD; requestedProperties += PROP_EMIT_ORIENTATION; + requestedProperties += PROP_EMIT_RADIUS; + requestedProperties += PROP_EMIT_RADIUS_START; + requestedProperties += PROP_POLAR_START; + requestedProperties += PROP_POLAR_FINISH; + requestedProperties += PROP_AZIMUTH_START; + requestedProperties += PROP_AZIMUTH_FINISH; return requestedProperties; } @@ -381,6 +417,12 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData, APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, getEmitSpeed()); APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, getSpeedSpread()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, getEmitOrientation()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS, getEmitRadius()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, getEmitRadiusStart()); + APPEND_ENTITY_PROPERTY(PROP_POLAR_START, getPolarStart()); + APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, getPolarFinish()); + APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_START, getAzimuthStart()); + APPEND_ENTITY_PROPERTY(PROP_AZIMUTH_FINISH, getAzimuthFinish()); } bool ParticleEffectEntityItem::isAnimatingSomething() const { diff --git a/libraries/entities/src/ParticleEffectEntityItem.h b/libraries/entities/src/ParticleEffectEntityItem.h index 429f6e02ba..d5ec4eb587 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.h +++ b/libraries/entities/src/ParticleEffectEntityItem.h @@ -140,6 +140,30 @@ public: void setEmitOrientation(const glm::quat& emitOrientation); const glm::quat& getEmitOrientation() const { return _emitOrientation; } + static const glm::vec3 DEFAULT_EMIT_RADIUS; + void setEmitRadius(const glm::vec3& emitRadius); + const glm::vec3& getEmitRadius() const { return _emitRadius; } + + static const float DEFAULT_EMIT_RADIUS_START; + void setEmitRadiusStart(float emitRadiusStart) { _emitRadiusStart = emitRadiusStart; } + float getEmitRadiusStart() const { return _emitRadiusStart; } + + static const float DEFAULT_POLAR_START; + void setPolarStart(float polarStart) { _polarStart = polarStart; } + float getPolarStart() const { return _polarStart; } + + static const float DEFAULT_POLAR_FINISH; + void setPolarFinish(float polarFinish) { _polarFinish = polarFinish; } + float getPolarFinish() const { return _polarFinish; } + + static const float DEFAULT_AZIMUTH_START; + void setAzimuthStart(float azimuthStart) { _azimuthStart = azimuthStart; } + float getAzimuthStart() const { return _azimuthStart; } + + static const float DEFAULT_AZIMUTH_FINISH; + void setAzimuthFinish(float azimuthFinish) { _azimuthFinish = azimuthFinish; } + float getAzimuthFinish() const { return _azimuthFinish; } + static const glm::vec3 DEFAULT_EMIT_ACCELERATION; void setEmitAcceleration(const glm::vec3& emitAcceleration); const glm::vec3& getEmitAcceleration() const { return _emitAcceleration; } @@ -209,6 +233,12 @@ protected: float _emitSpeed = DEFAULT_EMIT_SPEED; float _speedSpread = DEFAULT_SPEED_SPREAD; glm::quat _emitOrientation = DEFAULT_EMIT_ORIENTATION; + glm::vec3 _emitRadius = DEFAULT_EMIT_RADIUS; + float _emitRadiusStart = DEFAULT_EMIT_RADIUS_START; + float _polarStart = DEFAULT_POLAR_START; + float _polarFinish = DEFAULT_POLAR_FINISH; + float _azimuthStart = DEFAULT_AZIMUTH_START; + float _azimuthFinish = DEFAULT_AZIMUTH_FINISH; glm::vec3 _emitAcceleration = DEFAULT_EMIT_ACCELERATION; glm::vec3 _accelerationSpread = DEFAULT_ACCELERATION_SPREAD; float _particleRadius = DEFAULT_PARTICLE_RADIUS; From 12e2cf3ce9542b77082209e3ab36c2e80d3f7877 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Thu, 17 Sep 2015 17:14:35 -0700 Subject: [PATCH 03/11] Emit in all directions from a point or the surface of a spheroid --- examples/example/entities/particlesTest.js | 97 ++++++++++++++++--- .../entities/src/ParticleEffectEntityItem.cpp | 47 +++++++-- .../networking/src/udt/PacketHeaders.cpp | 2 +- libraries/networking/src/udt/PacketHeaders.h | 2 +- libraries/script-engine/src/Vec3.cpp | 25 ----- libraries/script-engine/src/Vec3.h | 4 +- libraries/shared/src/GLMHelpers.cpp | 24 +++++ libraries/shared/src/GLMHelpers.h | 4 + 8 files changed, 157 insertions(+), 48 deletions(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index b9d046e3a0..20556be515 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -13,13 +13,25 @@ (function () { var box, + sphere, + sphereDimensions = { x: 0.4, y: 0.8, z: 0.2 }, + pointDimensions = { x: 0.0, y: 0.0, z: 0.0 }, + sphereOrientation = Quat.fromPitchYawRollDegrees(-60.0, 30.0, 0.0), + verticalOrientation = Quat.fromPitchYawRollDegrees(-90.0, 0.0, 0.0), particles, particleExample = -1, - NUM_PARTICLE_EXAMPLES = 11, - PARTICLE_RADIUS = 0.04; + PARTICLE_RADIUS = 0.04, + SLOW_EMIT_RATE = 2.0, + FAST_EMIT_RATE = 100.0, + SLOW_EMIT_SPEED = 0.05, + FAST_EMIT_SPEED = 1.0, + GRAVITY_EMIT_ACCELERATON = { x: 0.0, y: -0.3, z: 0.0 }, + ZERO_EMIT_ACCELERATON = { x: 0.0, y: 0.0, z: 0.0 }, + PI = 3.141593, + NUM_PARTICLE_EXAMPLES = 13; function onClickDownOnEntity(entityID) { - if (entityID === box || entityID === particles) { + if (entityID === box || entityID === sphere || entityID === particles) { particleExample = (particleExample + 1) % NUM_PARTICLE_EXAMPLES; switch (particleExample) { @@ -104,20 +116,62 @@ }); break; case 10: - print("Stop emitting"); + print("Emit in all directions from point"); Entities.editEntity(particles, { colorStart: { red: 255, green: 255, blue: 255 }, colorFinish: { red: 255, green: 255, blue: 255 }, + emitRate: FAST_EMIT_RATE, + emitSpeed: SLOW_EMIT_SPEED, + emitAcceleration: ZERO_EMIT_ACCELERATON, + polarFinish: PI + }); + Entities.editEntity(box, { + visible: false + }); + Entities.editEntity(sphere, { + visible: true + }); + break; + case 11: + print("Emit from sphere surface"); + Entities.editEntity(particles, { + colorStart: { red: 255, green: 255, blue: 255 }, + colorFinish: { red: 255, green: 255, blue: 255 }, + emitRadius: sphereDimensions, + emitOrientation: sphereOrientation + }); + Entities.editEntity(box, { + visible: false + }); + Entities.editEntity(sphere, { + visible: true + }); + break; + case 12: + print("Stop emitting"); + Entities.editEntity(particles, { + emitRadius: pointDimensions, + emitOrientation: verticalOrientation, + emitRate: SLOW_EMIT_RATE, + emitSpeed: FAST_EMIT_SPEED, + emitAcceleration: GRAVITY_EMIT_ACCELERATON, + polarFinish: 0.0, animationIsPlaying: false }); + Entities.editEntity(box, { + visible: true + }); + Entities.editEntity(sphere, { + visible: false + }); break; } } } function setUp() { - var spawnPoint, - boxPoint, + var boxPoint, + spawnPoint, animation = { fps: 30, frameIndex: 0, @@ -129,32 +183,48 @@ boxPoint = Vec3.sum(MyAvatar.position, Vec3.multiply(4.0, Quat.getFront(Camera.getOrientation()))); boxPoint = Vec3.sum(boxPoint, { x: 0.0, y: -0.5, z: 0.0 }); - spawnPoint = Vec3.sum(boxPoint, { x: 0.0, y: 0.75, z: 0.0 }); + spawnPoint = Vec3.sum(boxPoint, { x: 0.0, y: 1.0, z: 0.0 }); box = Entities.addEntity({ type: "Box", name: "ParticlesTest Box", position: boxPoint, + rotation: verticalOrientation, dimensions: { x: 0.3, y: 0.3, z: 0.3 }, color: { red: 128, green: 128, blue: 128 }, - lifetime: 3600 // 1 hour; just in case + lifetime: 3600, // 1 hour; just in case + visible: true }); + // Same size and orientation as emitter when ellipsoid. + sphere = Entities.addEntity({ + type: "Sphere", + name: "ParticlesTest Sphere", + position: boxPoint, + rotation: sphereOrientation, + dimensions: sphereDimensions, + color: { red: 128, green: 128, blue: 128 }, + lifetime: 3600, // 1 hour; just in case + visible: false + }); + + // 1.0m above the box or ellipsoid. particles = Entities.addEntity({ type: "ParticleEffect", - name: "ParticlesTest Effect", + name: "ParticlesTest Emitter", position: spawnPoint, + emitOrientation: verticalOrientation, particleRadius: PARTICLE_RADIUS, radiusSpread: 0.0, - emitRate: 2.0, - emitSpeed: 1.0, + emitRate: SLOW_EMIT_RATE, + emitSpeed: FAST_EMIT_SPEED, speedSpread: 0.0, - emitAcceleration: { x: 0.0, y: -0.3, z: 0.0 }, + emitAcceleration: GRAVITY_EMIT_ACCELERATON, accelerationSpread: { x: 0.0, y: 0.0, z: 0.0 }, textures: "https://hifi-public.s3.amazonaws.com/alan/Particles/Particle-Sprite-Smoke-1.png", color: { red: 255, green: 255, blue: 255 }, lifespan: 5.0, - visible: true, + visible: false, locked: false, animationSettings: animation, animationIsPlaying: false, @@ -170,6 +240,7 @@ Entities.clickDownOnEntity.disconnect(onClickDownOnEntity); Entities.deleteEntity(particles); Entities.deleteEntity(box); + Entities.deleteEntity(sphere); } setUp(); diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 2e5ce09aa0..59a8e126cf 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -288,7 +288,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_MAX_PARTICLES, quint32, setMaxParticles); READ_ENTITY_PROPERTY(PROP_LIFESPAN, float, setLifespan); READ_ENTITY_PROPERTY(PROP_EMIT_RATE, float, setEmitRate); - if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER) { SKIP_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, glm::vec3); } @@ -297,7 +297,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread); READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures); - if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER) { SKIP_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, glm::vec3); } } else { @@ -326,7 +326,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_ALPHA_FINISH, float, setAlphaFinish); } - if (args.bitstreamVersion >= VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER) { + if (args.bitstreamVersion >= VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER) { READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed); READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread); READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); @@ -682,9 +682,44 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { updateRadius(i, 0.0f); // Velocity and acceleration - _particlePositions[i] = getPosition(); - _particleVelocities[i] = (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS); - _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; + if (_polarStart == 0.0f && _polarFinish == 0.0f) { + // Emit along z-axis + _particlePositions[i] = getPosition(); + _particleVelocities[i] = + (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS); + _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; + + } else if (_emitRadius == glm::vec3()) { + // Emit around point + float elevation = asin(2.0f * randFloat() - 1.0f); // Distribute points evenly over surface + glm::vec3 emitDirection = _emitOrientation * fromSpherical(elevation, randFloat() * TWO_PI); + + _particlePositions[i] = getPosition(); + _particleVelocities[i] = + (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * emitDirection); + _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; + + } else { + // Emit from ellipsoid + float elevation = asin(2.0f * randFloat() - 1.0f); // Distribute points approximately evenly over surface + float azimuth = (2.0f * randFloat() - 1.0f) * PI; + // TODO: Sort out ellipsoid equations to distribute completely evenly over surface. + + float x = _emitRadius.x * cos(elevation) * cos(azimuth); + float y = _emitRadius.y * cos(elevation) * sin(azimuth); + float z = _emitRadius.z * sin(elevation); + glm::vec3 emitPosition = glm::vec3(x, y, z); + glm::vec3 emitDirection = glm::normalize(glm::vec3( + x / (_emitRadius.x * _emitRadius.x), + y / (_emitRadius.y * _emitRadius.y), + z / (_emitRadius.z * _emitRadius.z) + )); + + _particlePositions[i] = getPosition() + _emitOrientation * emitPosition; + _particleVelocities[i] = + (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * emitDirection); + _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; + } integrateParticle(i, timeLeftInFrame); extendBounds(_particlePositions[i]); diff --git a/libraries/networking/src/udt/PacketHeaders.cpp b/libraries/networking/src/udt/PacketHeaders.cpp index 5552836a9a..a8cf743686 100644 --- a/libraries/networking/src/udt/PacketHeaders.cpp +++ b/libraries/networking/src/udt/PacketHeaders.cpp @@ -38,7 +38,7 @@ PacketVersion versionForPacketType(PacketType packetType) { case PacketType::EntityAdd: case PacketType::EntityEdit: case PacketType::EntityData: - return VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER; + return VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER; default: return 14; } diff --git a/libraries/networking/src/udt/PacketHeaders.h b/libraries/networking/src/udt/PacketHeaders.h index 5f6fb18814..9f3c5950a2 100644 --- a/libraries/networking/src/udt/PacketHeaders.h +++ b/libraries/networking/src/udt/PacketHeaders.h @@ -140,6 +140,6 @@ const PacketVersion VERSION_ENTITIES_POLYVOX_NEIGHBORS = 40; const PacketVersion VERSION_ENTITIES_PARTICLE_RADIUS_PROPERTIES = 41; const PacketVersion VERSION_ENTITIES_PARTICLE_COLOR_PROPERTIES = 42; const PacketVersion VERSION_ENTITIES_PROTOCOL_HEADER_SWAP = 43; -const PacketVersion VERSION_ENTITIES_PARTICLE_SPHEROID_EMITTER = 44; +const PacketVersion VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER = 44; #endif // hifi_PacketHeaders_h diff --git a/libraries/script-engine/src/Vec3.cpp b/libraries/script-engine/src/Vec3.cpp index 69961bfd8e..04e3a4fe05 100644 --- a/libraries/script-engine/src/Vec3.cpp +++ b/libraries/script-engine/src/Vec3.cpp @@ -58,28 +58,3 @@ glm::vec3 Vec3::toPolar(const glm::vec3& v) { return glm::vec3(elevation, azimuth, radius); } - -glm::vec3 Vec3::fromPolar(const glm::vec3& polar) { - float x = glm::cos(polar.x) * glm::sin(polar.y); - float y = glm::sin(-polar.x); - float z = glm::cos(polar.x) * glm::cos(polar.y); - - // Round small values to 0 - if (glm::abs(x) < EPSILON) { - x = 0.0f; - } - if (glm::abs(y) < EPSILON) { - y = 0.0f; - } - if (glm::abs(z) < EPSILON) { - z = 0.0f; - } - - return polar.z * glm::vec3(x, y, z); -} - -glm::vec3 Vec3::fromPolar(float elevation, float azimuth) { - glm::vec3 v = glm::vec3(elevation, azimuth, 1.0f); - return fromPolar(v); -} - diff --git a/libraries/script-engine/src/Vec3.h b/libraries/script-engine/src/Vec3.h index b05e729a49..2d703ac87e 100644 --- a/libraries/script-engine/src/Vec3.h +++ b/libraries/script-engine/src/Vec3.h @@ -43,8 +43,8 @@ public slots: bool withinEpsilon(const glm::vec3& v1, const glm::vec3& v2, float epsilon); // FIXME misnamed, should be 'spherical' or 'euler' depending on the implementation glm::vec3 toPolar(const glm::vec3& v); - glm::vec3 fromPolar(const glm::vec3& polar); - glm::vec3 fromPolar(float elevation, float azimuth); + glm::vec3 fromPolar(const glm::vec3& polar) { return fromSpherical(polar); } + glm::vec3 fromPolar(float elevation, float azimuth) { return fromSpherical(elevation, azimuth); } const glm::vec3& UNIT_X() { return Vectors::UNIT_X; } const glm::vec3& UNIT_Y() { return Vectors::UNIT_Y; } const glm::vec3& UNIT_Z() { return Vectors::UNIT_Z; } diff --git a/libraries/shared/src/GLMHelpers.cpp b/libraries/shared/src/GLMHelpers.cpp index 7d56157e53..3d705cf99e 100644 --- a/libraries/shared/src/GLMHelpers.cpp +++ b/libraries/shared/src/GLMHelpers.cpp @@ -225,6 +225,30 @@ glm::quat rotationBetween(const glm::vec3& v1, const glm::vec3& v2) { return glm::angleAxis(angle, axis); } +glm::vec3 fromSpherical(const glm::vec3& spherical) { + float x = glm::cos(spherical.x) * glm::sin(spherical.y); + float y = glm::sin(-spherical.x); + float z = glm::cos(spherical.x) * glm::cos(spherical.y); + + // Round small values to 0 + if (glm::abs(x) < EPSILON) { + x = 0.0f; + } + if (glm::abs(y) < EPSILON) { + y = 0.0f; + } + if (glm::abs(z) < EPSILON) { + z = 0.0f; + } + + return spherical.z * glm::vec3(x, y, z); +} + +glm::vec3 fromSpherical(float elevation, float azimuth) { + glm::vec3 v = glm::vec3(elevation, azimuth, 1.0f); + return fromSpherical(v); +} + bool isPointBehindTrianglesPlane(glm::vec3 point, glm::vec3 p0, glm::vec3 p1, glm::vec3 p2) { glm::vec3 v1 = p0 - p1, v2 = p2 - p1; // Non-collinear vectors contained in the plane glm::vec3 n = glm::cross(v1, v2); // Plane's normal vector, pointing out of the triangle diff --git a/libraries/shared/src/GLMHelpers.h b/libraries/shared/src/GLMHelpers.h index 6683088306..0245ca926f 100644 --- a/libraries/shared/src/GLMHelpers.h +++ b/libraries/shared/src/GLMHelpers.h @@ -117,6 +117,10 @@ float angleBetween(const glm::vec3& v1, const glm::vec3& v2); glm::quat rotationBetween(const glm::vec3& v1, const glm::vec3& v2); +glm::vec3 fromSpherical(const glm::vec3& spherical); + +glm::vec3 fromSpherical(float elevation, float azimuth); + bool isPointBehindTrianglesPlane(glm::vec3 point, glm::vec3 p0, glm::vec3 p1, glm::vec3 p2); glm::vec3 extractTranslation(const glm::mat4& matrix); From f647dcf1472ec793a7046a887115d9e38a3bdb45 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Thu, 17 Sep 2015 21:06:40 -0700 Subject: [PATCH 04/11] Change emitter radiuses to dimensions to match sphere properties --- examples/example/entities/particlesTest.js | 4 +-- .../entities/src/EntityItemProperties.cpp | 14 ++++---- libraries/entities/src/EntityItemProperties.h | 4 +-- libraries/entities/src/EntityPropertyFlags.h | 2 +- .../entities/src/ParticleEffectEntityItem.cpp | 35 ++++++++++--------- .../entities/src/ParticleEffectEntityItem.h | 8 ++--- 6 files changed, 34 insertions(+), 33 deletions(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index 20556be515..7fe98e3c28 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -137,7 +137,7 @@ Entities.editEntity(particles, { colorStart: { red: 255, green: 255, blue: 255 }, colorFinish: { red: 255, green: 255, blue: 255 }, - emitRadius: sphereDimensions, + emitDimensions: sphereDimensions, emitOrientation: sphereOrientation }); Entities.editEntity(box, { @@ -150,7 +150,7 @@ case 12: print("Stop emitting"); Entities.editEntity(particles, { - emitRadius: pointDimensions, + emitDimensions: pointDimensions, emitOrientation: verticalOrientation, emitRate: SLOW_EMIT_RATE, emitSpeed: FAST_EMIT_SPEED, diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp index 7702657790..4b50ec0d02 100644 --- a/libraries/entities/src/EntityItemProperties.cpp +++ b/libraries/entities/src/EntityItemProperties.cpp @@ -94,7 +94,7 @@ CONSTRUCT_PROPERTY(emitRate, ParticleEffectEntityItem::DEFAULT_EMIT_RATE), CONSTRUCT_PROPERTY(emitSpeed, ParticleEffectEntityItem::DEFAULT_EMIT_SPEED), CONSTRUCT_PROPERTY(speedSpread, ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD), CONSTRUCT_PROPERTY(emitOrientation, ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION), -CONSTRUCT_PROPERTY(emitRadius, ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS), +CONSTRUCT_PROPERTY(emitDimensions, ParticleEffectEntityItem::DEFAULT_EMIT_DIMENSIONS), CONSTRUCT_PROPERTY(emitRadiusStart, ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START), CONSTRUCT_PROPERTY(polarStart, ParticleEffectEntityItem::DEFAULT_POLAR_START), CONSTRUCT_PROPERTY(polarFinish, ParticleEffectEntityItem::DEFAULT_POLAR_FINISH), @@ -384,7 +384,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const { CHECK_PROPERTY_CHANGE(PROP_EMIT_SPEED, emitSpeed); CHECK_PROPERTY_CHANGE(PROP_SPEED_SPREAD, speedSpread); CHECK_PROPERTY_CHANGE(PROP_EMIT_ORIENTATION, emitOrientation); - CHECK_PROPERTY_CHANGE(PROP_EMIT_RADIUS, emitRadius); + CHECK_PROPERTY_CHANGE(PROP_EMIT_DIMENSIONS, emitDimensions); CHECK_PROPERTY_CHANGE(PROP_EMIT_RADIUS_START, emitRadiusStart); CHECK_PROPERTY_CHANGE(PROP_POLAR_START, polarStart); CHECK_PROPERTY_CHANGE(PROP_POLAR_FINISH, polarFinish); @@ -510,7 +510,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool COPY_PROPERTY_TO_QSCRIPTVALUE(emitSpeed); COPY_PROPERTY_TO_QSCRIPTVALUE(speedSpread); COPY_PROPERTY_TO_QSCRIPTVALUE(emitOrientation); - COPY_PROPERTY_TO_QSCRIPTVALUE(emitRadius); + COPY_PROPERTY_TO_QSCRIPTVALUE(emitDimensions); COPY_PROPERTY_TO_QSCRIPTVALUE(emitRadiusStart); COPY_PROPERTY_TO_QSCRIPTVALUE(polarStart); COPY_PROPERTY_TO_QSCRIPTVALUE(polarFinish); @@ -656,7 +656,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool COPY_PROPERTY_FROM_QSCRIPTVALUE(emitSpeed, float, setEmitSpeed); COPY_PROPERTY_FROM_QSCRIPTVALUE(speedSpread, float, setSpeedSpread); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitOrientation, glmQuat, setEmitOrientation); - COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRadius, glmVec3, setEmitRadius); + COPY_PROPERTY_FROM_QSCRIPTVALUE(emitDimensions, glmVec3, setEmitDimensions); COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRadiusStart, float, setEmitRadiusStart); COPY_PROPERTY_FROM_QSCRIPTVALUE(polarStart, float, setPolarStart); COPY_PROPERTY_FROM_QSCRIPTVALUE(polarFinish, float, setPolarFinish); @@ -916,7 +916,7 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, properties.getEmitSpeed()); APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, properties.getSpeedSpread()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, properties.getEmitOrientation()); - APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS, properties.getEmitRadius()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, properties.getEmitDimensions()); APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, properties.getEmitRadiusStart()); APPEND_ENTITY_PROPERTY(PROP_POLAR_START, properties.getPolarStart()); APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, properties.getPolarFinish()); @@ -1207,7 +1207,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_SPEED, float, setEmitSpeed); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SPEED_SPREAD, float, setSpeedSpread); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); - READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS, glm::vec3, setEmitRadius); + READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_DIMENSIONS, glm::vec3, setEmitDimensions); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_START, float, setPolarStart); READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_FINISH, float, setPolarFinish); @@ -1363,7 +1363,7 @@ void EntityItemProperties::markAllChanged() { _emitSpeedChanged = true; _speedSpreadChanged = true; _emitOrientationChanged = true; - _emitRadiusChanged = true; + _emitDimensionsChanged = true; _emitRadiusStartChanged = true; _polarStartChanged = true; _polarFinishChanged = true; diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h index 8e899d7651..30d63b407c 100644 --- a/libraries/entities/src/EntityItemProperties.h +++ b/libraries/entities/src/EntityItemProperties.h @@ -141,7 +141,7 @@ public: DEFINE_PROPERTY(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, float); DEFINE_PROPERTY(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, float); DEFINE_PROPERTY_REF(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat); - DEFINE_PROPERTY_REF(PROP_EMIT_RADIUS, EmitRadius, emitRadius, glm::vec3); + DEFINE_PROPERTY_REF(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, glm::vec3); DEFINE_PROPERTY(PROP_EMIT_RADIUS_START, EmitRadiusStart, emitRadiusStart, float); DEFINE_PROPERTY(PROP_POLAR_START, PolarStart, polarStart, float); DEFINE_PROPERTY(PROP_POLAR_FINISH, PolarFinish, polarFinish, float); @@ -345,7 +345,7 @@ inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) { DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitSpeed, emitSpeed, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, SpeedSpread, speedSpread, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitOrientation, emitOrientation, ""); - DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitRadius, emitRadius, ""); + DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitDimensions, emitDimensions, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, EmitRadiusStart, emitRadiusStart, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, PolarStart, polarStart, ""); DEBUG_PROPERTY_IF_CHANGED(debug, properties, PolarFinish, polarFinish, ""); diff --git a/libraries/entities/src/EntityPropertyFlags.h b/libraries/entities/src/EntityPropertyFlags.h index 741cfabf92..b3e20110c4 100644 --- a/libraries/entities/src/EntityPropertyFlags.h +++ b/libraries/entities/src/EntityPropertyFlags.h @@ -163,7 +163,7 @@ enum EntityPropertyList { PROP_EMIT_SPEED, PROP_SPEED_SPREAD, PROP_EMIT_ORIENTATION, - PROP_EMIT_RADIUS, + PROP_EMIT_DIMENSIONS, PROP_EMIT_RADIUS_START, PROP_POLAR_START, PROP_POLAR_FINISH, diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 59a8e126cf..7bb584fdcf 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -61,8 +61,8 @@ const float ParticleEffectEntityItem::DEFAULT_EMIT_RATE = 15.0f; const float ParticleEffectEntityItem::DEFAULT_EMIT_SPEED = 5.0f; const float ParticleEffectEntityItem::DEFAULT_SPEED_SPREAD = 1.0f; const glm::quat ParticleEffectEntityItem::DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, X_AXIS); // Vertical -const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS = glm::vec3(0.0f, 0.0f, 0.0f); // Emit from point -const float ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START = 1.0f; // Emit from surface (when emitRadius > 0) +const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_DIMENSIONS = glm::vec3(0.0f, 0.0f, 0.0f); // Emit from point +const float ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START = 1.0f; // Emit from surface (when emitDimensions > 0) const float ParticleEffectEntityItem::DEFAULT_POLAR_START = 0.0f; // Emit along z-axis const float ParticleEffectEntityItem::DEFAULT_POLAR_FINISH = 0.0f; // "" const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_START = -PI; // Emit full circumference (when polarFinish > 0) @@ -130,8 +130,8 @@ void ParticleEffectEntityItem::setEmitOrientation(const glm::quat& emitOrientati } -void ParticleEffectEntityItem::setEmitRadius(const glm::vec3& emitRadius) { - _emitRadius = emitRadius; +void ParticleEffectEntityItem::setEmitDimensions(const glm::vec3& emitDimensions) { + _emitDimensions = emitDimensions; computeAndUpdateDimensions(); } @@ -153,7 +153,7 @@ void ParticleEffectEntityItem::computeAndUpdateDimensions() { glm::vec3 maxVelocity = glm::abs(velocity) + velocitySpread; glm::vec3 maxAccleration = glm::abs(_acceleration) + _accelerationSpread; - glm::vec3 maxDistance = _emitRadius + time * maxVelocity + (0.5f * time * time) * maxAccleration; + glm::vec3 maxDistance = 0.5f * _emitDimensions + time * maxVelocity + (0.5f * time * time) * maxAccleration; float maxDistanceValue = std::max(maxDistance.x, std::max(maxDistance.y, maxDistance.z)); @@ -180,7 +180,7 @@ EntityItemProperties ParticleEffectEntityItem::getProperties() const { COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitSpeed, getEmitSpeed); COPY_ENTITY_PROPERTY_TO_PROPERTIES(speedSpread, getSpeedSpread); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitOrientation, getEmitOrientation); - COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitRadius, getEmitRadius); + COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitDimensions, getEmitDimensions); COPY_ENTITY_PROPERTY_TO_PROPERTIES(emitRadiusStart, getEmitRadiusStart); COPY_ENTITY_PROPERTY_TO_PROPERTIES(polarStart, getPolarStart); COPY_ENTITY_PROPERTY_TO_PROPERTIES(polarFinish, getPolarFinish); @@ -220,7 +220,7 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitSpeed, setEmitSpeed); SET_ENTITY_PROPERTY_FROM_PROPERTIES(speedSpread, setSpeedSpread); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitOrientation, setEmitOrientation); - SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitRadius, setEmitRadius); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitDimensions, setEmitDimensions); SET_ENTITY_PROPERTY_FROM_PROPERTIES(emitRadiusStart, setEmitRadiusStart); SET_ENTITY_PROPERTY_FROM_PROPERTIES(polarStart, setPolarStart); SET_ENTITY_PROPERTY_FROM_PROPERTIES(polarFinish, setPolarFinish); @@ -330,7 +330,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed); READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread); READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation); - READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS, glm::vec3, setEmitRadius); + READ_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, glm::vec3, setEmitDimensions); READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart); READ_ENTITY_PROPERTY(PROP_POLAR_START, float, setPolarStart); READ_ENTITY_PROPERTY(PROP_POLAR_FINISH, float, setPolarFinish); @@ -372,7 +372,7 @@ EntityPropertyFlags ParticleEffectEntityItem::getEntityProperties(EncodeBitstrea requestedProperties += PROP_EMIT_SPEED; requestedProperties += PROP_SPEED_SPREAD; requestedProperties += PROP_EMIT_ORIENTATION; - requestedProperties += PROP_EMIT_RADIUS; + requestedProperties += PROP_EMIT_DIMENSIONS; requestedProperties += PROP_EMIT_RADIUS_START; requestedProperties += PROP_POLAR_START; requestedProperties += PROP_POLAR_FINISH; @@ -417,7 +417,7 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData, APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, getEmitSpeed()); APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, getSpeedSpread()); APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, getEmitOrientation()); - APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS, getEmitRadius()); + APPEND_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, getEmitDimensions()); APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, getEmitRadiusStart()); APPEND_ENTITY_PROPERTY(PROP_POLAR_START, getPolarStart()); APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, getPolarFinish()); @@ -689,7 +689,7 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS); _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; - } else if (_emitRadius == glm::vec3()) { + } else if (_emitDimensions == glm::vec3()) { // Emit around point float elevation = asin(2.0f * randFloat() - 1.0f); // Distribute points evenly over surface glm::vec3 emitDirection = _emitOrientation * fromSpherical(elevation, randFloat() * TWO_PI); @@ -705,14 +705,15 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { float azimuth = (2.0f * randFloat() - 1.0f) * PI; // TODO: Sort out ellipsoid equations to distribute completely evenly over surface. - float x = _emitRadius.x * cos(elevation) * cos(azimuth); - float y = _emitRadius.y * cos(elevation) * sin(azimuth); - float z = _emitRadius.z * sin(elevation); + glm::vec3 radiuses = 0.5f * _emitDimensions; + float x = radiuses.x * cos(elevation) * cos(azimuth); + float y = radiuses.y * cos(elevation) * sin(azimuth); + float z = radiuses.z * sin(elevation); glm::vec3 emitPosition = glm::vec3(x, y, z); glm::vec3 emitDirection = glm::normalize(glm::vec3( - x / (_emitRadius.x * _emitRadius.x), - y / (_emitRadius.y * _emitRadius.y), - z / (_emitRadius.z * _emitRadius.z) + x / (radiuses.x * radiuses.x), + y / (radiuses.y * radiuses.y), + z / (radiuses.z * radiuses.z) )); _particlePositions[i] = getPosition() + _emitOrientation * emitPosition; diff --git a/libraries/entities/src/ParticleEffectEntityItem.h b/libraries/entities/src/ParticleEffectEntityItem.h index d5ec4eb587..9d39c4cd10 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.h +++ b/libraries/entities/src/ParticleEffectEntityItem.h @@ -140,9 +140,9 @@ public: void setEmitOrientation(const glm::quat& emitOrientation); const glm::quat& getEmitOrientation() const { return _emitOrientation; } - static const glm::vec3 DEFAULT_EMIT_RADIUS; - void setEmitRadius(const glm::vec3& emitRadius); - const glm::vec3& getEmitRadius() const { return _emitRadius; } + static const glm::vec3 DEFAULT_EMIT_DIMENSIONS; + void setEmitDimensions(const glm::vec3& emitDimensions); + const glm::vec3& getEmitDimensions() const { return _emitDimensions; } static const float DEFAULT_EMIT_RADIUS_START; void setEmitRadiusStart(float emitRadiusStart) { _emitRadiusStart = emitRadiusStart; } @@ -233,7 +233,7 @@ protected: float _emitSpeed = DEFAULT_EMIT_SPEED; float _speedSpread = DEFAULT_SPEED_SPREAD; glm::quat _emitOrientation = DEFAULT_EMIT_ORIENTATION; - glm::vec3 _emitRadius = DEFAULT_EMIT_RADIUS; + glm::vec3 _emitDimensions = DEFAULT_EMIT_DIMENSIONS; float _emitRadiusStart = DEFAULT_EMIT_RADIUS_START; float _polarStart = DEFAULT_POLAR_START; float _polarFinish = DEFAULT_POLAR_FINISH; From 9e2b5b75b641cd214a0c0c2c7af2b25adb82162e Mon Sep 17 00:00:00 2001 From: David Rowe Date: Thu, 17 Sep 2015 22:40:49 -0700 Subject: [PATCH 05/11] Make able to emit in specified range of directions Controlled by polar and azimuth start and finish angles, around point or from specified part of spheroid surface. --- examples/example/entities/particlesTest.js | 49 ++++++++++---- .../entities/src/ParticleEffectEntityItem.cpp | 66 +++++++++++-------- 2 files changed, 77 insertions(+), 38 deletions(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index 7fe98e3c28..3f07d9fae5 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -22,13 +22,15 @@ particleExample = -1, PARTICLE_RADIUS = 0.04, SLOW_EMIT_RATE = 2.0, + HALF_EMIT_RATE = 50.0, FAST_EMIT_RATE = 100.0, - SLOW_EMIT_SPEED = 0.05, + SLOW_EMIT_SPEED = 0.025, FAST_EMIT_SPEED = 1.0, GRAVITY_EMIT_ACCELERATON = { x: 0.0, y: -0.3, z: 0.0 }, ZERO_EMIT_ACCELERATON = { x: 0.0, y: 0.0, z: 0.0 }, PI = 3.141593, - NUM_PARTICLE_EXAMPLES = 13; + DEG_TO_RAD = PI / 180.0, + NUM_PARTICLE_EXAMPLES = 17; function onClickDownOnEntity(entityID) { if (entityID === box || entityID === sphere || entityID === particles) { @@ -116,23 +118,24 @@ }); break; case 10: - print("Emit in all directions from point"); + print("Emit in a spread beam"); Entities.editEntity(particles, { colorStart: { red: 255, green: 255, blue: 255 }, colorFinish: { red: 255, green: 255, blue: 255 }, + alphaFinish: 0.0, emitRate: FAST_EMIT_RATE, + polarFinish: 2.0 * DEG_TO_RAD + }); + break; + case 11: + print("Emit in all directions from point"); + Entities.editEntity(particles, { emitSpeed: SLOW_EMIT_SPEED, emitAcceleration: ZERO_EMIT_ACCELERATON, polarFinish: PI }); - Entities.editEntity(box, { - visible: false - }); - Entities.editEntity(sphere, { - visible: true - }); break; - case 11: + case 12: print("Emit from sphere surface"); Entities.editEntity(particles, { colorStart: { red: 255, green: 255, blue: 255 }, @@ -147,15 +150,39 @@ visible: true }); break; - case 12: + case 13: + print("Emit from hemisphere of sphere surface"); + Entities.editEntity(particles, { + polarFinish: PI / 2.0 + }); + break; + case 14: + print("Emit from equator of sphere surface"); + Entities.editEntity(particles, { + polarStart: PI / 2.0, + emitRate: HALF_EMIT_RATE + }); + break; + case 15: + print("Emit from half equator of sphere surface"); + Entities.editEntity(particles, { + azimuthStart: -PI / 2.0, + azimuthFinish: PI / 2.0 + }); + break; + case 16: print("Stop emitting"); Entities.editEntity(particles, { emitDimensions: pointDimensions, emitOrientation: verticalOrientation, + alphaFinish: 1.0, emitRate: SLOW_EMIT_RATE, emitSpeed: FAST_EMIT_SPEED, emitAcceleration: GRAVITY_EMIT_ACCELERATON, + polarStart: 0.0, polarFinish: 0.0, + azimuthStart: -PI, + azimuthFinish: PI, animationIsPlaying: false }); Entities.editEntity(box, { diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 7bb584fdcf..42de5bd7e4 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -66,7 +66,7 @@ const float ParticleEffectEntityItem::DEFAULT_EMIT_RADIUS_START = 1.0f; // Emit const float ParticleEffectEntityItem::DEFAULT_POLAR_START = 0.0f; // Emit along z-axis const float ParticleEffectEntityItem::DEFAULT_POLAR_FINISH = 0.0f; // "" const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_START = -PI; // Emit full circumference (when polarFinish > 0) -const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_FINISH = -PI; // "" +const float ParticleEffectEntityItem::DEFAULT_AZIMUTH_FINISH = PI; // "" const glm::vec3 ParticleEffectEntityItem::DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f); const glm::vec3 ParticleEffectEntityItem::DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f); const float ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS = 0.025f; @@ -689,34 +689,46 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * Z_AXIS); _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; - } else if (_emitDimensions == glm::vec3()) { - // Emit around point - float elevation = asin(2.0f * randFloat() - 1.0f); // Distribute points evenly over surface - glm::vec3 emitDirection = _emitOrientation * fromSpherical(elevation, randFloat() * TWO_PI); - - _particlePositions[i] = getPosition(); - _particleVelocities[i] = - (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * emitDirection); - _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; - } else { - // Emit from ellipsoid - float elevation = asin(2.0f * randFloat() - 1.0f); // Distribute points approximately evenly over surface - float azimuth = (2.0f * randFloat() - 1.0f) * PI; - // TODO: Sort out ellipsoid equations to distribute completely evenly over surface. - - glm::vec3 radiuses = 0.5f * _emitDimensions; - float x = radiuses.x * cos(elevation) * cos(azimuth); - float y = radiuses.y * cos(elevation) * sin(azimuth); - float z = radiuses.z * sin(elevation); - glm::vec3 emitPosition = glm::vec3(x, y, z); - glm::vec3 emitDirection = glm::normalize(glm::vec3( - x / (radiuses.x * radiuses.x), - y / (radiuses.y * radiuses.y), - z / (radiuses.z * radiuses.z) - )); + // Emit around point or from ellipsoid + // - Distribute directions evenly around point + // - Distribute points relatively evenly over ellipsoid surface + + float elevationMinZ = sin(PI_OVER_TWO - _polarFinish); + float elevationMaxZ = sin(PI_OVER_TWO - _polarStart); + float elevation = asin(elevationMinZ + (elevationMaxZ - elevationMinZ) * randFloat()); + + float azimuth; + if (_azimuthFinish >= _azimuthStart) { + azimuth = _azimuthStart + (_azimuthFinish - _azimuthStart) * randFloat(); + } else { + azimuth = _azimuthStart + (2.0 * PI + _azimuthFinish - _azimuthStart) * randFloat(); + } + + glm::vec3 emitDirection; + + if (_emitDimensions == glm::vec3()) { + // Point + emitDirection = _emitOrientation * fromSpherical(elevation, azimuth); + + _particlePositions[i] = getPosition(); + + } else { + // Ellipsoid + glm::vec3 radiuses = 0.5f * _emitDimensions; + float x = radiuses.x * cos(elevation) * cos(azimuth); + float y = radiuses.y * cos(elevation) * sin(azimuth); + float z = radiuses.z * sin(elevation); + glm::vec3 emitPosition = glm::vec3(x, y, z); + emitDirection = glm::normalize(glm::vec3( + x / (radiuses.x * radiuses.x), + y / (radiuses.y * radiuses.y), + z / (radiuses.z * radiuses.z) + )); + + _particlePositions[i] = getPosition() + _emitOrientation * emitPosition; + } - _particlePositions[i] = getPosition() + _emitOrientation * emitPosition; _particleVelocities[i] = (_emitSpeed + (2.0f * randFloat() - 1.0f) * _speedSpread) * (_emitOrientation * emitDirection); _particleAccelerations[i] = _emitAcceleration + (2.0f * randFloat() - 1.0f) * _accelerationSpread; From 8634b59914151dd623a9a79b630ead58bf7e7e99 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Thu, 17 Sep 2015 23:49:57 -0700 Subject: [PATCH 06/11] Make able to emit from within portion of ellipsoid volume --- examples/example/entities/particlesTest.js | 14 +++++++++++++- .../entities/src/ParticleEffectEntityItem.cpp | 10 +++++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index 3f07d9fae5..8548ce5f86 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -30,7 +30,7 @@ ZERO_EMIT_ACCELERATON = { x: 0.0, y: 0.0, z: 0.0 }, PI = 3.141593, DEG_TO_RAD = PI / 180.0, - NUM_PARTICLE_EXAMPLES = 17; + NUM_PARTICLE_EXAMPLES = 18; function onClickDownOnEntity(entityID) { if (entityID === box || entityID === sphere || entityID === particles) { @@ -171,6 +171,18 @@ }); break; case 16: + print("Emit within quarter of sphere volume"); + Entities.editEntity(particles, { + polarStart: 0.0, + polarFinish: PI / 2.0, + azimuthStart: 0, + azimuthFinish: PI / 2.0, + emitRadiusStart: 0.0, + alphaFinish: 1.0, + emitSpeed: 0.0 + }); + break; + case 17: print("Stop emitting"); Entities.editEntity(particles, { emitDimensions: pointDimensions, diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 42de5bd7e4..46b8e844dd 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -693,6 +693,7 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { // Emit around point or from ellipsoid // - Distribute directions evenly around point // - Distribute points relatively evenly over ellipsoid surface + // - Distribute points relatively evenly within ellipsoid volume float elevationMinZ = sin(PI_OVER_TWO - _polarFinish); float elevationMaxZ = sin(PI_OVER_TWO - _polarStart); @@ -715,7 +716,14 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { } else { // Ellipsoid - glm::vec3 radiuses = 0.5f * _emitDimensions; + float radiusScale = 1.0f; + if (_emitRadiusStart < 1.0f) { + float emitRadiusStart = glm::max(_emitRadiusStart, EPSILON); // Avoid math complications at center + float randRadius = emitRadiusStart + (1.0f - emitRadiusStart) * randFloat(); + radiusScale = 1.0f - std::pow(1.0f - randRadius, 3); + } + + glm::vec3 radiuses = radiusScale * 0.5f * _emitDimensions; float x = radiuses.x * cos(elevation) * cos(azimuth); float y = radiuses.y * cos(elevation) * sin(azimuth); float z = radiuses.z * sin(elevation); From 68874eed964cce5d43d9853dfe7a340d1b4a23b3 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Fri, 18 Sep 2015 11:34:26 -0700 Subject: [PATCH 07/11] Update particle scripts --- examples/entityScripts/sprayPaintCan.js | 14 +++++++------- examples/fireworks.js | 11 ++++------- examples/particleDance.js | 10 ++++------ examples/particles.js | 7 +++++-- examples/toys/grenade.js | 8 ++++---- 5 files changed, 24 insertions(+), 26 deletions(-) diff --git a/examples/entityScripts/sprayPaintCan.js b/examples/entityScripts/sprayPaintCan.js index 4407140184..fb90a8f447 100644 --- a/examples/entityScripts/sprayPaintCan.js +++ b/examples/entityScripts/sprayPaintCan.js @@ -83,19 +83,18 @@ lastFrame: 10000, running: true }); + var PI = 3.141593; + var DEG_TO_RAD = PI / 180.0; this.paintStream = Entities.addEntity({ type: "ParticleEffect", animationSettings: animationSettings, position: this.properties.position, textures: "https://raw.githubusercontent.com/ericrius1/SantasLair/santa/assets/smokeparticle.png", - emitVelocity: ZERO_VEC, + emitSpeed: 0, + speedSpread: 0.02, + polarFinish: 2 * DEG_TO_RAD, emitAcceleration: ZERO_VEC, - velocitySpread: { - x: .02, - y: .02, - z: 0.02 - }, emitRate: 100, particleRadius: 0.01, color: { @@ -132,7 +131,8 @@ position = Vec3.sum(position, Vec3.multiply(upVec, TIP_OFFSET_Y)) Entities.editEntity(self.paintStream, { position: position, - emitVelocity: Vec3.multiply(forwardVec, 4) + emitOrientation: forwardVec, + emitSpeed: 4 }); //Now check for an intersection with an entity diff --git a/examples/fireworks.js b/examples/fireworks.js index 621931ee36..3485b1687f 100644 --- a/examples/fireworks.js +++ b/examples/fireworks.js @@ -101,7 +101,6 @@ Rocket = function(point, colorPalette) { this.burst = false; this.emitRate = randInt(80, 120); - this.emitStrength = randInt(5.0, 7.0); this.rocket = Entities.addEntity({ type: "Sphere", @@ -163,6 +162,9 @@ Rocket.prototype.explode = function(position) { }); var colorIndex = 0; + var PI = 3.141593; + var DEG_TO_RAD = PI / 180.0; + for (var i = 0; i < NUM_BURSTS; ++i) { var color = this.colors[colorIndex]; print(JSON.stringify(color)); @@ -172,12 +174,7 @@ Rocket.prototype.explode = function(position) { position: position, textures: 'https://raw.githubusercontent.com/ericrius1/SantasLair/santa/assets/smokeparticle.png', emitRate: this.emitRate, - emitStrength: this.emitStrength, - emitDirection: { - x: Math.pow(-1, i) * randFloat(0.0, 1.4), - y: 1.0, - z: 0.0 - }, + polarFinish: 25 * DEG_TO_RAD, color: color, lifespan: 1.0, visible: true, diff --git a/examples/particleDance.js b/examples/particleDance.js index e920fcfa41..6b1f84bb8e 100644 --- a/examples/particleDance.js +++ b/examples/particleDance.js @@ -6,6 +6,9 @@ var AUDIO_RANGE = 0.5 * RANGE; var DIST_BETWEEN_BURSTS = 1.0; + var PI = 3.141593; + var DEG_TO_RAD = PI / 180.0; + var LOUDNESS_RADIUS_RATIO = 10; var TEXTURE_PATH = 'https://raw.githubusercontent.com/ericrius1/SantasLair/santa/assets/smokeparticle.png'; @@ -86,12 +89,7 @@ position: this.point, textures: TEXTURE_PATH, emitRate: this.emitRate, - emitStrength: this.emitStrength, - emitDirection: { - x: Math.pow(-1, i) * randFloat(0.0, 0.4), - y: 1.0, - z: 0.0 - }, + polarFinish: 25 * DEG_TO_RAD, color: color, lifespan: 1.0, visible: true, diff --git a/examples/particles.js b/examples/particles.js index ad232dd781..def21704d1 100644 --- a/examples/particles.js +++ b/examples/particles.js @@ -35,13 +35,16 @@ firstFrame: 0, lastFrame: 30, loop: true }); + var PI = 3.141593; + var DEG_TO_RAD = PI / 180.0; this.entity = Entities.addEntity({ type: "ParticleEffect", animationSettings: animationSettings, position: spawnPoint, dimensions: {x: 2, y: 2, z: 2}, - emitVelocity: {x: 0, y: 5, z: 0}, - velocitySpread: {x: 2, y: 0, z: 2}, + emitSpeed: 5, + speedSpread: 2, + polarFinish: 30 * DEG_TO_RAD, emitAcceleration: {x: 0, y: -9.8, z: 0}, textures: "https://hifi-public.s3.amazonaws.com/alan/Particles/Particle-Sprite-Smoke-1.png", color: color, diff --git a/examples/toys/grenade.js b/examples/toys/grenade.js index b2dfebb888..c6a9c5bdeb 100644 --- a/examples/toys/grenade.js +++ b/examples/toys/grenade.js @@ -45,6 +45,8 @@ var explodeAnimationSettings = JSON.stringify({ var GRAVITY = -9.8; var TIME_TO_EXPLODE = 2500; var DISTANCE_IN_FRONT_OF_ME = 1.0; +var PI = 3.141593; +var DEG_TO_RAD = PI / 180.0; function makeGrenade() { var position = Vec3.sum(MyAvatar.position, @@ -87,8 +89,7 @@ function update() { position: newProperties.position, textures: 'https://raw.githubusercontent.com/ericrius1/SantasLair/santa/assets/smokeparticle.png', emitRate: 100, - emitStrength: 2.0, - emitDirection: { x: 0.0, y: 1.0, z: 0.0 }, + polarFinish: 25 * DEG_TO_RAD, color: { red: 200, green: 0, blue: 0 }, lifespan: 10.0, visible: true, @@ -145,8 +146,7 @@ function boom() { position: properties.position, textures: 'https://raw.githubusercontent.com/ericrius1/SantasLair/santa/assets/smokeparticle.png', emitRate: 200, - emitStrength: 3.0, - emitDirection: { x: 0.0, y: 1.0, z: 0.0 }, + polarFinish: 25 * DEG_TO_RAD, color: { red: 255, green: 255, blue: 0 }, lifespan: 2.0, visible: true, From ec146069b14e97e86f80de360935bb6d483f5d82 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Fri, 18 Sep 2015 13:06:18 -0700 Subject: [PATCH 08/11] Reuse old property enum slots --- libraries/entities/src/EntityPropertyFlags.h | 8 +++----- libraries/entities/src/ParticleEffectEntityItem.cpp | 6 ++++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/libraries/entities/src/EntityPropertyFlags.h b/libraries/entities/src/EntityPropertyFlags.h index b3e20110c4..2298e41bde 100644 --- a/libraries/entities/src/EntityPropertyFlags.h +++ b/libraries/entities/src/EntityPropertyFlags.h @@ -96,7 +96,7 @@ enum EntityPropertyList { PROP_MAX_PARTICLES, PROP_LIFESPAN, PROP_EMIT_RATE, - PROP_EMIT_VELOCITY, + PROP_EMIT_SPEED, PROP_EMIT_STRENGTH, PROP_EMIT_ACCELERATION, PROP_PARTICLE_RADIUS, @@ -136,7 +136,7 @@ enum EntityPropertyList { PROP_STROKE_WIDTHS, // used by particles - PROP_VELOCITY_SPREAD, + PROP_SPEED_SPREAD, PROP_ACCELERATION_SPREAD, PROP_X_N_NEIGHBOR_ID, // used by PolyVox @@ -160,8 +160,6 @@ enum EntityPropertyList { PROP_ALPHA_SPREAD, PROP_ALPHA_START, PROP_ALPHA_FINISH, - PROP_EMIT_SPEED, - PROP_SPEED_SPREAD, PROP_EMIT_ORIENTATION, PROP_EMIT_DIMENSIONS, PROP_EMIT_RADIUS_START, @@ -202,7 +200,7 @@ enum EntityPropertyList { PROP_ATMOSPHERE_CENTER = PROP_MAX_PARTICLES, PROP_ATMOSPHERE_INNER_RADIUS = PROP_LIFESPAN, PROP_ATMOSPHERE_OUTER_RADIUS = PROP_EMIT_RATE, - PROP_ATMOSPHERE_MIE_SCATTERING = PROP_EMIT_VELOCITY, + PROP_ATMOSPHERE_MIE_SCATTERING = PROP_EMIT_SPEED, PROP_ATMOSPHERE_RAYLEIGH_SCATTERING = PROP_EMIT_STRENGTH, PROP_ATMOSPHERE_SCATTERING_WAVELENGTHS = PROP_EMIT_ACCELERATION, PROP_ATMOSPHERE_HAS_STARS = PROP_PARTICLE_RADIUS, diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 46b8e844dd..eb769dff3b 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -289,7 +289,8 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_LIFESPAN, float, setLifespan); READ_ENTITY_PROPERTY(PROP_EMIT_RATE, float, setEmitRate); if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER) { - SKIP_ENTITY_PROPERTY(PROP_EMIT_VELOCITY, glm::vec3); + // OLD PROP_EMIT_VELOCITY FAKEOUT + SKIP_ENTITY_PROPERTY(PROP_EMIT_SPEED, glm::vec3); } if (args.bitstreamVersion >= VERSION_ENTITIES_PARTICLE_MODIFICATIONS) { @@ -298,7 +299,8 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures); if (args.bitstreamVersion < VERSION_ENTITIES_PARTICLE_ELLIPSOID_EMITTER) { - SKIP_ENTITY_PROPERTY(PROP_VELOCITY_SPREAD, glm::vec3); + // OLD PROP_VELOCITY_SPREAD FAKEOUT + SKIP_ENTITY_PROPERTY(PROP_SPEED_SPREAD, glm::vec3); } } else { // EMIT_ACCELERATION FAKEOUT From 60ba6e174fa675a4b09e929d020e2658dc987f84 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Fri, 18 Sep 2015 16:44:20 -0700 Subject: [PATCH 09/11] Typo --- examples/example/entities/particlesTest.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/example/entities/particlesTest.js b/examples/example/entities/particlesTest.js index 8548ce5f86..bfa4a47ffb 100644 --- a/examples/example/entities/particlesTest.js +++ b/examples/example/entities/particlesTest.js @@ -171,7 +171,7 @@ }); break; case 16: - print("Emit within quarter of sphere volume"); + print("Emit within eighth of sphere volume"); Entities.editEntity(particles, { polarStart: 0.0, polarFinish: PI / 2.0, From 2b902238e73d85142eed36b8b04d666ab025da11 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Wed, 23 Sep 2015 10:33:31 -0700 Subject: [PATCH 10/11] Code tidying --- libraries/entities/src/ParticleEffectEntityItem.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index b5ec879f61..9958c0ac1e 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -303,11 +303,10 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch SKIP_ENTITY_PROPERTY(PROP_SPEED_SPREAD, glm::vec3); } } else { - // EMIT_ACCELERATION FAKEOUT - READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); - // ACCELERATION_SPREAD FAKEOUT - READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); - // ACTUAL PARTICLE_RADIUS + // OLD PROP_EMIT_ACCELERATION FAKEOUT + SKIP_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float); + // OLD PROP_ACCELERATION_SPREAD FAKEOUT + SKIP_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float); READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius); READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures); } From 3d44fdfdf5fc56bd563129d46437b91587ed36df Mon Sep 17 00:00:00 2001 From: David Rowe Date: Wed, 23 Sep 2015 21:18:23 -0700 Subject: [PATCH 11/11] Fix warnings --- libraries/entities/src/ParticleEffectEntityItem.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/libraries/entities/src/ParticleEffectEntityItem.cpp b/libraries/entities/src/ParticleEffectEntityItem.cpp index 9958c0ac1e..8c45c860fa 100644 --- a/libraries/entities/src/ParticleEffectEntityItem.cpp +++ b/libraries/entities/src/ParticleEffectEntityItem.cpp @@ -704,7 +704,7 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { if (_azimuthFinish >= _azimuthStart) { azimuth = _azimuthStart + (_azimuthFinish - _azimuthStart) * randFloat(); } else { - azimuth = _azimuthStart + (2.0 * PI + _azimuthFinish - _azimuthStart) * randFloat(); + azimuth = _azimuthStart + (2.0f * PI + _azimuthFinish - _azimuthStart) * randFloat(); } glm::vec3 emitDirection; @@ -721,13 +721,13 @@ void ParticleEffectEntityItem::stepSimulation(float deltaTime) { if (_emitRadiusStart < 1.0f) { float emitRadiusStart = glm::max(_emitRadiusStart, EPSILON); // Avoid math complications at center float randRadius = emitRadiusStart + (1.0f - emitRadiusStart) * randFloat(); - radiusScale = 1.0f - std::pow(1.0f - randRadius, 3); + radiusScale = 1.0f - std::pow(1.0f - randRadius, 3.0f); } glm::vec3 radiuses = radiusScale * 0.5f * _emitDimensions; - float x = radiuses.x * cos(elevation) * cos(azimuth); - float y = radiuses.y * cos(elevation) * sin(azimuth); - float z = radiuses.z * sin(elevation); + float x = radiuses.x * glm::cos(elevation) * glm::cos(azimuth); + float y = radiuses.y * glm::cos(elevation) * glm::sin(azimuth); + float z = radiuses.z * glm::sin(elevation); glm::vec3 emitPosition = glm::vec3(x, y, z); emitDirection = glm::normalize(glm::vec3( x / (radiuses.x * radiuses.x),