@rbxts/vfx-forge 2.2.2

package/out/effects/shockwave_ring.luau

@@ -0,0 +1,252 @@
+local CollectionService = game:GetService("CollectionService")
+
+local attr = require("@mod/attributes")
+local tween = require("@mod/tween")
+local types = require("@root/types")
+local utility = require("@mod/utility")
+
+local Promise = require("@pkg/Promise")
+local ObjectCache = require("@obj/ObjectCache")
+
+local rng = Random.new()
+
+local ring = {}
+
+local part_cache: ObjectCache.ObjectCache?
+
+function ring.init(cache)
+  part_cache = cache
+end
+
+function ring.deinit()
+  part_cache = nil
+end
+
+function ring.emit(origin: Attachment, ref: Part, scope: types.scope)
+  if not part_cache then
+    return
+  end
+
+  local raydir = attr.get(origin, "RayDirection", vector.create(0, -50, 0))
+
+  local rayColGroup = attr.get(origin, "RayCollisionGroup", "Default")
+  local rayFilterTag = attr.get(origin, "FilterTag", "")
+  local rayFilterType = attr.get(origin, "FilterType", "Exclude")
+
+  local rayIgnoreWater = attr.get(origin, "IgnoreWater", true)
+  local rayIgnoreCanCollide = attr.get(origin, "IgnoreCanCollide", false)
+
+  local params = RaycastParams.new()
+  params.CollisionGroup = rayColGroup
+  params.IgnoreWater = rayIgnoreWater
+  params.RespectCanCollide = not rayIgnoreCanCollide
+  params.FilterType = Enum.RaycastFilterType[rayFilterType]
+  params.FilterDescendantsInstances = CollectionService:GetTagged(rayFilterTag)
+
+  if rayFilterType == "Exclude" then
+    params:AddToFilter({ workspace.Terrain })
+  end
+
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+
+  local radius = attr.get(ref, "Radius", 5)
+  local segments = attr.get(ref, "Segments", 7)
+
+  local lifetime = attr.getRange(ref, "Lifetime", NumberRange.new(2, 3), NumberRange.new(0, math.huge))
+
+  local old_partOffset = attr.get(ref, "PartOffset", vector.zero, true)
+
+  local baseOffset = attr.get(ref, "BaseOffset", old_partOffset)
+  local offsetStart = attr.get(ref, "Offset_Start", old_partOffset)
+  local offsetEnd = attr.get(ref, "Offset_End", old_partOffset)
+
+  local offsetStartDuration = attr.get(ref, "Offset_Start_Duration", 0.5)
+  local offsetEndDuration = attr.get(ref, "Offset_End_Duration", 0.5)
+
+  local sizeScaleStart = attr.get(ref, "SizeScaleStart", vector.zero)
+  local sizeScaleEnd = attr.get(ref, "SizeScaleEnd", vector.zero)
+
+  local minSize = attr.get(ref, "MinSize", vector.create(2, 1, 2))
+  local maxSize = attr.get(ref, "MaxSize", vector.create(3, 2, 3))
+
+  local old_sizeCurve = attr.get(ref, "Size_Curve", utility.default_bezier, true)
+  local old_sizeDuration = attr.get(ref, "Size_Duration", 0.5, true)
+
+  local sizeStartCurve = attr.get(ref, "Size_Start_Curve", old_sizeCurve)
+  local sizeEndCurve = attr.get(ref, "Size_End_Curve", old_sizeCurve)
+
+  local sizeStartDuration = attr.get(ref, "Size_Start_Duration", old_sizeDuration)
+  local sizeEndDuration = attr.get(ref, "Size_End_Duration", old_sizeDuration)
+
+  local tpDuration = attr.get(ref, "Transparency_Duration", 0.5)
+
+  local tpStart = attr.get(ref, "Transparency_Start", 0)
+  local tpEnd = attr.get(ref, "Transparency_End", 0)
+
+  task.wait(emitDelay)
+
+  local promises = {}
+  local originCFrame = utility.getTransformedOriginExtents(origin)
+
+  for i = 0, segments - 1 do
+    local angle = i / segments * math.pi * 2
+
+    local x = radius * math.cos(angle)
+    local y = radius * math.sin(angle)
+
+    local result =
+      workspace:Raycast((originCFrame * CFrame.new(x, 0, y)).Position, originCFrame:VectorToWorldSpace(raydir), params)
+
+    if not result then
+      continue
+    end
+
+    local width = rng:NextNumber(minSize.X, maxSize.X)
+
+    local height = rng:NextNumber(minSize.Y, maxSize.Y)
+    local length = rng:NextNumber(minSize.Z, maxSize.Z)
+
+    local id = utility.getRandomId()
+
+    local part = part_cache:get(id)
+
+    local realPart = part._getReal()
+
+    utility.copyProperties(ref, realPart, utility.COPY_PART_PROPERTIES)
+    utility.copyProperties(ref, realPart, utility.COPY_EXTENDED_PART_PROPERTIES)
+
+    if #ref:GetChildren() ~= 0 then
+      local clone = ref:Clone()
+
+      for _, child in clone:GetChildren() do
+        child.Parent = realPart
+      end
+
+      clone:Destroy()
+    end
+
+    local emitOnFinish = scope.effects.prepareEmitOnFinish(part, scope)
+
+    table.insert(scope, function()
+      if part_cache then
+        part_cache:free(id)
+      end
+    end)
+
+    part.Color = result.Instance.Color
+    part.Material = result.Material
+    part.Transparency = result.Instance.Transparency
+
+    if part.Transparency == 0 then
+      part.Transparency = tpStart
+    end
+
+    part.Size = Vector3.zero
+
+    local rx = -math.cos(angle)
+    local rz = -math.sin(angle)
+
+    local dir = originCFrame:VectorToWorldSpace(Vector3.new(rx, 0, rz))
+    local right = dir:Cross(result.Normal).Unit
+
+    local rotCF = CFrame.fromMatrix(result.Position, right, result.Normal)
+      * CFrame.fromOrientation(-math.atan(height / length), 0, 0)
+
+    part.CFrame = CFrame.new(offsetStart) * rotCF
+
+    local sizeTween
+    local offsetTween
+
+    local currentOffset = Vector3.zero
+
+    if offsetStart ~= baseOffset then
+      offsetTween = tween.fromParams(
+        attr.get(ref, "Offset_Start_Curve", utility.default_bezier),
+        offsetStartDuration,
+        function(alpha, deltaTime)
+          currentOffset = offsetStart:Lerp(baseOffset, alpha)
+          part.CFrame = CFrame.new(currentOffset) * rotCF
+          return deltaTime
+        end
+      )
+
+      table.insert(scope, sizeTween)
+    end
+
+    local size = Vector3.new(width, height, length)
+
+    if size * sizeScaleStart ~= size then
+      sizeTween = tween.fromParams(sizeStartCurve, sizeStartDuration, function(alpha, deltaTime)
+        part.Size = (size * sizeScaleStart):Lerp(size, alpha)
+        return deltaTime
+      end)
+
+      table.insert(scope, sizeTween)
+    else
+      part.Size = size * sizeScaleStart
+    end
+
+    local env = scope.effects.emitNested(part, scope.depth + 1)
+    table.insert(promises, env.Finished)
+
+    task.delay(rng:NextNumber(lifetime.Min, lifetime.Max), function()
+      if sizeTween then
+        sizeTween:Disconnect()
+      end
+
+      if offsetTween then
+        offsetTween:Disconnect()
+      end
+
+      local startSize = part.Size
+      local startTp = part.Transparency
+
+      if startSize ~= size * sizeScaleEnd then
+        table.insert(
+          scope,
+          tween.fromParams(sizeEndCurve, sizeEndDuration, function(alpha, deltaTime)
+            part.Size = startSize:Lerp(size * sizeScaleEnd, alpha)
+            return deltaTime
+          end)
+        )
+      end
+
+      if currentOffset ~= offsetEnd then
+        table.insert(
+          scope,
+          tween.fromParams(
+            attr.get(ref, "Offset_End_Curve", utility.default_bezier),
+            offsetEndDuration,
+            function(alpha, deltaTime)
+              part.CFrame = CFrame.new(currentOffset:Lerp(offsetEnd, alpha)) * rotCF
+              return deltaTime
+            end
+          )
+        )
+      end
+
+      if startTp ~= tpEnd then
+        table.insert(
+          scope,
+          tween.fromParams(
+            attr.get(ref, "Transparency_Curve", utility.default_bezier),
+            tpDuration,
+            function(alpha, deltaTime)
+              part.Transparency = utility.lerp(startTp, tpEnd, alpha)
+              return deltaTime
+            end
+          )
+        )
+      end
+
+      local env = scope.effects.emitOnFinish(emitOnFinish, part, scope.depth + 1)
+      table.insert(promises, env.Finished)
+    end)
+  end
+
+  task.wait(lifetime.Max + math.max(sizeEndDuration, offsetEndDuration))
+
+  Promise.all(promises):await()
+end
+
+return ring

