@galacean/engine 2.0.0-alpha.17 → 2.0.0-alpha.18
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +98 -97
- package/dist/browser.js.map +1 -1
- package/dist/browser.min.js +1 -1
- package/dist/browser.min.js.map +1 -1
- package/dist/bundled.module.js +98 -97
- package/dist/bundled.module.js.map +1 -1
- package/dist/bundled.module.min.js +1 -1
- package/dist/bundled.module.min.js.map +1 -1
- package/dist/main.js +1 -1
- package/dist/module.js +1 -1
- package/package.json +5 -5
package/dist/browser.js
CHANGED
|
@@ -9887,7 +9887,7 @@
|
|
|
9887
9887
|
var color_over_lifetime_module = "#if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n uniform vec4 renderer_COLMaxGradientColor[4]; // x:time y:r z:g w:b\n uniform vec2 renderer_COLMaxGradientAlpha[4]; // x:time y:alpha\n\n #ifdef RENDERER_COL_RANDOM_GRADIENTS\n uniform vec4 renderer_COLMinGradientColor[4]; // x:time y:r z:g w:b\n uniform vec2 renderer_COLMinGradientAlpha[4]; // x:time y:alpha\n #endif\n\n uniform vec4 renderer_COLGradientKeysMaxTime; // x: minColorKeysMaxTime, y: minAlphaKeysMaxTime, z: maxColorKeysMaxTime, w: maxAlphaKeysMaxTime\n#endif\n\n\nvec4 computeParticleColor(in vec4 color, in float normalizedAge) {\n #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n vec4 gradientColor = evaluateParticleGradient(renderer_COLMaxGradientColor, renderer_COLGradientKeysMaxTime.z, renderer_COLMaxGradientAlpha, renderer_COLGradientKeysMaxTime.w, normalizedAge);\n #endif\n\n #ifdef RENDERER_COL_RANDOM_GRADIENTS\n gradientColor = mix(evaluateParticleGradient(renderer_COLMinGradientColor,renderer_COLGradientKeysMaxTime.x, renderer_COLMinGradientAlpha, renderer_COLGradientKeysMaxTime.y, normalizedAge), gradientColor, a_Random0.y);\n #endif\n\n #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n color *= gradientColor;\n #endif\n\n return color;\n}\n"; // eslint-disable-line
|
|
9888
9888
|
var texture_sheet_animation_module = "#if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n uniform float renderer_TSACycles;\n uniform vec3 renderer_TSATillingParams; // x:subU y:subV z:tileCount\n uniform vec2 renderer_TSAFrameMaxCurve[4]; // x:time y:value\n\n #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n uniform vec2 renderer_TSAFrameMinCurve[4]; // x:time y:value\n #endif\n#endif\n\nvec2 computeParticleUV(in vec2 uv, in float normalizedAge) {\n #if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n float scaledNormalizedAge = normalizedAge * renderer_TSACycles;\n float cycleNormalizedAge = scaledNormalizedAge - floor(scaledNormalizedAge);\n float normalizedFrame = evaluateParticleCurve(renderer_TSAFrameMaxCurve, cycleNormalizedAge);\n #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n normalizedFrame = mix(evaluateParticleCurve(renderer_TSAFrameMinCurve, cycleNormalizedAge), normalizedFrame, a_Random1.x);\n #endif\n\n float frame = floor(normalizedFrame * renderer_TSATillingParams.z);\n\n float tileRow = frame * renderer_TSATillingParams.x;\n float tileRowIndex = floor(tileRow);\n uv.x += tileRow - tileRowIndex;\n uv.y += tileRowIndex * renderer_TSATillingParams.y;\n #endif\n \n return uv;\n}\n"; // eslint-disable-line
|
|
9889
9889
|
var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE)\n #define _FOL_MODULE_ENABLED\n#endif\n\n#ifdef _FOL_MODULE_ENABLED\n uniform int renderer_FOLSpace;\n\n #ifdef RENDERER_FOL_CONSTANT_MODE\n uniform vec3 renderer_FOLMaxConst;\n\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n uniform vec3 renderer_FOLMinConst;\n #endif\n\n #endif\n\n #ifdef RENDERER_FOL_CURVE_MODE\n uniform vec2 renderer_FOLMaxGradientX[4];\n uniform vec2 renderer_FOLMaxGradientY[4];\n uniform vec2 renderer_FOLMaxGradientZ[4];\n\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n uniform vec2 renderer_FOLMinGradientX[4];\n uniform vec2 renderer_FOLMinGradientY[4];\n uniform vec2 renderer_FOLMinGradientZ[4];\n #endif\n #endif\n\n // (tHat - t1) * (tHat - t1) * (tHat - t1) * (a2 - a1) / ((t2 - t1) * 6.0) + a1 * (tHat - t1) * (tHat - t1) * 0.5 + v1 * (tHat - t1);\n // to = tHat - t1; tr = t2 - t1\n float computeDisplacementIntegral(in float to, in float tr, in float a1, in float a2, in float v1) {\n return to * to * to * (a2 - a1) / (tr * 6.0) + a1 * to * to * 0.5 + v1 * to;\n }\n\n float evaluateForceParticleCurveCumulative(in vec2 keys[4], in float normalizedAge, out float velocityCumulative) {\n float cumulativeValue = 0.0;\n velocityCumulative = 0.0;\n\n for (int i = 1; i < 4; i++){\n vec2 key = keys[i];\n vec2 lastKey = keys[i - 1];\n float timeRange = (key.x - lastKey.x) * a_ShapePositionStartLifeTime.w;\n\n if (key.x >= normalizedAge){\n float timeOffset = (normalizedAge - lastKey.x) * a_ShapePositionStartLifeTime.w;\n cumulativeValue += computeDisplacementIntegral(timeOffset, timeRange, lastKey.y, key.y, velocityCumulative);\n\n float finalAcceleration = mix(lastKey.y, key.y, timeOffset / timeRange);\n velocityCumulative += 0.5 * timeOffset * (finalAcceleration + lastKey.y);\n break;\n } else { \n cumulativeValue += computeDisplacementIntegral(timeRange, timeRange, lastKey.y, key.y, velocityCumulative);\n velocityCumulative += 0.5 * timeRange * (lastKey.y + key.y);\n }\n }\n return cumulativeValue;\n }\n\n vec3 computeForcePositionOffset(in float normalizedAge, in float age, out vec3 velocityOffset) {\n vec3 forcePosition;\n\n #if defined(RENDERER_FOL_CONSTANT_MODE)\n vec3 forceAcceleration = renderer_FOLMaxConst;\n\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n forceAcceleration = mix(renderer_FOLMinConst, forceAcceleration, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n #endif\n\n velocityOffset = forceAcceleration * age;\n\n forcePosition = 0.5 * forceAcceleration * age * age;\n #elif defined(RENDERER_FOL_CURVE_MODE)\n forcePosition = vec3(\n evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientX, normalizedAge, velocityOffset.x),\n evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientY, normalizedAge, velocityOffset.y),\n evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientZ, normalizedAge, velocityOffset.z)\n );\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n vec3 minVelocityOffset;\n\n forcePosition = vec3(\n mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientX, normalizedAge, minVelocityOffset.x), forcePosition.x, a_Random2.x),\n mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientY, normalizedAge, minVelocityOffset.y), forcePosition.y, a_Random2.y),\n mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientZ, normalizedAge, minVelocityOffset.z), forcePosition.z, a_Random2.z)\n );\n\n velocityOffset = mix(minVelocityOffset, velocityOffset, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n #endif\n #endif\n return forcePosition;\n }\n#endif"; // eslint-disable-line
|
|
9890
|
-
var limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n uniform int renderer_LVLSpace;\n uniform float renderer_LVLDampen;\n\n // Scalar limit\n #ifndef RENDERER_LVL_SEPARATE_AXES\n #ifdef
|
|
9890
|
+
var limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n uniform int renderer_LVLSpace;\n uniform float renderer_LVLDampen;\n\n // Scalar limit\n #ifndef RENDERER_LVL_SEPARATE_AXES\n #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n uniform float renderer_LVLSpeedMaxConst;\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n uniform float renderer_LVLSpeedMinConst;\n #endif\n #endif\n #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n uniform vec2 renderer_LVLSpeedMaxCurve[4];\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n uniform vec2 renderer_LVLSpeedMinCurve[4];\n #endif\n #endif\n #endif\n\n // Per-axis limit\n #ifdef RENDERER_LVL_SEPARATE_AXES\n #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n uniform vec3 renderer_LVLSpeedMaxConstVector;\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n uniform vec3 renderer_LVLSpeedMinConstVector;\n #endif\n #endif\n #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n uniform vec2 renderer_LVLSpeedXMaxCurve[4];\n uniform vec2 renderer_LVLSpeedYMaxCurve[4];\n uniform vec2 renderer_LVLSpeedZMaxCurve[4];\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n uniform vec2 renderer_LVLSpeedXMinCurve[4];\n uniform vec2 renderer_LVLSpeedYMinCurve[4];\n uniform vec2 renderer_LVLSpeedZMinCurve[4];\n #endif\n #endif\n #endif\n\n // Drag curve\n #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n uniform vec2 renderer_LVLDragMaxCurve[4];\n #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n uniform vec2 renderer_LVLDragMinCurve[4];\n #endif\n #endif\n\n float evaluateLVLDrag(float normalizedAge, float dragRand) {\n #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n float dragMax = evaluateParticleCurve(renderer_LVLDragMaxCurve, normalizedAge);\n #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n float dragMin = evaluateParticleCurve(renderer_LVLDragMinCurve, normalizedAge);\n return mix(dragMin, dragMax, dragRand);\n #else\n return dragMax;\n #endif\n #else\n return mix(renderer_LVLDragConstant.x, renderer_LVLDragConstant.y, dragRand);\n #endif\n }\n\n vec3 applyLVLSpeedLimitTF(vec3 velocity, float normalizedAge, float limitRand, float effectiveDampen) {\n #ifdef RENDERER_LVL_SEPARATE_AXES\n vec3 limitSpeed;\n #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n limitSpeed = renderer_LVLSpeedMaxConstVector;\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n limitSpeed = mix(renderer_LVLSpeedMinConstVector, limitSpeed, limitRand);\n #endif\n #endif\n #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n limitSpeed = vec3(\n evaluateParticleCurve(renderer_LVLSpeedXMaxCurve, normalizedAge),\n evaluateParticleCurve(renderer_LVLSpeedYMaxCurve, normalizedAge),\n evaluateParticleCurve(renderer_LVLSpeedZMaxCurve, normalizedAge)\n );\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n vec3 minLimitSpeed = vec3(\n evaluateParticleCurve(renderer_LVLSpeedXMinCurve, normalizedAge),\n evaluateParticleCurve(renderer_LVLSpeedYMinCurve, normalizedAge),\n evaluateParticleCurve(renderer_LVLSpeedZMinCurve, normalizedAge)\n );\n limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n #endif\n #endif\n\n vec3 absVel = abs(velocity);\n vec3 excess = max(absVel - limitSpeed, vec3(0.0));\n velocity = sign(velocity) * (absVel - excess * effectiveDampen);\n #else\n float limitSpeed;\n #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n limitSpeed = renderer_LVLSpeedMaxConst;\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n limitSpeed = mix(renderer_LVLSpeedMinConst, limitSpeed, limitRand);\n #endif\n #endif\n #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n limitSpeed = evaluateParticleCurve(renderer_LVLSpeedMaxCurve, normalizedAge);\n #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n float minLimitSpeed = evaluateParticleCurve(renderer_LVLSpeedMinCurve, normalizedAge);\n limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n #endif\n #endif\n\n float speed = length(velocity);\n if (speed > limitSpeed && speed > 0.0) {\n float excess = speed - limitSpeed;\n velocity = velocity * ((speed - excess * effectiveDampen) / speed);\n }\n #endif\n return velocity;\n }\n\n#endif\n"; // eslint-disable-line
|
|
9891
9891
|
var particle_feedback_simulation = "// Transform Feedback update shader for particle simulation.\n// Update order: VOL/FOL → Dampen → Drag → Position.\n// Runs once per particle per frame (no rasterization).\n\n// Previous frame TF data\nattribute vec3 a_FeedbackPosition;\nattribute vec3 a_FeedbackVelocity;\n\n// Per-particle instance data\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec3 a_StartSize;\nattribute float a_StartSpeed;\nattribute vec4 a_Random0;\nattribute vec4 a_Random1;\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\nattribute vec4 a_Random2;\n\n// Uniforms\nuniform float renderer_CurrentTime;\nuniform float renderer_DeltaTime;\nuniform vec3 renderer_Gravity;\nuniform vec2 renderer_LVLDragConstant;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform int renderer_SimulationSpace;\n\n// TF outputs\nvarying vec3 v_FeedbackPosition;\nvarying vec3 v_FeedbackVelocity;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <limit_velocity_over_lifetime_module>\n\n// Get VOL instantaneous velocity at normalizedAge\nvec3 getVOLVelocity(float normalizedAge) {\n vec3 vel = vec3(0.0);\n #ifdef _VOL_MODULE_ENABLED\n #ifdef RENDERER_VOL_CONSTANT_MODE\n vel = renderer_VOLMaxConst;\n #ifdef RENDERER_VOL_IS_RANDOM_TWO\n vel = mix(renderer_VOLMinConst, vel, a_Random1.yzw);\n #endif\n #endif\n #ifdef RENDERER_VOL_CURVE_MODE\n vel = vec3(\n evaluateParticleCurve(renderer_VOLMaxGradientX, normalizedAge),\n evaluateParticleCurve(renderer_VOLMaxGradientY, normalizedAge),\n evaluateParticleCurve(renderer_VOLMaxGradientZ, normalizedAge)\n );\n #ifdef RENDERER_VOL_IS_RANDOM_TWO\n vec3 minVel = vec3(\n evaluateParticleCurve(renderer_VOLMinGradientX, normalizedAge),\n evaluateParticleCurve(renderer_VOLMinGradientY, normalizedAge),\n evaluateParticleCurve(renderer_VOLMinGradientZ, normalizedAge)\n );\n vel = mix(minVel, vel, a_Random1.yzw);\n #endif\n #endif\n #endif\n return vel;\n}\n\n// Get FOL instantaneous acceleration at normalizedAge\nvec3 getFOLAcceleration(float normalizedAge) {\n vec3 acc = vec3(0.0);\n #ifdef _FOL_MODULE_ENABLED\n #ifdef RENDERER_FOL_CONSTANT_MODE\n acc = renderer_FOLMaxConst;\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n acc = mix(renderer_FOLMinConst, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n #endif\n #endif\n #ifdef RENDERER_FOL_CURVE_MODE\n acc = vec3(\n evaluateParticleCurve(renderer_FOLMaxGradientX, normalizedAge),\n evaluateParticleCurve(renderer_FOLMaxGradientY, normalizedAge),\n evaluateParticleCurve(renderer_FOLMaxGradientZ, normalizedAge)\n );\n #ifdef RENDERER_FOL_IS_RANDOM_TWO\n vec3 minAcc = vec3(\n evaluateParticleCurve(renderer_FOLMinGradientX, normalizedAge),\n evaluateParticleCurve(renderer_FOLMinGradientY, normalizedAge),\n evaluateParticleCurve(renderer_FOLMinGradientZ, normalizedAge)\n );\n acc = mix(minAcc, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n #endif\n #endif\n #endif\n return acc;\n}\n\nvoid main() {\n float age = renderer_CurrentTime - a_DirectionTime.w;\n float lifetime = a_ShapePositionStartLifeTime.w;\n float normalizedAge = age / lifetime;\n // Clamp to age on the first TF pass: particles emitted mid-frame have age < dt,\n // so using the full dt would over-integrate. Subsequent passes are unaffected (age >= dt).\n float dt = min(renderer_DeltaTime, age);\n\n // normalizedAge < 0.0: stale TF slot whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n if (normalizedAge >= 1.0 || normalizedAge < 0.0) {\n v_FeedbackPosition = a_FeedbackPosition;\n v_FeedbackVelocity = a_FeedbackVelocity;\n gl_Position = vec4(0.0);\n return;\n }\n\n vec4 worldRotation;\n if (renderer_SimulationSpace == 0) {\n worldRotation = renderer_WorldRotation;\n } else {\n worldRotation = a_SimulationWorldRotation;\n }\n vec4 invWorldRotation = quaternionConjugate(worldRotation);\n\n // Read previous frame state (initialized by CPU on particle birth)\n vec3 localVelocity = a_FeedbackVelocity;\n\n // =====================================================\n // Step 1: Apply velocity module deltas (VOL + FOL + Gravity)\n // =====================================================\n\n // Gravity (world space)\n vec3 gravityDelta = renderer_Gravity * a_Random0.x * dt;\n\n // VOL instantaneous velocity (animated velocity, not persisted)\n vec3 volLocal = vec3(0.0);\n vec3 volWorld = vec3(0.0);\n #ifdef _VOL_MODULE_ENABLED\n vec3 vol = getVOLVelocity(normalizedAge);\n if (renderer_VOLSpace == 0) {\n volLocal = vol;\n } else {\n volWorld = vol;\n }\n #endif\n\n // FOL acceleration → velocity delta (always persisted, like gravity)\n vec3 folDeltaLocal = vec3(0.0);\n #ifdef _FOL_MODULE_ENABLED\n vec3 folAcc = getFOLAcceleration(normalizedAge);\n vec3 folVelDelta = folAcc * dt;\n if (renderer_FOLSpace == 0) {\n folDeltaLocal = folVelDelta;\n } else {\n // World FOL: convert to local and persist, same as gravity\n folDeltaLocal = rotationByQuaternions(folVelDelta, invWorldRotation);\n }\n #endif\n\n // Gravity and FOL contribute to base velocity (persisted, subject to dampen/drag).\n vec3 gravityLocal = rotationByQuaternions(gravityDelta, invWorldRotation);\n localVelocity += folDeltaLocal + gravityLocal;\n\n // =====================================================\n // Step 2 & 3: Dampen (Limit Velocity) + Drag\n // VOL must be projected into the LVL target space so that\n // limit/drag see the full velocity regardless of VOL.space vs LVL.space.\n // =====================================================\n #ifdef RENDERER_LVL_MODULE_ENABLED\n // Precompute VOL in both spaces\n vec3 volAsLocal = volLocal + rotationByQuaternions(volWorld, invWorldRotation);\n vec3 volAsWorld = rotationByQuaternions(volLocal, worldRotation) + volWorld;\n\n float limitRand = a_Random2.w;\n float dampen = renderer_LVLDampen;\n // Frame-rate independent dampen (30fps as reference)\n float effectiveDampen = 1.0 - pow(1.0 - dampen, dt * 30.0);\n\n if (renderer_LVLSpace == 0) {\n // Local space: total = base + all VOL projected to local\n vec3 totalLocal = localVelocity + volAsLocal;\n vec3 dampenedTotal = applyLVLSpeedLimitTF(totalLocal, normalizedAge, limitRand, effectiveDampen);\n localVelocity = dampenedTotal - volAsLocal;\n } else {\n // World space: total = rotated base + all VOL projected to world\n vec3 totalWorld = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n vec3 dampenedTotal = applyLVLSpeedLimitTF(totalWorld, normalizedAge, limitRand, effectiveDampen);\n localVelocity = rotationByQuaternions(dampenedTotal - volAsWorld, invWorldRotation);\n }\n\n // Drag: same space as dampen\n {\n float dragCoeff = evaluateLVLDrag(normalizedAge, a_Random2.w);\n if (dragCoeff > 0.0) {\n vec3 totalVel;\n if (renderer_LVLSpace == 0) {\n totalVel = localVelocity + volAsLocal;\n } else {\n totalVel = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n }\n float velMagSqr = dot(totalVel, totalVel);\n float velMag = sqrt(velMagSqr);\n\n float drag = dragCoeff;\n\n #ifdef RENDERER_LVL_DRAG_MULTIPLY_SIZE\n float maxDim = max(a_StartSize.x, max(a_StartSize.y, a_StartSize.z));\n float radius = maxDim * 0.5;\n drag *= 3.14159265 * radius * radius;\n #endif\n\n #ifdef RENDERER_LVL_DRAG_MULTIPLY_VELOCITY\n drag *= velMagSqr;\n #endif\n\n if (velMag > 0.0) {\n float newVelMag = max(0.0, velMag - drag * dt);\n vec3 draggedTotal = totalVel * (newVelMag / velMag);\n if (renderer_LVLSpace == 0) {\n localVelocity = draggedTotal - volAsLocal;\n } else {\n localVelocity = rotationByQuaternions(draggedTotal - volAsWorld, invWorldRotation);\n }\n }\n }\n }\n #endif\n\n // =====================================================\n // Step 4: Integrate position in simulation space\n // Local mode: position in local space, velocity rotated to local\n // World mode: position in world space, velocity rotated to world\n // =====================================================\n // FOL is now fully in localVelocity (both local and world-space FOL).\n // Only VOL overlay needs to be added here.\n vec3 totalVelocity;\n if (renderer_SimulationSpace == 0) {\n // Local: integrate in local space\n totalVelocity = localVelocity + volLocal\n + rotationByQuaternions(volWorld, invWorldRotation);\n } else {\n // World: integrate in world space\n totalVelocity = rotationByQuaternions(localVelocity + volLocal, worldRotation) + volWorld;\n }\n vec3 position = a_FeedbackPosition + totalVelocity * dt;\n\n v_FeedbackPosition = position;\n v_FeedbackVelocity = localVelocity;\n gl_Position = vec4(0.0);\n}\n"; // eslint-disable-line
|
|
9892
9892
|
var sphere_billboard = "#ifdef RENDERER_MODE_SPHERE_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 sideVector = normalize(cross(camera_Forward, camera_Up));\n\tvec3 upVector = normalize(cross(sideVector, camera_Forward));\n\tcorner *= computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n if (renderer_ThreeDStartRotation) {\n vec3 rotation = radians(vec3(a_StartRotation0.xy, computeParticleRotationFloat(a_StartRotation0.z, age, normalizedAge)));\n center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, rotation);\n } else {\n float rot = radians(computeParticleRotationFloat(a_StartRotation0.x, age, normalizedAge));\n float c = cos(rot);\n float s = sin(rot);\n mat2 rotation = mat2(c, -s, s, c);\n corner = rotation * corner;\n center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n }\n #else\n if (renderer_ThreeDStartRotation) {\n center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, radians(a_StartRotation0));\n } else {\n float c = cos(radians(a_StartRotation0.x));\n float s = sin(radians(a_StartRotation0.x));\n mat2 rotation = mat2(c, -s, s, c);\n corner = rotation * corner;\n center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n }\n #endif\n#endif"; // eslint-disable-line
|
|
9893
9893
|
var stretched_billboard = "#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 velocity = rotationByQuaternions(renderer_SizeScale * localVelocity, worldRotation) + worldVelocity;\n\tvec3 cameraUpVector = normalize(velocity);\n\tvec3 direction = normalize(center - camera_Position);\n\tvec3 sideVector = normalize(cross(direction, normalize(velocity)));\n\n\tsideVector = renderer_SizeScale.xzy * sideVector;\n\tcameraUpVector = length(vec3(renderer_SizeScale.x, 0.0, 0.0)) * cameraUpVector;\n\n\tvec2 size = computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n\n\tconst mat2 rotationZHalfPI = mat2(0.0, -1.0, 1.0, 0.0);\n\tcorner = rotationZHalfPI * corner;\n\tcorner.y = corner.y - abs(corner.y);\n\n\tfloat speed = length(velocity); // TODO:\n\tcenter += sign(renderer_SizeScale.x) * (sign(renderer_StretchedBillboardLengthScale) * size.x * corner.x * sideVector\n\t + (speed * renderer_StretchedBillboardSpeedScale + size.y * renderer_StretchedBillboardLengthScale) * corner.y * cameraUpVector);\n#endif"; // eslint-disable-line
|
|
@@ -39590,10 +39590,10 @@
|
|
|
39590
39590
|
_inherits$2(LimitVelocityOverLifetimeModule, ParticleGeneratorModule);
|
|
39591
39591
|
function LimitVelocityOverLifetimeModule(generator) {
|
|
39592
39592
|
var _this;
|
|
39593
|
-
_this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this.
|
|
39594
|
-
_this.
|
|
39595
|
-
_this.
|
|
39596
|
-
_this.
|
|
39593
|
+
_this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._speedRand = new Rand(0, ParticleRandomSubSeeds.LimitVelocityOverLifetime), _this._speedMinConstantVec = new Vector3(), _this._speedMaxConstantVec = new Vector3(), _this._dragConstantVec = new Vector2(), _this._separateAxes = false, _this._dampen = 0, _this._multiplyDragByParticleSize = false, _this._multiplyDragByParticleVelocity = false, _this._space = ParticleSimulationSpace.Local;
|
|
39594
|
+
_this.speedX = new ParticleCompositeCurve(1);
|
|
39595
|
+
_this.speedY = new ParticleCompositeCurve(1);
|
|
39596
|
+
_this.speedZ = new ParticleCompositeCurve(1);
|
|
39597
39597
|
_this.drag = new ParticleCompositeCurve(0);
|
|
39598
39598
|
return _this;
|
|
39599
39599
|
}
|
|
@@ -39605,19 +39605,19 @@
|
|
|
39605
39605
|
};
|
|
39606
39606
|
/**
|
|
39607
39607
|
* @internal
|
|
39608
|
-
*/ _proto.
|
|
39608
|
+
*/ _proto._isSpeedRandomMode = function _isSpeedRandomMode() {
|
|
39609
39609
|
if (this._separateAxes) {
|
|
39610
|
-
return (this.
|
|
39610
|
+
return (this._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves) && (this._speedY.mode === ParticleCurveMode.TwoConstants || this._speedY.mode === ParticleCurveMode.TwoCurves) && (this._speedZ.mode === ParticleCurveMode.TwoConstants || this._speedZ.mode === ParticleCurveMode.TwoCurves);
|
|
39611
39611
|
}
|
|
39612
|
-
return this.
|
|
39612
|
+
return this._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves;
|
|
39613
39613
|
};
|
|
39614
39614
|
/**
|
|
39615
39615
|
* @internal
|
|
39616
39616
|
*/ _proto._updateShaderData = function _updateShaderData(shaderData) {
|
|
39617
39617
|
var enabledModuleMacro = null;
|
|
39618
39618
|
var separateAxesMacro = null;
|
|
39619
|
-
var
|
|
39620
|
-
var
|
|
39619
|
+
var speedModeMacro = null;
|
|
39620
|
+
var speedRandomMacro = null;
|
|
39621
39621
|
var dragCurveMacro = null;
|
|
39622
39622
|
var dragRandomMacro = null;
|
|
39623
39623
|
var dragSizeMacro = null;
|
|
@@ -39628,16 +39628,16 @@
|
|
|
39628
39628
|
shaderData.setFloat(LimitVelocityOverLifetimeModule._dampenProperty, this._dampen);
|
|
39629
39629
|
// Space
|
|
39630
39630
|
shaderData.setInt(LimitVelocityOverLifetimeModule._spaceProperty, this._space);
|
|
39631
|
-
// Limit
|
|
39631
|
+
// Limit speed
|
|
39632
39632
|
if (this._separateAxes) {
|
|
39633
39633
|
separateAxesMacro = LimitVelocityOverLifetimeModule._separateAxesMacro;
|
|
39634
|
-
var result = this.
|
|
39635
|
-
|
|
39636
|
-
|
|
39634
|
+
var result = this._uploadSeparateAxisSpeeds(shaderData);
|
|
39635
|
+
speedModeMacro = result.modeMacro;
|
|
39636
|
+
speedRandomMacro = result.randomMacro;
|
|
39637
39637
|
} else {
|
|
39638
|
-
var result1 = this.
|
|
39639
|
-
|
|
39640
|
-
|
|
39638
|
+
var result1 = this._uploadScalarSpeed(shaderData);
|
|
39639
|
+
speedModeMacro = result1.modeMacro;
|
|
39640
|
+
speedRandomMacro = result1.randomMacro;
|
|
39641
39641
|
}
|
|
39642
39642
|
// Drag
|
|
39643
39643
|
var dragResult = this._uploadDrag(shaderData);
|
|
@@ -39653,8 +39653,8 @@
|
|
|
39653
39653
|
}
|
|
39654
39654
|
this._enabledModuleMacro = this._enableMacro(shaderData, this._enabledModuleMacro, enabledModuleMacro);
|
|
39655
39655
|
this._separateAxesCachedMacro = this._enableMacro(shaderData, this._separateAxesCachedMacro, separateAxesMacro);
|
|
39656
|
-
this.
|
|
39657
|
-
this.
|
|
39656
|
+
this._speedModeMacro = this._enableMacro(shaderData, this._speedModeMacro, speedModeMacro);
|
|
39657
|
+
this._speedRandomMacro = this._enableMacro(shaderData, this._speedRandomMacro, speedRandomMacro);
|
|
39658
39658
|
this._dragCurveCachedMacro = this._enableMacro(shaderData, this._dragCurveCachedMacro, dragCurveMacro);
|
|
39659
39659
|
this._dragRandomCachedMacro = this._enableMacro(shaderData, this._dragRandomCachedMacro, dragRandomMacro);
|
|
39660
39660
|
this._dragSizeMacro = this._enableMacro(shaderData, this._dragSizeMacro, dragSizeMacro);
|
|
@@ -39663,26 +39663,26 @@
|
|
|
39663
39663
|
/**
|
|
39664
39664
|
* @internal
|
|
39665
39665
|
*/ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
|
|
39666
|
-
this.
|
|
39666
|
+
this._speedRand.reset(seed, ParticleRandomSubSeeds.LimitVelocityOverLifetime);
|
|
39667
39667
|
};
|
|
39668
|
-
_proto.
|
|
39669
|
-
var
|
|
39668
|
+
_proto._uploadScalarSpeed = function _uploadScalarSpeed(shaderData) {
|
|
39669
|
+
var speedX = this._speedX;
|
|
39670
39670
|
var modeMacro = null;
|
|
39671
39671
|
var randomMacro = null;
|
|
39672
|
-
var isRandomCurveMode =
|
|
39673
|
-
if (isRandomCurveMode ||
|
|
39674
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39675
|
-
modeMacro = LimitVelocityOverLifetimeModule.
|
|
39672
|
+
var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves;
|
|
39673
|
+
if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve) {
|
|
39674
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMaxCurveProperty, speedX.curveMax._getTypeArray());
|
|
39675
|
+
modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
|
|
39676
39676
|
if (isRandomCurveMode) {
|
|
39677
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39678
|
-
randomMacro = LimitVelocityOverLifetimeModule.
|
|
39677
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMinCurveProperty, speedX.curveMin._getTypeArray());
|
|
39678
|
+
randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
|
|
39679
39679
|
}
|
|
39680
39680
|
} else {
|
|
39681
|
-
shaderData.setFloat(LimitVelocityOverLifetimeModule.
|
|
39682
|
-
modeMacro = LimitVelocityOverLifetimeModule.
|
|
39683
|
-
if (
|
|
39684
|
-
shaderData.setFloat(LimitVelocityOverLifetimeModule.
|
|
39685
|
-
randomMacro = LimitVelocityOverLifetimeModule.
|
|
39681
|
+
shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMaxConstProperty, speedX.constantMax);
|
|
39682
|
+
modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
|
|
39683
|
+
if (speedX.mode === ParticleCurveMode.TwoConstants) {
|
|
39684
|
+
shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMinConstProperty, speedX.constantMin);
|
|
39685
|
+
randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
|
|
39686
39686
|
}
|
|
39687
39687
|
}
|
|
39688
39688
|
return {
|
|
@@ -39690,34 +39690,34 @@
|
|
|
39690
39690
|
randomMacro: randomMacro
|
|
39691
39691
|
};
|
|
39692
39692
|
};
|
|
39693
|
-
_proto.
|
|
39694
|
-
var
|
|
39695
|
-
var
|
|
39696
|
-
var
|
|
39693
|
+
_proto._uploadSeparateAxisSpeeds = function _uploadSeparateAxisSpeeds(shaderData) {
|
|
39694
|
+
var speedX = this._speedX;
|
|
39695
|
+
var speedY = this._speedY;
|
|
39696
|
+
var speedZ = this._speedZ;
|
|
39697
39697
|
var modeMacro = null;
|
|
39698
39698
|
var randomMacro = null;
|
|
39699
|
-
var isRandomCurveMode =
|
|
39700
|
-
if (isRandomCurveMode ||
|
|
39701
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39702
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39703
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39704
|
-
modeMacro = LimitVelocityOverLifetimeModule.
|
|
39699
|
+
var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves && speedY.mode === ParticleCurveMode.TwoCurves && speedZ.mode === ParticleCurveMode.TwoCurves;
|
|
39700
|
+
if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve && speedY.mode === ParticleCurveMode.Curve && speedZ.mode === ParticleCurveMode.Curve) {
|
|
39701
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMaxCurveProperty, speedX.curveMax._getTypeArray());
|
|
39702
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMaxCurveProperty, speedY.curveMax._getTypeArray());
|
|
39703
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMaxCurveProperty, speedZ.curveMax._getTypeArray());
|
|
39704
|
+
modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
|
|
39705
39705
|
if (isRandomCurveMode) {
|
|
39706
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39707
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39708
|
-
shaderData.setFloatArray(LimitVelocityOverLifetimeModule.
|
|
39709
|
-
randomMacro = LimitVelocityOverLifetimeModule.
|
|
39706
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMinCurveProperty, speedX.curveMin._getTypeArray());
|
|
39707
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMinCurveProperty, speedY.curveMin._getTypeArray());
|
|
39708
|
+
shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMinCurveProperty, speedZ.curveMin._getTypeArray());
|
|
39709
|
+
randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
|
|
39710
39710
|
}
|
|
39711
39711
|
} else {
|
|
39712
|
-
var constantMax = this.
|
|
39713
|
-
constantMax.set(
|
|
39714
|
-
shaderData.setVector3(LimitVelocityOverLifetimeModule.
|
|
39715
|
-
modeMacro = LimitVelocityOverLifetimeModule.
|
|
39716
|
-
if (
|
|
39717
|
-
var constantMin = this.
|
|
39718
|
-
constantMin.set(
|
|
39719
|
-
shaderData.setVector3(LimitVelocityOverLifetimeModule.
|
|
39720
|
-
randomMacro = LimitVelocityOverLifetimeModule.
|
|
39712
|
+
var constantMax = this._speedMaxConstantVec;
|
|
39713
|
+
constantMax.set(speedX.constantMax, speedY.constantMax, speedZ.constantMax);
|
|
39714
|
+
shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMaxConstVecProperty, constantMax);
|
|
39715
|
+
modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
|
|
39716
|
+
if (speedX.mode === ParticleCurveMode.TwoConstants && speedY.mode === ParticleCurveMode.TwoConstants && speedZ.mode === ParticleCurveMode.TwoConstants) {
|
|
39717
|
+
var constantMin = this._speedMinConstantVec;
|
|
39718
|
+
constantMin.set(speedX.constantMin, speedY.constantMin, speedZ.constantMin);
|
|
39719
|
+
shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMinConstVecProperty, constantMin);
|
|
39720
|
+
randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
|
|
39721
39721
|
}
|
|
39722
39722
|
}
|
|
39723
39723
|
return {
|
|
@@ -39767,57 +39767,57 @@
|
|
|
39767
39767
|
}
|
|
39768
39768
|
},
|
|
39769
39769
|
{
|
|
39770
|
-
key: "
|
|
39770
|
+
key: "speed",
|
|
39771
39771
|
get: /**
|
|
39772
39772
|
* Speed limit when separateAxes is false.
|
|
39773
39773
|
*/ function get() {
|
|
39774
|
-
return this.
|
|
39774
|
+
return this._speedX;
|
|
39775
39775
|
},
|
|
39776
39776
|
set: function set(value) {
|
|
39777
|
-
this.
|
|
39777
|
+
this.speedX = value;
|
|
39778
39778
|
}
|
|
39779
39779
|
},
|
|
39780
39780
|
{
|
|
39781
|
-
key: "
|
|
39781
|
+
key: "speedX",
|
|
39782
39782
|
get: /**
|
|
39783
39783
|
* Speed limit for the x-axis (or overall limit when separateAxes is false).
|
|
39784
39784
|
*/ function get() {
|
|
39785
|
-
return this.
|
|
39785
|
+
return this._speedX;
|
|
39786
39786
|
},
|
|
39787
39787
|
set: function set(value) {
|
|
39788
|
-
var lastValue = this.
|
|
39788
|
+
var lastValue = this._speedX;
|
|
39789
39789
|
if (value !== lastValue) {
|
|
39790
|
-
this.
|
|
39790
|
+
this._speedX = value;
|
|
39791
39791
|
this._onCompositeCurveChange(lastValue, value);
|
|
39792
39792
|
}
|
|
39793
39793
|
}
|
|
39794
39794
|
},
|
|
39795
39795
|
{
|
|
39796
|
-
key: "
|
|
39796
|
+
key: "speedY",
|
|
39797
39797
|
get: /**
|
|
39798
39798
|
* Speed limit for the y-axis.
|
|
39799
39799
|
*/ function get() {
|
|
39800
|
-
return this.
|
|
39800
|
+
return this._speedY;
|
|
39801
39801
|
},
|
|
39802
39802
|
set: function set(value) {
|
|
39803
|
-
var lastValue = this.
|
|
39803
|
+
var lastValue = this._speedY;
|
|
39804
39804
|
if (value !== lastValue) {
|
|
39805
|
-
this.
|
|
39805
|
+
this._speedY = value;
|
|
39806
39806
|
this._onCompositeCurveChange(lastValue, value);
|
|
39807
39807
|
}
|
|
39808
39808
|
}
|
|
39809
39809
|
},
|
|
39810
39810
|
{
|
|
39811
|
-
key: "
|
|
39811
|
+
key: "speedZ",
|
|
39812
39812
|
get: /**
|
|
39813
39813
|
* Speed limit for the z-axis.
|
|
39814
39814
|
*/ function get() {
|
|
39815
|
-
return this.
|
|
39815
|
+
return this._speedZ;
|
|
39816
39816
|
},
|
|
39817
39817
|
set: function set(value) {
|
|
39818
|
-
var lastValue = this.
|
|
39818
|
+
var lastValue = this._speedZ;
|
|
39819
39819
|
if (value !== lastValue) {
|
|
39820
|
-
this.
|
|
39820
|
+
this._speedZ = value;
|
|
39821
39821
|
this._onCompositeCurveChange(lastValue, value);
|
|
39822
39822
|
}
|
|
39823
39823
|
}
|
|
@@ -39885,6 +39885,7 @@
|
|
|
39885
39885
|
key: "space",
|
|
39886
39886
|
get: /**
|
|
39887
39887
|
* Specifies if the velocity limits are in local space or world space.
|
|
39888
|
+
* @remarks Only takes effect when 'separateAxes' is enabled.
|
|
39888
39889
|
*/ function get() {
|
|
39889
39890
|
return this._space;
|
|
39890
39891
|
},
|
|
@@ -39919,25 +39920,25 @@
|
|
|
39919
39920
|
}(ParticleGeneratorModule);
|
|
39920
39921
|
LimitVelocityOverLifetimeModule._enabledMacro = ShaderMacro.getByName("RENDERER_LVL_MODULE_ENABLED");
|
|
39921
39922
|
LimitVelocityOverLifetimeModule._separateAxesMacro = ShaderMacro.getByName("RENDERER_LVL_SEPARATE_AXES");
|
|
39922
|
-
LimitVelocityOverLifetimeModule.
|
|
39923
|
-
LimitVelocityOverLifetimeModule.
|
|
39924
|
-
LimitVelocityOverLifetimeModule.
|
|
39923
|
+
LimitVelocityOverLifetimeModule._speedConstantModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CONSTANT_MODE");
|
|
39924
|
+
LimitVelocityOverLifetimeModule._speedCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CURVE_MODE");
|
|
39925
|
+
LimitVelocityOverLifetimeModule._speedIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_IS_RANDOM_TWO");
|
|
39925
39926
|
LimitVelocityOverLifetimeModule._dragCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_CURVE_MODE");
|
|
39926
39927
|
LimitVelocityOverLifetimeModule._dragIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_IS_RANDOM_TWO");
|
|
39927
39928
|
LimitVelocityOverLifetimeModule._multiplyDragBySizeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_SIZE");
|
|
39928
39929
|
LimitVelocityOverLifetimeModule._multiplyDragByVelocityMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_VELOCITY");
|
|
39929
|
-
LimitVelocityOverLifetimeModule.
|
|
39930
|
-
LimitVelocityOverLifetimeModule.
|
|
39931
|
-
LimitVelocityOverLifetimeModule.
|
|
39932
|
-
LimitVelocityOverLifetimeModule.
|
|
39933
|
-
LimitVelocityOverLifetimeModule.
|
|
39934
|
-
LimitVelocityOverLifetimeModule.
|
|
39935
|
-
LimitVelocityOverLifetimeModule.
|
|
39936
|
-
LimitVelocityOverLifetimeModule.
|
|
39937
|
-
LimitVelocityOverLifetimeModule.
|
|
39938
|
-
LimitVelocityOverLifetimeModule.
|
|
39939
|
-
LimitVelocityOverLifetimeModule.
|
|
39940
|
-
LimitVelocityOverLifetimeModule.
|
|
39930
|
+
LimitVelocityOverLifetimeModule._speedMaxConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConst");
|
|
39931
|
+
LimitVelocityOverLifetimeModule._speedMinConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConst");
|
|
39932
|
+
LimitVelocityOverLifetimeModule._speedMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxCurve");
|
|
39933
|
+
LimitVelocityOverLifetimeModule._speedMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMinCurve");
|
|
39934
|
+
LimitVelocityOverLifetimeModule._speedMaxConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConstVector");
|
|
39935
|
+
LimitVelocityOverLifetimeModule._speedMinConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConstVector");
|
|
39936
|
+
LimitVelocityOverLifetimeModule._speedXMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMaxCurve");
|
|
39937
|
+
LimitVelocityOverLifetimeModule._speedXMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMinCurve");
|
|
39938
|
+
LimitVelocityOverLifetimeModule._speedYMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMaxCurve");
|
|
39939
|
+
LimitVelocityOverLifetimeModule._speedYMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMinCurve");
|
|
39940
|
+
LimitVelocityOverLifetimeModule._speedZMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMaxCurve");
|
|
39941
|
+
LimitVelocityOverLifetimeModule._speedZMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMinCurve");
|
|
39941
39942
|
LimitVelocityOverLifetimeModule._dampenProperty = ShaderProperty.getByName("renderer_LVLDampen");
|
|
39942
39943
|
LimitVelocityOverLifetimeModule._dragConstantProperty = ShaderProperty.getByName("renderer_LVLDragConstant");
|
|
39943
39944
|
LimitVelocityOverLifetimeModule._dragMaxCurveProperty = ShaderProperty.getByName("renderer_LVLDragMaxCurve");
|
|
@@ -39945,13 +39946,13 @@
|
|
|
39945
39946
|
LimitVelocityOverLifetimeModule._spaceProperty = ShaderProperty.getByName("renderer_LVLSpace");
|
|
39946
39947
|
__decorate$1([
|
|
39947
39948
|
ignoreClone
|
|
39948
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39949
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedRand", void 0);
|
|
39949
39950
|
__decorate$1([
|
|
39950
39951
|
ignoreClone
|
|
39951
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39952
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedMinConstantVec", void 0);
|
|
39952
39953
|
__decorate$1([
|
|
39953
39954
|
ignoreClone
|
|
39954
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39955
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedMaxConstantVec", void 0);
|
|
39955
39956
|
__decorate$1([
|
|
39956
39957
|
ignoreClone
|
|
39957
39958
|
], LimitVelocityOverLifetimeModule.prototype, "_dragConstantVec", void 0);
|
|
@@ -39963,10 +39964,10 @@
|
|
|
39963
39964
|
], LimitVelocityOverLifetimeModule.prototype, "_separateAxesCachedMacro", void 0);
|
|
39964
39965
|
__decorate$1([
|
|
39965
39966
|
ignoreClone
|
|
39966
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39967
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedModeMacro", void 0);
|
|
39967
39968
|
__decorate$1([
|
|
39968
39969
|
ignoreClone
|
|
39969
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39970
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedRandomMacro", void 0);
|
|
39970
39971
|
__decorate$1([
|
|
39971
39972
|
ignoreClone
|
|
39972
39973
|
], LimitVelocityOverLifetimeModule.prototype, "_dragCurveCachedMacro", void 0);
|
|
@@ -39981,13 +39982,13 @@
|
|
|
39981
39982
|
], LimitVelocityOverLifetimeModule.prototype, "_dragVelocityMacro", void 0);
|
|
39982
39983
|
__decorate$1([
|
|
39983
39984
|
deepClone
|
|
39984
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39985
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedX", void 0);
|
|
39985
39986
|
__decorate$1([
|
|
39986
39987
|
deepClone
|
|
39987
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39988
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedY", void 0);
|
|
39988
39989
|
__decorate$1([
|
|
39989
39990
|
deepClone
|
|
39990
|
-
], LimitVelocityOverLifetimeModule.prototype, "
|
|
39991
|
+
], LimitVelocityOverLifetimeModule.prototype, "_speedZ", void 0);
|
|
39991
39992
|
__decorate$1([
|
|
39992
39993
|
deepClone
|
|
39993
39994
|
], LimitVelocityOverLifetimeModule.prototype, "_drag", void 0);
|
|
@@ -41676,8 +41677,8 @@
|
|
|
41676
41677
|
instanceVertices[offset + 40] = rand1.random();
|
|
41677
41678
|
}
|
|
41678
41679
|
var limitVelocityOverLifetime = this.limitVelocityOverLifetime;
|
|
41679
|
-
if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime.
|
|
41680
|
-
instanceVertices[offset + 41] = limitVelocityOverLifetime.
|
|
41680
|
+
if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isSpeedRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
|
|
41681
|
+
instanceVertices[offset + 41] = limitVelocityOverLifetime._speedRand.random();
|
|
41681
41682
|
}
|
|
41682
41683
|
// Initialize feedback buffer for this particle
|
|
41683
41684
|
if (this._useTransformFeedback) {
|
|
@@ -54058,7 +54059,7 @@
|
|
|
54058
54059
|
], EXT_texture_webp);
|
|
54059
54060
|
|
|
54060
54061
|
//@ts-ignore
|
|
54061
|
-
var version = "2.0.0-alpha.
|
|
54062
|
+
var version = "2.0.0-alpha.18";
|
|
54062
54063
|
console.log("Galacean Engine Version: " + version);
|
|
54063
54064
|
for(var key in CoreObjects){
|
|
54064
54065
|
Loader.registerClass(key, CoreObjects[key]);
|