@rbxts/vfx-forge 2.2.2-ts.1

package/out/forge-vfx/effects/tweener.luau

@@ -0,0 +1,122 @@
+local attr = require(script.Parent.Parent.mod.attributes)
+local lerp = require(script.Parent.Parent.mod.lerp)
+local tween = require(script.Parent.Parent.mod.tween)
+local types = require(script.Parent.Parent.types)
+local utility = require(script.Parent.Parent.mod.utility)
+
+local rng = Random.new()
+
+local tweener = {}
+
+function tweener.emit(obj: RayValue, scope: types.scope, isAttribute: boolean)
+  local target = utility.getTarget(obj)
+
+  if not target then
+    return
+  end
+
+  local name = obj.Name
+
+  local emitDelay = attr.get(obj, "EmitDelay", 0)
+  local resetOnFinish = attr.get(obj, "ResetOnFinish", true)
+
+  local durationRange = attr.getRange(obj, "Duration", NumberRange.new(1, 1), NumberRange.new(0, math.huge))
+
+  if emitDelay > 0 then
+    task.wait(emitDelay)
+  end
+
+  local endValue = attr.get(obj, "_END_VALUE", nil)
+  local overrideStartValue = attr.get(obj, "_START_VALUE", nil)
+
+  local startValue
+
+  if isAttribute then
+    startValue = attr.get(target, name, nil)
+  else
+    local ok, val = pcall(function()
+      return target[name]
+    end)
+
+    if not ok then
+      return
+    end
+
+    startValue = val
+  end
+
+  if overrideStartValue then
+    startValue = overrideStartValue
+  end
+
+  local typeName = typeof(startValue)
+
+  if typeName ~= typeof(endValue) then
+    return
+  end
+
+  local duration = rng:NextNumber(durationRange.Min, durationRange.Max)
+
+  local speedStart = attr.get(obj, "Speed_Start", 1)
+  local speedEnd = attr.get(obj, "Speed_End", 1)
+
+  local currentSpeed = speedStart
+
+  local speedTween
+
+  if speedStart ~= speedEnd then
+    speedTween = tween.fromParams(
+      attr.get(obj, "Speed_Curve", utility.default_bezier),
+      attr.get(obj, "Speed_Duration", 0.1),
+      function(alpha, deltaTime)
+        currentSpeed = utility.lerp(speedStart, speedEnd, alpha)
+        return deltaTime
+      end
+    )
+
+    table.insert(scope, speedTween)
+  end
+
+  local lfunc = lerp[typeName] or lerp.Other
+
+  local animator = if isAttribute
+    then function(alpha, deltaTime)
+      attr.set(target, name, lfunc(startValue, endValue, alpha))
+      return deltaTime * currentSpeed
+    end
+    else function(alpha, deltaTime)
+      target[name] = lfunc(startValue, endValue, alpha)
+      return deltaTime * currentSpeed
+    end
+
+  table.insert(
+    scope,
+    tween.fromParams(
+      attr.get(obj, "Easing_Curve", utility.linear_bezier),
+      duration,
+      animator,
+      speedTween,
+      nil,
+      nil,
+      utility.RENDER_PRIORITY + scope.depth
+    )
+  )
+
+  if resetOnFinish then
+    table.insert(scope, function()
+      if isAttribute then
+        attr.set(target, name, startValue)
+      else
+        target[name] = startValue
+      end
+    end)
+  end
+
+  tween.timer(duration, function(deltaTime, elapsed)
+    return if currentSpeed > 0 or (elapsed > 0 and speedTween and speedTween.Connected)
+      then deltaTime * currentSpeed
+      else nil
+  end, speedTween, scope)
+end
+
+return tweener

package/out/forge-vfx/emitters.luau