package/out/effects/sound.luau

@@ -0,0 +1,311 @@
+local RunService = game:GetService("RunService")
+local CollectionService = game:GetService("CollectionService")
+
+local attr = require("@mod/attributes")
+
+local tween = require("@mod/tween")
+local types = require("@root/types")
+local utility = require("@mod/utility")
+local Promise = require("@pkg/Promise")
+
+local rng = Random.new()
+
+local sound = {}
+
+local soundWidget: DockWidgetPluginGui?
+
+local function selectRandomSound(ref: Sound): Sound?
+  local poolTag = attr.get(ref, "SoundPoolTag", "")
+
+  if poolTag == "" then
+    return ref
+  end
+
+  local sounds = CollectionService:GetTagged(poolTag)
+
+  local weights: { number } = {}
+  local validSounds: { Sound } = {}
+
+  local totalWeight = 0
+
+  for _, obj in sounds do
+    if not obj:IsA("Sound") then
+      continue
+    end
+
+    table.insert(validSounds, obj)
+
+    local weight = attr.get(obj, "SoundPoolWeight", 1)
+
+    table.insert(weights, weight)
+    totalWeight += weight
+  end
+
+  if #validSounds == 0 then
+    return ref
+  end
+
+  if totalWeight > 0 then
+    local roll = rng:NextNumber() * totalWeight
+    local accumulated = 0
+
+    for i, weight in weights do
+      accumulated += weight
+
+      if roll <= accumulated then
+        return validSounds[i]
+      end
+    end
+  end
+
+  return validSounds[rng:NextInteger(1, #validSounds)]
+end
+
+local function createSoundClone(ref: Sound, sourceSound: Sound, scope: types.scope): (Sound, Part?)
+  local clone = sourceSound:Clone()
+
+  for _, tag in clone:GetTags() do
+    clone:RemoveTag(tag)
+  end
+
+  local parent = ref:FindFirstAncestorWhichIsA("BasePart")
+
+  local partClone
+
+  if utility.PLUGIN_CONTEXT then
+    if parent then
+      partClone = Instance.new("Part")
+
+      partClone.Name = "SoundEmitter"
+      partClone.Anchored = true
+      partClone.CanCollide = false
+      partClone.CanQuery = false
+      partClone.CanTouch = false
+      partClone.Transparency = 1
+      partClone.Size = Vector3.one
+      partClone.CFrame = parent.CFrame
+      partClone.Parent = soundWidget
+
+      clone.Parent = partClone
+
+      table.insert(scope, partClone)
+    else
+      clone.Parent = soundWidget
+      table.insert(scope, clone)
+    end
+  else
+    if parent then
+      clone.Parent = parent
+    else
+      clone.Parent = workspace.Terrain
+    end
+
+    table.insert(scope, clone)
+  end
+
+  return clone, partClone
+end
+
+local function playSingleSound(
+  ref: Sound,
+  src: Sound,
+  clone: Sound,
+  partClone: Part?,
+  scope: types.scope,
+  emitDuration: number
+): RBXScriptConnection?
+  local currentSpeed = clone.PlaybackSpeed
+
+  local volumeEnd = attr.get(src, "Volume_End", clone.Volume)
+  local volumeStart = attr.get(src, "Volume_Start", clone.Volume)
+
+  clone.Volume = volumeStart
+
+  if volumeStart ~= volumeEnd then
+    local volumeDuration = attr.get(src, "Volume_Duration", clone.TimeLength)
+
+    table.insert(
+      scope,
+      tween.fromParams(attr.get(src, "Volume_Curve", utility.default_bezier), volumeDuration, function(alpha, deltaTime)
+        clone.Volume = utility.lerp(volumeStart, volumeEnd, alpha)
+        return deltaTime * currentSpeed
+      end)
+    )
+  else
+    clone.Volume = volumeStart
+  end
+
+  local speedEnd = attr.get(src, "Speed_End", clone.PlaybackSpeed)
+  local speedStart = attr.get(src, "Speed_Start", clone.PlaybackSpeed)
+
+  currentSpeed = speedStart
+
+  local speedTween: RBXScriptConnection? = nil
+
+  if speedStart ~= speedEnd then
+    local speedDuration = attr.get(src, "Speed_Duration", clone.TimeLength)
+
+    speedTween = tween.fromParams(
+      attr.get(src, "Speed_Curve", utility.default_bezier),
+      speedDuration,
+      function(alpha, deltaTime)
+        currentSpeed = utility.lerp(speedStart, speedEnd, alpha)
+        clone.PlaybackSpeed = currentSpeed
+        return deltaTime
+      end
+    )
+
+    table.insert(scope, speedTween)
+  else
+    clone.PlaybackSpeed = speedStart
+  end
+
+  local rolloffEnd = attr.get(src, "RollOff_End", clone.RollOffMinDistance)
+  local rolloffStart = attr.get(src, "RollOff_Start", clone.RollOffMinDistance)
+
+  if rolloffStart ~= rolloffEnd then
+    local rolloffDuration = attr.get(src, "RollOff_Duration", clone.TimeLength)
+
+    table.insert(
+      scope,
+      tween.fromParams(
+        attr.get(src, "RollOff_Curve", utility.default_bezier),
+        rolloffDuration,
+        function(alpha, deltaTime)
+          clone.RollOffMinDistance = utility.lerp(rolloffStart, rolloffEnd, alpha)
+          return deltaTime * currentSpeed
+        end,
+        speedTween
+      )
+    )
+  end
+
+  if clone.PlayOnRemove and not utility.PLUGIN_CONTEXT then
+    clone:Destroy()
+  else
+    clone:Play()
+  end
+
+  if partClone then
+    local parent = ref:FindFirstAncestorWhichIsA("BasePart")
+
+    if parent then
+      table.insert(
+        scope,
+        RunService.Heartbeat:Connect(function()
+          if partClone.Parent then
+            partClone.CFrame = parent.CFrame
+          end
+        end)
+      )
+    end
+  end
+
+  if emitDuration > 0 then
+    task.wait(emitDuration)
+    clone:Stop()
+  else
+    tween.timer(clone.TimeLength, function(deltaTime, elapsed)
+      return if clone.PlaybackSpeed > 0 or (elapsed > 0 and speedTween and speedTween.Connected)
+        then deltaTime * clone.PlaybackSpeed
+        else nil
+    end, speedTween, scope)
+  end
+
+  return speedTween
+end
+
+function sound.init()
+  if not utility.PLUGIN_CONTEXT then
+    return
+  end
+
+  local plugin = script:FindFirstAncestorOfClass("Plugin")
+
+  if not plugin then
+    return
+  end
+
+  soundWidget = plugin:CreateDockWidgetPluginGui(
+    "VFXForgeSoundPlayer",
+    DockWidgetPluginGuiInfo.new(Enum.InitialDockState.Float, false, true, 200, 100, 100, 50)
+  )
+
+  if soundWidget then
+    soundWidget.Name = "VFXForgeSoundPlayer"
+  end
+end
+
+function sound.deinit()
+  if soundWidget then
+    soundWidget:Destroy()
+    soundWidget = nil
+  end
+end
+
+function sound.emit(ref: Sound, scope: types.scope)
+  if ref.Playing then
+    ref:Stop()
+  end
+
+  local isSource = attr.get(ref, "SoundPoolIsSource", false)
+  local inheritPoolAttributes = attr.get(ref, "SoundPoolInheritAttributes", false)
+
+  if inheritPoolAttributes then
+    ref = not isSource and selectRandomSound(ref) or ref
+  end
+
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+  local emitDuration = attr.get(ref, "EmitDuration", 0)
+
+  local emitCount = attr.get(ref, "EmitCount", 1)
+  local emitInterval = attr.getRange(ref, "EmitInterval", NumberRange.new(0, 0))
+
+  local repeatCount = attr.get(ref, "RepeatCount", 1)
+  local repeatInterval = attr.getRange(ref, "RepeatInterval", NumberRange.new(0, 0))
+
+  task.wait(emitDelay)
+
+  local promises = {}
+
+  for i = 1, emitCount do
+    local sourceSound = inheritPoolAttributes and ref or (not isSource and selectRandomSound(ref) or ref)
+
+    if not sourceSound then
+      continue
+    end
+
+    local src = if inheritPoolAttributes and sourceSound ~= ref then sourceSound else ref
+
+    for r = 1, repeatCount do
+      table.insert(
+        promises,
+        Promise.new(function(resolve)
+          local clone, partClone = createSoundClone(ref, sourceSound, scope)
+
+          playSingleSound(ref, src, clone, partClone, scope, emitDuration)
+
+          if partClone then
+            partClone:Destroy()
+          else
+            clone:Destroy()
+          end
+
+          resolve()
+        end)
+      )
+
+      if r < repeatCount and repeatInterval.Max > 0 then
+        task.wait(rng:NextNumber(repeatInterval.Min, repeatInterval.Max))
+      end
+    end
+
+    if i < emitCount and emitInterval.Max > 0 then
+      task.wait(rng:NextNumber(emitInterval.Min, emitInterval.Max))
+    end
+  end
+
+  Promise.all(promises):await()
+end
+
+return sound

package/out/effects/spin.luau

@@ -0,0 +1,88 @@
+local attr = require("@mod/attributes")
+local tween = require("@mod/tween")
+local types = require("@root/types")
+local utility = require("@mod/utility")
+
+local spin = {}
+
+function spin.emit(ref: Model, scope: types.scope)
+  if utility.isSpinModelStatic(ref) then
+    return
+  end
+
+  local rotation = attr.get(ref, "SpinRotation", vector.zero) * utility.DEG_TO_RAD
+
+  local scaleStart = attr.get(ref, "Scale_Start", 1)
+  local scaleEnd = attr.get(ref, "Scale_End", 1)
+
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+  local resetDelay = attr.get(ref, "ResetDelay", 0)
+  local resetOnFinish = attr.get(ref, "ResetOnFinish", true)
+
+  local sync = attr.get(ref, "SyncPosition", false)
+  local duration = attr.get(ref, "SpinDuration", 0.5)
+
+  local speedDuration = attr.get(ref, "SpinSpeed_Duration", 0.1)
+
+  local speedStart = attr.get(ref, "SpinSpeed_Start", 0)
+  local speedEnd = attr.get(ref, "SpinSpeed_End", 1)
+
+  local currentSpeed = speedStart
+
+  task.wait(emitDelay)
+
+  local speedTween
+
+  if speedStart ~= speedEnd then
+    speedTween = tween.fromParams(
+      attr.get(ref, "SpinSpeed_Curve", utility.default_bezier),
+      speedDuration,
+      function(alpha, deltaTime)
+        currentSpeed = utility.lerp(speedStart, speedEnd, alpha)
+        return deltaTime
+      end
+    )
+
+    table.insert(scope, speedTween)
+  end
+
+  local originalPivot = ref:GetPivot()
+  local originalScale = ref:GetScale()
+
+  if scaleStart ~= scaleEnd then
+    table.insert(
+      scope,
+      tween.fromParams(attr.get(ref, "Scale_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+        ref:ScaleTo(utility.lerp(scaleStart, scaleEnd, alpha))
+        return deltaTime
+      end)
+    )
+  else
+    ref:ScaleTo(scaleStart)
+  end
+
+  local parent = ref:FindFirstAncestorOfClass("Attachment") or ref:FindFirstAncestorWhichIsA("BasePart")
+
+  if resetOnFinish then
+    table.insert(scope, function()
+      ref:PivotTo(parent and utility.getTransformedOriginExtents(parent) or originalPivot)
+      ref:ScaleTo(originalScale)
+    end)
+  end
+
+  rotation *= duration
+
+  tween.timer(duration + resetDelay, function(deltaTime, elapsed)
+    local alpha = math.clamp(elapsed / duration, 0, 1)
+
+    local r = rotation * alpha
+    local cf = (if parent and sync then utility.getTransformedOriginExtents(parent) else originalPivot)
+      * CFrame.fromOrientation(r.x, r.y, r.z)
+
+    ref:PivotTo(cf)
+
+    return if currentSpeed > 0 or (elapsed > 0 and speedTween.Connected) then deltaTime * currentSpeed else nil
+  end, speedTween, scope, utility.RENDER_PRIORITY + scope.depth)
+end
+
+return spin