spine-runtimes/spine-lua/SkeletonBounds.lua

-------------------------------------------------------------------------------
-- Spine Runtimes License Agreement
-- Last updated May 1, 2019. Replaces all prior versions.
--
-- Copyright (c) 2013-2019, Esoteric Software LLC
--
-- Integration of the Spine Runtimes into software or otherwise creating
-- derivative works of the Spine Runtimes is permitted under the terms and
-- conditions of Section 2 of the Spine Editor License Agreement:
-- http://esotericsoftware.com/spine-editor-license
--
-- Otherwise, it is permitted to integrate the Spine Runtimes into software
-- or otherwise create derivative works of the Spine Runtimes (collectively,
-- "Products"), provided that each user of the Products must obtain their own
-- Spine Editor license and redistribution of the Products in any form must
-- include this license and copyright notice.
--
-- THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY EXPRESS
-- OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
-- NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,
-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-- BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS
-- INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY
-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------

local AttachmentType = require "spine-lua.attachments.AttachmentType"
local utils = require "spine-lua.utils"

local setmetatable = setmetatable
local math_min = math.min
local math_max = math.max
local ipairs = ipairs
local table_insert = table.insert

local SkeletonBounds = {}
SkeletonBounds.__index = SkeletonBounds

function SkeletonBounds.new ()
	local self = {
		minX = 0, minY = 0, maxX = 0, maxY = 0,
		polygons = {},
		boundingBoxes = {},
	}
	setmetatable(self, SkeletonBounds)

	return self
end

function SkeletonBounds:update (skeleton, updateAabb)
	if skeleton == nil then error("skeleton cannot be null", 2) end
	local boundingBoxes = {}
	self.boundingBoxes = boundingBoxes
	local polygons = {}
	self.polygons = polygons
	local slots = skeleton.slots

	for _,slot in ipairs(skeleton.slots) do
    if (slot.bone.active) then
      local attachment = slot.attachment
      if attachment and attachment.type == AttachmentType.boundingbox then
        local boundingBox = attachment
        table_insert(boundingBoxes, boundingBox)

        local polygon = {}
        table_insert(polygons, polygon)

        boundingBox:computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon, 0, 2)
      end
    end
	end

	if updateAabb then 
    self:aabbCompute()
  else
    self.minX = 9999999
    self.minY = 9999999
    self.maxX = -9999999
    self.maxY = -9999999
  end
end

function SkeletonBounds:aabbCompute ()
	local minX, minY, maxX, maxY = 9999999, 9999999, -9999999, -9999999
	local polygons = self.polygons
	for _,vertices in ipairs(polygons) do
		local count = #vertices
		for ii = 1, count, 2 do
			local x = vertices[ii]
			local y = vertices[ii + 1]
			minX = math_min(minX, x)
			minY = math_min(minY, y)
			maxX = math_max(maxX, x)
			maxY = math_max(maxY, y)
		end
	end
	self.minX = minX
	self.minY = minY
	self.maxX = maxX
	self.maxY = maxY
end

function SkeletonBounds:aabbContainsPoint (x, y)
	return x >= self.minX and x <= self.maxX and y >= self.minY and y <= self.maxY
end

function SkeletonBounds:aabbIntersectsSegment (x1, y1, x2, y2)
	local minX, minY, maxX, maxY = self.minX, self.minY, self.maxX, self.maxY
	if (x1 <= minX and x2 <= minX) or (y1 <= minY and y2 <= minY) or (x1 >= maxX and x2 >= maxX) or (y1 >= maxY and y2 >= maxY) then
			return false
	end
	local m = (y2 - y1) / (x2 - x1)
	local y = m * (minX - x1) + y1
	if y > minY and y < maxY then return true end
	y = m * (maxX - x1) + y1
	if y > minY and y < maxY then return true end
	local x = (minY - y1) / m + x1
	if x > minX and x < maxX then return true end
	x = (maxY - y1) / m + x1
	if x > minX and x < maxX then return true end
	return false
end

function SkeletonBounds:aabbIntersectsSkeleton (bounds)
	return self.minX < bounds.maxX and self.maxX > bounds.minX and self.minY < bounds.maxY and self.maxY > bounds.minY
end

function SkeletonBounds:containsPoint (x, y)
	for i,polygon in ipairs(self.polygons) do
		if self:polygonContainsPoint(polygon, x, y) then return self.boundingBoxes[i] end
	end
	return nil
end

function SkeletonBounds:intersectsSegment (x1, y1, x2, y2)
	for i,polygon in ipairs(self.polygons) do
		if self:polygonIntersectsSegment(polygon, x1, y1, x2, y2) then return self.boundingBoxes[i] end
	end
	return nil
end

function SkeletonBounds:polygonContainsPoint (polygon, x, y)
	local nn = #polygon
	local prevIndex = nn - 1
	local inside = false
	for ii = 1, nn, 2 do
		local vertexY = polygon[ii + 1]
		local prevY = polygon[prevIndex + 1]
		if (vertexY < y and prevY >= y) or (prevY < y and vertexY >= y) then
			local vertexX = polygon[ii]
			if vertexX + (y - vertexY) / (prevY - vertexY) * (polygon[prevIndex] - vertexX) < x then inside = not inside end
		end
		prevIndex = ii
	end
	return inside
end

function SkeletonBounds:polygonIntersectsSegment (polygon, x1, y1, x2, y2)
	local nn = #polygon
	local width12, height12 = x1 - x2, y1 - y2
	local det1 = x1 * y2 - y1 * x2
	local x3, y3 = polygon[nn - 2], polygon[nn - 1]
	for ii = 1, nn, 2 do
		local x4, y4 = polygon[ii], polygon[ii + 1]
		local det2 = x3 * y4 - y3 * x4
		local width34, height34 = x3 - x4, y3 - y4
		local det3 = width12 * height34 - height12 * width34
		local x = (det1 * width34 - width12 * det2) / det3
		if ((x >= x3 and x <= x4) or (x >= x4 and x <= x3)) and ((x >= x1 and x <= x2) or (x >= x2 and x <= x1)) then
			local y = (det1 * height34 - height12 * det2) / det3
			if ((y >= y3 and y <= y4) or (y >= y4 and y <= y3)) and ((y >= y1 and y <= y2) or (y >= y2 and y <= y1)) then return true end
		end
		x3 = x4
		y3 = y4
	end
	return false
end

function SkeletonBounds:getPolygon (attachment)
	local index = utils.indexOf(self.boundingBoxes, attachment)
	if index == -1 then
		return nil
	else
		return self.polygons[index]
	end
end

function SkeletonBounds:getWidth()
	return self.maxX - self.minX
end

function SkeletonBounds:getHeight()
	return self.maxY - self.minY
end

return SkeletonBounds