@rbxts/vfx-forge 2.2.2-ts.1

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

@@ -0,0 +1,392 @@
+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 bezier_common = require(script.Parent.Parent.mod.common.bezier)
+
+local Bezier = require(script.Parent.Parent.obj.Bezier)
+local ObjectCache = require(script.Parent.Parent.obj.ObjectCache)
+
+local bezier = {}
+
+local part_cache: ObjectCache.ObjectCache?
+
+function bezier.init(cache)
+  part_cache = cache
+end
+
+function bezier.deinit()
+  part_cache = nil
+end
+
+local function readBezierAttributes(ref: Attachment)
+  return {
+    -- animation
+    facePath = attr.get(ref, "FacePath", false),
+    arcSpace = attr.get(ref, "ArcSpace", false),
+
+    -- rotation
+    rotSpeedStart = attr.getRange(ref, "RotSpeed_Start", NumberRange.new(0, 0)),
+    rotSpeedEnd = attr.getRange(ref, "RotSpeed_End", NumberRange.new(0, 0)),
+    minInitRot = attr.get(ref, "MinInitRot", vector.zero),
+    maxInitRot = attr.get(ref, "MaxInitRot", vector.zero),
+
+    -- curves
+    speedCurve = attr.get(ref, "Speed_Curve", utility.default_bezier),
+    speedDuration = attr.get(ref, "Speed_Duration", 0.1),
+    easingCurve = attr.get(ref, "Easing_Curve", utility.linear_bezier),
+  }
+end
+
+function bezier.emit(ref: Attachment, refObj: Part, scope: types.scope, mustEmit: boolean?)
+  local root = ref:FindFirstChild("Points")
+
+  if not root or not root:IsA("Attachment") or not part_cache then
+    return
+  end
+
+  local common = bezier_common.readCommonAttributes(ref)
+  local attrs = readBezierAttributes(ref)
+
+  local drawFunc = bezier_common.drawFuncMap[common.shapeType]
+    and bezier_common.drawFuncMap[common.shapeType][common.shapeStyle]
+
+  if not drawFunc then
+    return
+  end
+
+  local useDuration = common.emitDuration > 0
+
+  task.wait(common.emitDelay)
+
+  if useDuration and not mustEmit then
+    attr.trigger(ref, "Enabled", true)
+
+    if common.speedStart ~= common.speedEnd then
+      attr.setState(ref, "SpeedTweening", true)
+
+      table.insert(
+        scope,
+        tween.fromParams(
+          attrs.speedCurve,
+          attrs.speedDuration,
+          function(alpha, deltaTime)
+            attr.setState(ref, "SpeedOverride", utility.lerp(common.speedStart, common.speedEnd, alpha))
+            return deltaTime
+          end,
+          nil,
+          function()
+            attr.setState(ref, "SpeedTweening", nil)
+          end
+        )
+      )
+    end
+
+    task.wait(common.emitDuration)
+
+    attr.trigger(ref, "Enabled", false)
+    attr.clearState(ref)
+
+    return
+  end
+
+  if common.emitCount <= 0 then
+    return
+  end
+
+  local parent = bezier_common.validateParent(ref)
+
+  if not parent then
+    return
+  end
+
+  local originCFrame, originSize = utility.getTransformedOriginExtents(parent)
+
+  if not originCFrame then
+    return
+  end
+
+  local endPoint, endT1 = bezier_common.findEndAttachments(ref)
+  local points = utility.getBezierPoints(root)
+
+  local rng = Random.new()
+  local baseBezier = not endPoint and Bezier.new(points)
+
+  -- Hitbox params
+  local hitboxParams = bezier_common.createHitboxParams({
+    enabled = common.hitboxEnabled,
+    collisionGroup = common.hitboxCollisionGroup,
+    filterTag = common.hitboxFilterTag,
+    filterType = common.hitboxFilterType,
+    ignoreCanCollide = common.hitboxIgnoreCanCollide,
+  }, parent, root)
+
+  local promises = {}
+
+  for _ = 1, common.emitCount do
+    local rotSpeedStart = rng:NextNumber(attrs.rotSpeedStart.Min, attrs.rotSpeedStart.Max)
+    local rotSpeedEnd = rng:NextNumber(attrs.rotSpeedEnd.Min, attrs.rotSpeedEnd.Max)
+
+    local initRot = vector.create(
+      rng:NextNumber(attrs.minInitRot.x, attrs.maxInitRot.x),
+      rng:NextNumber(attrs.minInitRot.y, attrs.maxInitRot.y),
+      rng:NextNumber(attrs.minInitRot.z, attrs.maxInitRot.z)
+    )
+
+    local duration = rng:NextNumber(common.duration.Min, common.duration.Max)
+    local lifetime = common.projectileEnabled
+      and rng:NextNumber(common.projectileLifetime.Min, common.projectileLifetime.Max)
+
+    table.insert(
+      promises,
+      TS.Promise.new(function(resolve)
+        -- Calculate emission CFrame
+        local cf = bezier_common.calculateEmissionCFrame(originCFrame, originSize, {
+          face = common.face,
+          spreadAngle = common.spreadAngle,
+          mirror = common.mirror,
+          mirrorRot = common.mirrorRot,
+          partial = common.partial,
+          emissionDirection = common.emissionDirection,
+        }, drawFunc, rng, endPoint, parent:IsA("Attachment"))
+
+        -- create bezier
+        local pathBezier = baseBezier or bezier_common.createBezierWithEndpoint(points, cf, endPoint, endT1)
+        local getPos = bezier_common.createPosGetter(pathBezier, points, cf, endPoint, attrs.arcSpace)
+
+        -- get part from cache
+        local cacheId = utility.getRandomId()
+
+        if not part_cache then
+          resolve()
+          return
+        end
+
+        local objAbstr = part_cache:get(cacheId)
+        objAbstr.CFrame = CFrame.new(getPos(0))
+
+        local obj = objAbstr._getReal()
+
+        utility.copyProperties(refObj, obj, utility.COPY_PART_PROPERTIES)
+        utility.copyProperties(refObj, obj, utility.COPY_EXTENDED_PART_PROPERTIES)
+
+        -- clone children from reference
+        do
+          local clone = refObj:Clone()
+          for _, child in clone:GetChildren() do
+            child.Parent = obj
+          end
+          clone:Destroy()
+        end
+
+        local emitOnFinish = scope.effects.prepareEmitOnFinish(obj, scope)
+        local env = scope.effects.emitNested(obj, scope.depth + 1)
+
+        table.insert(promises, env.Finished)
+
+        table.insert(scope, function()
+          if part_cache then
+            part_cache:free(cacheId)
+          end
+        end)
+
+        -- animation state
+        local lastPos = Vector3.zero
+        local lastVelocity = Vector3.zero
+
+        local didHit = false
+        local finished = false
+
+        local prevCF = CFrame.identity
+        local currentSpeed = common.speedStart
+
+        local currentRot = CFrame.fromOrientation(initRot.x, initRot.y, initRot.z)
+        local currentRotSpeed = rotSpeedStart
+
+        local function onFinish()
+          if finished then
+            return
+          end
+
+          if common.syncPosition then
+            local initOrigin = utility.getTransformedOriginExtents(parent)
+            local initPartPos = objAbstr.CFrame
+
+            local function updatePos()
+              objAbstr.CFrame = utility.getTransformedOriginExtents(parent) * initOrigin:ToObjectSpace(initPartPos)
+            end
+
+            local id = utility.getRandomId()
+
+            RunService:BindToRenderStep(id, utility.RENDER_PRIORITY + scope.depth, updatePos)
+
+            table.insert(scope, function()
+              RunService:UnbindFromRenderStep(id)
+            end)
+          end
+
+          finished = true
+
+          local finishEnv = scope.effects.emitOnFinish(emitOnFinish, obj, scope.depth + 1)
+          finishEnv.Finished:finally(function()
+            resolve()
+          end)
+        end
+
+        local function shapecast()
+          if not common.hitboxEnabled then
+            return false
+          end
+
+          local result = workspace:GetPartsInPart(obj, hitboxParams)
+          return result[1] ~= nil
+        end
+
+        -- Speed tween
+        local speedTween
+
+        if common.speedStart ~= common.speedEnd and not attr.getState(ref, "SpeedOverride", nil) then
+          speedTween = tween.fromParams(attrs.speedCurve, attrs.speedDuration, function(alpha, deltaTime)
+            currentSpeed = utility.lerp(common.speedStart, common.speedEnd, alpha)
+            return deltaTime
+          end)
+
+          table.insert(scope, speedTween)
+        end
+
+        local function getEffectiveSpeed()
+          return attr.getState(ref, "SpeedOverride", currentSpeed)
+        end
+
+        local function isSpeedTweening()
+          return if speedTween then speedTween.Connected else attr.getState(ref, "SpeedTweening", false)
+        end
+
+        -- Rotation speed tween
+        bezier_common.createPropertyTween(scope, ref, "RotSpeed", duration, rotSpeedStart, rotSpeedEnd, function(v)
+          currentRotSpeed = v
+        end, function()
+          return getEffectiveSpeed()
+        end, speedTween)
+
+        -- main animation
+        table.insert(
+          scope,
+          tween.fromParams(
+            attrs.easingCurve,
+            duration,
+            function(alpha, deltaTime, elapsed)
+              local pos1 = getPos(alpha)
+              local newCF = CFrame.new(pos1)
+
+              if attrs.facePath then
+                local pos2 = getPos(math.clamp((elapsed + (1.6666666666666665E-2)) / duration, 0, 1))
+
+                if pos1 ~= pos2 then
+                  newCF = CFrame.lookAt(pos1, pos2)
+                else
+                  newCF *= prevCF.Rotation
+                end
+              end
+
+              local add = initRot:Sign() * currentRotSpeed * utility.DEG_TO_RAD * deltaTime
+              currentRot *= CFrame.fromOrientation(add.x, add.y, add.z)
+
+              -- save current cframe before applying rotation
+              prevCF = newCF
+              newCF *= currentRot
+
+              if common.syncPosition then
+                objAbstr.CFrame = utility.getTransformedOriginExtents(parent) * originCFrame:ToObjectSpace(newCF)
+              else
+                objAbstr.CFrame = newCF
+              end
+
+              lastVelocity = (pos1 - lastPos) / deltaTime
+              lastPos = pos1
+
+              if shapecast() then
+                onFinish()
+                didHit = true
+                return nil
+              end
+
+              local speed = getEffectiveSpeed()
+              currentSpeed = speed
+
+              if speed == 0 and not isSpeedTweening() then
+                return nil
+              end
+
+              if (common.projectileEnabled and alpha * duration < lifetime) or not common.projectileEnabled then
+                return deltaTime * speed
+              else
+                onFinish()
+                return nil
+              end
+            end,
+            speedTween,
+            function(organic)
+              if not common.projectileEnabled or didHit then
+                if organic then
+                  onFinish()
+                end
+                return
+              end
+
+              -- Projectile mode
+              local dir = if common.projectileMatchEnd and endPoint
+                then endPoint.WorldCFrame.LookVector
+                else lastVelocity.Unit
+
+              if dir ~= dir then
+                dir = Vector3.zero
+              end
+
+              lastVelocity = dir * common.projectileSpeed
+
+              local projectileOrigin = obj.Position
+              local originCFrameAtProjectileInit = utility.getTransformedOriginExtents(parent)
+
+              tween.timer(lifetime, function(deltaTime, elapsed)
+                if common.syncPosition then
+                  objAbstr.CFrame = utility.getTransformedOriginExtents(parent)
+                    * originCFrameAtProjectileInit:ToObjectSpace(CFrame.new(projectileOrigin + lastVelocity * elapsed))
+                else
+                  objAbstr.CFrame = CFrame.new(projectileOrigin + lastVelocity * elapsed) * obj.CFrame.Rotation
+                end
+
+                if shapecast() then
+                  onFinish()
+                  didHit = true
+                  return nil
+                end
+
+                local speed = getEffectiveSpeed()
+                currentSpeed = speed
+
+                return if speed > 0 or (elapsed > 0 and isSpeedTweening()) then deltaTime * speed else nil
+              end, speedTween, scope, utility.RENDER_PRIORITY + scope.depth)
+
+              if not didHit then
+                onFinish()
+              end
+            end,
+            true, -- start at zero, important for facepath to work on short durations
+            utility.RENDER_PRIORITY + scope.depth
+          )
+        )
+      end)
+    )
+  end
+
+  TS.Promise.all(promises):await()
+
+  task.wait(common.destroyDelay)
+end
+
+return bezier

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

