@rbxts/vfx-forge 2.2.2-ts.1

package/out/forge-vfx/obj/Bezier.luau

@@ -0,0 +1,268 @@
+--!native
+--!nocheck
+--!optimize 2
+type n = vector | number
+
+local EASE_LUT_SIZE = 64
+
+local NEWTON_MIN_TOL = 0.001
+local NEWTON_MAX_ITER = 5
+
+local function cubicBezier(p0: n, p1: n, p2: n, p3: n, t: n): n
+  -- stylua: ignore
+  return (1-t)^3*p0+3*(1-t)^2*t*p1+3*(1-t)*t^2*p2+t^3*p3
+end
+
+local function cubicBezierDerivative(p0: n, p1: n, p2: n, p3: n, t: n): n
+  -- stylua: ignore
+  return 3*(1-t)^2*(p1-p0)+6*(1-t)*t*(p2-p1)+3*t^2*(p3-p2)
+end
+
+local bezier = {}
+bezier.__index = bezier
+
+export type Bezier = typeof(bezier) & {
+  points: { vector },
+  cumulative_lengths: { number },
+  ease_lut: { vector }?,
+
+  length: number,
+  accuracy: number,
+  point_count: number,
+}
+
+function bezier.new(points: { vector }, samplingAccuracy: number?)
+  local self = setmetatable({}, bezier)
+
+  self.points = points
+  self.accuracy = samplingAccuracy or 20
+
+  self.point_count = 0
+  self.cumulative_lengths = {}
+
+  self:_recalculate()
+
+  return self
+end
+
+function bezier.setPoints(self: Bezier, points: { vector })
+  self.points = points
+  self.ease_lut = nil
+
+  self:_recalculate()
+end
+
+function bezier.getSegmentPoints(self: Bezier, index: number)
+  if index < 1 or index > self.point_count - 1 then
+    if index <= 0 then
+      return vector.zero, vector.zero, vector.zero, vector.zero
+    end
+
+    error("attempt to get a non-existent segment at index " .. index)
+  end
+
+  local offset = (index - 1) * 4 - math.max(index - 2, 0)
+  local start = math.max(offset, 1)
+
+  local p0 = self.points[start]
+  local p1 = self.points[start + 1]
+  local p2 = self.points[start + 2]
+  local p3 = self.points[start + 3]
+
+  return p0, p1, p2, p3
+end
+
+function bezier.forSample(self: Bezier, size: number, callback: (pos: vector, i: number) -> ())
+  local amount = self.length // size
+
+  if amount == 0 then
+    return
+  end
+
+  for i = 0, amount do
+    local t = i / amount
+    callback(self:getPositionArcSpace(t), i)
+  end
+end
+
+function bezier.getPosition(self: Bezier, t: number)
+  local i, u = self:getSegmentIndex(t)
+  local p0, p1, p2, p3 = self:getSegmentPoints(i)
+
+  return cubicBezier(p0, p1, p2, p3, u)
+end
+
+function bezier.getSegmentIndex(self: Bezier, t: number)
+  t = math.clamp(t, 0, 1)
+
+  local m = self.point_count - 1
+  local s = t * m
+
+  local i = math.min(math.floor(s) + 1, m)
+  local u = s - math.floor(s)
+
+  if t == 1 then
+    u = 1
+  end
+
+  return i, u
+end
+
+-- only works with beziers whose input is the X axis
+function bezier.getEasedSegmentIndex(self: Bezier, t: number)
+  local i = self.point_count - 1
+  local u = 1
+
+  for j = 1, i do
+    local p0, _, _, p3 = self:getSegmentPoints(j)
+
+    local start = p0.x
+    local stop = p3.x
+
+    if t >= start and t < stop then
+      i = j
+      u = (t - start) / (stop - start)
+
+      break
+    end
+  end
+
+  return i, u
+end
+
+function bezier._getEaseRaw(self: Bezier, t: number)
+  local i, s = self:getEasedSegmentIndex(t)
+  local p0, p1, p2, p3 = self:getSegmentPoints(i)
+
+  for i = 1, NEWTON_MAX_ITER do
+    local x = cubicBezier(p0.x, p1.x, p2.x, p3.x, s)
+    local dx = cubicBezierDerivative(p0.x, p1.x, p2.x, p3.x, s)
+
+    if dx == 0 then
+      break
+    end
+
+    local ds = (x - t) / dx
+    s = s - ds
+
+    if s < 0 then
+      s = 0
+    elseif s > 1 then
+      s = 1
+    end
+
+    if math.abs(ds) < NEWTON_MIN_TOL then
+      break
+    end
+  end
+
+  return cubicBezier(p0, p1, p2, p3, s)
+end
+
+function bezier._buildEaseLUT(self: Bezier)
+  local lut = table.create(EASE_LUT_SIZE + 1)
+
+  for i = 0, EASE_LUT_SIZE do
+    local t = i / EASE_LUT_SIZE
+    lut[i] = self:_getEaseRaw(t)
+  end
+
+  self.ease_lut = lut
+end
+
+function bezier.getEase(self: Bezier, t: number)
+  local lut = self.ease_lut
+
+  if not lut then
+    self:_buildEaseLUT()
+    lut = self.ease_lut
+  end
+
+  t = math.clamp(t, 0, 1)
+
+  local idx = t * EASE_LUT_SIZE
+
+  local lo = math.floor(idx)
+  local hi = math.min(lo + 1, EASE_LUT_SIZE)
+
+  local frac = idx - lo
+
+  local loVal = lut[lo]
+  local hiVal = lut[hi]
+
+  if not loVal or not hiVal then
+    return self:_getEaseRaw(t)
+  end
+
+  return loVal:Lerp(hiVal, frac)
+end
+
+function bezier.getPositionArcSpace(self: Bezier, t: number)
+  if self.length <= 0 then
+    return self.points[1] or vector.zero
+  end
+
+  t = math.clamp(t, 0, 1)
+
+  local targetLength = t * self.cumulative_lengths[self.accuracy + 1]
+  local low, high, index = 1,(self.accuracy + 1)
+  
+while low < high do
+    index = low + (high - low) // 2
+
+    if self.cumulative_lengths[index] < targetLength then
+      low = index + 1
+    else
+      high = index
+    end
+  end
+
+  if self.cumulative_lengths[index] > targetLength and index > 1 then
+    index -= 1
+  end
+
+  local lengthBefore = self.cumulative_lengths[index]
+
+  if lengthBefore == targetLength then
+    return self:getPosition((index - 1) / self.accuracy)
+  else
+    return self:getPosition(
+      ((index - 1) + (targetLength - lengthBefore) / (self.cumulative_lengths[index + 1] - lengthBefore))
+        / self.accuracy
+    )
+  end
+end
+
+function bezier._recalculate(self: Bezier)
+  table.clear(self.cumulative_lengths)
+  table.insert(self.cumulative_lengths, 0)
+
+  local count = math.ceil(#self.points / 3)
+
+  self.point_count = count
+
+  local total = 0
+
+  local prev: vector
+
+  for j = 1, self.accuracy do
+    local p = self:getPosition(j / self.accuracy)
+
+    if not prev then
+      prev = self:getPosition(0)
+    end
+
+    total += vector.magnitude(p - prev)
+    prev = p
+
+    table.insert(self.cumulative_lengths, total)
+  end
+
+  self.length = total
+
+  for i, len in self.cumulative_lengths do
+    self.cumulative_lengths[i] = len / total
+  end
+end
+
+return bezier

package/out/forge-vfx/obj/ObjectCache.luau

@@ -0,0 +1,289 @@
+local utility = require(script.Parent.Parent.mod.utility)
+
+local RECYCLE_INTERVAL = 15
+
+local cache = {}
+cache.__index = cache
+
+type item = {
+  key: any,
+  value: Instance,
+
+  added: number,
+  dependents: number,
+}
+
+type params = {
+  size: number?,
+  excess_lifetime: number?,
+  on_free: ((item) -> ())?,
+}
+
+export type ObjectCache = typeof(cache) & {
+  ref: Instance,
+  parent: Instance?,
+
+  params: params,
+
+  amount: number,
+  restore_amount: number,
+
+  part_mode: boolean,
+
+  item_map: { [any]: item },
+  unused: { item },
+
+  scope: { any },
+}
+
+local function reconcile(a, b)
+  for k, v in b do
+    if a[k] == nil then
+      a[k] = v
+    end
+  end
+
+  return a
+end
+
+local moveParts: { BasePart } = table.create(10_000)
+local movePartCFrames: { CFrame } = table.create(10_000)
+
+local partUpdateScheduled = false
+
+local bulkPartMoveThread = coroutine.create(function()
+  while true do
+    workspace:BulkMoveTo(moveParts, movePartCFrames, Enum.BulkMoveMode.FireCFrameChanged)
+
+    table.clear(moveParts)
+    table.clear(movePartCFrames)
+
+    partUpdateScheduled = false
+
+    coroutine.yield()
+  end
+end)
+
+function cache.new(ref: Instance, parent: Instance?, params: params?)
+  local self = setmetatable({}, cache)
+
+  self.ref = ref
+  self.parent = parent
+
+  self.amount = 0
+  self.restore_amount = 0
+
+  self.params = reconcile(params or {}, {
+    size = 100,
+    excess_lifetime = 30,
+  })
+
+  self.scope = { ref, parent }
+  self.unused = table.create(self.params.size)
+  self.item_map = {}
+
+  self.part_mode = ref:IsA("BasePart")
+
+  for _ = 1, self.params.size do
+    self:_add()
+  end
+
+  table.insert(
+    self.scope,
+    task.spawn(function()
+      while task.wait(RECYCLE_INTERVAL) do
+        if self.restore_amount > 0 then
+          for _ = 1, self.restore_amount do
+            self:_add()
+            self.restore_amount -= 1
+          end
+        end
+
+        if self.amount <= self.params.size then
+          continue
+        end
+
+        local offset = 0
+
+        for i = 1, #self.unused do
+          if self.amount <= self.params.size then
+            break
+          end
+
+          i -= offset
+
+          local item = self.unused[i]
+
+          if item.dependents ~= 0 or (os.clock() - item.added) > self.params.excess_lifetime then
+            continue
+          end
+
+          item:destroy()
+
+          table.remove(self.unused, i)
+
+          self.item_map[item.key] = nil
+          self.amount -= 1
+
+          offset += 1
+        end
+      end
+    end)
+  )
+
+  return self
+end
+
+function cache._add(self: ObjectCache, key: any?, excess: boolean?)
+  local obj = self.ref:Clone()
+  obj.Archivable = false
+  obj.Parent = self.parent
+
+  local item = {
+    key = key,
+    value = obj,
+
+    added = os.clock(),
+    dependents = 1,
+  }
+
+  local ignoreDestroy = false
+
+  function item:destroy()
+    ignoreDestroy = true
+    obj:Destroy()
+  end
+
+  self.amount += 1
+
+  obj.Destroying:Connect(function()
+    if ignoreDestroy then
+      return
+    end
+
+    local index = table.find(self.unused, item)
+
+    if index then
+      table.remove(self.unused, index)
+    end
+
+    if item.key then
+      self.item_map[item.key] = nil
+    end
+
+    self.amount -= 1
+    self.restore_amount += 1
+  end)
+
+  if key then
+    self.item_map[key] = item
+  end
+
+  if not excess then
+    table.insert(self.unused, item)
+  end
+
+  return item
+end
+
+function cache.has(self: ObjectCache, key: any)
+  return if self.item_map[key] then true else false
+end
+
+function cache.peek(self: ObjectCache, key: any)
+  return self.item_map[key]
+end
+
+function cache.get(self: ObjectCache, key: any)
+  if self:has(key) then
+    local item = self:peek(key)
+
+    if item then
+      item.dependents += 1
+    end
+
+    return item.value
+  end
+
+  local item = table.remove(self.unused)
+
+  if item then
+    item.key = key
+    item.added = os.clock()
+
+    self.item_map[key] = item
+  else
+    item = self:_add(key, true)
+  end
+
+  if self.part_mode then
+    local meta = {}
+
+    function meta:__newindex(key, value)
+      if key == "CFrame" then
+        table.insert(moveParts, item.value)
+        table.insert(movePartCFrames, value)
+
+        if not partUpdateScheduled then
+          partUpdateScheduled = true
+          task.defer(bulkPartMoveThread)
+        end
+      else
+        item.value[key] = value
+      end
+    end
+
+    function meta:__index(key)
+      local v = item.value[key]
+
+      if typeof(v) == "function" then
+        return function(_, ...)
+          return v(item.value, ...)
+        end
+      else
+        return v
+      end
+    end
+
+    return setmetatable({
+      _getReal = function()
+        return item.value
+      end,
+    }, meta)
+  else
+    return item.value
+  end
+end
+
+function cache.free(self: ObjectCache, key: any)
+  local item = self.item_map[key]
+
+  if not item then
+    return
+  end
+
+  item.dependents = math.max(item.dependents - 1, 0)
+
+  if item.dependents == 0 then
+    item.added = os.clock()
+
+    if self.params.on_free then
+      task.spawn(self.params.on_free, item)
+    end
+
+    table.insert(self.unused, item)
+  end
+end
+
+function cache.destroy(self: ObjectCache)
+  utility.cleanupScope(self.scope)
+
+  for _, item in self.item_map do
+    item.value:Destroy()
+  end
+
+  table.clear(self.unused)
+  table.clear(self.item_map)
+end
+
+return cache

package/out/forge-vfx/services/caches.luau

@@ -0,0 +1,62 @@
+local ObjectCache = require(script.Parent.Parent.obj.ObjectCache)
+
+local utility = require(script.Parent.Parent.mod.utility)
+
+local caches = {}
+
+function caches.init(scope: { any })
+  local shared_part_cache
+
+  do
+    local template = Instance.new("Part")
+    template.Transparency = 1
+    template.Anchored = true
+    template.CanCollide = false
+    template.CanQuery = false
+    template.Locked = true
+
+    local parent = Instance.new("Folder")
+    parent.Name = "DO_NOT_REMOVE_ForgeSharedPartCache"
+    parent.Archivable = false
+    parent.Parent = workspace.Terrain
+
+    utility.protectParent(scope, parent)
+
+    shared_part_cache = ObjectCache.new(template, parent, {
+      size = 150,
+      on_free = function(item)
+        local part = item.value
+
+        part.Transparency = 1
+
+        part.Anchored = true
+        part.CanQuery = false
+        part.CanCollide = false
+
+        part.CollisionGroup = "ForgeMouseIgnore"
+
+        part.AssemblyLinearVelocity = Vector3.zero
+        part.AssemblyAngularVelocity = Vector3.zero
+
+        part.Parent = parent
+
+        -- this is probably not very good for performance lol
+        -- but I don't think there's currently a more reasonable
+        -- way of recycling parts
+        part:ClearAllChildren()
+      end,
+    })
+  end
+
+  local result = {
+    shared_part = shared_part_cache,
+  }
+
+  table.insert(scope, function()
+    shared_part_cache:destroy()
+  end)
+
+  return result
+end
+
+return caches