From d51cab3e3d58cec59be452ece77d2d8ae3034f50 Mon Sep 17 00:00:00 2001 From: David Rowe Date: Wed, 16 Sep 2015 14:51:08 -0700 Subject: [PATCH] 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