Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
{
|
|
|
|
|
"MaxCount": 4096,
|
2019-02-14 21:55:21 +00:00
|
|
|
"Duration": 1,
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
"Rate": 400,
|
|
|
|
|
"Life": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Constant",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": true,
|
|
|
|
|
"Bidirectional": false,
|
|
|
|
|
"A0": 1,
|
2019-02-27 16:19:19 +00:00
|
|
|
"A1": 3
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
},
|
2019-02-15 19:29:38 +00:00
|
|
|
"Drawable": {
|
|
|
|
|
"Type": "SkCircleDrawable",
|
|
|
|
|
"Radius": 2
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"Spawn": [
|
2019-02-28 20:48:05 +00:00
|
|
|
{
|
|
|
|
|
"Type": "SkPositionOnPathAffector",
|
|
|
|
|
"Enabled": true,
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Random",
|
|
|
|
|
"TileMode": "Clamp",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-28 20:48:05 +00:00
|
|
|
"SetHeading": true,
|
|
|
|
|
"Path": "h50"
|
|
|
|
|
},
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
{
|
2019-02-14 21:55:21 +00:00
|
|
|
"Type": "SkLinearVelocityAffector",
|
2019-02-26 15:02:15 +00:00
|
|
|
"Enabled": true,
|
2019-02-14 21:55:21 +00:00
|
|
|
"Force": false,
|
2019-02-26 19:58:40 +00:00
|
|
|
"Frame": "World",
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
"Angle": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Constant",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": true,
|
|
|
|
|
"Bidirectional": false,
|
2019-02-22 16:48:18 +00:00
|
|
|
"A0": -10,
|
2019-02-27 16:19:19 +00:00
|
|
|
"A1": 10
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
},
|
|
|
|
|
"Strength": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Constant",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": true,
|
|
|
|
|
"Bidirectional": false,
|
|
|
|
|
"A0": 50,
|
2019-02-27 16:19:19 +00:00
|
|
|
"A1": 60
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"Update": [
|
|
|
|
|
{
|
|
|
|
|
"Type": "SkLinearVelocityAffector",
|
2019-02-26 15:02:15 +00:00
|
|
|
"Enabled": true,
|
2019-02-14 21:55:21 +00:00
|
|
|
"Force": true,
|
2019-02-26 19:58:40 +00:00
|
|
|
"Frame": "World",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Angle": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Constant",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": false,
|
|
|
|
|
"Bidirectional": false,
|
2019-02-27 16:19:19 +00:00
|
|
|
"A0": 90
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"Strength": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Cubic",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": false,
|
|
|
|
|
"Bidirectional": true,
|
|
|
|
|
"A0": 180,
|
|
|
|
|
"B0": -90,
|
|
|
|
|
"C0": -120,
|
2019-02-27 16:19:19 +00:00
|
|
|
"D0": -200
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
"Type": "SkSizeAffector",
|
2019-02-26 15:02:15 +00:00
|
|
|
"Enabled": true,
|
2019-02-14 21:55:21 +00:00
|
|
|
"Curve": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-14 21:55:21 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Linear",
|
2019-02-14 21:55:21 +00:00
|
|
|
"Ranged": false,
|
|
|
|
|
"Bidirectional": false,
|
2019-02-15 19:29:38 +00:00
|
|
|
"A0": 3,
|
2019-02-27 16:19:19 +00:00
|
|
|
"D0": 1.5
|
2019-02-14 21:55:21 +00:00
|
|
|
}
|
|
|
|
|
]
|
|
|
|
|
}
|
2019-02-20 17:25:20 +00:00
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
"Type": "SkColorAffector",
|
2019-02-26 15:02:15 +00:00
|
|
|
"Enabled": true,
|
2019-02-20 17:25:20 +00:00
|
|
|
"Curve": {
|
2019-03-04 15:55:22 +00:00
|
|
|
"Input": {
|
|
|
|
|
"Source": "Age",
|
|
|
|
|
"TileMode": "Repeat",
|
|
|
|
|
"Left": 0,
|
|
|
|
|
"Right": 1
|
|
|
|
|
},
|
2019-02-20 17:25:20 +00:00
|
|
|
"XValues": [],
|
|
|
|
|
"Segments": [
|
|
|
|
|
{
|
2019-02-27 16:19:19 +00:00
|
|
|
"Type": "Linear",
|
2019-02-20 17:25:20 +00:00
|
|
|
"Ranged": true,
|
|
|
|
|
"A0": [ 0.0999616, 0.140218, 0.784314, 1 ],
|
|
|
|
|
"D0": [ 0.523837, 0.886396, 0.980392, 1 ],
|
|
|
|
|
"A1": [ 0.378665, 0.121107, 0.705882, 1 ],
|
|
|
|
|
"D1": [ 0.934257, 0.229599, 0.955882, 1 ]
|
|
|
|
|
}
|
|
|
|
|
]
|
|
|
|
|
}
|
Experimental Particle System
This adds a new "Particles" slide to viewer, that allows
editing, loading, and saving particle effects. All of the
particle system code is in modules/particles.
There are many rough edges and some not-yet-finished changes
to generalize the model[1]. A rough overview:
- SkReflected.h implements a lightweight reflection system
for classes derived from SkReflected. Adding a new class
involves deriving from SkReflected, adding a macro to the
class declaration, and implementing visitFields(), which
simply calls a virtual on an SkFieldVisitor for each field.
Currently, emitters and affectors use this mechanism.
- SkParticleSerialization.h demonstrates two useful field
visitors - for serializing to and from JSON. The driver
code that uses those is directly in ParticlesSlide.
- SkParticleData.h and SkCurve.h define a variety of helper
types for talking about particles, both for parameterizing
individual values, and communicating about the state of a
particle among the effect, affectors, and emitters.
- SkParticleEffect.h defines the static data definition of
an effect (SkParticleEffectParams), as well as a running
instance of an effect (SkParticleEffect). The effect has
simple update() and draw() methods.
- ParticlesSlide.cpp adds a third field visitor to generate
GUIs for interactively editing the running effect.
---
1: The critical change I'd like to make is to remove all
special case behavior over time and at spawn (setting sprite
frames, size over time, color over time, etc...). Integration
is the only fixed function behavior. Everything else is driven
by two lists of affectors. One is applied at spawn time, using
the effect's lifetime to evaluate curves. This allows spawning
particles with different colors as the effect ages out, for
example. The second list is applied every frame to update
existing particles, and is driven by the particle's lifetime.
This allows particles to change color after being spawned, for
example.
With a small set of affectors using a single expressive curve
primitive (keyframed list of cubic curve segments), we can
have affectors that update color, size, velocity, position,
sprite frame, etc., and implement many complex behaviors.
Bug: skia:
Change-Id: Id9402bef22825d55d021c5a2f9e5e41791aabaf4
Reviewed-on: https://skia-review.googlesource.com/c/181404
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 18:27:51 +00:00
|
|
|
}
|
|
|
|
|
]
|
|
|
|
|
}
|