godot.gen.godot.CPUParticles2D.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of godot-library-release Show documentation
Show all versions of godot-library-release Show documentation
Contains godot api as kotlin classes and jvm cpp interaction code.
// THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY!
@file:Suppress("PackageDirectoryMismatch", "unused", "FunctionName", "RedundantModalityModifier",
"UNCHECKED_CAST", "JoinDeclarationAndAssignment", "USELESS_CAST",
"RemoveRedundantQualifierName", "NOTHING_TO_INLINE", "NON_FINAL_MEMBER_IN_OBJECT",
"RedundantVisibilityModifier", "RedundantUnitReturnType", "MemberVisibilityCanBePrivate")
package godot
import godot.`annotation`.CoreTypeHelper
import godot.`annotation`.CoreTypeLocalCopy
import godot.`annotation`.GodotBaseType
import godot.core.Color
import godot.core.PackedColorArray
import godot.core.PackedVector2Array
import godot.core.TypeManager
import godot.core.VariantType.BOOL
import godot.core.VariantType.COLOR
import godot.core.VariantType.DOUBLE
import godot.core.VariantType.LONG
import godot.core.VariantType.NIL
import godot.core.VariantType.OBJECT
import godot.core.VariantType.PACKED_COLOR_ARRAY
import godot.core.VariantType.PACKED_VECTOR2_ARRAY
import godot.core.VariantType.VECTOR2
import godot.core.Vector2
import godot.core.memory.TransferContext
import godot.signals.Signal0
import godot.signals.signal
import godot.util.VoidPtr
import kotlin.Boolean
import kotlin.Double
import kotlin.Float
import kotlin.Int
import kotlin.Long
import kotlin.Suppress
import kotlin.Unit
/**
* A CPU-based 2D particle emitter.
*
* Tutorials:
* [$DOCS_URL/tutorials/2d/particle_systems_2d.html]($DOCS_URL/tutorials/2d/particle_systems_2d.html)
*
* CPU-based 2D particle node used to create a variety of particle systems and effects.
*
* See also [godot.GPUParticles2D], which provides the same functionality with hardware acceleration, but may not run on older devices.
*/
@GodotBaseType
public open class CPUParticles2D : Node2D() {
/**
* Emitted when all active particles have finished processing. When [oneShot] is disabled, particles will process continuously, so this is never emitted.
*/
public val finished: Signal0 by signal()
/**
* If `true`, particles are being emitted. [emitting] can be used to start and stop particles from emitting. However, if [oneShot] is `true` setting [emitting] to `true` will not restart the emission cycle until after all active particles finish processing. You can use the [finished] signal to be notified once all active particles finish processing.
*/
public var emitting: Boolean
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.isEmittingPtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setEmittingPtr, NIL)
}
/**
* Number of particles emitted in one emission cycle.
*/
public var amount: Int
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getAmountPtr, LONG)
return (TransferContext.readReturnValue(LONG, false) as Long).toInt()
}
set(`value`) {
TransferContext.writeArguments(LONG to value.toLong())
TransferContext.callMethod(rawPtr, MethodBindings.setAmountPtr, NIL)
}
/**
* Amount of time each particle will exist.
*/
public var lifetime: Double
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getLifetimePtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double)
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value)
TransferContext.callMethod(rawPtr, MethodBindings.setLifetimePtr, NIL)
}
/**
* If `true`, only one emission cycle occurs. If set `true` during a cycle, emission will stop at the cycle's end.
*/
public var oneShot: Boolean
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getOneShotPtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setOneShotPtr, NIL)
}
/**
* Particle system starts as if it had already run for this many seconds.
*/
public var preprocess: Double
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getPreProcessTimePtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double)
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value)
TransferContext.callMethod(rawPtr, MethodBindings.setPreProcessTimePtr, NIL)
}
/**
* Particle system's running speed scaling ratio. A value of `0` can be used to pause the particles.
*/
public var speedScale: Double
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getSpeedScalePtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double)
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value)
TransferContext.callMethod(rawPtr, MethodBindings.setSpeedScalePtr, NIL)
}
/**
* How rapidly particles in an emission cycle are emitted. If greater than `0`, there will be a gap in emissions before the next cycle begins.
*/
public var explosiveness: Float
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getExplosivenessRatioPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setExplosivenessRatioPtr, NIL)
}
/**
* Emission lifetime randomness ratio.
*/
public var randomness: Float
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getRandomnessRatioPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setRandomnessRatioPtr, NIL)
}
/**
* Particle lifetime randomness ratio.
*/
public var lifetimeRandomness: Double
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getLifetimeRandomnessPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double)
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value)
TransferContext.callMethod(rawPtr, MethodBindings.setLifetimeRandomnessPtr, NIL)
}
/**
* The particle system's frame rate is fixed to a value. For example, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself.
*/
public var fixedFps: Int
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getFixedFpsPtr, LONG)
return (TransferContext.readReturnValue(LONG, false) as Long).toInt()
}
set(`value`) {
TransferContext.writeArguments(LONG to value.toLong())
TransferContext.callMethod(rawPtr, MethodBindings.setFixedFpsPtr, NIL)
}
/**
* If `true`, results in fractional delta calculation which has a smoother particles display effect.
*/
public var fractDelta: Boolean
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getFractionalDeltaPtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setFractionalDeltaPtr, NIL)
}
/**
* If `true`, particles use the parent node's coordinate space (known as local coordinates). This will cause particles to move and rotate along the [godot.CPUParticles2D] node (and its parents) when it is moved or rotated. If `false`, particles use global coordinates; they will not move or rotate along the [godot.CPUParticles2D] node (and its parents) when it is moved or rotated.
*/
public var localCoords: Boolean
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getUseLocalCoordinatesPtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setUseLocalCoordinatesPtr, NIL)
}
/**
* Particle draw order. Uses [enum DrawOrder] values.
*/
public var drawOrder: DrawOrder
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getDrawOrderPtr, LONG)
return CPUParticles2D.DrawOrder.from(TransferContext.readReturnValue(LONG) as Long)
}
set(`value`) {
TransferContext.writeArguments(LONG to value.id)
TransferContext.callMethod(rawPtr, MethodBindings.setDrawOrderPtr, NIL)
}
/**
* Particle texture. If `null`, particles will be squares.
*/
public var texture: Texture2D?
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getTexturePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Texture2D?)
}
set(`value`) {
TransferContext.writeArguments(OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setTexturePtr, NIL)
}
/**
* Particles will be emitted inside this region. See [enum EmissionShape] for possible values.
*/
public var emissionShape: EmissionShape
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionShapePtr, LONG)
return CPUParticles2D.EmissionShape.from(TransferContext.readReturnValue(LONG) as Long)
}
set(`value`) {
TransferContext.writeArguments(LONG to value.id)
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionShapePtr, NIL)
}
/**
* The sphere's radius if [emissionShape] is set to [EMISSION_SHAPE_SPHERE].
*/
public var emissionSphereRadius: Float
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionSphereRadiusPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionSphereRadiusPtr, NIL)
}
/**
* The rectangle's extents if [emissionShape] is set to [EMISSION_SHAPE_RECTANGLE].
*/
@CoreTypeLocalCopy
public var emissionRectExtents: Vector2
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionRectExtentsPtr, VECTOR2)
return (TransferContext.readReturnValue(VECTOR2, false) as Vector2)
}
set(`value`) {
TransferContext.writeArguments(VECTOR2 to value)
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionRectExtentsPtr, NIL)
}
/**
* Sets the initial positions to spawn particles when using [EMISSION_SHAPE_POINTS] or [EMISSION_SHAPE_DIRECTED_POINTS].
*/
public var emissionPoints: PackedVector2Array
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionPointsPtr, PACKED_VECTOR2_ARRAY)
return (TransferContext.readReturnValue(PACKED_VECTOR2_ARRAY, false) as PackedVector2Array)
}
set(`value`) {
TransferContext.writeArguments(PACKED_VECTOR2_ARRAY to value)
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionPointsPtr, NIL)
}
/**
* Sets the direction the particles will be emitted in when using [EMISSION_SHAPE_DIRECTED_POINTS].
*/
public var emissionNormals: PackedVector2Array
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionNormalsPtr, PACKED_VECTOR2_ARRAY)
return (TransferContext.readReturnValue(PACKED_VECTOR2_ARRAY, false) as PackedVector2Array)
}
set(`value`) {
TransferContext.writeArguments(PACKED_VECTOR2_ARRAY to value)
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionNormalsPtr, NIL)
}
/**
* Sets the [godot.core.Color]s to modulate particles by when using [EMISSION_SHAPE_POINTS] or [EMISSION_SHAPE_DIRECTED_POINTS].
*/
public var emissionColors: PackedColorArray
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getEmissionColorsPtr, PACKED_COLOR_ARRAY)
return (TransferContext.readReturnValue(PACKED_COLOR_ARRAY, false) as PackedColorArray)
}
set(`value`) {
TransferContext.writeArguments(PACKED_COLOR_ARRAY to value)
TransferContext.callMethod(rawPtr, MethodBindings.setEmissionColorsPtr, NIL)
}
/**
* Align Y axis of particle with the direction of its velocity.
*/
public var particleFlagAlignY: Boolean
get() {
TransferContext.writeArguments(LONG to 0L)
TransferContext.callMethod(rawPtr, MethodBindings.getParticleFlagPtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(LONG to 0L, BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParticleFlagPtr, NIL)
}
/**
* Unit vector specifying the particles' emission direction.
*/
@CoreTypeLocalCopy
public var direction: Vector2
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getDirectionPtr, VECTOR2)
return (TransferContext.readReturnValue(VECTOR2, false) as Vector2)
}
set(`value`) {
TransferContext.writeArguments(VECTOR2 to value)
TransferContext.callMethod(rawPtr, MethodBindings.setDirectionPtr, NIL)
}
/**
* Each particle's initial direction range from `+spread` to `-spread` degrees.
*/
public var spread: Float
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getSpreadPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setSpreadPtr, NIL)
}
/**
* Gravity applied to every particle.
*/
@CoreTypeLocalCopy
public var gravity: Vector2
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getGravityPtr, VECTOR2)
return (TransferContext.readReturnValue(VECTOR2, false) as Vector2)
}
set(`value`) {
TransferContext.writeArguments(VECTOR2 to value)
TransferContext.callMethod(rawPtr, MethodBindings.setGravityPtr, NIL)
}
/**
* Minimum equivalent of [initialVelocityMax].
*/
public var initialVelocityMin: Float
get() {
TransferContext.writeArguments(LONG to 0L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 0L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum initial velocity magnitude for each particle. Direction comes from [direction] and [spread].
*/
public var initialVelocityMax: Float
get() {
TransferContext.writeArguments(LONG to 0L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 0L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Minimum equivalent of [angularVelocityMax].
*/
public var angularVelocityMin: Float
get() {
TransferContext.writeArguments(LONG to 1L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 1L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum initial angular velocity (rotation speed) applied to each particle in *degrees* per second.
*/
public var angularVelocityMax: Float
get() {
TransferContext.writeArguments(LONG to 1L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 1L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's angular velocity will vary along this [godot.Curve].
*/
public var angularVelocityCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 1L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 1L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [orbitVelocityMax].
*/
public var orbitVelocityMin: Float
get() {
TransferContext.writeArguments(LONG to 2L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 2L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum orbital velocity applied to each particle. Makes the particles circle around origin. Specified in number of full rotations around origin per second.
*/
public var orbitVelocityMax: Float
get() {
TransferContext.writeArguments(LONG to 2L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 2L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's orbital velocity will vary along this [godot.Curve].
*/
public var orbitVelocityCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 2L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 2L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [linearAccelMax].
*/
public var linearAccelMin: Float
get() {
TransferContext.writeArguments(LONG to 3L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 3L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum linear acceleration applied to each particle in the direction of motion.
*/
public var linearAccelMax: Float
get() {
TransferContext.writeArguments(LONG to 3L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 3L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's linear acceleration will vary along this [godot.Curve].
*/
public var linearAccelCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 3L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 3L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [radialAccelMax].
*/
public var radialAccelMin: Float
get() {
TransferContext.writeArguments(LONG to 4L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 4L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum radial acceleration applied to each particle. Makes particle accelerate away from the origin or towards it if negative.
*/
public var radialAccelMax: Float
get() {
TransferContext.writeArguments(LONG to 4L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 4L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's radial acceleration will vary along this [godot.Curve].
*/
public var radialAccelCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 4L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 4L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [tangentialAccelMax].
*/
public var tangentialAccelMin: Float
get() {
TransferContext.writeArguments(LONG to 5L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 5L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum tangential acceleration applied to each particle. Tangential acceleration is perpendicular to the particle's velocity giving the particles a swirling motion.
*/
public var tangentialAccelMax: Float
get() {
TransferContext.writeArguments(LONG to 5L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 5L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's tangential acceleration will vary along this [godot.Curve].
*/
public var tangentialAccelCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 5L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 5L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [dampingMax].
*/
public var dampingMin: Float
get() {
TransferContext.writeArguments(LONG to 6L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 6L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* The maximum rate at which particles lose velocity. For example value of `100` means that the particle will go from `100` velocity to `0` in `1` second.
*/
public var dampingMax: Float
get() {
TransferContext.writeArguments(LONG to 6L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 6L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Damping will vary along this [godot.Curve].
*/
public var dampingCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 6L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 6L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [angleMax].
*/
public var angleMin: Float
get() {
TransferContext.writeArguments(LONG to 7L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 7L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum initial rotation applied to each particle, in degrees.
*/
public var angleMax: Float
get() {
TransferContext.writeArguments(LONG to 7L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 7L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's rotation will be animated along this [godot.Curve].
*/
public var angleCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 7L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 7L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [scaleAmountMax].
*/
public var scaleAmountMin: Float
get() {
TransferContext.writeArguments(LONG to 8L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 8L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum initial scale applied to each particle.
*/
public var scaleAmountMax: Float
get() {
TransferContext.writeArguments(LONG to 8L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 8L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's scale will vary along this [godot.Curve].
*/
public var scaleAmountCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 8L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 8L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* If `true`, the scale curve will be split into x and y components. See [scaleCurveX] and [scaleCurveY].
*/
public var splitScale: Boolean
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getSplitScalePtr, BOOL)
return (TransferContext.readReturnValue(BOOL, false) as Boolean)
}
set(`value`) {
TransferContext.writeArguments(BOOL to value)
TransferContext.callMethod(rawPtr, MethodBindings.setSplitScalePtr, NIL)
}
/**
* Each particle's horizontal scale will vary along this [godot.Curve].
*
* [splitScale] must be enabled.
*/
public var scaleCurveX: Curve?
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getScaleCurveXPtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setScaleCurveXPtr, NIL)
}
/**
* Each particle's vertical scale will vary along this [godot.Curve].
*
* [splitScale] must be enabled.
*/
public var scaleCurveY: Curve?
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getScaleCurveYPtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setScaleCurveYPtr, NIL)
}
/**
* Each particle's initial color. If [texture] is defined, it will be multiplied by this color.
*/
@CoreTypeLocalCopy
public var color: Color
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getColorPtr, COLOR)
return (TransferContext.readReturnValue(COLOR, false) as Color)
}
set(`value`) {
TransferContext.writeArguments(COLOR to value)
TransferContext.callMethod(rawPtr, MethodBindings.setColorPtr, NIL)
}
/**
* Each particle's color will vary along this [godot.Gradient] (multiplied with [color]).
*/
public var colorRamp: Gradient?
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getColorRampPtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Gradient?)
}
set(`value`) {
TransferContext.writeArguments(OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setColorRampPtr, NIL)
}
/**
* Each particle's initial color will vary along this [godot.GradientTexture1D] (multiplied with [color]).
*/
public var colorInitialRamp: Gradient?
get() {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.getColorInitialRampPtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Gradient?)
}
set(`value`) {
TransferContext.writeArguments(OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setColorInitialRampPtr, NIL)
}
/**
* Minimum equivalent of [hueVariationMax].
*/
public var hueVariationMin: Float
get() {
TransferContext.writeArguments(LONG to 9L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 9L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum initial hue variation applied to each particle. It will shift the particle color's hue.
*/
public var hueVariationMax: Float
get() {
TransferContext.writeArguments(LONG to 9L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 9L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's hue will vary along this [godot.Curve].
*/
public var hueVariationCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 9L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 9L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [animSpeedMax].
*/
public var animSpeedMin: Float
get() {
TransferContext.writeArguments(LONG to 10L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 10L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum particle animation speed. Animation speed of `1` means that the particles will make full `0` to `1` offset cycle during lifetime, `2` means `2` cycles etc.
*
* With animation speed greater than `1`, remember to enable [godot.CanvasItemMaterial.particlesAnimLoop] property if you want the animation to repeat.
*/
public var animSpeedMax: Float
get() {
TransferContext.writeArguments(LONG to 10L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 10L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's animation speed will vary along this [godot.Curve].
*/
public var animSpeedCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 10L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 10L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
/**
* Minimum equivalent of [animOffsetMax].
*/
public var animOffsetMin: Float
get() {
TransferContext.writeArguments(LONG to 11L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMinPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 11L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMinPtr, NIL)
}
/**
* Maximum animation offset that corresponds to frame index in the texture. `0` is the first frame, `1` is the last one. See [godot.CanvasItemMaterial.particlesAnimation].
*/
public var animOffsetMax: Float
get() {
TransferContext.writeArguments(LONG to 11L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamMaxPtr, DOUBLE)
return (TransferContext.readReturnValue(DOUBLE, false) as Double).toFloat()
}
set(`value`) {
TransferContext.writeArguments(LONG to 11L, DOUBLE to value.toDouble())
TransferContext.callMethod(rawPtr, MethodBindings.setParamMaxPtr, NIL)
}
/**
* Each particle's animation offset will vary along this [godot.Curve].
*/
public var animOffsetCurve: Curve?
get() {
TransferContext.writeArguments(LONG to 11L)
TransferContext.callMethod(rawPtr, MethodBindings.getParamCurvePtr, OBJECT)
return (TransferContext.readReturnValue(OBJECT, true) as Curve?)
}
set(`value`) {
TransferContext.writeArguments(LONG to 11L, OBJECT to value)
TransferContext.callMethod(rawPtr, MethodBindings.setParamCurvePtr, NIL)
}
public override fun new(scriptIndex: Int): Boolean {
callConstructor(ENGINECLASS_CPUPARTICLES2D, scriptIndex)
return true
}
/**
* The rectangle's extents if [emissionShape] is set to [EMISSION_SHAPE_RECTANGLE].
*
* This is a helper function to make dealing with local copies easier.
*
* For more information, see our
* [documentation](https://godot-kotl.in/en/stable/user-guide/api-differences/#core-types).
*
* Allow to directly modify the local copy of the property and assign it back to the Object.
*
* Prefer that over writing:
* ``````
* val myCoreType = cpuparticles2d.emissionRectExtents
* //Your changes
* cpuparticles2d.emissionRectExtents = myCoreType
* ``````
*/
@CoreTypeHelper
public open fun emissionRectExtentsMutate(block: Vector2.() -> Unit): Vector2 =
emissionRectExtents.apply{
block(this)
emissionRectExtents = this
}
/**
* Unit vector specifying the particles' emission direction.
*
* This is a helper function to make dealing with local copies easier.
*
* For more information, see our
* [documentation](https://godot-kotl.in/en/stable/user-guide/api-differences/#core-types).
*
* Allow to directly modify the local copy of the property and assign it back to the Object.
*
* Prefer that over writing:
* ``````
* val myCoreType = cpuparticles2d.direction
* //Your changes
* cpuparticles2d.direction = myCoreType
* ``````
*/
@CoreTypeHelper
public open fun directionMutate(block: Vector2.() -> Unit): Vector2 = direction.apply{
block(this)
direction = this
}
/**
* Gravity applied to every particle.
*
* This is a helper function to make dealing with local copies easier.
*
* For more information, see our
* [documentation](https://godot-kotl.in/en/stable/user-guide/api-differences/#core-types).
*
* Allow to directly modify the local copy of the property and assign it back to the Object.
*
* Prefer that over writing:
* ``````
* val myCoreType = cpuparticles2d.gravity
* //Your changes
* cpuparticles2d.gravity = myCoreType
* ``````
*/
@CoreTypeHelper
public open fun gravityMutate(block: Vector2.() -> Unit): Vector2 = gravity.apply{
block(this)
gravity = this
}
/**
* Each particle's initial color. If [texture] is defined, it will be multiplied by this color.
*
* This is a helper function to make dealing with local copies easier.
*
* For more information, see our
* [documentation](https://godot-kotl.in/en/stable/user-guide/api-differences/#core-types).
*
* Allow to directly modify the local copy of the property and assign it back to the Object.
*
* Prefer that over writing:
* ``````
* val myCoreType = cpuparticles2d.color
* //Your changes
* cpuparticles2d.color = myCoreType
* ``````
*/
@CoreTypeHelper
public open fun colorMutate(block: Color.() -> Unit): Color = color.apply{
block(this)
color = this
}
/**
* Restarts the particle emitter.
*/
public fun restart(): Unit {
TransferContext.writeArguments()
TransferContext.callMethod(rawPtr, MethodBindings.restartPtr, NIL)
}
/**
* Sets this node's properties to match a given [godot.GPUParticles2D] node with an assigned [godot.ParticleProcessMaterial].
*/
public fun convertFromParticles(particles: Node): Unit {
TransferContext.writeArguments(OBJECT to particles)
TransferContext.callMethod(rawPtr, MethodBindings.convertFromParticlesPtr, NIL)
}
public enum class DrawOrder(
id: Long,
) {
/**
* Particles are drawn in the order emitted.
*/
DRAW_ORDER_INDEX(0),
/**
* Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.
*/
DRAW_ORDER_LIFETIME(1),
;
public val id: Long
init {
this.id = id
}
public companion object {
public fun from(`value`: Long) = entries.single { it.id == `value` }
}
}
public enum class Parameter(
id: Long,
) {
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set initial velocity properties.
*/
PARAM_INITIAL_LINEAR_VELOCITY(0),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set angular velocity properties.
*/
PARAM_ANGULAR_VELOCITY(1),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set orbital velocity properties.
*/
PARAM_ORBIT_VELOCITY(2),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set linear acceleration properties.
*/
PARAM_LINEAR_ACCEL(3),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set radial acceleration properties.
*/
PARAM_RADIAL_ACCEL(4),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set tangential acceleration properties.
*/
PARAM_TANGENTIAL_ACCEL(5),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set damping properties.
*/
PARAM_DAMPING(6),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set angle properties.
*/
PARAM_ANGLE(7),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set scale properties.
*/
PARAM_SCALE(8),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set hue variation properties.
*/
PARAM_HUE_VARIATION(9),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set animation speed properties.
*/
PARAM_ANIM_SPEED(10),
/**
* Use with [setParamMin], [setParamMax], and [setParamCurve] to set animation offset properties.
*/
PARAM_ANIM_OFFSET(11),
/**
* Represents the size of the [enum Parameter] enum.
*/
PARAM_MAX(12),
;
public val id: Long
init {
this.id = id
}
public companion object {
public fun from(`value`: Long) = entries.single { it.id == `value` }
}
}
public enum class ParticleFlags(
id: Long,
) {
/**
* Use with [setParticleFlag] to set [particleFlagAlignY].
*/
PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY(0),
/**
* Present for consistency with 3D particle nodes, not used in 2D.
*/
PARTICLE_FLAG_ROTATE_Y(1),
/**
* Present for consistency with 3D particle nodes, not used in 2D.
*/
PARTICLE_FLAG_DISABLE_Z(2),
/**
* Represents the size of the [enum ParticleFlags] enum.
*/
PARTICLE_FLAG_MAX(3),
;
public val id: Long
init {
this.id = id
}
public companion object {
public fun from(`value`: Long) = entries.single { it.id == `value` }
}
}
public enum class EmissionShape(
id: Long,
) {
/**
* All particles will be emitted from a single point.
*/
EMISSION_SHAPE_POINT(0),
/**
* Particles will be emitted in the volume of a sphere flattened to two dimensions.
*/
EMISSION_SHAPE_SPHERE(1),
/**
* Particles will be emitted on the surface of a sphere flattened to two dimensions.
*/
EMISSION_SHAPE_SPHERE_SURFACE(2),
/**
* Particles will be emitted in the area of a rectangle.
*/
EMISSION_SHAPE_RECTANGLE(3),
/**
* Particles will be emitted at a position chosen randomly among [emissionPoints]. Particle color will be modulated by [emissionColors].
*/
EMISSION_SHAPE_POINTS(4),
/**
* Particles will be emitted at a position chosen randomly among [emissionPoints]. Particle velocity and rotation will be set based on [emissionNormals]. Particle color will be modulated by [emissionColors].
*/
EMISSION_SHAPE_DIRECTED_POINTS(5),
/**
* Represents the size of the [enum EmissionShape] enum.
*/
EMISSION_SHAPE_MAX(6),
;
public val id: Long
init {
this.id = id
}
public companion object {
public fun from(`value`: Long) = entries.single { it.id == `value` }
}
}
public companion object
internal object MethodBindings {
public val setEmittingPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emitting")
public val setAmountPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "set_amount")
public val setLifetimePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_lifetime")
public val setOneShotPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_one_shot")
public val setPreProcessTimePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_pre_process_time")
public val setExplosivenessRatioPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_explosiveness_ratio")
public val setRandomnessRatioPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_randomness_ratio")
public val setLifetimeRandomnessPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_lifetime_randomness")
public val setUseLocalCoordinatesPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_use_local_coordinates")
public val setFixedFpsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_fixed_fps")
public val setFractionalDeltaPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_fractional_delta")
public val setSpeedScalePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_speed_scale")
public val isEmittingPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "is_emitting")
public val getAmountPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "get_amount")
public val getLifetimePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_lifetime")
public val getOneShotPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_one_shot")
public val getPreProcessTimePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_pre_process_time")
public val getExplosivenessRatioPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_explosiveness_ratio")
public val getRandomnessRatioPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_randomness_ratio")
public val getLifetimeRandomnessPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_lifetime_randomness")
public val getUseLocalCoordinatesPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_use_local_coordinates")
public val getFixedFpsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_fixed_fps")
public val getFractionalDeltaPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_fractional_delta")
public val getSpeedScalePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_speed_scale")
public val setDrawOrderPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_draw_order")
public val getDrawOrderPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_draw_order")
public val setTexturePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_texture")
public val getTexturePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_texture")
public val restartPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "restart")
public val setDirectionPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_direction")
public val getDirectionPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_direction")
public val setSpreadPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "set_spread")
public val getSpreadPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "get_spread")
public val setParamMinPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_param_min")
public val getParamMinPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_param_min")
public val setParamMaxPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_param_max")
public val getParamMaxPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_param_max")
public val setParamCurvePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_param_curve")
public val getParamCurvePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_param_curve")
public val setColorPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "set_color")
public val getColorPtr: VoidPtr = TypeManager.getMethodBindPtr("CPUParticles2D", "get_color")
public val setColorRampPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_color_ramp")
public val getColorRampPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_color_ramp")
public val setColorInitialRampPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_color_initial_ramp")
public val getColorInitialRampPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_color_initial_ramp")
public val setParticleFlagPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_particle_flag")
public val getParticleFlagPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_particle_flag")
public val setEmissionShapePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_shape")
public val getEmissionShapePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_shape")
public val setEmissionSphereRadiusPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_sphere_radius")
public val getEmissionSphereRadiusPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_sphere_radius")
public val setEmissionRectExtentsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_rect_extents")
public val getEmissionRectExtentsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_rect_extents")
public val setEmissionPointsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_points")
public val getEmissionPointsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_points")
public val setEmissionNormalsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_normals")
public val getEmissionNormalsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_normals")
public val setEmissionColorsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_emission_colors")
public val getEmissionColorsPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_emission_colors")
public val getGravityPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_gravity")
public val setGravityPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_gravity")
public val getSplitScalePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_split_scale")
public val setSplitScalePtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_split_scale")
public val getScaleCurveXPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_scale_curve_x")
public val setScaleCurveXPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_scale_curve_x")
public val getScaleCurveYPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "get_scale_curve_y")
public val setScaleCurveYPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "set_scale_curve_y")
public val convertFromParticlesPtr: VoidPtr =
TypeManager.getMethodBindPtr("CPUParticles2D", "convert_from_particles")
}
}