@rbxts/vfx-forge 2.2.2-ts.1

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

@@ -0,0 +1,466 @@
+local TS = _G[script.Parent.Parent.Parent]
+--!nolint LocalShadow
+local RunService = game:GetService("RunService")
+
+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 flipbook_common = require(script.Parent.Parent.mod.common.flipbook)
+
+local Oklab = require(script.Parent.Parent.mod.color.Oklab)
+
+local rng = Random.new()
+
+local mesh = {}
+
+function mesh.emit(ref: Model, obj: BasePart, scope: types.scope, scale: number, mustEmit: boolean?)
+  local start = ref:FindFirstChild("Start")
+  local goal = ref:FindFirstChild("End")
+
+  if
+    not start
+    or not goal
+    or not start:IsA("BasePart")
+    or not goal:IsA("BasePart")
+    or (ref:GetAttribute("Enabled") and not mustEmit)
+  then
+    return
+  end
+
+  local legacy_duration = attr.get(ref, "Duration", 1, true)
+
+  local durationRange = attr.getRange(
+    ref,
+    "EffectDuration",
+    NumberRange.new(legacy_duration, legacy_duration),
+    NumberRange.new(0, math.huge)
+  )
+
+  local duration = rng:NextNumber(durationRange.Min, durationRange.Max)
+
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+  local destroyDelay = attr.get(ref, "DestroyDelay", 0)
+  local emitDuration = attr.get(ref, "EmitDuration", 0)
+
+  local legacy_isFlipbook = attr.get(ref, "Flipbook", false, true)
+  local legacy_flipbookFadeOffset = attr.get(ref, "FlipbookFadeOffset", 0, true)
+
+  -- stone age compatibility
+  do
+    local prefix
+
+    if legacy_isFlipbook or not start:FindFirstChildOfClass("Decal") then
+      prefix = "Mesh_"
+    else
+      prefix = "Decal_"
+    end
+
+    local ts = ref:GetAttribute("StartTransparency")
+
+    if ts ~= nil then
+      ref:SetAttribute(prefix .. "StartTransparency", ts)
+      ref:SetAttribute("StartTransparency", nil)
+    end
+
+    local te = ref:GetAttribute("EndTransparency")
+
+    if te ~= nil then
+      ref:SetAttribute(prefix .. "EndTransparency", te)
+      ref:SetAttribute("EndTransparency", nil)
+    end
+  end
+
+  local useEmitDuration = ref:GetAttribute("Enabled") ~= nil and ref:HasTag(utility.ENABLED_VFX_TAG) and duration > 0
+
+  local legacy_decalST = attr.get(ref, "Decal_StartTransparency", 0, true)
+  local legacy_decalET = attr.get(ref, "Decal_EndTransparency", 0, true)
+
+  local partDefaultTp = 0
+
+  do
+    local decal = start and start:FindFirstChildOfClass("Decal")
+
+    if decal then
+      partDefaultTp = 1
+    end
+  end
+
+  local legacy_meshST = attr.get(ref, "Mesh_StartTransparency", partDefaultTp, true)
+  local legacy_meshET = attr.get(ref, "Mesh_EndTransparency", partDefaultTp, true)
+
+  local sync = attr.get(ref, "SyncPosition", false)
+
+  local speedStart = attr.get(ref, "Speed_Start", 1)
+  local speedEnd = attr.get(ref, "Speed_End", 1)
+
+  local tpStart = attr.get(ref, "Part_Transparency_Start", legacy_meshST)
+  local tpEnd = attr.get(ref, "Part_Transparency_End", legacy_meshET)
+
+  local spreadAngle = attr.get(ref, "SpreadAngle", vector.zero)
+
+  local rotSpeedStartRange = attr.getRange(ref, "Part_RotSpeed_Start", NumberRange.new(0, 0))
+  local rotSpeedEndRange = attr.getRange(ref, "Part_RotSpeed_End", NumberRange.new(0, 0))
+
+  local rotAroundOrigin = attr.get(ref, "RotAroundOrigin", false)
+
+  local minInitRot = attr.get(ref, "MinInitRot", vector.zero)
+  local maxInitRot = attr.get(ref, "MaxInitRot", vector.zero)
+
+  local rotSpeedStart = rng:NextNumber(rotSpeedStartRange.Min, rotSpeedStartRange.Max)
+  local rotSpeedEnd = rng:NextNumber(rotSpeedEndRange.Min, rotSpeedEndRange.Max)
+
+  local initRot = vector.create(
+    rng:NextNumber(minInitRot.x, maxInitRot.x),
+    rng:NextNumber(minInitRot.y, maxInitRot.y),
+    rng:NextNumber(minInitRot.z, maxInitRot.z)
+  ) * utility.DEG_TO_RAD
+
+  task.wait(emitDelay)
+
+  if useEmitDuration and not mustEmit then
+    attr.trigger(ref, "Enabled", true)
+
+    if speedStart ~= speedEnd then
+      attr.setState(ref, "SpeedTweening", true)
+
+      table.insert(
+        scope,
+        tween.fromParams(
+          attr.get(ref, "Speed_Curve", utility.default_bezier),
+          attr.get(ref, "Speed_Duration", 0.1),
+          function(alpha, deltaTime)
+            attr.setState(ref, "SpeedOverride", utility.lerp(speedStart, speedEnd, alpha))
+            return deltaTime
+          end,
+          nil,
+          function()
+            attr.setState(ref, "SpeedTweening", nil)
+          end
+        )
+      )
+    end
+
+    task.wait(emitDuration)
+
+    attr.trigger(ref, "Enabled", false)
+    attr.clearState(ref)
+
+    return
+  end
+
+  local parent = ref:FindFirstAncestorOfClass("Attachment") or start
+  local realObj = typeof(obj) == "table" and obj._getReal() or obj
+
+  local origin = utility.getTransformedOriginExtents(parent)
+  local goalCFrameOffset = start.CFrame:ToObjectSpace(goal.CFrame)
+
+  local currentSpeed = speedStart
+  local currentRotSpeed = rotSpeedStart
+
+  local currentRot = CFrame.fromOrientation(initRot.x, initRot.y, initRot.z)
+  local currentCFrame = CFrame.identity
+
+  local spread = CFrame.fromOrientation(
+    math.rad(rng:NextNumber(-spreadAngle.x, spreadAngle.x)),
+    math.rad(rng:NextNumber(-spreadAngle.y, spreadAngle.y)),
+    0
+  )
+
+  local function updatePos(deltaTime: number)
+    local o = sync and utility.getTransformedOriginExtents(parent) or origin
+    local add = initRot:Sign() * currentRotSpeed * deltaTime
+
+    currentRot *= CFrame.fromOrientation(add.x, add.y, add.z)
+
+    local cf
+
+    if rotAroundOrigin then
+      cf = o * spread * currentRot * currentCFrame
+    else
+      cf = o * spread * currentCFrame * currentRot
+    end
+
+    cf *= currentRot
+
+    obj.CFrame = cf
+  end
+
+  updatePos(0)
+
+  do
+    local id = utility.getRandomId()
+
+    RunService:BindToRenderStep(id, utility.RENDER_PRIORITY + scope.depth, updatePos)
+
+    table.insert(scope, function()
+      RunService:UnbindFromRenderStep(id)
+    end)
+  end
+
+  local promises = {}
+
+  local emitOnFinish = scope.effects.prepareEmitOnFinish(obj, scope)
+
+  local env = scope.effects.emitNested(obj, scope.depth + 1)
+  table.insert(promises, env.Finished)
+
+  local speedTween
+
+  if speedStart ~= speedEnd and not attr.getState(ref, "SpeedOverride", nil) then
+    speedTween = tween.fromParams(
+      attr.get(ref, "Speed_Curve", utility.default_bezier),
+      attr.get(ref, "Speed_Duration", 0.1),
+      function(alpha, deltaTime)
+        currentSpeed = utility.lerp(speedStart, speedEnd, alpha)
+        return deltaTime
+      end
+    )
+
+    table.insert(scope, speedTween)
+  end
+
+  if goalCFrameOffset ~= CFrame.identity then
+    table.insert(
+      scope,
+      tween.fromParams(attr.get(ref, "Part_CFrame_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+        currentCFrame = CFrame.identity:Lerp(goalCFrameOffset, alpha)
+        return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+      end, speedTween)
+    )
+  end
+
+  if rotSpeedStart ~= rotSpeedEnd then
+    table.insert(
+      scope,
+      tween.fromParams(
+        attr.get(ref, "Part_RotSpeed_Curve", utility.default_bezier),
+        duration,
+        function(alpha, deltaTime)
+          currentRotSpeed = utility.lerp(rotSpeedStart, rotSpeedEnd, alpha)
+          return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+        end,
+        speedTween
+      )
+    )
+  end
+
+  if tpStart ~= tpEnd then
+    table.insert(
+      scope,
+      tween.fromParams(
+        attr.get(ref, "Part_Transparency_Curve", utility.default_bezier),
+        duration,
+        function(alpha, deltaTime)
+          obj.Transparency = utility.lerp(tpStart, tpEnd, alpha)
+          return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+        end,
+        speedTween
+      )
+    )
+  else
+    obj.Transparency = tpStart
+  end
+
+  local sizeStart, sizeEnd = start.Size * scale, goal.Size * scale
+
+  if sizeStart ~= sizeEnd then
+    local lastSizeAlpha = -1
+    
+table.insert(
+      scope,
+      tween.fromParams(attr.get(ref, "Part_Size_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+        local speed = attr.getState(ref, "SpeedOverride", currentSpeed)
+
+        -- reduce size writes
+        if math.abs(alpha - lastSizeAlpha) < 0.005 then
+          return deltaTime * speed
+        end
+
+        lastSizeAlpha = alpha
+        obj.Size = sizeStart:Lerp(sizeEnd, alpha)
+
+        return deltaTime * speed
+      end, speedTween)
+    )
+  else
+    obj.Size = sizeStart
+  end
+
+  local startMesh = start:FindFirstChildOfClass("SpecialMesh")
+  local goalMesh = goal:FindFirstChildOfClass("SpecialMesh")
+
+  local objMesh = obj:FindFirstChildOfClass("SpecialMesh")
+
+  if objMesh then
+    if startMesh and goalMesh then
+      local scaleStart, scaleEnd = startMesh.Scale * scale, goalMesh.Scale * scale
+
+      if scaleStart ~= scaleEnd then
+        table.insert(
+          scope,
+          tween.fromParams(
+            attr.get(ref, "Mesh_Scale_Curve", utility.default_bezier),
+            duration,
+            function(alpha, deltaTime)
+              objMesh.Scale = utility.lerp(scaleStart, scaleEnd, alpha)
+              return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+            end,
+            speedTween
+          )
+        )
+      end
+    else
+      objMesh.Parent = nil
+
+      table.insert(scope, function()
+        objMesh.Parent = realObj
+      end)
+    end
+  end
+
+  local decals, flipbooks, fromToMap = utility.getMeshDecals(ref, obj)
+
+  local longestFlipbookDuration = 0
+
+  if legacy_isFlipbook then
+    table.sort(decals, function(a, b)
+      local x = a.Name:match("%d+") or 0
+      local y = b.Name:match("%d+") or 0
+
+      return tonumber(x) < tonumber(y)
+    end)
+
+    local displayDecal = Instance.new("Decal")
+    displayDecal.Parent = realObj
+
+    table.insert(scope, displayDecal)
+
+    if legacy_flipbookFadeOffset > 0 then
+      if legacy_decalST ~= legacy_decalET then
+        table.insert(
+          scope,
+          tween.fromParams(utility.default_bezier, duration + legacy_flipbookFadeOffset, function(alpha, deltaTime)
+            displayDecal.Transparency = utility.lerp(legacy_decalST, legacy_decalET, alpha)
+            return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+          end, speedTween)
+        )
+      end
+    end
+
+    table.insert(
+      scope,
+      tween.fromParams(utility.default_bezier, duration, function(alpha, deltaTime)
+        local index = math.max(math.round(#decals * alpha), 1)
+        local target = decals[index]
+
+        displayDecal.Texture = target.Texture
+
+        displayDecal.Color3 = target.Color3
+        displayDecal.ZIndex = target.ZIndex
+
+        if legacy_flipbookFadeOffset == 0 then
+          displayDecal.Transparency = utility.lerp(legacy_decalST, legacy_decalET, alpha)
+          displayDecal.ZIndex = target.ZIndex
+        end
+
+        return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+      end, speedTween)
+    )
+  else
+    for _, decal in decals do
+      local from = decal
+      local to = fromToMap[from]
+
+      local decal_tpStart = attr.get(from, "Transparency_Start", legacy_decalST)
+      local decal_tpEnd = attr.get(from, "Transparency_End", legacy_decalET)
+
+      if decal_tpStart ~= decal_tpEnd then
+        table.insert(
+          scope,
+          tween.fromParams(
+            attr.get(from, "Transparency_Curve", utility.default_bezier),
+            duration,
+            function(alpha, deltaTime)
+              decal.Transparency = utility.lerp(decal_tpStart, decal_tpEnd, alpha)
+              return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+            end,
+            speedTween
+          )
+        )
+      else
+        decal.Transparency = decal_tpStart
+      end
+
+      if from.Color3 ~= to.Color3 then
+        table.insert(
+          scope,
+          tween.fromParams(attr.get(from, "Color_Curve", utility.default_bezier), duration, function(alpha, deltaTime)
+            local a = Oklab.fromSRGB(from.Color3)
+            local b = Oklab.fromSRGB(to.Color3)
+
+            decal.Color3 = Oklab.toSRGB(a:Lerp(b, alpha), true)
+
+            return deltaTime * (attr.getState(ref, "SpeedOverride", currentSpeed))
+          end, speedTween)
+        )
+      end
+
+      local flipbook = flipbooks[from]
+
+      if flipbook then
+        local config = {
+          ref = from,
+          frames = flipbook,
+          speedTween = speedTween,
+          effectDuration = duration,
+
+          curve = attr.get(from, "Flipbook_Change_Curve", utility.linear_bezier),
+          duration = attr.get(from, "Flipbook_Change_Duration", duration),
+
+          getSpeed = function()
+            return attr.getState(ref, "SpeedOverride", currentSpeed)
+          end,
+
+          setTexture = function(texture)
+            decal.Texture = texture
+          end,
+        }
+
+        local changeDuration = flipbook_common.getChangeDuration(config)
+
+        if changeDuration > longestFlipbookDuration then
+          longestFlipbookDuration = changeDuration
+        end
+
+        table.insert(
+          scope,
+          tween.fromParams(config.curve, changeDuration, flipbook_common.createUpdateCallback(config), speedTween)
+        )
+      end
+    end
+  end
+
+  tween.timer(
+    math.max(duration, longestFlipbookDuration) + legacy_flipbookFadeOffset + destroyDelay,
+    function(deltaTime, elapsed)
+      local speed = attr.getState(ref, "SpeedOverride", currentSpeed)
+
+      currentSpeed = speed
+
+      return if speed > 0
+          or (elapsed > 0 and if speedTween then speedTween.Connected else attr.getState(ref, "SpeedTweening", false))
+        then deltaTime * speed
+        else nil
+    end,
+    speedTween,
+    scope
+  )
+
+  TS.Promise.all(promises):await()
+
+  local env = scope.effects.emitOnFinish(emitOnFinish, realObj, scope.depth + 1)
+  env.Finished:await()
+end
+
+return mesh

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

@@ -0,0 +1,64 @@
+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 particle = {}
+
+function particle.emit(ref: ParticleEmitter, obj: ParticleEmitter, scope: types.scope)
+  if ref.Enabled then
+    ref.Enabled = false
+  end
+
+  local delay = attr.get(ref, "EmitDelay", 0)
+  local count = attr.get(ref, "EmitCount", 1)
+  local duration = attr.get(ref, "EmitDuration", 0)
+
+  local useDuration = duration > 0
+
+  task.wait(delay)
+
+  if useDuration then
+    obj.Enabled = true
+  end
+
+  local timeScaleDuration = attr.get(ref, "TimeScale_Duration", 0.1)
+
+  local timeScaleStart = attr.get(ref, "TimeScale_Start", obj.TimeScale, true)
+  local timeScaleEnd = attr.get(ref, "TimeScale_End", obj.TimeScale, true)
+
+  local speedTween
+
+  if timeScaleStart ~= timeScaleEnd then
+    speedTween = tween.fromParams(
+      attr.get(ref, "TimeScale_Curve", utility.default_bezier),
+      timeScaleDuration,
+      function(alpha, deltaTime)
+        local speed = utility.lerp(timeScaleStart, timeScaleEnd, math.clamp(alpha, 0, 1))
+
+        obj.TimeScale = speed
+
+        return deltaTime
+      end
+    )
+
+    table.insert(scope, speedTween)
+  elseif timeScaleStart ~= obj.TimeScale then
+    obj.TimeScale = timeScaleStart
+  end
+
+  obj:Emit(count)
+
+  if useDuration then
+    task.wait(duration)
+    obj.Enabled = false
+  end
+
+  tween.timer(ref.Lifetime.Max, function(deltaTime, elapsed)
+    return if ref.TimeScale > 0 or (elapsed > 0 and speedTween and speedTween.Connected)
+      then deltaTime * ref.TimeScale
+      else nil
+  end, speedTween, scope)
+end
+
+return particle

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

@@ -0,0 +1,110 @@
+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 Bezier = require(script.Parent.Parent.obj.Bezier)
+
+local rng = Random.new()
+
+local randomizer = {}
+
+local function getBezier(params: string): Bezier.Bezier?
+  local bezier = tween.bezier_cache[params]
+
+  if not bezier then
+    local success, points = pcall(function()
+      return utility.deserializePath(params)
+    end)
+
+    if not success then
+      return nil
+    end
+
+    bezier = Bezier.new(points, 0)
+    tween.bezier_cache[params] = bezier
+  end
+
+  return bezier
+end
+
+local function sampleWeighted(bezier: Bezier.Bezier): number
+  local t = rng:NextNumber()
+  local weight = 1 - bezier:getEase(t).y
+
+  return weight
+end
+
+function randomizer.emit(obj: RayValue, scope: types.scope, isAttribute: boolean)
+  local target = utility.getTarget(obj)
+
+  if not target then
+    return
+  end
+
+  local name = obj.Name
+
+  local startValue = attr.get(obj, "_START_VALUE", nil)
+  local endValue = attr.get(obj, "_END_VALUE", nil)
+
+  if startValue == nil or endValue == nil then
+    return
+  end
+
+  local typeName = typeof(startValue)
+
+  if typeName ~= typeof(endValue) then
+    return
+  end
+
+  local weightCurve = attr.get(obj, "Weight_Curve", utility.linear_bezier)
+  local bezier = getBezier(weightCurve)
+
+  if not bezier then
+    return
+  end
+
+  local originalValue
+
+  if isAttribute then
+    originalValue = attr.get(target, name, nil)
+  else
+    local ok, val = pcall(function()
+      return target[name]
+    end)
+
+    if not ok then
+      return
+    end
+
+    originalValue = val
+  end
+
+  local lfunc = lerp[typeName] or lerp.Other
+
+  local alpha = sampleWeighted(bezier)
+  local newValue = lfunc(startValue, endValue, alpha)
+
+  local resetOnFinish = attr.get(obj, "ResetOnFinish", true)
+
+  if isAttribute then
+    attr.set(target, name, newValue)
+  else
+    target[name] = newValue
+  end
+
+  if resetOnFinish then
+    -- reset on next frame (after the target effects are emitted)
+    task.defer(function()
+      if isAttribute then
+        attr.set(target, name, originalValue)
+      else
+        target[name] = originalValue
+      end
+    end)
+  end
+end
+
+return randomizer

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

@@ -0,0 +1,61 @@
+local RunService = game:GetService("RunService")
+
+local attr = require(script.Parent.Parent.mod.attributes)
+local types = require(script.Parent.Parent.types)
+local utility = require(script.Parent.Parent.mod.utility)
+
+local screen = {}
+
+function screen.emit(ref: BasePart, scope: types.scope)
+  if not ref:GetAttribute("Enabled") then
+    return
+  end
+
+  local scale = attr.get(ref, "PartScale", vector.one)
+  local distance = attr.get(ref, "PartDistance", 1.5)
+
+  local pos = attr.get(ref, "OffsetPosition", vector.zero)
+  local rot = attr.get(ref, "OffsetRotation", vector.zero) * utility.DEG_TO_RAD
+
+  local originalCF = ref.CFrame
+  local originalSize = ref.Size
+  local originalColGroup = ref.CollisionGroup
+
+  ref.CollisionGroup = "ForgeMouseIgnore"
+
+  table.insert(scope, function()
+    ref.Size = originalSize
+    ref.CFrame = originalCF
+    ref.CollisionGroup = originalColGroup ~= "" and originalColGroup or "Default"
+  end)
+
+  -- crazy how BindToRenderStep will always run before RenderStepped in studio
+  local function frame()
+    local camera = workspace.CurrentCamera
+
+    local halfFovRad = math.rad(camera.FieldOfView / 2)
+    local height = math.tan(halfFovRad) * distance * 2
+    local width = (camera.ViewportSize.X / camera.ViewportSize.Y) * height
+
+    local cf = camera.CFrame * CFrame.new(0, 0, -distance)
+
+    ref.Size = Vector3.new(width, height, ref.Size.Z) * scale
+    ref.CFrame = cf * CFrame.new(pos) * CFrame.fromOrientation(rot.x, rot.y, rot.z)
+  end
+
+  if not RunService:IsRunning() then
+    table.insert(scope, RunService.RenderStepped:Connect(frame))
+  else
+    local id = utility.getRandomId()
+
+    RunService:BindToRenderStep(id, Enum.RenderPriority.Last.Value + 2 + scope.depth, frame)
+
+    table.insert(scope, function()
+      RunService:UnbindFromRenderStep(id)
+    end)
+  end
+
+  return true
+end
+
+return screen