@@ -0,0 +1,200 @@
+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 Shake = require(script.Parent.Parent.Parent.shake)
+
+local activeShakes = {}
+local totalShakeCF = CFrame.identity
+
+local function updateCamera()
+  if #activeShakes == 0 then
+    return
+  end
+
+  local camera = workspace.CurrentCamera
+
+  if not RunService:IsRunning() then
+    camera.CFrame *= totalShakeCF:Inverse()
+
+    -- I <3 THE STUDIO CAMERA SYSTEM !!!! YAYAY AIHU;S H;GDFAH GSDFL
+    local cf = camera.CFrame
+    local rx, ry = cf:ToOrientation()
+
+    -- NO HAX ALLOWED!!!!!!!
+    camera.CFrame = CFrame.new(cf.Position) * CFrame.fromOrientation(rx, ry, 0)
+  end
+
+  local totalPos = vector.zero
+  local totalRot = CFrame.identity
+
+  local stillActive = {}
+
+  for _, v in activeShakes do
+    if v.done then
+      continue
+    end
+
+    totalPos += v.pos
+    totalRot *= CFrame.Angles(v.rot.x, v.rot.y, v.rot.z)
+
+    table.insert(stillActive, v)
+  end
+
+  activeShakes = stillActive
+
+  local total = CFrame.new(totalPos) * totalRot
+
+  if not RunService:IsRunning() then
+    totalShakeCF = total
+  end
+
+  camera.CFrame *= total
+end
+
+local camera_shake = {}
+
+local conn
+local lastCameraCf
+
+function camera_shake.init()
+  if conn then
+    return
+  end
+
+  if RunService:IsRunning() then
+    conn = RunService.Heartbeat:Connect(function()
+      if not lastCameraCf then
+        return
+      end
+
+      workspace.CurrentCamera.CFrame = lastCameraCf
+    end)
+  end
+
+  RunService:BindToRenderStep("forge_updateCameraShake", Enum.RenderPriority.Last.Value + 1, updateCamera)
+end
+
+function camera_shake.deinit()
+  if conn then
+    conn:Disconnect()
+    conn = nil
+  end
+
+  RunService:UnbindFromRenderStep("forge_updateCameraShake")
+end
+
+function camera_shake.emit(ref: RayValue, scope: types.scope)
+  local emitDelay = attr.get(ref, "EmitDelay", 0)
+  local emitDuration = attr.get(ref, "EmitDuration", 0)
+
+  local falloff = attr.get(ref, "Falloff", 30)
+
+  local amplitude = attr.get(ref, "Amplitude", 2.5)
+  local frequency = attr.get(ref, "Frequency", 0.2)
+
+  local fadeInTime = attr.get(ref, "FadeInTime", 0.3)
+  local fadeOutTime = attr.get(ref, "FadeOutTime", 2)
+  local sustainTime = attr.get(ref, "SustainTime", 1)
+
+  local posInfluence = attr.get(ref, "PositionInfluence", vector.one)
+  local rotInfluence = attr.get(ref, "RotationInfluence", vector.one * 0.2)
+
+  local speedStart = attr.get(ref, "Speed_Start", 1)
+  local speedEnd = attr.get(ref, "Speed_End", 1)
+
+  local sustained = emitDuration > 0
+
+  local shake = Shake.new()
+  shake.Sustain = sustained
+  shake.Amplitude = amplitude
+  shake.Frequency = frequency
+  shake.FadeInTime = fadeInTime
+  shake.FadeOutTime = fadeOutTime
+  shake.SustainTime = sustainTime
+  shake.PositionInfluence = posInfluence
+  shake.RotationInfluence = rotInfluence
+
+  local currentSpeed = 1
+
+  local elapsed = 0
+
+  shake.TimeFunction = function()
+    return elapsed
+  end
+
+  if speedStart ~= speedEnd then
+    local 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
+
+  table.insert(
+    scope,
+    RunService.RenderStepped:Connect(function(deltaTime)
+      elapsed += deltaTime * currentSpeed
+    end)
+  )
+
+  local obj = {
+    done = false,
+    pos = vector.zero,
+    rot = vector.zero,
+  }
+
+  task.wait(emitDelay)
+
+  table.insert(activeShakes, obj)
+
+  local thread = coroutine.running()
+
+  shake:BindToRenderStep(Shake.NextRenderName(), utility.RENDER_PRIORITY + scope.depth, function(pos, rot, isDone)
+    local camera = workspace.CurrentCamera
+
+    lastCameraCf = camera.CFrame
+
+    local origin = ref:FindFirstAncestorOfClass("Attachment") or ref:FindFirstAncestorWhichIsA("BasePart")
+
+    if origin then
+      local originCFrame = utility.getTransformedOriginExtents(origin)
+      local originPosition = originCFrame and originCFrame.Position or origin.Position
+
+      local alpha = 1 - math.clamp((camera.CFrame.Position - originPosition).Magnitude / falloff, 0, 1)
+
+      pos *= alpha
+      rot *= alpha
+    end
+
+    obj.pos = pos
+    obj.rot = rot
+    obj.done = isDone
+
+    if isDone then
+      lastCameraCf = nil
+      task.spawn(thread)
+    end
+  end)
+
+  shake:Start()
+
+  if sustained then
+    task.wait(emitDuration)
+    shake:StopSustain()
+  end
+
+  if not obj.done then
+    coroutine.yield()
+  end
+end
+
+return camera_shake