@@ -0,0 +1,387 @@
+local TS = _G[script.Parent.Parent]
+local Beam = require(script.Parent.effects.beam)
+local Spin = require(script.Parent.effects.spin)
+local Mesh = require(script.Parent.effects.mesh)
+local Sound = require(script.Parent.effects.sound)
+local Bezier = require(script.Parent.effects.bezier)
+local Screen = require(script.Parent.effects.screen)
+local Particle = require(script.Parent.effects.particle)
+local Lightning = require(script.Parent.effects.lightning)
+local CameraShake = require(script.Parent.effects.camera_shake)
+local Tweener = require(script.Parent.effects.tweener)
+local Randomizer = require(script.Parent.effects.randomizer)
+local ShockwaveRing = require(script.Parent.effects.shockwave_ring)
+local ShockwaveLine = require(script.Parent.effects.shockwave_line)
+local ShockwaveDebris = require(script.Parent.effects.shockwave_debris)
+
+local attr = require(script.Parent.mod.attributes)
+local types = require(script.Parent.types)
+local utility = require(script.Parent.mod.utility)
+
+
+local emitters = {}
+
+local function processRandomizers(obj: Instance, scope: types.scope)
+  local r_prop = obj:QueryDescendants(`> RayValue.{utility.PROPERTY_RANDOMIZER_TAG}`)
+  local r_attr = obj:QueryDescendants(`> RayValue.{utility.ATTRIBUTE_RANDOMIZER_TAG}`)
+
+  -- allow emitting the randomizer directly
+  if obj:IsA("RayValue") then
+    if obj:HasTag(utility.PROPERTY_RANDOMIZER_TAG) then
+      table.insert(r_prop, obj)
+    elseif obj:HasTag(utility.ATTRIBUTE_RANDOMIZER_TAG) then
+      table.insert(r_attr, obj)
+    end
+  end
+
+  for _, obj in r_prop do
+    utility.try(`failed to emit property randomizer with error: %s`, Randomizer.emit, obj, scope, false)
+  end
+
+  for _, obj in r_attr do
+    utility.try(`failed to emit attribute randomizer with error: %s`, Randomizer.emit, obj, scope, true)
+  end
+end
+
+function emitters.particle(
+  obj: ParticleEmitter,
+  scope: types.scope,
+  sharedUncMap: { [Instance]: number },
+  sharedRefMap: { [Instance]: Instance },
+  legacyScale: number
+)
+  local count = attr.get(obj, "EmitCount", 1, true)
+  local duration = attr.get(obj, "EmitDuration", 0, true)
+
+  if count <= 0 and duration <= 0 then
+    return
+  end
+
+  if not obj:IsDescendantOf(workspace) then
+    local parent, ancestor = utility.cloneParticleAncestry(obj, sharedRefMap)
+
+    if not parent then
+      return
+    end
+
+    local clone = obj:Clone()
+    clone.Archivable = false
+    clone.Parent = parent
+
+    if not sharedUncMap[ancestor] then
+      ancestor.Parent = workspace.Terrain
+      sharedUncMap[ancestor] = 1
+    else
+      sharedUncMap[ancestor] += 1
+    end
+
+    table.insert(scope, function()
+      sharedUncMap[ancestor] -= 1
+
+      if sharedUncMap[ancestor] <= 0 then
+        ancestor:Destroy()
+      end
+    end)
+
+    utility.try(`failed to emit particle with error: %s`, Particle.emit, obj, clone, scope, legacyScale)
+  else
+    utility.try(`failed to emit particle with error: %s`, Particle.emit, obj, obj, scope, legacyScale)
+  end
+end
+
+function emitters.beam(obj: Beam, scope: types.scope, legacyScale: number)
+  local att0, att1 = obj.Attachment0, obj.Attachment1
+
+  if not att0 or not att1 then
+    return
+  end
+
+  local clone = obj:Clone()
+  clone.Archivable = false
+  clone.Parent = workspace.Terrain
+
+  -- clone attachments for beams with scaled length
+  local unscaled = NumberRange.new(1, 1)
+
+  if
+    attr.get(obj, "Length_Scale_Start", unscaled, true) ~= unscaled
+    or attr.get(obj, "Length_Scale_End", unscaled, true) ~= unscaled
+  then
+    local a, b = att0:Clone(), att1:Clone()
+
+    table.insert(scope, a)
+    table.insert(scope, b)
+
+    a.Name = "_ForgeTempAttachment"
+    b.Name = "_ForgeTempAttachment"
+
+    a:AddTag(utility.EMIT_EXCLUDE_TAG)
+    b:AddTag(utility.EMIT_EXCLUDE_TAG)
+
+    clone.Attachment0 = a
+    clone.Attachment1 = b
+
+    a.Parent = att0.Parent
+    b.Parent = att1.Parent
+  end
+
+  table.insert(scope, clone)
+
+  utility.try(`failed to emit beam with error: %s`, Beam.emit, obj, clone, scope, legacyScale)
+end
+
+function emitters.trail(obj: Trail)
+  obj.Enabled = true
+end
+
+function emitters.bezier(obj: Instance, scope: types.scope, skipEnabledCheck: boolean?)
+  local part = obj:FindFirstChildOfClass("Part")
+
+  if not part then
+    return
+  end
+
+  if not skipEnabledCheck and obj:GetAttribute("Enabled") then
+    obj:SetAttribute("Enabled", false)
+  end
+
+  local clone = part:Clone()
+  clone.Locked = true
+
+  table.insert(scope, clone)
+
+  utility.try(`failed to emit bezier with error: %s`, Bezier.emit, obj, clone, scope, skipEnabledCheck)
+end
+
+function emitters.lightning(obj: Instance, scope: types.scope, skipEnabledCheck: boolean?)
+  local part = obj:FindFirstChildOfClass("Part")
+
+  if not part then
+    return
+  end
+
+  if not skipEnabledCheck and obj:GetAttribute("Enabled") then
+    obj:SetAttribute("Enabled", false)
+  end
+
+  local clone = part:Clone()
+  clone.Locked = true
+
+  table.insert(scope, clone)
+
+  utility.try(`failed to emit lightning with error: %s`, Lightning.emit, obj, clone, scope, skipEnabledCheck)
+end
+
+function emitters.mesh(
+  obj: Instance,
+  scope: types.scope,
+  shared_part_cache: any,
+  legacyScale: number,
+  skipEnabledCheck: boolean?
+)
+  local start = obj:FindFirstChild("Start")
+
+  if not start then
+    return
+  end
+
+  if not skipEnabledCheck and obj:GetAttribute("Enabled") then
+    obj:SetAttribute("Enabled", false)
+  end
+
+  local tasks = {}
+
+  for i = 1, attr.get(obj, "EmitCount", 1) do
+    table.insert(
+      tasks,
+      TS.Promise.new(function(resolve)
+        utility.try(
+          `failed to emit mesh with error: %s`,
+          Mesh.emit,
+          obj,
+          utility.assembleMeshVFX(start, scope, shared_part_cache),
+          scope,
+          legacyScale,
+          skipEnabledCheck
+        )
+
+        resolve()
+      end)
+    )
+  end
+
+  TS.Promise.all(tasks):await()
+end
+
+function emitters.spin(obj: Model, scope: types.scope)
+  if utility.lock(obj) then
+    return
+  end
+
+  utility.try(`failed to emit spinning model with error: %s`, Spin.emit, obj, scope)
+  utility.unlock(obj)
+end
+
+function emitters.camera_shake(obj: RayValue, scope: types.scope)
+  utility.try(`failed to emit camera shake with error: %s`, CameraShake.emit, obj, scope)
+end
+
+function emitters.property_tweener(obj: RayValue, scope: types.scope)
+  if not obj.Parent or utility.lock(obj) then
+    return
+  end
+
+  utility.try(`failed to emit property tweener with error: %s`, Tweener.emit, obj, scope, false)
+  utility.unlock(obj)
+end
+
+function emitters.attribute_tweener(obj: RayValue, scope: types.scope)
+  if not obj.Parent or utility.lock(obj) then
+    return
+  end
+
+  utility.try(`failed to emit attribute tweener with error: %s`, Tweener.emit, obj.Parent, obj, scope, true)
+  utility.unlock(obj)
+end
+
+function emitters.screen(obj: BasePart, scope: types.scope)
+  local ok, result = utility.try(`failed to emit screen effect with error: %s`, Screen.emit, obj, scope)
+
+  return if ok then result else false
+end
+
+function emitters.shockwave_ring(att: Attachment, obj: Part, scope: types.scope)
+  utility.try(`failed to emit shockwave ring with error: %s`, ShockwaveRing.emit, att, obj, scope)
+end
+
+function emitters.shockwave_debris(att: Attachment, obj: Part, scope: types.scope)
+  utility.try(`failed to emit shockwave debris with error: %s`, ShockwaveDebris.emit, att, obj, scope)
+end
+
+function emitters.shockwave_line(att: Attachment, obj: Part, scope: types.scope)
+  utility.try(`failed to emit shockwave line with error: %s`, ShockwaveLine.emit, att, obj, scope)
+end
+
+function emitters.sound(obj: Sound, scope: types.scope)
+  local emitCount = attr.get(obj, "EmitCount", 1, true)
+
+  if emitCount <= 0 then
+    return
+  end
+
+  utility.try(`failed to emit sound with error: %s`, Sound.emit, obj, scope)
+end
+
+-- Dispatch function to determine which emitter to use and call it
+function emitters.dispatch(
+  obj: any, -- since we don't use IsA(...), we don't get type narrowing
+  scope: types.scope,
+  sharedUncMap: { [Instance]: number },
+  sharedRefMap: { [Instance]: Instance },
+  shared_part_cache: any,
+  legacyScale: number
+)
+  local className = obj.ClassName
+
+  processRandomizers(obj, scope)
+
+  if className == "ParticleEmitter" then
+    emitters.particle(obj, scope, sharedUncMap, sharedRefMap, legacyScale)
+    return
+  elseif className == "Beam" then
+    emitters.beam(obj, scope, legacyScale)
+    return
+  elseif className == "Trail" then
+    emitters.trail(obj)
+    return
+  elseif className == "Sound" then
+    emitters.sound(obj, scope)
+    return
+  elseif className == "RayValue" then
+    if obj:HasTag(utility.SCREENSHAKE_TAG) then
+      emitters.camera_shake(obj, scope)
+    elseif obj:HasTag(utility.ATTRIBUTE_TWEENER_TAG) then
+      emitters.attribute_tweener(obj, scope)
+    elseif obj:HasTag(utility.PROPERTY_RANDOMIZER_TAG) or obj:HasTag(utility.ATTRIBUTE_RANDOMIZER_TAG) then
+      -- skip randomizer effects because they have already been emitted
+    else
+      -- fall back to property tweens for backwards compatibility
+      emitters.property_tweener(obj, scope)
+    end
+
+    return
+  end
+
+  if obj:HasTag(utility.BEZIER_TAG) then
+    emitters.bezier(obj, scope)
+    return
+  end
+
+  if obj:HasTag(utility.LIGHTNING_TAG) then
+    emitters.lightning(obj, scope)
+    return
+  end
+
+  if className == "Model" then
+    if utility.isMeshVFX(obj) then
+      emitters.mesh(obj, scope, shared_part_cache, legacyScale)
+    else
+      emitters.spin(obj, scope)
+    end
+
+    return
+  end
+
+  if className == "Part" then
+    local att = utility.findFirstClassWithTag(obj, "Attachment", utility.SHOCKWAVE_TAG)
+
+    if att then
+      local name = obj.Parent and obj.Parent.Name or ""
+
+      if name == "Rings" then
+        emitters.shockwave_ring(att, obj, scope)
+      elseif name == "Debris" then
+        emitters.shockwave_debris(att, obj, scope)
+      elseif name == "Lines" then
+        emitters.shockwave_line(att, obj, scope)
+      end
+    end
+  end
+end
+
+-- Registry for enabled effects (effects that emit continuously)
+type EnabledEffectConfig = {
+  check: (obj: Instance) -> boolean,
+  emit: (obj: Instance, scope: types.scope, shared_part_cache: any) -> (),
+}
+
+emitters.enabled_registry = {
+  mesh = {
+    check = function(obj: Instance)
+      return utility.isMeshVFX(obj)
+    end,
+    emit = function(obj: Instance, scope: types.scope, shared_part_cache: any)
+      emitters.mesh(obj, scope, shared_part_cache, 1, true)
+    end,
+  },
+
+  bezier = {
+    check = function(obj: Instance)
+      return obj:HasTag(utility.BEZIER_TAG)
+    end,
+    emit = function(obj: Instance, scope: types.scope, shared_part_cache: any)
+      emitters.bezier(obj, scope, true)
+    end,
+  },
+
+  lightning = {
+    check = function(obj: Instance)
+      return obj:HasTag(utility.LIGHTNING_TAG)
+    end,
+    emit = function(obj: Instance, scope: types.scope, shared_part_cache: any)
+      emitters.lightning(obj, scope, true)
+    end,
+  },
+} :: { [string]: EnabledEffectConfig }
+
+return emitters