@rbxts/vfx-forge 2.2.2-ts.1

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

@@ -0,0 +1,277 @@
+local TS = _G[script.Parent.Parent.Parent]
+local RunService = game:GetService("RunService")
+local CollectionService = game:GetService("CollectionService")
+
+local attr = require(script.Parent.Parent.mod.attributes)
+local tween = require(script.Parent.Parent.mod.tween)
+local types = require(script.Parent.Parent.types)
+local utility = require(script.Parent.Parent.mod.utility)
+
+local ObjectCache = require(script.Parent.Parent.obj.ObjectCache)
+
+local rng = Random.new()
+
+local debris = {}
+local physicsParts = {}
+
+local part_cache: ObjectCache.ObjectCache?
+local physicsStepper: RBXScriptConnection?
+
+function debris.init(cache)
+  if physicsStepper then
+    return
+  end
+
+  part_cache = cache
+
+  if utility.PLUGIN_CONTEXT then
+    physicsStepper = RunService.RenderStepped:Connect(function(deltaTime)
+      if #physicsParts == 0 then
+        return
+      end
+
+      workspace:StepPhysics(deltaTime, physicsParts)
+    end)
+  end
+end
+
+function debris.deinit()
+  if physicsStepper then
+    physicsStepper:Disconnect()
+    physicsStepper = nil
+  end
+
+  part_cache = nil
+
+  for _, part in physicsParts do
+    part:Destroy()
+  end
+
+  table.clear(physicsParts)
+end
+
+function debris.emit(origin: Attachment, ref: Part, scope: types.scope)
+  if not part_cache then
+    return
+  end
+
+  local params
+
+  local inherit = attr.get(ref, "InheritanceEnabled", true)
+  local inheritRadius = attr.get(ref, "InheritanceRadius", 5)
+
+  local rayColGroup = attr.get(origin, "RayCollisionGroup", "Default")
+
+  local rayFilterTag = attr.get(origin, "FilterTag", "")
+  local rayFilterType = attr.get(origin, "FilterType", "Exclude")
+
+  local rayIgnoreCanCollide = attr.get(origin, "IgnoreCanCollide", false)
+
+  if inherit then
+    local inheritMaxResults = attr.get(ref, "InheritanceMaxResults", 5)
+
+    params = OverlapParams.new()
+    params.MaxParts = inheritMaxResults
+    params.CollisionGroup = rayColGroup
+    params.RespectCanCollide = not rayIgnoreCanCollide
+    params.FilterType = Enum.RaycastFilterType[rayFilterType]
+    params.FilterDescendantsInstances = CollectionService:GetTagged(rayFilterTag)
+
+    if rayFilterType == "Exclude" then
+      params:AddToFilter({ workspace.Terrain })
+    end
+  end
+
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+
+  local amount = attr.getRange(ref, "Amount", NumberRange.new(5, 10), NumberRange.new(0, math.huge))
+  local lifetime = attr.getRange(ref, "Lifetime", NumberRange.new(2, 3), NumberRange.new(0, math.huge))
+  local airtime = attr.getRange(ref, "Airtime", NumberRange.new(0.5, 0.5), NumberRange.new(0, math.huge))
+
+  local linmag = attr.getRange(ref, "LinearMagnitude", NumberRange.new(15, 25))
+  local angmag = attr.getRange(ref, "AngularMagnitude", NumberRange.new(5, 15))
+
+  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 minDir = attr.get(ref, "MinDirection", -vector.one)
+  local maxDir = attr.get(ref, "MaxDirection", vector.one)
+
+  local count = rng:NextInteger(amount.Min, amount.Max)
+
+  local sizeCurve = attr.get(ref, "Size_Curve", utility.default_bezier)
+  local tpCurve = attr.get(ref, "Transparency_Curve", utility.default_bezier)
+
+  local tpDuration = attr.get(ref, "Transparency_Duration", 0.5)
+  local sizeDuration = attr.get(ref, "Size_Duration", 0.5)
+
+  local tpStart = attr.get(ref, "Transparency_Start", 0)
+  local tpEnd = attr.get(ref, "Transparency_End", 1)
+
+  local partData = {}
+  local promises = {}
+
+  ref.CanCollide = false
+
+  local originCFrame = utility.getTransformedOriginExtents(origin)
+  local originPosition = originCFrame.Position
+
+  if params then
+    local parts = workspace:GetPartBoundsInRadius(originPosition, inheritRadius, params)
+
+    for _, p in parts do
+      if p.Transparency == 1 then
+        continue
+      end
+
+      table.insert(partData, p)
+    end
+  end
+
+  task.wait(emitDelay)
+
+  for _ = 1, count do
+    local iref = #partData ~= 0 and partData[rng:NextInteger(1, #partData)]
+
+    local id = utility.getRandomId()
+
+    local part = part_cache:get(id)
+
+    local realPart = part._getReal() :: BasePart
+
+    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(realPart, scope)
+    local emitOnImpact = scope.effects.prepareEmitFolder(realPart, "EmitOnImpact", scope)
+
+    if emitOnImpact and #emitOnImpact:GetChildren() > 0 then
+      local conn
+      conn = realPart.Touched:Connect(function(hit)
+        if
+          (not rayIgnoreCanCollide and not hit:CanCollideWith(realPart)) -- ignore parts we can't collide with if they can be ignored
+          or hit:IsDescendantOf(workspace.Terrain) -- ignore all debris parts/other effects
+          or (rayFilterType == "Exclude" and hit:HasTag(rayFilterTag)) -- ignore all excluded tags
+        then
+          return
+        end
+
+        conn:Disconnect()
+
+        local env = scope.effects.emitFromFolder(emitOnImpact, realPart, scope.depth + 1)
+        table.insert(promises, env.Finished)
+      end)
+
+      table.insert(scope, function()
+        if conn then
+          conn:Disconnect()
+          conn = nil
+        end
+      end)
+    end
+
+    part.Anchored = false
+    part.CanCollide = true
+
+    if part.CollisionGroup == "Default" then
+      part.CollisionGroup = "ForgeDebris"
+    end
+
+    part.CFrame = CFrame.new(originPosition)
+
+    local size = Vector3.new(
+      rng:NextNumber(minSize.X, maxSize.X),
+      rng:NextNumber(minSize.Y, maxSize.Y),
+      rng:NextNumber(minSize.Z, maxSize.Z)
+    )
+
+    part.Size = size
+
+    if iref then
+      part.Material = iref.Material
+      part.Color = iref.Color
+      part.Transparency = iref.Transparency
+    else
+      part.Transparency = tpStart
+    end
+
+    table.insert(scope, function()
+      local index = table.find(physicsParts, realPart)
+
+      if index then
+        table.remove(physicsParts, index)
+      end
+
+      if part_cache then
+        part_cache:free(id)
+      end
+    end)
+
+    table.insert(physicsParts, realPart)
+
+    part.AssemblyLinearVelocity = originCFrame:VectorToWorldSpace(part.AssemblyLinearVelocity)
+
+    local relDir = utility.randomUnitVector(minDir, maxDir)
+    local worldDir = originCFrame:VectorToWorldSpace(relDir)
+
+    part:ApplyImpulse(
+      part.AssemblyMass
+        * utility.getImpulseForce(
+          originPosition,
+          originPosition + worldDir.Unit * rng:NextNumber(linmag.Min, linmag.Max),
+          rng:NextNumber(airtime.Min, airtime.Max)
+        )
+    )
+
+    part:ApplyAngularImpulse(part.AssemblyMass * rng:NextUnitVector() * rng:NextNumber(angmag.Min, angmag.Max))
+
+    local env = scope.effects.emitNested(realPart, scope.depth + 1)
+    table.insert(promises, env.Finished)
+
+    task.delay(rng:NextNumber(lifetime.Min, lifetime.Max), function()
+      local startSize = part.Size
+      local startTp = part.Transparency
+
+      if startSize ~= size * sizeScaleEnd then
+        table.insert(
+          scope,
+          tween.fromParams(sizeCurve, sizeDuration, function(alpha, deltaTime)
+            part.Size = startSize:Lerp(size * sizeScaleEnd, alpha)
+            return deltaTime
+          end)
+        )
+      end
+
+      if startTp ~= tpEnd then
+        table.insert(
+          scope,
+          tween.fromParams(tpCurve, tpDuration, function(alpha, deltaTime)
+            part.Transparency = utility.lerp(startTp, tpEnd, alpha)
+            return deltaTime
+          end)
+        )
+      end
+
+      local env = scope.effects.emitOnFinish(emitOnFinish, realPart, scope.depth + 1)
+      table.insert(promises, env.Finished)
+    end)
+  end
+
+  task.wait(lifetime.Max + math.max(tpDuration, sizeDuration))
+
+  TS.Promise.all(promises):await()
+end
+
+return debris

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

