gaming/godot
gaming/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot synced 2024-09-16 02:27:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename ParticlesMaterial to ParticleProcessMaterial

Browse source 
Also affects their file names, related classes and documentation.
This commit is contained in:
Micky 2022-08-18 11:09:22 +02:00
parent 9876382df8
commit 723bf85145
30 changed files with 291 additions and 289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
doc/classes/BaseMaterial3D.xml
View file

@ -718,7 +718,7 @@
</constant> </constant>
<constant name="BILLBOARD_PARTICLES" value="3" enum="BillboardMode"> <constant name="BILLBOARD_PARTICLES" value="3" enum="BillboardMode">
Used for particle systems when assigned to [GPUParticles3D] and [CPUParticles3D] nodes. Enables [code]particles_anim_*[/code] properties. Used for particle systems when assigned to [GPUParticles3D] and [CPUParticles3D] nodes. Enables [code]particles_anim_*[/code] properties.
The [member ParticlesMaterial.anim_speed_min] or [member CPUParticles3D.anim_speed_min] should also be set to a value bigger than zero for the animation to play. The [member ParticleProcessMaterial.anim_speed_min] or [member CPUParticles3D.anim_speed_min] should also be set to a value bigger than zero for the animation to play.
</constant> </constant>
<constant name="TEXTURE_CHANNEL_RED" value="0" enum="TextureChannel"> <constant name="TEXTURE_CHANNEL_RED" value="0" enum="TextureChannel">
Used to read from the red channel of a texture. Used to read from the red channel of a texture.

2
doc/classes/CPUParticles2D.xml
View file

@ -15,7 +15,7 @@
<return type="void" /> <return type="void" />
<param index="0" name="particles" type="Node" /> <param index="0" name="particles" type="Node" />
<description> <description>
Sets this node's properties to match a given [GPUParticles2D] node with an assigned [ParticlesMaterial]. Sets this node's properties to match a given [GPUParticles2D] node with an assigned [ParticleProcessMaterial].
</description> </description>
</method> </method>
<method name="get_param_curve" qualifiers="const"> <method name="get_param_curve" qualifiers="const">

2
doc/classes/CPUParticles3D.xml
View file

@ -14,7 +14,7 @@
<return type="void" /> <return type="void" />
<param index="0" name="particles" type="Node" /> <param index="0" name="particles" type="Node" />
<description> <description>
Sets this node's properties to match a given [GPUParticles3D] node with an assigned [ParticlesMaterial]. Sets this node's properties to match a given [GPUParticles3D] node with an assigned [ParticleProcessMaterial].
</description> </description>
</method> </method>
<method name="get_param_curve" qualifiers="const"> <method name="get_param_curve" qualifiers="const">

2
doc/classes/CanvasItemMaterial.xml
View file

@ -28,7 +28,7 @@
[b]Note:[/b] This property is only used and visible in the editor if [member particles_animation] is [code]true[/code]. [b]Note:[/b] This property is only used and visible in the editor if [member particles_animation] is [code]true[/code].
</member> </member>
<member name="particles_animation" type="bool" setter="set_particles_animation" getter="get_particles_animation" default="false"> <member name="particles_animation" type="bool" setter="set_particles_animation" getter="get_particles_animation" default="false">
If [code]true[/code], enable spritesheet-based animation features when assigned to [GPUParticles2D] and [CPUParticles2D] nodes. The [member ParticlesMaterial.anim_speed_max] or [member CPUParticles2D.anim_speed_max] should also be set to a positive value for the animation to play. If [code]true[/code], enable spritesheet-based animation features when assigned to [GPUParticles2D] and [CPUParticles2D] nodes. The [member ParticleProcessMaterial.anim_speed_max] or [member CPUParticles2D.anim_speed_max] should also be set to a positive value for the animation to play.
This property (and other [code]particles_anim_*[/code] properties that depend on it) has no effect on other types of nodes. This property (and other [code]particles_anim_*[/code] properties that depend on it) has no effect on other types of nodes.
</member> </member>
</members> </members>

4
doc/classes/GPUParticles2D.xml
View file

@ -5,7 +5,7 @@
</brief_description> </brief_description>
<description> <description>
2D particle node used to create a variety of particle systems and effects. [GPUParticles2D] features an emitter that generates some number of particles at a given rate. 2D particle node used to create a variety of particle systems and effects. [GPUParticles2D] features an emitter that generates some number of particles at a given rate.
Use the [code]process_material[/code] property to add a [ParticlesMaterial] to configure particle appearance and behavior. Alternatively, you can add a [ShaderMaterial] which will be applied to all particles. Use the [code]process_material[/code] property to add a [ParticleProcessMaterial] to configure particle appearance and behavior. Alternatively, you can add a [ShaderMaterial] which will be applied to all particles.
</description> </description>
<tutorials> <tutorials>
<link title="Particle systems (2D)">$DOCS_URL/tutorials/2d/particle_systems_2d.html</link> <link title="Particle systems (2D)">$DOCS_URL/tutorials/2d/particle_systems_2d.html</link>
@ -73,7 +73,7 @@
Particle system starts as if it had already run for this many seconds. Particle system starts as if it had already run for this many seconds.
</member> </member>
<member name="process_material" type="Material" setter="set_process_material" getter="get_process_material"> <member name="process_material" type="Material" setter="set_process_material" getter="get_process_material">
[Material] for processing particles. Can be a [ParticlesMaterial] or a [ShaderMaterial]. [Material] for processing particles. Can be a [ParticleProcessMaterial] or a [ShaderMaterial].
</member> </member>
<member name="randomness" type="float" setter="set_randomness_ratio" getter="get_randomness_ratio" default="0.0"> <member name="randomness" type="float" setter="set_randomness_ratio" getter="get_randomness_ratio" default="0.0">
Emission lifetime randomness ratio. Emission lifetime randomness ratio.

4
doc/classes/GPUParticles3D.xml
View file

@ -5,7 +5,7 @@
</brief_description> </brief_description>
<description> <description>
3D particle node used to create a variety of particle systems and effects. [GPUParticles3D] features an emitter that generates some number of particles at a given rate. 3D particle node used to create a variety of particle systems and effects. [GPUParticles3D] features an emitter that generates some number of particles at a given rate.
Use the [code]process_material[/code] property to add a [ParticlesMaterial] to configure particle appearance and behavior. Alternatively, you can add a [ShaderMaterial] which will be applied to all particles. Use the [code]process_material[/code] property to add a [ParticleProcessMaterial] to configure particle appearance and behavior. Alternatively, you can add a [ShaderMaterial] which will be applied to all particles.
</description> </description>
<tutorials> <tutorials>
<link title="Controlling thousands of fish with Particles">$DOCS_URL/tutorials/performance/vertex_animation/controlling_thousands_of_fish.html</link> <link title="Controlling thousands of fish with Particles">$DOCS_URL/tutorials/performance/vertex_animation/controlling_thousands_of_fish.html</link>
@ -105,7 +105,7 @@
Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting.
</member> </member>
<member name="process_material" type="Material" setter="set_process_material" getter="get_process_material"> <member name="process_material" type="Material" setter="set_process_material" getter="get_process_material">
[Material] for processing particles. Can be a [ParticlesMaterial] or a [ShaderMaterial]. [Material] for processing particles. Can be a [ParticleProcessMaterial] or a [ShaderMaterial].
</member> </member>
<member name="randomness" type="float" setter="set_randomness_ratio" getter="get_randomness_ratio" default="0.0"> <member name="randomness" type="float" setter="set_randomness_ratio" getter="get_randomness_ratio" default="0.0">
Emission randomness ratio. Emission randomness ratio.

2
doc/classes/GPUParticlesAttractor3D.xml
View file

@ -18,7 +18,7 @@
<member name="cull_mask" type="int" setter="set_cull_mask" getter="get_cull_mask" default="4294967295"> <member name="cull_mask" type="int" setter="set_cull_mask" getter="get_cull_mask" default="4294967295">
The particle rendering layers ([member VisualInstance3D.layers]) that will be affected by the attractor. By default, all particles are affected by an attractor. The particle rendering layers ([member VisualInstance3D.layers]) that will be affected by the attractor. By default, all particles are affected by an attractor.
After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by attractors. For example, this can be used if you're using an attractor as part of a spell effect but don't want the attractor to affect unrelated weather particles at the same position. After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by attractors. For example, this can be used if you're using an attractor as part of a spell effect but don't want the attractor to affect unrelated weather particles at the same position.
Particle attraction can also be disabled on a per-process material basis by setting [member ParticlesMaterial.attractor_interaction_enabled] on the [GPUParticles3D] node. Particle attraction can also be disabled on a per-process material basis by setting [member ParticleProcessMaterial.attractor_interaction_enabled] on the [GPUParticles3D] node.
</member> </member>
<member name="directionality" type="float" setter="set_directionality" getter="get_directionality" default="0.0"> <member name="directionality" type="float" setter="set_directionality" getter="get_directionality" default="0.0">
Adjusts how directional the attractor is. At [code]0.0[/code], the attractor is not directional at all: it will attract particles towards its center. At [code]1.0[/code], the attractor is fully directional: particles will always be pushed towards local -Z (or +Z if [member strength] is negative). Adjusts how directional the attractor is. At [code]0.0[/code], the attractor is not directional at all: it will attract particles towards its center. At [code]1.0[/code], the attractor is fully directional: particles will always be pushed towards local -Z (or +Z if [member strength] is negative).

6
doc/classes/GPUParticlesCollision3D.xml
View file