@@ -0,0 +1,356 @@
+local TS = _G[script.Parent.Parent.Parent]
+local CollectionService = game:GetService("CollectionService")
+
+local attr = require(script.Parent.Parent.mod.attributes)
+local tween = require(script.Parent.Parent.mod.tween)
+local types = require(script.Parent.Parent.types)
+local logger = require(script.Parent.Parent.mod.logger)
+local utility = require(script.Parent.Parent.mod.utility)
+
+local Bezier = require(script.Parent.Parent.obj.Bezier)
+local ObjectCache = require(script.Parent.Parent.obj.ObjectCache)
+
+local rng = Random.new()
+
+local line = {}
+
+local part_cache: ObjectCache.ObjectCache?
+
+function line.init(cache)
+  part_cache = cache
+end
+
+function line.deinit()
+  part_cache = nil
+end
+
+function line.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 rateStart = attr.get(ref, "Rate_Start", 30)
+  local rateEnd = attr.get(ref, "Rate_End", 30)
+
+  local fixedAmount = attr.get(ref, "FixedAmount", 0)
+
+  local scaleStart = attr.get(ref, "Scale_Start", 1)
+  local scaleEnd = attr.get(ref, "Scale_End", 1)
+
+  local duration = attr.get(ref, "Duration", 1)
+  local direction = attr.get(ref, "Direction", vector.create(0, 0, -1))
+  local lineLength = attr.get(ref, "Length", 50)
+
+  local rot = attr.getRange(ref, "Rotation", NumberRange.new(-180, 180))
+
+  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 lifetime = attr.getRange(ref, "Lifetime", NumberRange.new(2, 3), NumberRange.new(0, math.huge))
+
+  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)
+
+  local sync = attr.get(ref, "SyncPosition", false)
+
+  duration = math.max(duration, 0.001)
+
+  if fixedAmount > 0 then
+    local rate = fixedAmount / duration
+
+    rateStart = rate
+    rateEnd = rate
+  end
+
+  direction = direction.Unit
+
+  if direction ~= direction then
+    direction = -Vector3.zAxis
+  end
+
+  task.wait(emitDelay)
+
+  local promises = {}
+
+  local start = utility.getTransformedOriginExtents(origin)
+
+  local last = 0
+  local total = 0
+
+  local currentRate = rateStart
+  local currentScale = scaleStart
+
+  if scaleStart ~= scaleEnd then
+    table.insert(
+      scope,
+      tween.fromParams(attr.get(ref, "Scale_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+        currentScale = utility.lerp(scaleStart, scaleEnd, alpha)
+        return deltaTime
+      end)
+    )
+  end
+
+  if rateStart ~= rateEnd then
+    table.insert(
+      scope,
+      tween.fromParams(attr.get(ref, "Rate_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+        currentRate = utility.lerp(rateStart, rateEnd, alpha)
+        return deltaTime
+      end)
+    )
+  end
+
+  local pathCurve = attr.get(ref, "Path_Curve", utility.linear_bezier)
+
+  local ok, points = pcall(function()
+    return utility.deserializePath(pathCurve)
+  end)
+
+  if not ok then
+    logger.error(`failed to decode bezier path data with error: {points}`)
+  end
+
+  local bezier = Bezier.new(points, 0)
+
+  table.insert(
+    scope,
+    tween.fromParams(utility.linear_bezier, duration, function(_, deltaTime)
+      last += deltaTime
+
+      local threshold = 1 / currentRate
+      local max = duration * currentRate
+
+      if last < threshold or total >= max then
+        return deltaTime
+      end
+
+      local ticks = last // threshold
+
+      for i = 1, ticks do
+        if total >= max then
+          continue
+        end
+
+        total += 1
+
+        local t = math.clamp(total / max, 0, 1)
+        local alpha = 1 - bezier:getEase(t).y
+
+        if sync then
+          start = utility.getTransformedOriginExtents(origin)
+        end
+
+        local originCFrame = utility.getTransformedOriginExtents(origin)
+        local result = workspace:Raycast(
+          start.Position + start:VectorToWorldSpace(direction) * lineLength * alpha,
+          originCFrame:VectorToWorldSpace(raydir),
+          params
+        )
+
+        if not result then
+          last = 0
+          return deltaTime
+        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(realPart, 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 angle = rng:NextNumber(rot.Min, rot.Max)
+
+        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, offsetTween)
+        end
+
+        local size = Vector3.new(width, height, length) * currentScale
+
+        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(realPart, 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, realPart, scope.depth + 1)
+          table.insert(promises, env.Finished)
+        end)
+      end
+
+      last %= threshold
+
+      return deltaTime
+    end, nil, nil, true, utility.RENDER_PRIORITY + scope.depth)
+  )
+
+  task.wait(lifetime.Max + duration + math.max(sizeEndDuration, offsetEndDuration))
+
+  TS.Promise.all(promises):await()
+end
+
+return line