@ -7,7 +7,7 @@
Particle collision shapes can be used to make particles stop or bounce against them. Particle collision shapes can be used to make particles stop or bounce against them.
Particle collision shapes in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is [i]not[/i] supported. Particle collision shapes in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is [i]not[/i] supported.
Particle collision shapes can be temporarily disabled by hiding them. Particle collision shapes can be temporarily disabled by hiding them.
[b]Note:[/b] [member ParticlesMaterial.collision_mode] must be [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work. [b]Note:[/b] [member ParticleProcessMaterial.collision_mode] must be [constant ParticleProcessMaterial.COLLISION_RIGID] or [constant ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work.
[b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D]. [b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D].
[b]Note:[/b] Particles pushed by a collider that is being moved will not be interpolated, which can result in visible stuttering. This can be alleviated by setting [member GPUParticles3D.fixed_fps] to [code]0[/code] or a value that matches or exceeds the target framerate. [b]Note:[/b] Particles pushed by a collider that is being moved will not be interpolated, which can result in visible stuttering. This can be alleviated by setting [member GPUParticles3D.fixed_fps] to [code]0[/code] or a value that matches or exceeds the target framerate.
</description> </description>
@ -15,9 +15,9 @@
</tutorials> </tutorials>
<members> <members>
<member name="cull_mask" type="int" setter="set_cull_mask" getter="get_cull_mask" default="4294967295"> <member name="cull_mask" type="int" setter="set_cull_mask" getter="get_cull_mask" default="4294967295">
The particle rendering layers ([member VisualInstance3D.layers]) that will be affected by the collision shape. By default, all particles that have [member ParticlesMaterial.collision_mode] set to [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] will be affected by a collision shape. The particle rendering layers ([member VisualInstance3D.layers]) that will be affected by the collision shape. By default, all particles that have [member ParticleProcessMaterial.collision_mode] set to [constant ParticleProcessMaterial.COLLISION_RIGID] or [constant ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT] will be affected by a collision shape.
After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by attractors. For example, this can be used if you're using an attractor as part of a spell effect but don't want the attractor to affect unrelated weather particles at the same position. After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by attractors. For example, this can be used if you're using an attractor as part of a spell effect but don't want the attractor to affect unrelated weather particles at the same position.
Particle attraction can also be disabled on a per-process material basis by setting [member ParticlesMaterial.attractor_interaction_enabled] on the [GPUParticles3D] node. Particle attraction can also be disabled on a per-process material basis by setting [member ParticleProcessMaterial.attractor_interaction_enabled] on the [GPUParticles3D] node.
</member> </member>
</members> </members>
</class> </class>

2
doc/classes/GPUParticlesCollisionBox3D.xml
View file

@ -5,7 +5,7 @@
</brief_description> </brief_description>
<description> <description>
Box-shaped 3D particle collision shape affecting [GPUParticles3D] nodes. Box-shaped 3D particle collision shape affecting [GPUParticles3D] nodes.
[b]Note:[/b] [member ParticlesMaterial.collision_mode] must be [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work. [b]Note:[/b] [member ParticleProcessMaterial.collision_mode] must be [constant ParticleProcessMaterial.COLLISION_RIGID] or [constant ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work.
[b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D]. [b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D].
</description> </description>
<tutorials> <tutorials>

2
doc/classes/GPUParticlesCollisionHeightField3D.xml
View file

@ -7,7 +7,7 @@
Real-time heightmap-shaped 3D particle attractor affecting [GPUParticles3D] nodes. Real-time heightmap-shaped 3D particle attractor affecting [GPUParticles3D] nodes.
Heightmap shapes allow for efficiently representing collisions for convex and concave objects with a single "floor" (such as terrain). This is less flexible than [GPUParticlesCollisionSDF3D], but it doesn't require a baking step. Heightmap shapes allow for efficiently representing collisions for convex and concave objects with a single "floor" (such as terrain). This is less flexible than [GPUParticlesCollisionSDF3D], but it doesn't require a baking step.
[GPUParticlesCollisionHeightField3D] can also be regenerated in real-time when it is moved, when the camera moves, or even continuously. This makes [GPUParticlesCollisionHeightField3D] a good choice for weather effects such as rain and snow and games with highly dynamic geometry. However, since heightmaps cannot represent overhangs, [GPUParticlesCollisionHeightField3D] is not suited for indoor particle collision. [GPUParticlesCollisionHeightField3D] can also be regenerated in real-time when it is moved, when the camera moves, or even continuously. This makes [GPUParticlesCollisionHeightField3D] a good choice for weather effects such as rain and snow and games with highly dynamic geometry. However, since heightmaps cannot represent overhangs, [GPUParticlesCollisionHeightField3D] is not suited for indoor particle collision.
[b]Note:[/b] [member ParticlesMaterial.collision_mode] must be [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work. [b]Note:[/b] [member ParticleProcessMaterial.collision_mode] must be [code]true[/code] on the [GPUParticles3D]'s process material for collision to work.
[b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D]. [b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D].
</description> </description>
<tutorials> <tutorials>

2
doc/classes/GPUParticlesCollisionSDF3D.xml
View file

@ -8,7 +8,7 @@
Signed distance fields (SDF) allow for efficiently representing approximate collision shapes for convex and concave objects of any shape. This is more flexible than [GPUParticlesCollisionHeightField3D], but it requires a baking step. Signed distance fields (SDF) allow for efficiently representing approximate collision shapes for convex and concave objects of any shape. This is more flexible than [GPUParticlesCollisionHeightField3D], but it requires a baking step.
[b]Baking:[/b] The signed distance field texture can be baked by selecting the [GPUParticlesCollisionSDF3D] node in the editor, then clicking [b]Bake SDF[/b] at the top of the 3D viewport. Any [i]visible[/i] [MeshInstance3D]s touching the [member extents] will be taken into account for baking, regardless of their [member GeometryInstance3D.gi_mode]. [b]Baking:[/b] The signed distance field texture can be baked by selecting the [GPUParticlesCollisionSDF3D] node in the editor, then clicking [b]Bake SDF[/b] at the top of the 3D viewport. Any [i]visible[/i] [MeshInstance3D]s touching the [member extents] will be taken into account for baking, regardless of their [member GeometryInstance3D.gi_mode].
[b]Note:[/b] Baking a [GPUParticlesCollisionSDF3D]'s [member texture] is only possible within the editor, as there is no bake method exposed for use in exported projects. However, it's still possible to load pre-baked [Texture3D]s into its [member texture] property in an exported project. [b]Note:[/b] Baking a [GPUParticlesCollisionSDF3D]'s [member texture] is only possible within the editor, as there is no bake method exposed for use in exported projects. However, it's still possible to load pre-baked [Texture3D]s into its [member texture] property in an exported project.
[b]Note:[/b] [member ParticlesMaterial.collision_mode] must be [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work. [b]Note:[/b] [member ParticleProcessMaterial.collision_mode] must be [constant ParticleProcessMaterial.COLLISION_RIGID] or [constant ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work.
[b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D]. [b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D].
</description> </description>
<tutorials> <tutorials>

2
doc/classes/GPUParticlesCollisionSphere3D.xml
View file

@ -5,7 +5,7 @@
</brief_description> </brief_description>
<description> <description>
Sphere-shaped 3D particle collision shape affecting [GPUParticles3D] nodes. Sphere-shaped 3D particle collision shape affecting [GPUParticles3D] nodes.
[b]Note:[/b] [member ParticlesMaterial.collision_mode] must be [constant ParticlesMaterial.COLLISION_RIGID] or [constant ParticlesMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work. [b]Note:[/b] [member ParticleProcessMaterial.collision_mode] must be [constant ParticleProcessMaterial.COLLISION_RIGID] or [constant ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT] on the [GPUParticles3D]'s process material for collision to work.
[b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D]. [b]Note:[/b] Particle collision only affects [GPUParticles3D], not [CPUParticles3D].
</description> </description>
<tutorials> <tutorials>

26
doc/classes/ParticlesMaterial.xml → doc/classes/ParticleProcessMaterial.xml
View file

@ -1,10 +1,10 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8" ?>
<class name="ParticlesMaterial" inherits="Material" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd"> <class name="ParticleProcessMaterial" inherits="Material" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description> <brief_description>
Particle properties for [GPUParticles3D] and [GPUParticles2D] nodes. Particle properties for [GPUParticles3D] and [GPUParticles2D] nodes.
</brief_description> </brief_description>
<description> <description>
ParticlesMaterial defines particle properties and behavior. It is used in the [code]process_material[/code] of [GPUParticles3D] and [GPUParticles2D] emitter nodes. ParticleProcessMaterial defines particle properties and behavior. It is used in the [code]process_material[/code] of [GPUParticles3D] and [GPUParticles2D] emitter nodes.
Some of this material's properties are applied to each particle when emitted, while others can have a [CurveTexture] applied to vary values over the lifetime of the particle. Some of this material's properties are applied to each particle when emitted, while others can have a [CurveTexture] applied to vary values over the lifetime of the particle.
Particle animation is available only in [GPUParticles2D]. To use it, attach a [CanvasItemMaterial], with [member CanvasItemMaterial.particles_animation] enabled, to the particles node. Particle animation is available only in [GPUParticles2D]. To use it, attach a [CanvasItemMaterial], with [member CanvasItemMaterial.particles_animation] enabled, to the particles node.
</description> </description>
@ -13,35 +13,35 @@
<methods> <methods>
<method name="get_param_max" qualifiers="const"> <method name="get_param_max" qualifiers="const">
<return type="float" /> <return type="float" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<description> <description>
Returns the maximum value range for the given parameter. Returns the maximum value range for the given parameter.
</description> </description>
</method> </method>
<method name="get_param_min" qualifiers="const"> <method name="get_param_min" qualifiers="const">
<return type="float" /> <return type="float" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<description> <description>
Returns the minimum value range for the given parameter. Returns the minimum value range for the given parameter.
</description> </description>
</method> </method>
<method name="get_param_texture" qualifiers="const"> <method name="get_param_texture" qualifiers="const">
<return type="Texture2D" /> <return type="Texture2D" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<description> <description>
Returns the [Texture2D] used by the specified parameter. Returns the [Texture2D] used by the specified parameter.
</description> </description>
</method> </method>
<method name="get_particle_flag" qualifiers="const"> <method name="get_particle_flag" qualifiers="const">
<return type="bool" /> <return type="bool" />
<param index="0" name="particle_flag" type="int" enum="ParticlesMaterial.ParticleFlags" /> <param index="0" name="particle_flag" type="int" enum="ParticleProcessMaterial.ParticleFlags" />
<description> <description>
Returns [code]true[/code] if the specified particle flag is enabled. See [enum ParticleFlags] for options. Returns [code]true[/code] if the specified particle flag is enabled. See [enum ParticleFlags] for options.
</description> </description>
</method> </method>
<method name="set_param_max"> <method name="set_param_max">
<return type="void" /> <return type="void" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<param index="1" name="value" type="float" /> <param index="1" name="value" type="float" />
<description> <description>
Sets the maximum value range for the given parameter. Sets the maximum value range for the given parameter.
@ -49,7 +49,7 @@
</method> </method>
<method name="set_param_min"> <method name="set_param_min">
<return type="void" /> <return type="void" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<param index="1" name="value" type="float" /> <param index="1" name="value" type="float" />
<description> <description>
Sets the minimum value range for the given parameter. Sets the minimum value range for the given parameter.
@ -57,7 +57,7 @@
</method> </method>
<method name="set_param_texture"> <method name="set_param_texture">
<return type="void" /> <return type="void" />
<param index="0" name="param" type="int" enum="ParticlesMaterial.Parameter" /> <param index="0" name="param" type="int" enum="ParticleProcessMaterial.Parameter" />
<param index="1" name="texture" type="Texture2D" /> <param index="1" name="texture" type="Texture2D" />
<description> <description>
Sets the [Texture2D] for the specified [enum Parameter]. Sets the [Texture2D] for the specified [enum Parameter].
@ -65,7 +65,7 @@
</method> </method>
<method name="set_particle_flag"> <method name="set_particle_flag">
<return type="void" /> <return type="void" />
<param index="0" name="particle_flag" type="int" enum="ParticlesMaterial.ParticleFlags" /> <param index="0" name="particle_flag" type="int" enum="ParticleProcessMaterial.ParticleFlags" />
<param index="1" name="enable" type="bool" /> <param index="1" name="enable" type="bool" />
<description> <description>
If [code]true[/code], enables the specified particle flag. See [enum ParticleFlags] for options. If [code]true[/code], enables the specified particle flag. See [enum ParticleFlags] for options.
@ -121,7 +121,7 @@
<member name="collision_friction" type="float" setter="set_collision_friction" getter="get_collision_friction"> <member name="collision_friction" type="float" setter="set_collision_friction" getter="get_collision_friction">
The particles' friction. Values range from [code]0[/code] (frictionless) to [code]1[/code] (maximum friction). Only effective if [member collision_mode] is [constant COLLISION_RIGID]. The particles' friction. Values range from [code]0[/code] (frictionless) to [code]1[/code] (maximum friction). Only effective if [member collision_mode] is [constant COLLISION_RIGID].
</member> </member>
<member name="collision_mode" type="int" setter="set_collision_mode" getter="get_collision_mode" enum="ParticlesMaterial.CollisionMode" default="0"> <member name="collision_mode" type="int" setter="set_collision_mode" getter="get_collision_mode" enum="ParticleProcessMaterial.CollisionMode" default="0">
The particles' collision mode. The particles' collision mode.
[b]Note:[/b] Particles can only collide with [GPUParticlesCollision3D] nodes, not [PhysicsBody3D] nodes. To make particles collide with various objects, you can add [GPUParticlesCollision3D] nodes as children of [PhysicsBody3D] nodes. [b]Note:[/b] Particles can only collide with [GPUParticlesCollision3D] nodes, not [PhysicsBody3D] nodes. To make particles collide with various objects, you can add [GPUParticlesCollision3D] nodes as children of [PhysicsBody3D] nodes.
</member> </member>
@ -176,7 +176,7 @@
<member name="emission_ring_radius" type="float" setter="set_emission_ring_radius" getter="get_emission_ring_radius"> <member name="emission_ring_radius" type="float" setter="set_emission_ring_radius" getter="get_emission_ring_radius">
The radius of the ring when using the emitter [constant EMISSION_SHAPE_RING]. The radius of the ring when using the emitter [constant EMISSION_SHAPE_RING].
</member> </member>
<member name="emission_shape" type="int" setter="set_emission_shape" getter="get_emission_shape" enum="ParticlesMaterial.EmissionShape" default="0"> <member name="emission_shape" type="int" setter="set_emission_shape" getter="get_emission_shape" enum="ParticleProcessMaterial.EmissionShape" default="0">
Particles will be emitted inside this region. Use [enum EmissionShape] constants for values. Particles will be emitted inside this region. Use [enum EmissionShape] constants for values.
</member> </member>
<member name="emission_sphere_radius" type="float" setter="set_emission_sphere_radius" getter="get_emission_sphere_radius"> <member name="emission_sphere_radius" type="float" setter="set_emission_sphere_radius" getter="get_emission_sphere_radius">
@ -261,7 +261,7 @@
</member> </member>
<member name="sub_emitter_keep_velocity" type="bool" setter="set_sub_emitter_keep_velocity" getter="get_sub_emitter_keep_velocity" default="false"> <member name="sub_emitter_keep_velocity" type="bool" setter="set_sub_emitter_keep_velocity" getter="get_sub_emitter_keep_velocity" default="false">
</member> </member>
<member name="sub_emitter_mode" type="int" setter="set_sub_emitter_mode" getter="get_sub_emitter_mode" enum="ParticlesMaterial.SubEmitterMode" default="0"> <member name="sub_emitter_mode" type="int" setter="set_sub_emitter_mode" getter="get_sub_emitter_mode" enum="ParticleProcessMaterial.SubEmitterMode" default="0">
</member> </member>
<member name="tangential_accel_curve" type="Texture2D" setter="set_param_texture" getter="get_param_texture"> <member name="tangential_accel_curve" type="Texture2D" setter="set_param_texture" getter="get_param_texture">
Each particle's tangential acceleration will vary along this [CurveTexture]. Each particle's tangential acceleration will vary along this [CurveTexture].

2
editor/editor_node.cpp
View file

@ -7294,7 +7294,7 @@ EditorNode::EditorNode() {
canvas_item_mat_convert.instantiate(); canvas_item_mat_convert.instantiate();
resource_conversion_plugins.push_back(canvas_item_mat_convert); resource_conversion_plugins.push_back(canvas_item_mat_convert);
Ref<ParticlesMaterialConversionPlugin> particles_mat_convert; Ref<ParticleProcessMaterialConversionPlugin> particles_mat_convert;
particles_mat_convert.instantiate(); particles_mat_convert.instantiate();
resource_conversion_plugins.push_back(particles_mat_convert); resource_conversion_plugins.push_back(particles_mat_convert);

0
editor/icons/ParticlesMaterial.svg → editor/icons/ParticleProcessMaterial.svg
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 883 B

After

Width:  |  Height:  |  Size: 883 B

2
editor/plugins/cpu_particles_2d_editor_plugin.cpp
View file

@ -37,7 +37,7 @@
#include "editor/editor_undo_redo_manager.h" #include "editor/editor_undo_redo_manager.h"
#include "scene/2d/cpu_particles_2d.h" #include "scene/2d/cpu_particles_2d.h"
#include "scene/gui/separator.h" #include "scene/gui/separator.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
void CPUParticles2DEditorPlugin::edit(Object *p_object) { void CPUParticles2DEditorPlugin::edit(Object *p_object) {
particles = Object::cast_to<CPUParticles2D>(p_object); particles = Object::cast_to<CPUParticles2D>(p_object);

10
editor/plugins/gpu_particles_2d_editor_plugin.cpp
View file

@ -38,7 +38,7 @@
#include "editor/scene_tree_dock.h" #include "editor/scene_tree_dock.h"
#include "scene/2d/cpu_particles_2d.h" #include "scene/2d/cpu_particles_2d.h"
#include "scene/gui/separator.h" #include "scene/gui/separator.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
void GPUParticles2DEditorPlugin::edit(Object *p_object) { void GPUParticles2DEditorPlugin::edit(Object *p_object) {
particles = Object::cast_to<GPUParticles2D>(p_object); particles = Object::cast_to<GPUParticles2D>(p_object);
@ -167,9 +167,9 @@ void GPUParticles2DEditorPlugin::_generate_visibility_rect() {
} }
void GPUParticles2DEditorPlugin::_generate_emission_mask() { void GPUParticles2DEditorPlugin::_generate_emission_mask() {
Ref<ParticlesMaterial> pm = particles->get_process_material(); Ref<ParticleProcessMaterial> pm = particles->get_process_material();
if (!pm.is_valid()) { if (!pm.is_valid()) {
EditorNode::get_singleton()->show_warning(TTR("Can only set point into a ParticlesMaterial process material")); EditorNode::get_singleton()->show_warning(TTR("Can only set point into a ParticleProcessMaterial process material"));
return; return;
} }
@ -320,7 +320,7 @@ void GPUParticles2DEditorPlugin::_generate_emission_mask() {
} }
if (valid_normals.size()) { if (valid_normals.size()) {
pm->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_DIRECTED_POINTS); pm->set_emission_shape(ParticleProcessMaterial::EMISSION_SHAPE_DIRECTED_POINTS);
Vector<uint8_t> normdata; Vector<uint8_t> normdata;
normdata.resize(w * h * 2 * sizeof(float)); //use RG texture normdata.resize(w * h * 2 * sizeof(float)); //use RG texture
@ -339,7 +339,7 @@ void GPUParticles2DEditorPlugin::_generate_emission_mask() {
pm->set_emission_normal_texture(ImageTexture::create_from_image(img)); pm->set_emission_normal_texture(ImageTexture::create_from_image(img));
} else { } else {
pm->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_POINTS); pm->set_emission_shape(ParticleProcessMaterial::EMISSION_SHAPE_POINTS);
} }
} }

12
editor/plugins/gpu_particles_3d_editor_plugin.cpp
View file

@ -36,7 +36,7 @@
#include "editor/plugins/node_3d_editor_plugin.h" #include "editor/plugins/node_3d_editor_plugin.h"
#include "editor/scene_tree_dock.h" #include "editor/scene_tree_dock.h"
#include "scene/3d/cpu_particles_3d.h" #include "scene/3d/cpu_particles_3d.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
bool GPUParticles3DEditorBase::_generate(Vector<Vector3> &points, Vector<Vector3> &normals) { bool GPUParticles3DEditorBase::_generate(Vector<Vector3> &points, Vector<Vector3> &normals) {
bool use_normals = emission_fill->get_selected() == 1; bool use_normals = emission_fill->get_selected() == 1;
@ -255,9 +255,9 @@ void GPUParticles3DEditor::_menu_option(int p_option) {
} }
} break; } break;
case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE: { case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE: {
Ref<ParticlesMaterial> material = node->get_process_material(); Ref<ParticleProcessMaterial> material = node->get_process_material();
if (material.is_null()) { if (material.is_null()) {
EditorNode::get_singleton()->show_warning(TTR("A processor material of type 'ParticlesMaterial' is required.")); EditorNode::get_singleton()->show_warning(TTR("A processor material of type 'ParticleProcessMaterial' is required."));
return; return;
} }
@ -366,11 +366,11 @@ void GPUParticles3DEditor::_generate_emission_points() {
Ref<Image> image = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img)); Ref<Image> image = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img));
Ref<ImageTexture> tex = ImageTexture::create_from_image(image); Ref<ImageTexture> tex = ImageTexture::create_from_image(image);
Ref<ParticlesMaterial> material = node->get_process_material(); Ref<ParticleProcessMaterial> material = node->get_process_material();
ERR_FAIL_COND(material.is_null()); ERR_FAIL_COND(material.is_null());
if (normals.size() > 0) { if (normals.size() > 0) {
material->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_DIRECTED_POINTS); material->set_emission_shape(ParticleProcessMaterial::EMISSION_SHAPE_DIRECTED_POINTS);
material->set_emission_point_count(point_count); material->set_emission_point_count(point_count);
material->set_emission_point_texture(tex); material->set_emission_point_texture(tex);
@ -392,7 +392,7 @@ void GPUParticles3DEditor::_generate_emission_points() {
Ref<Image> image2 = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img2)); Ref<Image> image2 = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img2));
material->set_emission_normal_texture(ImageTexture::create_from_image(image2)); material->set_emission_normal_texture(ImageTexture::create_from_image(image2));
} else { } else {
material->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_POINTS); material->set_emission_shape(ParticleProcessMaterial::EMISSION_SHAPE_POINTS);
material->set_emission_point_count(point_count); material->set_emission_point_count(point_count);
material->set_emission_point_texture(tex); material->set_emission_point_texture(tex);
} }

12
editor/plugins/material_editor_plugin.cpp
View file

@ -36,7 +36,7 @@
#include "editor/editor_undo_redo_manager.h" #include "editor/editor_undo_redo_manager.h"
#include "scene/gui/subviewport_container.h" #include "scene/gui/subviewport_container.h"
#include "scene/resources/fog_material.h" #include "scene/resources/fog_material.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
#include "scene/resources/sky_material.h" #include "scene/resources/sky_material.h"
void MaterialEditor::_notification(int p_what) { void MaterialEditor::_notification(int p_what) {
@ -405,17 +405,17 @@ Ref<Resource> ORMMaterial3DConversionPlugin::convert(const Ref<Resource> &p_reso
return smat; return smat;
} }
String ParticlesMaterialConversionPlugin::converts_to() const { String ParticleProcessMaterialConversionPlugin::converts_to() const {
return "ShaderMaterial"; return "ShaderMaterial";
} }
bool ParticlesMaterialConversionPlugin::handles(const Ref<Resource> &p_resource) const { bool ParticleProcessMaterialConversionPlugin::handles(const Ref<Resource> &p_resource) const {
Ref<ParticlesMaterial> mat = p_resource; Ref<ParticleProcessMaterial> mat = p_resource;
return mat.is_valid(); return mat.is_valid();
} }
Ref<Resource> ParticlesMaterialConversionPlugin::convert(const Ref<Resource> &p_resource) const { Ref<Resource> ParticleProcessMaterialConversionPlugin::convert(const Ref<Resource> &p_resource) const {
Ref<ParticlesMaterial> mat = p_resource; Ref<ParticleProcessMaterial> mat = p_resource;
ERR_FAIL_COND_V(!mat.is_valid(), Ref<Resource>()); ERR_FAIL_COND_V(!mat.is_valid(), Ref<Resource>());
Ref<ShaderMaterial> smat; Ref<ShaderMaterial> smat;

4
editor/plugins/material_editor_plugin.h
View file

@ -122,8 +122,8 @@ public:
virtual Ref<Resource> convert(const Ref<Resource> &p_resource) const override; virtual Ref<Resource> convert(const Ref<Resource> &p_resource) const override;
}; };
class ParticlesMaterialConversionPlugin : public EditorResourceConversionPlugin { class ParticleProcessMaterialConversionPlugin : public EditorResourceConversionPlugin {
GDCLASS(ParticlesMaterialConversionPlugin, EditorResourceConversionPlugin); GDCLASS(ParticleProcessMaterialConversionPlugin, EditorResourceConversionPlugin);
public: public:
virtual String converts_to() const override; virtual String converts_to() const override;

5
editor/project_converter_3_to_4.cpp
View file

@ -201,7 +201,7 @@ static const char *gdscript_function_renames[][2] = {
// { "set_color", "surface_set_color"}, // ImmediateMesh broke Light2D, Theme, SurfaceTool // { "set_color", "surface_set_color"}, // ImmediateMesh broke Light2D, Theme, SurfaceTool
// { "set_event", "set_shortcut" }, // BaseButton - Cyclic Rename // { "set_event", "set_shortcut" }, // BaseButton - Cyclic Rename
// { "set_extents", "set_size"}, // BoxShape, RectangleShape broke ReflectionProbe // { "set_extents", "set_size"}, // BoxShape, RectangleShape broke ReflectionProbe
// { "set_flag", "set_particle_flag"}, // ParticlesMaterial broke Window, HingeJoint3D // { "set_flag", "set_particle_flag"}, // ParticleProcessMaterial broke Window, HingeJoint3D
// { "set_h_offset", "set_drag_horizontal_offset" }, // Camera2D broke Camera3D, PathFollow3D, PathFollow2D // { "set_h_offset", "set_drag_horizontal_offset" }, // Camera2D broke Camera3D, PathFollow3D, PathFollow2D
// { "set_margin", "set_offset" }, // Control broke Shape3D, AtlasTexture // { "set_margin", "set_offset" }, // Control broke Shape3D, AtlasTexture
// { "set_mode", "set_mode_file_mode" }, // FileDialog broke Panel, Shader, CSGPolygon, Tilemap // { "set_mode", "set_mode_file_mode" }, // FileDialog broke Panel, Shader, CSGPolygon, Tilemap
@ -610,7 +610,7 @@ static const char *csharp_function_renames[][2] = {
// { "SetColor", "SurfaceSetColor"}, // ImmediateMesh broke Light2D, Theme, SurfaceTool // { "SetColor", "SurfaceSetColor"}, // ImmediateMesh broke Light2D, Theme, SurfaceTool
// { "SetEvent", "SetShortcut" }, // BaseButton - Cyclic Rename // { "SetEvent", "SetShortcut" }, // BaseButton - Cyclic Rename
// { "SetExtents", "SetSize"}, // BoxShape, RectangleShape broke ReflectionProbe // { "SetExtents", "SetSize"}, // BoxShape, RectangleShape broke ReflectionProbe
// { "SetFlag", "SetParticleFlag"}, // ParticlesMaterial broke Window, HingeJoint3D // { "SetFlag", "SetParticleFlag"}, // ParticleProcessMaterial broke Window, HingeJoint3D
// { "SetHOffset", "SetDragHorizontalOffset" }, // Camera2D broke Camera3D, PathFollow3D, PathFollow2D // { "SetHOffset", "SetDragHorizontalOffset" }, // Camera2D broke Camera3D, PathFollow3D, PathFollow2D
// { "SetMargin", "SetOffset" }, // Control broke Shape3D, AtlasTexture // { "SetMargin", "SetOffset" }, // Control broke Shape3D, AtlasTexture
// { "SetMode", "SetModeFileMode" }, // FileDialog broke Panel, Shader, CSGPolygon, Tilemap // { "SetMode", "SetModeFileMode" }, // FileDialog broke Panel, Shader, CSGPolygon, Tilemap
@ -1357,6 +1357,7 @@ static const char *class_renames[][2] = {
{ "PanoramaSky", "Sky" }, { "PanoramaSky", "Sky" },
{ "Particles", "GPUParticles3D" }, // Be careful, this will be used everywhere { "Particles", "GPUParticles3D" }, // Be careful, this will be used everywhere
{ "Particles2D", "GPUParticles2D" }, { "Particles2D", "GPUParticles2D" },
{ "ParticlesMaterial", "ParticleProcessMaterial" },
{ "Path", "Path3D" }, // Be careful, this will be used everywhere { "Path", "Path3D" }, // Be careful, this will be used everywhere
{ "PathFollow", "PathFollow3D" }, { "PathFollow", "PathFollow3D" },
{ "PhysicalBone", "PhysicalBone3D" }, { "PhysicalBone", "PhysicalBone3D" },

26
scene/2d/cpu_particles_2d.cpp
View file

@ -32,7 +32,7 @@
#include "core/core_string_names.h" #include "core/core_string_names.h"
#include "scene/2d/gpu_particles_2d.h" #include "scene/2d/gpu_particles_2d.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
void CPUParticles2D::set_emitting(bool p_emitting) { void CPUParticles2D::set_emitting(bool p_emitting) {
if (emitting == p_emitting) { if (emitting == p_emitting) {
@ -890,7 +890,7 @@ void CPUParticles2D::_particles_process(double p_delta) {
real_t orbit_amount = tex_orbit_velocity * Math::lerp(parameters_min[PARAM_ORBIT_VELOCITY], parameters_max[PARAM_ORBIT_VELOCITY], rand_from_seed(alt_seed)); real_t orbit_amount = tex_orbit_velocity * Math::lerp(parameters_min[PARAM_ORBIT_VELOCITY], parameters_max[PARAM_ORBIT_VELOCITY], rand_from_seed(alt_seed));
if (orbit_amount != 0.0) { if (orbit_amount != 0.0) {
real_t ang = orbit_amount * local_delta * Math_TAU; real_t ang = orbit_amount * local_delta * Math_TAU;
// Not sure why the ParticlesMaterial code uses a clockwise rotation matrix, // Not sure why the ParticleProcessMaterial code uses a clockwise rotation matrix,
// but we use -ang here to reproduce its behavior. // but we use -ang here to reproduce its behavior.
Transform2D rot = Transform2D(-ang, Vector2()); Transform2D rot = Transform2D(-ang, Vector2());
p.transform[2] -= diff; p.transform[2] -= diff;
@ -1184,7 +1184,7 @@ void CPUParticles2D::convert_from_particles(Node *p_particles) {
set_material(mat); set_material(mat);
} }
Ref<ParticlesMaterial> material = particles->get_process_material(); Ref<ParticleProcessMaterial> material = particles->get_process_material();
if (material.is_null()) { if (material.is_null()) {
return; return;
} }
@ -1205,14 +1205,14 @@ void CPUParticles2D::convert_from_particles(Node *p_particles) {
set_color_initial_ramp(gti->get_gradient()); set_color_initial_ramp(gti->get_gradient());
} }
set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, material->get_particle_flag(ParticlesMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY)); set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, material->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY));
set_emission_shape(EmissionShape(material->get_emission_shape())); set_emission_shape(EmissionShape(material->get_emission_shape()));
set_emission_sphere_radius(material->get_emission_sphere_radius()); set_emission_sphere_radius(material->get_emission_sphere_radius());
Vector2 rect_extents = Vector2(material->get_emission_box_extents().x, material->get_emission_box_extents().y); Vector2 rect_extents = Vector2(material->get_emission_box_extents().x, material->get_emission_box_extents().y);
set_emission_rect_extents(rect_extents); set_emission_rect_extents(rect_extents);
Ref<CurveXYZTexture> scale3D = material->get_param_texture(ParticlesMaterial::PARAM_SCALE); Ref<CurveXYZTexture> scale3D = material->get_param_texture(ParticleProcessMaterial::PARAM_SCALE);
if (scale3D.is_valid()) { if (scale3D.is_valid()) {
split_scale = true; split_scale = true;
scale_curve_x = scale3D->get_curve_x(); scale_curve_x = scale3D->get_curve_x();
@ -1222,14 +1222,14 @@ void CPUParticles2D::convert_from_particles(Node *p_particles) {
set_gravity(gravity); set_gravity(gravity);
set_lifetime_randomness(material->get_lifetime_randomness()); set_lifetime_randomness(material->get_lifetime_randomness());
#define CONVERT_PARAM(m_param) \ #define CONVERT_PARAM(m_param) \
set_param_min(m_param, material->get_param_min(ParticlesMaterial::m_param)); \ set_param_min(m_param, material->get_param_min(ParticleProcessMaterial::m_param)); \
{ \ { \
Ref<CurveTexture> ctex = material->get_param_texture(ParticlesMaterial::m_param); \ Ref<CurveTexture> ctex = material->get_param_texture(ParticleProcessMaterial::m_param); \
if (ctex.is_valid()) \ if (ctex.is_valid()) \
set_param_curve(m_param, ctex->get_curve()); \ set_param_curve(m_param, ctex->get_curve()); \
} \ } \
set_param_max(m_param, material->get_param_max(ParticlesMaterial::m_param)); set_param_max(m_param, material->get_param_max(ParticleProcessMaterial::m_param));
CONVERT_PARAM(PARAM_INITIAL_LINEAR_VELOCITY); CONVERT_PARAM(PARAM_INITIAL_LINEAR_VELOCITY);
CONVERT_PARAM(PARAM_ANGULAR_VELOCITY); CONVERT_PARAM(PARAM_ANGULAR_VELOCITY);

16
scene/2d/gpu_particles_2d.cpp
View file

@ -30,7 +30,7 @@
#include "gpu_particles_2d.h" #include "gpu_particles_2d.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "core/config/engine.h" #include "core/config/engine.h"
@ -123,10 +123,10 @@ void GPUParticles2D::_update_particle_emission_transform() {
void GPUParticles2D::set_process_material(const Ref<Material> &p_material) { void GPUParticles2D::set_process_material(const Ref<Material> &p_material) {
process_material = p_material; process_material = p_material;
Ref<ParticlesMaterial> pm = p_material; Ref<ParticleProcessMaterial> pm = p_material;
if (pm.is_valid() && !pm->get_particle_flag(ParticlesMaterial::PARTICLE_FLAG_DISABLE_Z) && pm->get_gravity() == Vector3(0, -9.8, 0)) { if (pm.is_valid() && !pm->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_DISABLE_Z) && pm->get_gravity() == Vector3(0, -9.8, 0)) {
// Likely a new (3D) material, modify it to match 2D space // Likely a new (3D) material, modify it to match 2D space
pm->set_particle_flag(ParticlesMaterial::PARTICLE_FLAG_DISABLE_Z, true); pm->set_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_DISABLE_Z, true);
pm->set_gravity(Vector3(0, 98, 0)); pm->set_gravity(Vector3(0, 98, 0));
} }
RID material_rid; RID material_rid;
@ -308,10 +308,10 @@ TypedArray<String> GPUParticles2D::get_configuration_warnings() const {
CanvasItemMaterial *mat = Object::cast_to<CanvasItemMaterial>(get_material().ptr()); CanvasItemMaterial *mat = Object::cast_to<CanvasItemMaterial>(get_material().ptr());
if (get_material().is_null() || (mat && !mat->get_particles_animation())) { if (get_material().is_null() || (mat && !mat->get_particles_animation())) {
const ParticlesMaterial *process = Object::cast_to<ParticlesMaterial>(process_material.ptr()); const ParticleProcessMaterial *process = Object::cast_to<ParticleProcessMaterial>(process_material.ptr());
if (process && if (process &&
(process->get_param_max(ParticlesMaterial::PARAM_ANIM_SPEED) != 0.0 || process->get_param_max(ParticlesMaterial::PARAM_ANIM_OFFSET) != 0.0 || (process->get_param_max(ParticleProcessMaterial::PARAM_ANIM_SPEED) != 0.0 || process->get_param_max(ParticleProcessMaterial::PARAM_ANIM_OFFSET) != 0.0 ||
process->get_param_texture(ParticlesMaterial::PARAM_ANIM_SPEED).is_valid() || process->get_param_texture(ParticlesMaterial::PARAM_ANIM_OFFSET).is_valid())) { process->get_param_texture(ParticleProcessMaterial::PARAM_ANIM_SPEED).is_valid() || process->get_param_texture(ParticleProcessMaterial::PARAM_ANIM_OFFSET).is_valid())) {
warnings.push_back(RTR("Particles2D animation requires the usage of a CanvasItemMaterial with \"Particles Animation\" enabled.")); warnings.push_back(RTR("Particles2D animation requires the usage of a CanvasItemMaterial with \"Particles Animation\" enabled."));
} }
} }
@ -625,7 +625,7 @@ void GPUParticles2D::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_sections", PROPERTY_HINT_RANGE, "2,128,1"), "set_trail_sections", "get_trail_sections"); ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_sections", PROPERTY_HINT_RANGE, "2,128,1"), "set_trail_sections", "get_trail_sections");
ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_section_subdivisions", PROPERTY_HINT_RANGE, "1,1024,1"), "set_trail_section_subdivisions", "get_trail_section_subdivisions"); ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_section_subdivisions", PROPERTY_HINT_RANGE, "1,1024,1"), "set_trail_section_subdivisions", "get_trail_section_subdivisions");
ADD_GROUP("Process Material", "process_"); ADD_GROUP("Process Material", "process_");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticlesMaterial"), "set_process_material", "get_process_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticleProcessMaterial"), "set_process_material", "get_process_material");
ADD_GROUP("Textures", ""); ADD_GROUP("Textures", "");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture");

30
scene/3d/cpu_particles_3d.cpp
View file

@ -33,7 +33,7 @@
#include "scene/3d/camera_3d.h" #include "scene/3d/camera_3d.h"
#include "scene/3d/gpu_particles_3d.h" #include "scene/3d/gpu_particles_3d.h"
#include "scene/main/viewport.h" #include "scene/main/viewport.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
AABB CPUParticles3D::get_aabb() const { AABB CPUParticles3D::get_aabb() const {
return AABB(); return AABB();
@ -983,7 +983,7 @@ void CPUParticles3D::_particles_process(double p_delta) {
real_t orbit_amount = tex_orbit_velocity * Math::lerp(parameters_min[PARAM_ORBIT_VELOCITY], parameters_max[PARAM_ORBIT_VELOCITY], rand_from_seed(alt_seed)); real_t orbit_amount = tex_orbit_velocity * Math::lerp(parameters_min[PARAM_ORBIT_VELOCITY], parameters_max[PARAM_ORBIT_VELOCITY], rand_from_seed(alt_seed));
if (orbit_amount != 0.0) { if (orbit_amount != 0.0) {
real_t ang = orbit_amount * local_delta * Math_TAU; real_t ang = orbit_amount * local_delta * Math_TAU;
// Not sure why the ParticlesMaterial code uses a clockwise rotation matrix, // Not sure why the ParticleProcessMaterial code uses a clockwise rotation matrix,
// but we use -ang here to reproduce its behavior. // but we use -ang here to reproduce its behavior.
Transform2D rot = Transform2D(-ang, Vector2()); Transform2D rot = Transform2D(-ang, Vector2());
Vector2 rotv = rot.basis_xform(Vector2(diff.x, diff.y)); Vector2 rotv = rot.basis_xform(Vector2(diff.x, diff.y));
@ -1343,7 +1343,7 @@ void CPUParticles3D::convert_from_particles(Node *p_particles) {
set_draw_order(DrawOrder(particles->get_draw_order())); set_draw_order(DrawOrder(particles->get_draw_order()));
set_mesh(particles->get_draw_pass_mesh(0)); set_mesh(particles->get_draw_pass_mesh(0));
Ref<ParticlesMaterial> material = particles->get_process_material(); Ref<ParticleProcessMaterial> material = particles->get_process_material();
if (material.is_null()) { if (material.is_null()) {
return; return;
} }
@ -1364,14 +1364,14 @@ void CPUParticles3D::convert_from_particles(Node *p_particles) {
set_color_initial_ramp(gti->get_gradient()); set_color_initial_ramp(gti->get_gradient());
} }
set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, material->get_particle_flag(ParticlesMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY)); set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, material->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY));
set_particle_flag(PARTICLE_FLAG_ROTATE_Y, material->get_particle_flag(ParticlesMaterial::PARTICLE_FLAG_ROTATE_Y)); set_particle_flag(PARTICLE_FLAG_ROTATE_Y, material->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_ROTATE_Y));
set_particle_flag(PARTICLE_FLAG_DISABLE_Z, material->get_particle_flag(ParticlesMaterial::PARTICLE_FLAG_DISABLE_Z)); set_particle_flag(PARTICLE_FLAG_DISABLE_Z, material->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_DISABLE_Z));
set_emission_shape(EmissionShape(material->get_emission_shape())); set_emission_shape(EmissionShape(material->get_emission_shape()));
set_emission_sphere_radius(material->get_emission_sphere_radius()); set_emission_sphere_radius(material->get_emission_sphere_radius());
set_emission_box_extents(material->get_emission_box_extents()); set_emission_box_extents(material->get_emission_box_extents());
Ref<CurveXYZTexture> scale3D = material->get_param_texture(ParticlesMaterial::PARAM_SCALE); Ref<CurveXYZTexture> scale3D = material->get_param_texture(ParticleProcessMaterial::PARAM_SCALE);
if (scale3D.is_valid()) { if (scale3D.is_valid()) {
split_scale = true; split_scale = true;
scale_curve_x = scale3D->get_curve_x(); scale_curve_x = scale3D->get_curve_x();
@ -1382,14 +1382,14 @@ void CPUParticles3D::convert_from_particles(Node *p_particles) {
set_gravity(material->get_gravity()); set_gravity(material->get_gravity());
set_lifetime_randomness(material->get_lifetime_randomness()); set_lifetime_randomness(material->get_lifetime_randomness());
#define CONVERT_PARAM(m_param) \ #define CONVERT_PARAM(m_param) \
set_param_min(m_param, material->get_param_min(ParticlesMaterial::m_param)); \ set_param_min(m_param, material->get_param_min(ParticleProcessMaterial::m_param)); \
{ \ { \
Ref<CurveTexture> ctex = material->get_param_texture(ParticlesMaterial::m_param); \ Ref<CurveTexture> ctex = material->get_param_texture(ParticleProcessMaterial::m_param); \
if (ctex.is_valid()) \ if (ctex.is_valid()) \
set_param_curve(m_param, ctex->get_curve()); \ set_param_curve(m_param, ctex->get_curve()); \
} \ } \
set_param_max(m_param, material->get_param_max(ParticlesMaterial::m_param)); set_param_max(m_param, material->get_param_max(ParticleProcessMaterial::m_param));
CONVERT_PARAM(PARAM_INITIAL_LINEAR_VELOCITY); CONVERT_PARAM(PARAM_INITIAL_LINEAR_VELOCITY);
CONVERT_PARAM(PARAM_ANGULAR_VELOCITY); CONVERT_PARAM(PARAM_ANGULAR_VELOCITY);

10
scene/3d/gpu_particles_3d.cpp
View file

@ -30,7 +30,7 @@
#include "gpu_particles_3d.h" #include "gpu_particles_3d.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
AABB GPUParticles3D::get_aabb() const { AABB GPUParticles3D::get_aabb() const {
return AABB(); return AABB();
@ -306,10 +306,10 @@ TypedArray<String> GPUParticles3D::get_configuration_warnings() const {
if (process_material.is_null()) { if (process_material.is_null()) {
warnings.push_back(RTR("A material to process the particles is not assigned, so no behavior is imprinted.")); warnings.push_back(RTR("A material to process the particles is not assigned, so no behavior is imprinted."));
} else { } else {
const ParticlesMaterial *process = Object::cast_to<ParticlesMaterial>(process_material.ptr()); const ParticleProcessMaterial *process = Object::cast_to<ParticleProcessMaterial>(process_material.ptr());
if (!anim_material_found && process && if (!anim_material_found && process &&
(process->get_param_max(ParticlesMaterial::PARAM_ANIM_SPEED) != 0.0 || process->get_param_max(ParticlesMaterial::PARAM_ANIM_OFFSET) != 0.0 || (process->get_param_max(ParticleProcessMaterial::PARAM_ANIM_SPEED) != 0.0 || process->get_param_max(ParticleProcessMaterial::PARAM_ANIM_OFFSET) != 0.0 ||
process->get_param_texture(ParticlesMaterial::PARAM_ANIM_SPEED).is_valid() || process->get_param_texture(ParticlesMaterial::PARAM_ANIM_OFFSET).is_valid())) { process->get_param_texture(ParticleProcessMaterial::PARAM_ANIM_SPEED).is_valid() || process->get_param_texture(ParticleProcessMaterial::PARAM_ANIM_OFFSET).is_valid())) {
warnings.push_back(RTR("Particles animation requires the usage of a BaseMaterial3D whose Billboard Mode is set to \"Particle Billboard\".")); warnings.push_back(RTR("Particles animation requires the usage of a BaseMaterial3D whose Billboard Mode is set to \"Particle Billboard\"."));
} }
} }
@ -585,7 +585,7 @@ void GPUParticles3D::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trail_enabled"), "set_trail_enabled", "is_trail_enabled"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trail_enabled"), "set_trail_enabled", "is_trail_enabled");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "trail_length_secs", PROPERTY_HINT_RANGE, "0.01,10,0.01,suffix:s"), "set_trail_length", "get_trail_length"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "trail_length_secs", PROPERTY_HINT_RANGE, "0.01,10,0.01,suffix:s"), "set_trail_length", "get_trail_length");
ADD_GROUP("Process Material", ""); ADD_GROUP("Process Material", "");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticlesMaterial"), "set_process_material", "get_process_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticleProcessMaterial"), "set_process_material", "get_process_material");
ADD_GROUP("Draw Passes", "draw_"); ADD_GROUP("Draw Passes", "draw_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_passes", PROPERTY_HINT_RANGE, "0," + itos(MAX_DRAW_PASSES) + ",1"), "set_draw_passes", "get_draw_passes"); ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_passes", PROPERTY_HINT_RANGE, "0," + itos(MAX_DRAW_PASSES) + ",1"), "set_draw_passes", "get_draw_passes");
for (int i = 0; i < MAX_DRAW_PASSES; i++) { for (int i = 0; i < MAX_DRAW_PASSES; i++) {

11
scene/register_scene_types.cpp
View file

@ -162,7 +162,7 @@
#include "scene/resources/multimesh.h" #include "scene/resources/multimesh.h"
#include "scene/resources/navigation_mesh.h" #include "scene/resources/navigation_mesh.h"
#include "scene/resources/packed_scene.h" #include "scene/resources/packed_scene.h"
#include "scene/resources/particles_material.h" #include "scene/resources/particle_process_material.h"
#include "scene/resources/physics_material.h" #include "scene/resources/physics_material.h"
#include "scene/resources/polygon_path_finder.h" #include "scene/resources/polygon_path_finder.h"
#include "scene/resources/primitive_meshes.h" #include "scene/resources/primitive_meshes.h"
@ -761,9 +761,9 @@ void register_scene_types() {
/* REGISTER RESOURCES */ /* REGISTER RESOURCES */
GDREGISTER_ABSTRACT_CLASS(Shader); GDREGISTER_ABSTRACT_CLASS(Shader);
GDREGISTER_CLASS(ParticlesMaterial); GDREGISTER_CLASS(ParticleProcessMaterial);
SceneTree::add_idle_callback(ParticlesMaterial::flush_changes); SceneTree::add_idle_callback(ParticleProcessMaterial::flush_changes);
ParticlesMaterial::init_shaders(); ParticleProcessMaterial::init_shaders();
GDREGISTER_VIRTUAL_CLASS(Mesh); GDREGISTER_VIRTUAL_CLASS(Mesh);
GDREGISTER_CLASS(ArrayMesh); GDREGISTER_CLASS(ArrayMesh);
@ -1019,6 +1019,7 @@ void register_scene_types() {
ClassDB::add_compatibility_class("PanoramaSky", "Sky"); ClassDB::add_compatibility_class("PanoramaSky", "Sky");
ClassDB::add_compatibility_class("Particles", "GPUParticles3D"); ClassDB::add_compatibility_class("Particles", "GPUParticles3D");
ClassDB::add_compatibility_class("Particles2D", "GPUParticles2D"); ClassDB::add_compatibility_class("Particles2D", "GPUParticles2D");
ClassDB::add_compatibility_class("ParticlesMaterial", "ParticleProcessMaterial");
ClassDB::add_compatibility_class("Path", "Path3D"); ClassDB::add_compatibility_class("Path", "Path3D");
ClassDB::add_compatibility_class("PathFollow", "PathFollow3D"); ClassDB::add_compatibility_class("PathFollow", "PathFollow3D");
ClassDB::add_compatibility_class("PhysicalBone", "PhysicalBone3D"); ClassDB::add_compatibility_class("PhysicalBone", "PhysicalBone3D");
@ -1209,7 +1210,7 @@ void unregister_scene_types() {
ProceduralSkyMaterial::cleanup_shader(); ProceduralSkyMaterial::cleanup_shader();
#endif // _3D_DISABLED #endif // _3D_DISABLED
ParticlesMaterial::finish_shaders(); ParticleProcessMaterial::finish_shaders();
CanvasItemMaterial::finish_shaders(); CanvasItemMaterial::finish_shaders();
ColorPicker::finish_shaders(); ColorPicker::finish_shaders();
SceneStringNames::free(); SceneStringNames::free();

336
scene/resources/particles_material.cpp → scene/resources/particle_process_material.cpp
View file

@ -1,5 +1,5 @@
/*************************************************************************/ /*************************************************************************/
/* particles_material.cpp */ /* particle_process_material.cpp */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* GODOT ENGINE */
@ -28,17 +28,17 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#include "particles_material.h" #include "particle_process_material.h"
#include "core/version.h" #include "core/version.h"
Mutex ParticlesMaterial::material_mutex; Mutex ParticleProcessMaterial::material_mutex;
SelfList<ParticlesMaterial>::List *ParticlesMaterial::dirty_materials = nullptr; SelfList<ParticleProcessMaterial>::List *ParticleProcessMaterial::dirty_materials = nullptr;
HashMap<ParticlesMaterial::MaterialKey, ParticlesMaterial::ShaderData, ParticlesMaterial::MaterialKey> ParticlesMaterial::shader_map; HashMap<ParticleProcessMaterial::MaterialKey, ParticleProcessMaterial::ShaderData, ParticleProcessMaterial::MaterialKey> ParticleProcessMaterial::shader_map;
ParticlesMaterial::ShaderNames *ParticlesMaterial::shader_names = nullptr; ParticleProcessMaterial::ShaderNames *ParticleProcessMaterial::shader_names = nullptr;
void ParticlesMaterial::init_shaders() { void ParticleProcessMaterial::init_shaders() {
dirty_materials = memnew(SelfList<ParticlesMaterial>::List); dirty_materials = memnew(SelfList<ParticleProcessMaterial>::List);
shader_names = memnew(ShaderNames); shader_names = memnew(ShaderNames);
@ -121,14 +121,14 @@ void ParticlesMaterial::init_shaders() {
shader_names->collision_bounce = "collision_bounce"; shader_names->collision_bounce = "collision_bounce";
} }
void ParticlesMaterial::finish_shaders() { void ParticleProcessMaterial::finish_shaders() {
memdelete(dirty_materials); memdelete(dirty_materials);
dirty_materials = nullptr; dirty_materials = nullptr;
memdelete(shader_names); memdelete(shader_names);
} }
void ParticlesMaterial::_update_shader() { void ParticleProcessMaterial::_update_shader() {
dirty_materials->remove(&element); dirty_materials->remove(&element);
MaterialKey mk = _compute_key(); MaterialKey mk = _compute_key();
@ -155,7 +155,7 @@ void ParticlesMaterial::_update_shader() {
//must create a shader! //must create a shader!
// Add a comment to describe the shader origin (useful when converting to ShaderMaterial). // Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
String code = "// NOTE: Shader automatically converted from " VERSION_NAME " " VERSION_FULL_CONFIG "'s ParticlesMaterial.\n\n"; String code = "// NOTE: Shader automatically converted from " VERSION_NAME " " VERSION_FULL_CONFIG "'s ParticleProcessMaterial.\n\n";
code += "shader_type particles;\n"; code += "shader_type particles;\n";
@ -908,7 +908,7 @@ void ParticlesMaterial::_update_shader() {
RS::get_singleton()->material_set_shader(_get_material(), shader_data.shader); RS::get_singleton()->material_set_shader(_get_material(), shader_data.shader);
} }
void ParticlesMaterial::flush_changes() { void ParticleProcessMaterial::flush_changes() {
MutexLock lock(material_mutex); MutexLock lock(material_mutex);
while (dirty_materials->first()) { while (dirty_materials->first()) {
@ -916,7 +916,7 @@ void ParticlesMaterial::flush_changes() {
} }
} }
void ParticlesMaterial::_queue_shader_change() { void ParticleProcessMaterial::_queue_shader_change() {
MutexLock lock(material_mutex); MutexLock lock(material_mutex);
if (is_initialized && !element.in_list()) { if (is_initialized && !element.in_list()) {
@ -924,40 +924,40 @@ void ParticlesMaterial::_queue_shader_change() {
} }
} }
bool ParticlesMaterial::_is_shader_dirty() const { bool ParticleProcessMaterial::_is_shader_dirty() const {
MutexLock lock(material_mutex); MutexLock lock(material_mutex);
return element.in_list(); return element.in_list();
} }
void ParticlesMaterial::set_direction(Vector3 p_direction) { void ParticleProcessMaterial::set_direction(Vector3 p_direction) {
direction = p_direction; direction = p_direction;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->direction, direction); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->direction, direction);
} }
Vector3 ParticlesMaterial::get_direction() const { Vector3 ParticleProcessMaterial::get_direction() const {
return direction; return direction;
} }
void ParticlesMaterial::set_spread(float p_spread) { void ParticleProcessMaterial::set_spread(float p_spread) {
spread = p_spread; spread = p_spread;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->spread, p_spread); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->spread, p_spread);
} }
float ParticlesMaterial::get_spread() const { float ParticleProcessMaterial::get_spread() const {
return spread; return spread;
} }
void ParticlesMaterial::set_flatness(float p_flatness) { void ParticleProcessMaterial::set_flatness(float p_flatness) {
flatness = p_flatness; flatness = p_flatness;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->flatness, p_flatness); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->flatness, p_flatness);
} }
float ParticlesMaterial::get_flatness() const { float ParticleProcessMaterial::get_flatness() const {
return flatness; return flatness;
} }
void ParticlesMaterial::set_param_min(Parameter p_param, float p_value) { void ParticleProcessMaterial::set_param_min(Parameter p_param, float p_value) {
ERR_FAIL_INDEX(p_param, PARAM_MAX); ERR_FAIL_INDEX(p_param, PARAM_MAX);
params_min[p_param] = p_value; params_min[p_param] = p_value;
@ -1016,13 +1016,13 @@ void ParticlesMaterial::set_param_min(Parameter p_param, float p_value) {
} }
} }
float ParticlesMaterial::get_param_min(Parameter p_param) const { float ParticleProcessMaterial::get_param_min(Parameter p_param) const {
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0); ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
return params_min[p_param]; return params_min[p_param];
} }
void ParticlesMaterial::set_param_max(Parameter p_param, float p_value) { void ParticleProcessMaterial::set_param_max(Parameter p_param, float p_value) {
ERR_FAIL_INDEX(p_param, PARAM_MAX); ERR_FAIL_INDEX(p_param, PARAM_MAX);
params_max[p_param] = p_value; params_max[p_param] = p_value;
@ -1081,7 +1081,7 @@ void ParticlesMaterial::set_param_max(Parameter p_param, float p_value) {
} }
} }
float ParticlesMaterial::get_param_max(Parameter p_param) const { float ParticleProcessMaterial::get_param_max(Parameter p_param) const {
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0); ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
return params_max[p_param]; return params_max[p_param];
@ -1096,7 +1096,7 @@ static void _adjust_curve_range(const Ref<Texture2D> &p_texture, float p_min, fl
curve_tex->ensure_default_setup(p_min, p_max); curve_tex->ensure_default_setup(p_min, p_max);
} }
void ParticlesMaterial::set_param_texture(Parameter p_param, const Ref<Texture2D> &p_texture) { void ParticleProcessMaterial::set_param_texture(Parameter p_param, const Ref<Texture2D> &p_texture) {
ERR_FAIL_INDEX(p_param, PARAM_MAX); ERR_FAIL_INDEX(p_param, PARAM_MAX);
tex_parameters[p_param] = p_texture; tex_parameters[p_param] = p_texture;
@ -1167,22 +1167,22 @@ void ParticlesMaterial::set_param_texture(Parameter p_param, const Ref<Texture2D
_queue_shader_change(); _queue_shader_change();
} }
Ref<Texture2D> ParticlesMaterial::get_param_texture(Parameter p_param) const { Ref<Texture2D> ParticleProcessMaterial::get_param_texture(Parameter p_param) const {
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, Ref<Texture2D>()); ERR_FAIL_INDEX_V(p_param, PARAM_MAX, Ref<Texture2D>());
return tex_parameters[p_param]; return tex_parameters[p_param];
} }
void ParticlesMaterial::set_color(const Color &p_color) { void ParticleProcessMaterial::set_color(const Color &p_color) {
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color, p_color); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color, p_color);
color = p_color; color = p_color;
} }
Color ParticlesMaterial::get_color() const { Color ParticleProcessMaterial::get_color() const {
return color; return color;
} }
void ParticlesMaterial::set_color_ramp(const Ref<Texture2D> &p_texture) { void ParticleProcessMaterial::set_color_ramp(const Ref<Texture2D> &p_texture) {
color_ramp = p_texture; color_ramp = p_texture;
RID tex_rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); RID tex_rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color_ramp, tex_rid); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color_ramp, tex_rid);
@ -1190,11 +1190,11 @@ void ParticlesMaterial::set_color_ramp(const Ref<Texture2D> &p_texture) {
notify_property_list_changed(); notify_property_list_changed();
} }
Ref<Texture2D> ParticlesMaterial::get_color_ramp() const { Ref<Texture2D> ParticleProcessMaterial::get_color_ramp() const {
return color_ramp; return color_ramp;
} }
void ParticlesMaterial::set_color_initial_ramp(const Ref<Texture2D> &p_texture) { void ParticleProcessMaterial::set_color_initial_ramp(const Ref<Texture2D> &p_texture) {
color_initial_ramp = p_texture; color_initial_ramp = p_texture;
RID tex_rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); RID tex_rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color_initial_ramp, tex_rid); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->color_initial_ramp, tex_rid);
@ -1202,11 +1202,11 @@ void ParticlesMaterial::set_color_initial_ramp(const Ref<Texture2D> &p_texture)
notify_property_list_changed(); notify_property_list_changed();
} }
Ref<Texture2D> ParticlesMaterial::get_color_initial_ramp() const { Ref<Texture2D> ParticleProcessMaterial::get_color_initial_ramp() const {
return color_initial_ramp; return color_initial_ramp;
} }
void ParticlesMaterial::set_particle_flag(ParticleFlags p_particle_flag, bool p_enable) { void ParticleProcessMaterial::set_particle_flag(ParticleFlags p_particle_flag, bool p_enable) {
ERR_FAIL_INDEX(p_particle_flag, PARTICLE_FLAG_MAX); ERR_FAIL_INDEX(p_particle_flag, PARTICLE_FLAG_MAX);
particle_flags[p_particle_flag] = p_enable; particle_flags[p_particle_flag] = p_enable;
_queue_shader_change(); _queue_shader_change();
@ -1215,165 +1215,165 @@ void ParticlesMaterial::set_particle_flag(ParticleFlags p_particle_flag, bool p_
} }
} }
bool ParticlesMaterial::get_particle_flag(ParticleFlags p_particle_flag) const { bool ParticleProcessMaterial::get_particle_flag(ParticleFlags p_particle_flag) const {
ERR_FAIL_INDEX_V(p_particle_flag, PARTICLE_FLAG_MAX, false); ERR_FAIL_INDEX_V(p_particle_flag, PARTICLE_FLAG_MAX, false);
return particle_flags[p_particle_flag]; return particle_flags[p_particle_flag];
} }
void ParticlesMaterial::set_emission_shape(EmissionShape p_shape) { void ParticleProcessMaterial::set_emission_shape(EmissionShape p_shape) {
ERR_FAIL_INDEX(p_shape, EMISSION_SHAPE_MAX); ERR_FAIL_INDEX(p_shape, EMISSION_SHAPE_MAX);
emission_shape = p_shape; emission_shape = p_shape;
notify_property_list_changed(); notify_property_list_changed();
_queue_shader_change(); _queue_shader_change();
} }
void ParticlesMaterial::set_emission_sphere_radius(real_t p_radius) { void ParticleProcessMaterial::set_emission_sphere_radius(real_t p_radius) {
emission_sphere_radius = p_radius; emission_sphere_radius = p_radius;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_sphere_radius, p_radius); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_sphere_radius, p_radius);
} }
void ParticlesMaterial::set_emission_box_extents(Vector3 p_extents) { void ParticleProcessMaterial::set_emission_box_extents(Vector3 p_extents) {
emission_box_extents = p_extents; emission_box_extents = p_extents;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_box_extents, p_extents); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_box_extents, p_extents);
} }
void ParticlesMaterial::set_emission_point_texture(const Ref<Texture2D> &p_points) { void ParticleProcessMaterial::set_emission_point_texture(const Ref<Texture2D> &p_points) {
emission_point_texture = p_points; emission_point_texture = p_points;
RID tex_rid = p_points.is_valid() ? p_points->get_rid() : RID(); RID tex_rid = p_points.is_valid() ? p_points->get_rid() : RID();
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_points, tex_rid); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_points, tex_rid);
} }
void ParticlesMaterial::set_emission_normal_texture(const Ref<Texture2D> &p_normals) { void ParticleProcessMaterial::set_emission_normal_texture(const Ref<Texture2D> &p_normals) {
emission_normal_texture = p_normals; emission_normal_texture = p_normals;
RID tex_rid = p_normals.is_valid() ? p_normals->get_rid() : RID(); RID tex_rid = p_normals.is_valid() ? p_normals->get_rid() : RID();
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_normal, tex_rid); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_normal, tex_rid);
} }
void ParticlesMaterial::set_emission_color_texture(const Ref<Texture2D> &p_colors) { void ParticleProcessMaterial::set_emission_color_texture(const Ref<Texture2D> &p_colors) {
emission_color_texture = p_colors; emission_color_texture = p_colors;
RID tex_rid = p_colors.is_valid() ? p_colors->get_rid() : RID(); RID tex_rid = p_colors.is_valid() ? p_colors->get_rid() : RID();
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_color, tex_rid); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_color, tex_rid);
_queue_shader_change(); _queue_shader_change();
} }
void ParticlesMaterial::set_emission_point_count(int p_count) { void ParticleProcessMaterial::set_emission_point_count(int p_count) {
emission_point_count = p_count; emission_point_count = p_count;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_point_count, p_count); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_point_count, p_count);
} }
void ParticlesMaterial::set_emission_ring_axis(Vector3 p_axis) { void ParticleProcessMaterial::set_emission_ring_axis(Vector3 p_axis) {
emission_ring_axis = p_axis; emission_ring_axis = p_axis;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_axis, p_axis); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_axis, p_axis);
} }
void ParticlesMaterial::set_emission_ring_height(real_t p_height) { void ParticleProcessMaterial::set_emission_ring_height(real_t p_height) {
emission_ring_height = p_height; emission_ring_height = p_height;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_height, p_height); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_height, p_height);
} }
void ParticlesMaterial::set_emission_ring_radius(real_t p_radius) { void ParticleProcessMaterial::set_emission_ring_radius(real_t p_radius) {
emission_ring_radius = p_radius; emission_ring_radius = p_radius;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_radius, p_radius); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_radius, p_radius);
} }
void ParticlesMaterial::set_emission_ring_inner_radius(real_t p_radius) { void ParticleProcessMaterial::set_emission_ring_inner_radius(real_t p_radius) {
emission_ring_inner_radius = p_radius; emission_ring_inner_radius = p_radius;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_inner_radius, p_radius); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_inner_radius, p_radius);
} }
ParticlesMaterial::EmissionShape ParticlesMaterial::get_emission_shape() const { ParticleProcessMaterial::EmissionShape ParticleProcessMaterial::get_emission_shape() const {
return emission_shape; return emission_shape;
} }
real_t ParticlesMaterial::get_emission_sphere_radius() const { real_t ParticleProcessMaterial::get_emission_sphere_radius() const {
return emission_sphere_radius; return emission_sphere_radius;
} }
Vector3 ParticlesMaterial::get_emission_box_extents() const { Vector3 ParticleProcessMaterial::get_emission_box_extents() const {
return emission_box_extents; return emission_box_extents;
} }
Ref<Texture2D> ParticlesMaterial::get_emission_point_texture() const { Ref<Texture2D> ParticleProcessMaterial::get_emission_point_texture() const {
return emission_point_texture; return emission_point_texture;
} }
Ref<Texture2D> ParticlesMaterial::get_emission_normal_texture() const { Ref<Texture2D> ParticleProcessMaterial::get_emission_normal_texture() const {
return emission_normal_texture; return emission_normal_texture;
} }
Ref<Texture2D> ParticlesMaterial::get_emission_color_texture() const { Ref<Texture2D> ParticleProcessMaterial::get_emission_color_texture() const {
return emission_color_texture; return emission_color_texture;
} }
int ParticlesMaterial::get_emission_point_count() const { int ParticleProcessMaterial::get_emission_point_count() const {
return emission_point_count; return emission_point_count;
} }
Vector3 ParticlesMaterial::get_emission_ring_axis() const { Vector3 ParticleProcessMaterial::get_emission_ring_axis() const {
return emission_ring_axis; return emission_ring_axis;
} }
real_t ParticlesMaterial::get_emission_ring_height() const { real_t ParticleProcessMaterial::get_emission_ring_height() const {
return emission_ring_height; return emission_ring_height;
} }
real_t ParticlesMaterial::get_emission_ring_radius() const { real_t ParticleProcessMaterial::get_emission_ring_radius() const {
return emission_ring_radius; return emission_ring_radius;
} }
real_t ParticlesMaterial::get_emission_ring_inner_radius() const { real_t ParticleProcessMaterial::get_emission_ring_inner_radius() const {
return emission_ring_inner_radius; return emission_ring_inner_radius;
} }
void ParticlesMaterial::set_turbulence_enabled(const bool p_turbulence_enabled) { void ParticleProcessMaterial::set_turbulence_enabled(const bool p_turbulence_enabled) {
turbulence_enabled = p_turbulence_enabled; turbulence_enabled = p_turbulence_enabled;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_enabled, turbulence_enabled); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_enabled, turbulence_enabled);
_queue_shader_change(); _queue_shader_change();
notify_property_list_changed(); notify_property_list_changed();
} }
bool ParticlesMaterial::get_turbulence_enabled() const { bool ParticleProcessMaterial::get_turbulence_enabled() const {
return turbulence_enabled; return turbulence_enabled;
} }
void ParticlesMaterial::set_turbulence_noise_strength(float p_turbulence_noise_strength) { void ParticleProcessMaterial::set_turbulence_noise_strength(float p_turbulence_noise_strength) {
turbulence_noise_strength = p_turbulence_noise_strength; turbulence_noise_strength = p_turbulence_noise_strength;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_strength, p_turbulence_noise_strength); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_strength, p_turbulence_noise_strength);
} }
float ParticlesMaterial::get_turbulence_noise_strength() const { float ParticleProcessMaterial::get_turbulence_noise_strength() const {
return turbulence_noise_strength; return turbulence_noise_strength;
} }
void ParticlesMaterial::set_turbulence_noise_scale(float p_turbulence_noise_scale) { void ParticleProcessMaterial::set_turbulence_noise_scale(float p_turbulence_noise_scale) {
turbulence_noise_scale = p_turbulence_noise_scale; turbulence_noise_scale = p_turbulence_noise_scale;
float shader_turbulence_noise_scale = (pow(p_turbulence_noise_scale, 0.25) * 5.6234 / 10.0) * 4.0 - 3.0; float shader_turbulence_noise_scale = (pow(p_turbulence_noise_scale, 0.25) * 5.6234 / 10.0) * 4.0 - 3.0;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_scale, shader_turbulence_noise_scale); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_scale, shader_turbulence_noise_scale);
} }
float ParticlesMaterial::get_turbulence_noise_scale() const { float ParticleProcessMaterial::get_turbulence_noise_scale() const {
return turbulence_noise_scale; return turbulence_noise_scale;
} }
void ParticlesMaterial::set_turbulence_noise_speed_random(float p_turbulence_noise_speed_random) { void ParticleProcessMaterial::set_turbulence_noise_speed_random(float p_turbulence_noise_speed_random) {
turbulence_noise_speed_random = p_turbulence_noise_speed_random; turbulence_noise_speed_random = p_turbulence_noise_speed_random;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_speed_random, p_turbulence_noise_speed_random); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_speed_random, p_turbulence_noise_speed_random);
} }
float ParticlesMaterial::get_turbulence_noise_speed_random() const { float ParticleProcessMaterial::get_turbulence_noise_speed_random() const {
return turbulence_noise_speed_random; return turbulence_noise_speed_random;
} }
void ParticlesMaterial::set_turbulence_noise_speed(const Vector3 &p_turbulence_noise_speed) { void ParticleProcessMaterial::set_turbulence_noise_speed(const Vector3 &p_turbulence_noise_speed) {
turbulence_noise_speed = p_turbulence_noise_speed; turbulence_noise_speed = p_turbulence_noise_speed;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_speed, turbulence_noise_speed); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->turbulence_noise_speed, turbulence_noise_speed);
} }
Vector3 ParticlesMaterial::get_turbulence_noise_speed() const { Vector3 ParticleProcessMaterial::get_turbulence_noise_speed() const {
return turbulence_noise_speed; return turbulence_noise_speed;
} }
void ParticlesMaterial::set_gravity(const Vector3 &p_gravity) { void ParticleProcessMaterial::set_gravity(const Vector3 &p_gravity) {
gravity = p_gravity; gravity = p_gravity;
Vector3 gset = gravity; Vector3 gset = gravity;
if (gset == Vector3()) { if (gset == Vector3()) {
@ -1382,25 +1382,25 @@ void ParticlesMaterial::set_gravity(const Vector3 &p_gravity) {
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->gravity, gset); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->gravity, gset);
} }
Vector3 ParticlesMaterial::get_gravity() const { Vector3 ParticleProcessMaterial::get_gravity() const {
return gravity; return gravity;
} }
void ParticlesMaterial::set_lifetime_randomness(double p_lifetime) { void ParticleProcessMaterial::set_lifetime_randomness(double p_lifetime) {
lifetime_randomness = p_lifetime; lifetime_randomness = p_lifetime;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->lifetime_randomness, lifetime_randomness); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->lifetime_randomness, lifetime_randomness);
} }
double ParticlesMaterial::get_lifetime_randomness() const { double ParticleProcessMaterial::get_lifetime_randomness() const {
return lifetime_randomness; return lifetime_randomness;
} }
RID ParticlesMaterial::get_shader_rid() const { RID ParticleProcessMaterial::get_shader_rid() const {
ERR_FAIL_COND_V(!shader_map.has(current_key), RID()); ERR_FAIL_COND_V(!shader_map.has(current_key), RID());
return shader_map[current_key].shader; return shader_map[current_key].shader;
} }
void ParticlesMaterial::_validate_property(PropertyInfo &p_property) const { void ParticleProcessMaterial::_validate_property(PropertyInfo &p_property) const {
if (p_property.name == "emission_sphere_radius" && (emission_shape != EMISSION_SHAPE_SPHERE && emission_shape != EMISSION_SHAPE_SPHERE_SURFACE)) { if (p_property.name == "emission_sphere_radius" && (emission_shape != EMISSION_SHAPE_SPHERE && emission_shape != EMISSION_SHAPE_SPHERE_SURFACE)) {
p_property.usage = PROPERTY_USAGE_NONE; p_property.usage = PROPERTY_USAGE_NONE;
} }
@ -1460,203 +1460,203 @@ void ParticlesMaterial::_validate_property(PropertyInfo &p_property) const {
} }
} }
void ParticlesMaterial::set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode) { void ParticleProcessMaterial::set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode) {
sub_emitter_mode = p_sub_emitter_mode; sub_emitter_mode = p_sub_emitter_mode;
_queue_shader_change(); _queue_shader_change();
notify_property_list_changed(); notify_property_list_changed();
} }
ParticlesMaterial::SubEmitterMode ParticlesMaterial::get_sub_emitter_mode() const { ParticleProcessMaterial::SubEmitterMode ParticleProcessMaterial::get_sub_emitter_mode() const {
return sub_emitter_mode; return sub_emitter_mode;
} }
void ParticlesMaterial::set_sub_emitter_frequency(double p_frequency) { void ParticleProcessMaterial::set_sub_emitter_frequency(double p_frequency) {
sub_emitter_frequency = p_frequency; sub_emitter_frequency = p_frequency;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_frequency, 1.0 / p_frequency); //pass delta instead of frequency, since its easier to compute RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_frequency, 1.0 / p_frequency); //pass delta instead of frequency, since its easier to compute
} }
double ParticlesMaterial::get_sub_emitter_frequency() const { double ParticleProcessMaterial::get_sub_emitter_frequency() const {
return sub_emitter_frequency; return sub_emitter_frequency;
} }
void ParticlesMaterial::set_sub_emitter_amount_at_end(int p_amount) { void ParticleProcessMaterial::set_sub_emitter_amount_at_end(int p_amount) {
sub_emitter_amount_at_end = p_amount; sub_emitter_amount_at_end = p_amount;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_amount_at_end, p_amount); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_amount_at_end, p_amount);
} }
int ParticlesMaterial::get_sub_emitter_amount_at_end() const { int ParticleProcessMaterial::get_sub_emitter_amount_at_end() const {
return sub_emitter_amount_at_end; return sub_emitter_amount_at_end;
} }
void ParticlesMaterial::set_sub_emitter_keep_velocity(bool p_enable) { void ParticleProcessMaterial::set_sub_emitter_keep_velocity(bool p_enable) {
sub_emitter_keep_velocity = p_enable; sub_emitter_keep_velocity = p_enable;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_keep_velocity, p_enable); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_keep_velocity, p_enable);
} }
bool ParticlesMaterial::get_sub_emitter_keep_velocity() const { bool ParticleProcessMaterial::get_sub_emitter_keep_velocity() const {
return sub_emitter_keep_velocity; return sub_emitter_keep_velocity;
} }
void ParticlesMaterial::set_attractor_interaction_enabled(bool p_enable) { void ParticleProcessMaterial::set_attractor_interaction_enabled(bool p_enable) {
attractor_interaction_enabled = p_enable; attractor_interaction_enabled = p_enable;
_queue_shader_change(); _queue_shader_change();
} }
bool ParticlesMaterial::is_attractor_interaction_enabled() const { bool ParticleProcessMaterial::is_attractor_interaction_enabled() const {
return attractor_interaction_enabled; return attractor_interaction_enabled;
} }
void ParticlesMaterial::set_collision_mode(CollisionMode p_collision_mode) { void ParticleProcessMaterial::set_collision_mode(CollisionMode p_collision_mode) {
collision_mode = p_collision_mode; collision_mode = p_collision_mode;
_queue_shader_change(); _queue_shader_change();
notify_property_list_changed(); notify_property_list_changed();
} }
ParticlesMaterial::CollisionMode ParticlesMaterial::get_collision_mode() const { ParticleProcessMaterial::CollisionMode ParticleProcessMaterial::get_collision_mode() const {
return collision_mode; return collision_mode;
} }
void ParticlesMaterial::set_collision_use_scale(bool p_scale) { void ParticleProcessMaterial::set_collision_use_scale(bool p_scale) {
collision_scale = p_scale; collision_scale = p_scale;
_queue_shader_change(); _queue_shader_change();
} }
bool ParticlesMaterial::is_collision_using_scale() const { bool ParticleProcessMaterial::is_collision_using_scale() const {
return collision_scale; return collision_scale;
} }
void ParticlesMaterial::set_collision_friction(float p_friction) { void ParticleProcessMaterial::set_collision_friction(float p_friction) {
collision_friction = p_friction; collision_friction = p_friction;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->collision_friction, p_friction); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->collision_friction, p_friction);
} }
float ParticlesMaterial::get_collision_friction() const { float ParticleProcessMaterial::get_collision_friction() const {
return collision_friction; return collision_friction;
} }
void ParticlesMaterial::set_collision_bounce(float p_bounce) { void ParticleProcessMaterial::set_collision_bounce(float p_bounce) {
collision_bounce = p_bounce; collision_bounce = p_bounce;
RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->collision_bounce, p_bounce); RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->collision_bounce, p_bounce);
} }
float ParticlesMaterial::get_collision_bounce() const { float ParticleProcessMaterial::get_collision_bounce() const {
return collision_bounce; return collision_bounce;
} }
Shader::Mode ParticlesMaterial::get_shader_mode() const { Shader::Mode ParticleProcessMaterial::get_shader_mode() const {
return Shader::MODE_PARTICLES; return Shader::MODE_PARTICLES;
} }
void ParticlesMaterial::_bind_methods() { void ParticleProcessMaterial::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_direction", "degrees"), &ParticlesMaterial::set_direction); ClassDB::bind_method(D_METHOD("set_direction", "degrees"), &ParticleProcessMaterial::set_direction);
ClassDB::bind_method(D_METHOD("get_direction"), &ParticlesMaterial::get_direction); ClassDB::bind_method(D_METHOD("get_direction"), &ParticleProcessMaterial::get_direction);
ClassDB::bind_method(D_METHOD("set_spread", "degrees"), &ParticlesMaterial::set_spread); ClassDB::bind_method(D_METHOD("set_spread", "degrees"), &ParticleProcessMaterial::set_spread);
ClassDB::bind_method(D_METHOD("get_spread"), &ParticlesMaterial::get_spread); ClassDB::bind_method(D_METHOD("get_spread"), &ParticleProcessMaterial::get_spread);
ClassDB::bind_method(D_METHOD("set_flatness", "amount"), &ParticlesMaterial::set_flatness); ClassDB::bind_method(D_METHOD("set_flatness", "amount"), &ParticleProcessMaterial::set_flatness);
ClassDB::bind_method(D_METHOD("get_flatness"), &ParticlesMaterial::get_flatness); ClassDB::bind_method(D_METHOD("get_flatness"), &ParticleProcessMaterial::get_flatness);
ClassDB::bind_method(D_METHOD("set_param_min", "param", "value"), &ParticlesMaterial::set_param_min); ClassDB::bind_method(D_METHOD("set_param_min", "param", "value"), &ParticleProcessMaterial::set_param_min);
ClassDB::bind_method(D_METHOD("get_param_min", "param"), &ParticlesMaterial::get_param_min); ClassDB::bind_method(D_METHOD("get_param_min", "param"), &ParticleProcessMaterial::get_param_min);
ClassDB::bind_method(D_METHOD("set_param_max", "param", "value"), &ParticlesMaterial::set_param_max); ClassDB::bind_method(D_METHOD("set_param_max", "param", "value"), &ParticleProcessMaterial::set_param_max);
ClassDB::bind_method(D_METHOD("get_param_max", "param"), &ParticlesMaterial::get_param_max); ClassDB::bind_method(D_METHOD("get_param_max", "param"), &ParticleProcessMaterial::get_param_max);
ClassDB::bind_method(D_METHOD("set_param_texture", "param", "texture"), &ParticlesMaterial::set_param_texture); ClassDB::bind_method(D_METHOD("set_param_texture", "param", "texture"), &ParticleProcessMaterial::set_param_texture);
ClassDB::bind_method(D_METHOD("get_param_texture", "param"), &ParticlesMaterial::get_param_texture); ClassDB::bind_method(D_METHOD("get_param_texture", "param"), &ParticleProcessMaterial::get_param_texture);
ClassDB::bind_method(D_METHOD("set_color", "color"), &ParticlesMaterial::set_color); ClassDB::bind_method(D_METHOD("set_color", "color"), &ParticleProcessMaterial::set_color);
ClassDB::bind_method(D_METHOD("get_color"), &ParticlesMaterial::get_color); ClassDB::bind_method(D_METHOD("get_color"), &ParticleProcessMaterial::get_color);
ClassDB::bind_method(D_METHOD("set_color_ramp", "ramp"), &ParticlesMaterial::set_color_ramp); ClassDB::bind_method(D_METHOD("set_color_ramp", "ramp"), &ParticleProcessMaterial::set_color_ramp);
ClassDB::bind_method(D_METHOD("get_color_ramp"), &ParticlesMaterial::get_color_ramp); ClassDB::bind_method(D_METHOD("get_color_ramp"), &ParticleProcessMaterial::get_color_ramp);
ClassDB::bind_method(D_METHOD("set_color_initial_ramp", "ramp"), &ParticlesMaterial::set_color_initial_ramp); ClassDB::bind_method(D_METHOD("set_color_initial_ramp", "ramp"), &ParticleProcessMaterial::set_color_initial_ramp);
ClassDB::bind_method(D_METHOD("get_color_initial_ramp"), &ParticlesMaterial::get_color_initial_ramp); ClassDB::bind_method(D_METHOD("get_color_initial_ramp"), &ParticleProcessMaterial::get_color_initial_ramp);
ClassDB::bind_method(D_METHOD("set_particle_flag", "particle_flag", "enable"), &ParticlesMaterial::set_particle_flag); ClassDB::bind_method(D_METHOD("set_particle_flag", "particle_flag", "enable"), &ParticleProcessMaterial::set_particle_flag);
ClassDB::bind_method(D_METHOD("get_particle_flag", "particle_flag"), &ParticlesMaterial::get_particle_flag); ClassDB::bind_method(D_METHOD("get_particle_flag", "particle_flag"), &ParticleProcessMaterial::get_particle_flag);
ClassDB::bind_method(D_METHOD("set_emission_shape", "shape"), &ParticlesMaterial::set_emission_shape); ClassDB::bind_method(D_METHOD("set_emission_shape", "shape"), &ParticleProcessMaterial::set_emission_shape);
ClassDB::bind_method(D_METHOD("get_emission_shape"), &ParticlesMaterial::get_emission_shape); ClassDB::bind_method(D_METHOD("get_emission_shape"), &ParticleProcessMaterial::get_emission_shape);
ClassDB::bind_method(D_METHOD("set_emission_sphere_radius", "radius"), &ParticlesMaterial::set_emission_sphere_radius); ClassDB::bind_method(D_METHOD("set_emission_sphere_radius", "radius"), &ParticleProcessMaterial::set_emission_sphere_radius);
ClassDB::bind_method(D_METHOD("get_emission_sphere_radius"), &ParticlesMaterial::get_emission_sphere_radius); ClassDB::bind_method(D_METHOD("get_emission_sphere_radius"), &ParticleProcessMaterial::get_emission_sphere_radius);
ClassDB::bind_method(D_METHOD("set_emission_box_extents", "extents"), &ParticlesMaterial::set_emission_box_extents); ClassDB::bind_method(D_METHOD("set_emission_box_extents", "extents"), &ParticleProcessMaterial::set_emission_box_extents);
ClassDB::bind_method(D_METHOD("get_emission_box_extents"), &ParticlesMaterial::get_emission_box_extents); ClassDB::bind_method(D_METHOD("get_emission_box_extents"), &ParticleProcessMaterial::get_emission_box_extents);
ClassDB::bind_method(D_METHOD("set_emission_point_texture", "texture"), &ParticlesMaterial::set_emission_point_texture); ClassDB::bind_method(D_METHOD("set_emission_point_texture", "texture"), &ParticleProcessMaterial::set_emission_point_texture);
ClassDB::bind_method(D_METHOD("get_emission_point_texture"), &ParticlesMaterial::get_emission_point_texture); ClassDB::bind_method(D_METHOD("get_emission_point_texture"), &ParticleProcessMaterial::get_emission_point_texture);
ClassDB::bind_method(D_METHOD("set_emission_normal_texture", "texture"), &ParticlesMaterial::set_emission_normal_texture); ClassDB::bind_method(D_METHOD("set_emission_normal_texture", "texture"), &ParticleProcessMaterial::set_emission_normal_texture);
ClassDB::bind_method(D_METHOD("get_emission_normal_texture"), &ParticlesMaterial::get_emission_normal_texture); ClassDB::bind_method(D_METHOD("get_emission_normal_texture"), &ParticleProcessMaterial::get_emission_normal_texture);
ClassDB::bind_method(D_METHOD("set_emission_color_texture", "texture"), &ParticlesMaterial::set_emission_color_texture); ClassDB::bind_method(D_METHOD("set_emission_color_texture", "texture"), &ParticleProcessMaterial::set_emission_color_texture);
ClassDB::bind_method(D_METHOD("get_emission_color_texture"), &ParticlesMaterial::get_emission_color_texture); ClassDB::bind_method(D_METHOD("get_emission_color_texture"), &ParticleProcessMaterial::get_emission_color_texture);
ClassDB::bind_method(D_METHOD("set_emission_point_count", "point_count"), &ParticlesMaterial::set_emission_point_count); ClassDB::bind_method(D_METHOD("set_emission_point_count", "point_count"), &ParticleProcessMaterial::set_emission_point_count);
ClassDB::bind_method(D_METHOD("get_emission_point_count"), &ParticlesMaterial::get_emission_point_count); ClassDB::bind_method(D_METHOD("get_emission_point_count"), &ParticleProcessMaterial::get_emission_point_count);
ClassDB::bind_method(D_METHOD("set_emission_ring_axis", "axis"), &ParticlesMaterial::set_emission_ring_axis); ClassDB::bind_method(D_METHOD("set_emission_ring_axis", "axis"), &ParticleProcessMaterial::set_emission_ring_axis);
ClassDB::bind_method(D_METHOD("get_emission_ring_axis"), &ParticlesMaterial::get_emission_ring_axis); ClassDB::bind_method(D_METHOD("get_emission_ring_axis"), &ParticleProcessMaterial::get_emission_ring_axis);
ClassDB::bind_method(D_METHOD("set_emission_ring_height", "height"), &ParticlesMaterial::set_emission_ring_height); ClassDB::bind_method(D_METHOD("set_emission_ring_height", "height"), &ParticleProcessMaterial::set_emission_ring_height);
ClassDB::bind_method(D_METHOD("get_emission_ring_height"), &ParticlesMaterial::get_emission_ring_height); ClassDB::bind_method(D_METHOD("get_emission_ring_height"), &ParticleProcessMaterial::get_emission_ring_height);
ClassDB::bind_method(D_METHOD("set_emission_ring_radius", "radius"), &ParticlesMaterial::set_emission_ring_radius); ClassDB::bind_method(D_METHOD("set_emission_ring_radius", "radius"), &ParticleProcessMaterial::set_emission_ring_radius);
ClassDB::bind_method(D_METHOD("get_emission_ring_radius"), &ParticlesMaterial::get_emission_ring_radius); ClassDB::bind_method(D_METHOD("get_emission_ring_radius"), &ParticleProcessMaterial::get_emission_ring_radius);
ClassDB::bind_method(D_METHOD("set_emission_ring_inner_radius", "inner_radius"), &ParticlesMaterial::set_emission_ring_inner_radius); ClassDB::bind_method(D_METHOD("set_emission_ring_inner_radius", "inner_radius"), &ParticleProcessMaterial::set_emission_ring_inner_radius);
ClassDB::bind_method(D_METHOD("get_emission_ring_inner_radius"), &ParticlesMaterial::get_emission_ring_inner_radius); ClassDB::bind_method(D_METHOD("get_emission_ring_inner_radius"), &ParticleProcessMaterial::get_emission_ring_inner_radius);
ClassDB::bind_method(D_METHOD("get_turbulence_enabled"), &ParticlesMaterial::get_turbulence_enabled); ClassDB::bind_method(D_METHOD("get_turbulence_enabled"), &ParticleProcessMaterial::get_turbulence_enabled);
ClassDB::bind_method(D_METHOD("set_turbulence_enabled", "turbulence_enabled"), &ParticlesMaterial::set_turbulence_enabled); ClassDB::bind_method(D_METHOD("set_turbulence_enabled", "turbulence_enabled"), &ParticleProcessMaterial::set_turbulence_enabled);
ClassDB::bind_method(D_METHOD("get_turbulence_noise_strength"), &ParticlesMaterial::get_turbulence_noise_strength); ClassDB::bind_method(D_METHOD("get_turbulence_noise_strength"), &ParticleProcessMaterial::get_turbulence_noise_strength);
ClassDB::bind_method(D_METHOD("set_turbulence_noise_strength", "turbulence_noise_strength"), &ParticlesMaterial::set_turbulence_noise_strength); ClassDB::bind_method(D_METHOD("set_turbulence_noise_strength", "turbulence_noise_strength"), &ParticleProcessMaterial::set_turbulence_noise_strength);
ClassDB::bind_method(D_METHOD("get_turbulence_noise_scale"), &ParticlesMaterial::get_turbulence_noise_scale); ClassDB::bind_method(D_METHOD("get_turbulence_noise_scale"), &ParticleProcessMaterial::get_turbulence_noise_scale);
ClassDB::bind_method(D_METHOD("set_turbulence_noise_scale", "turbulence_noise_scale"), &ParticlesMaterial::set_turbulence_noise_scale); ClassDB::bind_method(D_METHOD("set_turbulence_noise_scale", "turbulence_noise_scale"), &ParticleProcessMaterial::set_turbulence_noise_scale);
ClassDB::bind_method(D_METHOD("get_turbulence_noise_speed_random"), &ParticlesMaterial::get_turbulence_noise_speed_random); ClassDB::bind_method(D_METHOD("get_turbulence_noise_speed_random"), &ParticleProcessMaterial::get_turbulence_noise_speed_random);
ClassDB::bind_method(D_METHOD("set_turbulence_noise_speed_random", "turbulence_noise_speed_random"), &ParticlesMaterial::set_turbulence_noise_speed_random); ClassDB::bind_method(D_METHOD("set_turbulence_noise_speed_random", "turbulence_noise_speed_random"), &ParticleProcessMaterial::set_turbulence_noise_speed_random);
ClassDB::bind_method(D_METHOD("get_turbulence_noise_speed"), &ParticlesMaterial::get_turbulence_noise_speed); ClassDB::bind_method(D_METHOD("get_turbulence_noise_speed"), &ParticleProcessMaterial::get_turbulence_noise_speed);
ClassDB::bind_method(D_METHOD("set_turbulence_noise_speed", "turbulence_noise_speed"), &ParticlesMaterial::set_turbulence_noise_speed); ClassDB::bind_method(D_METHOD("set_turbulence_noise_speed", "turbulence_noise_speed"), &ParticleProcessMaterial::set_turbulence_noise_speed);
ClassDB::bind_method(D_METHOD("get_gravity"), &ParticlesMaterial::get_gravity); ClassDB::bind_method(D_METHOD("get_gravity"), &ParticleProcessMaterial::get_gravity);
ClassDB::bind_method(D_METHOD("set_gravity", "accel_vec"), &ParticlesMaterial::set_gravity); ClassDB::bind_method(D_METHOD("set_gravity", "accel_vec"), &ParticleProcessMaterial::set_gravity);
ClassDB::bind_method(D_METHOD("set_lifetime_randomness", "randomness"), &ParticlesMaterial::set_lifetime_randomness); ClassDB::bind_method(D_METHOD("set_lifetime_randomness", "randomness"), &ParticleProcessMaterial::set_lifetime_randomness);
ClassDB::bind_method(D_METHOD("get_lifetime_randomness"), &ParticlesMaterial::get_lifetime_randomness); ClassDB::bind_method(D_METHOD("get_lifetime_randomness"), &ParticleProcessMaterial::get_lifetime_randomness);
ClassDB::bind_method(D_METHOD("get_sub_emitter_mode"), &ParticlesMaterial::get_sub_emitter_mode); ClassDB::bind_method(D_METHOD("get_sub_emitter_mode"), &ParticleProcessMaterial::get_sub_emitter_mode);
ClassDB::bind_method(D_METHOD("set_sub_emitter_mode", "mode"), &ParticlesMaterial::set_sub_emitter_mode); ClassDB::bind_method(D_METHOD("set_sub_emitter_mode", "mode"), &ParticleProcessMaterial::set_sub_emitter_mode);
ClassDB::bind_method(D_METHOD("get_sub_emitter_frequency"), &ParticlesMaterial::get_sub_emitter_frequency); ClassDB::bind_method(D_METHOD("get_sub_emitter_frequency"), &ParticleProcessMaterial::get_sub_emitter_frequency);
ClassDB::bind_method(D_METHOD("set_sub_emitter_frequency", "hz"), &ParticlesMaterial::set_sub_emitter_frequency); ClassDB::bind_method(D_METHOD("set_sub_emitter_frequency", "hz"), &ParticleProcessMaterial::set_sub_emitter_frequency);
ClassDB::bind_method(D_METHOD("get_sub_emitter_amount_at_end"), &ParticlesMaterial::get_sub_emitter_amount_at_end); ClassDB::bind_method(D_METHOD("get_sub_emitter_amount_at_end"), &ParticleProcessMaterial::get_sub_emitter_amount_at_end);
ClassDB::bind_method(D_METHOD("set_sub_emitter_amount_at_end", "amount"), &ParticlesMaterial::set_sub_emitter_amount_at_end); ClassDB::bind_method(D_METHOD("set_sub_emitter_amount_at_end", "amount"), &ParticleProcessMaterial::set_sub_emitter_amount_at_end);
ClassDB::bind_method(D_METHOD("get_sub_emitter_keep_velocity"), &ParticlesMaterial::get_sub_emitter_keep_velocity); ClassDB::bind_method(D_METHOD("get_sub_emitter_keep_velocity"), &ParticleProcessMaterial::get_sub_emitter_keep_velocity);
ClassDB::bind_method(D_METHOD("set_sub_emitter_keep_velocity", "enable"), &ParticlesMaterial::set_sub_emitter_keep_velocity); ClassDB::bind_method(D_METHOD("set_sub_emitter_keep_velocity", "enable"), &ParticleProcessMaterial::set_sub_emitter_keep_velocity);
ClassDB::bind_method(D_METHOD("set_attractor_interaction_enabled", "enabled"), &ParticlesMaterial::set_attractor_interaction_enabled); ClassDB::bind_method(D_METHOD("set_attractor_interaction_enabled", "enabled"), &ParticleProcessMaterial::set_attractor_interaction_enabled);
ClassDB::bind_method(D_METHOD("is_attractor_interaction_enabled"), &ParticlesMaterial::is_attractor_interaction_enabled); ClassDB::bind_method(D_METHOD("is_attractor_interaction_enabled"), &ParticleProcessMaterial::is_attractor_interaction_enabled);
ClassDB::bind_method(D_METHOD("set_collision_mode", "mode"), &ParticlesMaterial::set_collision_mode); ClassDB::bind_method(D_METHOD("set_collision_mode", "mode"), &ParticleProcessMaterial::set_collision_mode);
ClassDB::bind_method(D_METHOD("get_collision_mode"), &ParticlesMaterial::get_collision_mode); ClassDB::bind_method(D_METHOD("get_collision_mode"), &ParticleProcessMaterial::get_collision_mode);
ClassDB::bind_method(D_METHOD("set_collision_use_scale", "radius"), &ParticlesMaterial::set_collision_use_scale); ClassDB::bind_method(D_METHOD("set_collision_use_scale", "radius"), &ParticleProcessMaterial::set_collision_use_scale);
ClassDB::bind_method(D_METHOD("is_collision_using_scale"), &ParticlesMaterial::is_collision_using_scale); ClassDB::bind_method(D_METHOD("is_collision_using_scale"), &ParticleProcessMaterial::is_collision_using_scale);
ClassDB::bind_method(D_METHOD("set_collision_friction", "friction"), &ParticlesMaterial::set_collision_friction); ClassDB::bind_method(D_METHOD("set_collision_friction", "friction"), &ParticleProcessMaterial::set_collision_friction);
ClassDB::bind_method(D_METHOD("get_collision_friction"), &ParticlesMaterial::get_collision_friction); ClassDB::bind_method(D_METHOD("get_collision_friction"), &ParticleProcessMaterial::get_collision_friction);
ClassDB::bind_method(D_METHOD("set_collision_bounce", "bounce"), &ParticlesMaterial::set_collision_bounce); ClassDB::bind_method(D_METHOD("set_collision_bounce", "bounce"), &ParticleProcessMaterial::set_collision_bounce);
ClassDB::bind_method(D_METHOD("get_collision_bounce"), &ParticlesMaterial::get_collision_bounce); ClassDB::bind_method(D_METHOD("get_collision_bounce"), &ParticleProcessMaterial::get_collision_bounce);
ADD_GROUP("Time", ""); ADD_GROUP("Time", "");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "lifetime_randomness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_lifetime_randomness", "get_lifetime_randomness"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "lifetime_randomness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_lifetime_randomness", "get_lifetime_randomness");
@ -1806,7 +1806,7 @@ void ParticlesMaterial::_bind_methods() {
BIND_ENUM_CONSTANT(COLLISION_MAX); BIND_ENUM_CONSTANT(COLLISION_MAX);
} }
ParticlesMaterial::ParticlesMaterial() : ParticleProcessMaterial::ParticleProcessMaterial() :
element(this) { element(this) {
set_direction(Vector3(1, 0, 0)); set_direction(Vector3(1, 0, 0));
set_spread(45); set_spread(45);
@ -1879,7 +1879,7 @@ ParticlesMaterial::ParticlesMaterial() :
_queue_shader_change(); _queue_shader_change();
} }
ParticlesMaterial::~ParticlesMaterial() { ParticleProcessMaterial::~ParticleProcessMaterial() {
MutexLock lock(material_mutex); MutexLock lock(material_mutex);
if (shader_map.has(current_key)) { if (shader_map.has(current_key)) {

30
scene/resources/particles_material.h → scene/resources/particle_process_material.h
View file

@ -1,5 +1,5 @@
/*************************************************************************/ /*************************************************************************/
/* particles_material.h */ /* particle_process_material.h */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* GODOT ENGINE */
@ -31,8 +31,8 @@
#include "core/templates/rid.h" #include "core/templates/rid.h"
#include "scene/resources/material.h" #include "scene/resources/material.h"
#ifndef PARTICLES_MATERIAL_H #ifndef PARTICLE_PROCESS_MATERIAL_H
#define PARTICLES_MATERIAL_H #define PARTICLE_PROCESS_MATERIAL_H
/* /*
TODO: TODO:
@ -41,8 +41,8 @@
-Proper trails -Proper trails
*/ */
class ParticlesMaterial : public Material { class ParticleProcessMaterial : public Material {
GDCLASS(ParticlesMaterial, Material); GDCLASS(ParticleProcessMaterial, Material);
public: public:
enum Parameter { enum Parameter {
@ -170,7 +170,7 @@ private:
} }
static Mutex material_mutex; static Mutex material_mutex;
static SelfList<ParticlesMaterial>::List *dirty_materials; static SelfList<ParticleProcessMaterial>::List *dirty_materials;
struct ShaderNames { struct ShaderNames {
StringName direction; StringName direction;
@ -254,7 +254,7 @@ private:
static ShaderNames *shader_names; static ShaderNames *shader_names;
SelfList<ParticlesMaterial> element; SelfList<ParticleProcessMaterial> element;
void _update_shader(); void _update_shader();
_FORCE_INLINE_ void _queue_shader_change(); _FORCE_INLINE_ void _queue_shader_change();
@ -425,14 +425,14 @@ public:
virtual Shader::Mode get_shader_mode() const override; virtual Shader::Mode get_shader_mode() const override;
ParticlesMaterial(); ParticleProcessMaterial();
~ParticlesMaterial(); ~ParticleProcessMaterial();
}; };
VARIANT_ENUM_CAST(ParticlesMaterial::Parameter) VARIANT_ENUM_CAST(ParticleProcessMaterial::Parameter)
VARIANT_ENUM_CAST(ParticlesMaterial::ParticleFlags) VARIANT_ENUM_CAST(ParticleProcessMaterial::ParticleFlags)
VARIANT_ENUM_CAST(ParticlesMaterial::EmissionShape) VARIANT_ENUM_CAST(ParticleProcessMaterial::EmissionShape)
VARIANT_ENUM_CAST(ParticlesMaterial::SubEmitterMode) VARIANT_ENUM_CAST(ParticleProcessMaterial::SubEmitterMode)
VARIANT_ENUM_CAST(ParticlesMaterial::CollisionMode) VARIANT_ENUM_CAST(ParticleProcessMaterial::CollisionMode)
#endif // PARTICLES_MATERIAL_H #endif // PARTICLE_PROCESS_MATERIAL_H

12
servers/rendering/renderer_rd/storage_rd/particles_storage.cpp
View file

@ -134,7 +134,7 @@ void process() {
material_storage->material_initialize(particles_shader.default_material); material_storage->material_initialize(particles_shader.default_material);
material_storage->material_set_shader(particles_shader.default_material, particles_shader.default_shader); material_storage->material_set_shader(particles_shader.default_material, particles_shader.default_shader);
ParticlesMaterialData *md = static_cast<ParticlesMaterialData *>(material_storage->material_get_data(particles_shader.default_material, MaterialStorage::SHADER_TYPE_PARTICLES)); ParticleProcessMaterialData *md = static_cast<ParticleProcessMaterialData *>(material_storage->material_get_data(particles_shader.default_material, MaterialStorage::SHADER_TYPE_PARTICLES));
particles_shader.default_shader_rd = particles_shader.shader.version_get_shader(md->shader_data->version, 0); particles_shader.default_shader_rd = particles_shader.shader.version_get_shader(md->shader_data->version, 0);
Vector<RD::Uniform> uniforms; Vector<RD::Uniform> uniforms;
@ -1072,9 +1072,9 @@ void ParticlesStorage::_particles_process(Particles *p_particles, double p_delta
RD::get_singleton()->buffer_update(p_particles->frame_params_buffer, 0, sizeof(ParticlesFrameParams) * p_particles->trail_params.size(), p_particles->trail_params.ptr()); RD::get_singleton()->buffer_update(p_particles->frame_params_buffer, 0, sizeof(ParticlesFrameParams) * p_particles->trail_params.size(), p_particles->trail_params.ptr());
ParticlesMaterialData *m = static_cast<ParticlesMaterialData *>(material_storage->material_get_data(p_particles->process_material, MaterialStorage::SHADER_TYPE_PARTICLES)); ParticleProcessMaterialData *m = static_cast<ParticleProcessMaterialData *>(material_storage->material_get_data(p_particles->process_material, MaterialStorage::SHADER_TYPE_PARTICLES));
if (!m) { if (!m) {
m = static_cast<ParticlesMaterialData *>(material_storage->material_get_data(particles_shader.default_material, MaterialStorage::SHADER_TYPE_PARTICLES)); m = static_cast<ParticleProcessMaterialData *>(material_storage->material_get_data(particles_shader.default_material, MaterialStorage::SHADER_TYPE_PARTICLES));
} }
ERR_FAIL_COND(!m); ERR_FAIL_COND(!m);
@ -1696,16 +1696,16 @@ MaterialStorage::ShaderData *ParticlesStorage::_create_particles_shader_func() {
return shader_data; return shader_data;
} }
bool ParticlesStorage::ParticlesMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) { bool ParticlesStorage::ParticleProcessMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
return update_parameters_uniform_set(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, uniform_set, ParticlesStorage::get_singleton()->particles_shader.shader.version_get_shader(shader_data->version, 0), 3); return update_parameters_uniform_set(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, uniform_set, ParticlesStorage::get_singleton()->particles_shader.shader.version_get_shader(shader_data->version, 0), 3);
} }
ParticlesStorage::ParticlesMaterialData::~ParticlesMaterialData() { ParticlesStorage::ParticleProcessMaterialData::~ParticleProcessMaterialData() {
free_parameters_uniform_set(uniform_set); free_parameters_uniform_set(uniform_set);
} }
MaterialStorage::MaterialData *ParticlesStorage::_create_particles_material_func(ParticlesShaderData *p_shader) { MaterialStorage::MaterialData *ParticlesStorage::_create_particles_material_func(ParticlesShaderData *p_shader) {
ParticlesMaterialData *material_data = memnew(ParticlesMaterialData); ParticleProcessMaterialData *material_data = memnew(ParticleProcessMaterialData);
material_data->shader_data = p_shader; material_data->shader_data = p_shader;
//update will happen later anyway so do nothing. //update will happen later anyway so do nothing.
return material_data; return material_data;

4
servers/rendering/renderer_rd/storage_rd/particles_storage.h
View file

@ -354,14 +354,14 @@ private:
return ParticlesStorage::get_singleton()->_create_particles_shader_func(); return ParticlesStorage::get_singleton()->_create_particles_shader_func();
} }
struct ParticlesMaterialData : public MaterialStorage::MaterialData { struct ParticleProcessMaterialData : public MaterialStorage::MaterialData {
ParticlesShaderData *shader_data = nullptr; ParticlesShaderData *shader_data = nullptr;
RID uniform_set; RID uniform_set;
virtual void set_render_priority(int p_priority) {} virtual void set_render_priority(int p_priority) {}
virtual void set_next_pass(RID p_pass) {} virtual void set_next_pass(RID p_pass) {}
virtual bool update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty); virtual bool update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty);
virtual ~ParticlesMaterialData(); virtual ~ParticleProcessMaterialData();
}; };
MaterialStorage::MaterialData *_create_particles_material_func(ParticlesShaderData *p_shader); MaterialStorage::MaterialData *_create_particles_material_func(ParticlesShaderData *p_shader);