LÖVE

Code: Select all

-- cam.update(cam,dt) -- uses cam instead of implicit self
-- Limit the camera to the world's boundary, if checks are enabled

	-- cam.x and cam.y are the position of the camera, that is, the middle of the viewport; cam.o is its orientation, and cam.s is the scale.
	if cam.checkBounds then

		-- boundary checking helpers
		local topLeft = {}

		topLeft.x = cam.x - (viewport.width  / 2) / cam.s
		topLeft.y = cam.y - (viewport.height / 2) / cam.s

		-- check if coords are inside the world boundary
		if topLeft.x < 0 then
			cam.x = (viewport.width  / 2) / cam.s
		end
		if topLeft.x > world.width - (viewport.width / cam.s)  then
			cam.x = world.width - (viewport.width  / 2) / cam.s
		end
		if topLeft.y < 0 then
			cam.y = (viewport.height / 2) / cam.s
		end
		if topLeft.y > world.height - (viewport.height / cam.s) then
			cam.y = world.height - (viewport.height / 2) / cam.s
		end

	end

Code: Select all

local dx = viewport.width/2/cam.s
local dy = viewport.height/2/cam.s
topLeft.x = cam.x - dx * math.cos(cam.o) - dy * math.sin(cam.o)
topLeft.y = cam.y + dx * math.sin(cam.o) - dy * math.cos(cam.o)

Code: Select all

if cam.checkBounds then

		-- boundary checking helpers
		local topLeft = {}
		local bottomRight = {}

		local hx = viewport.width  / 2
		local hy = viewport.height / 2

		local dx = hx / cam.s
		local dy = hy / cam.s

		local ax = -dx * math.cos(cam.o) - dy * math.sin(cam.o)
		local ay =  dx * math.sin(cam.o) - dy * math.cos(cam.o)

		topLeft.x = cam.x + ax
		topLeft.y = cam.y + ay

		bottomRight.x = cam.x - ax
		bottomRight.y = cam.y - ay

		-- check if the viewport is wholly inside the world boundary, and move it back, if not

		if topLeft.x < 0 then cam.x = 0 - ax end
		if topLeft.y < 0 then cam.y = 0 - ay end

		if bottomRight.x < 0 then cam.x = 0 + ax end
		if bottomRight.y < 0 then cam.y = 0 + ay end

		if bottomRight.x > world.width  + dx + ax then cam.x = world.width  + ax end
		if bottomRight.y > world.height + dy + ay then cam.y = world.height + ay end

		if topLeft.x > world.width  + dx - ax then cam.x = world.width  - ax end
		if topLeft.y > world.height + dy - ay then cam.y = world.height - ay end

	end

Code: Select all

largestX = math.max(topleft.x,topright.x,bottomleft.x,bottomright.x)

Code: Select all

if largestX > world.width then
  cam.x = cam.x - (largestX - world.width)
end

Code: Select all

function minmax( min, max, va, vb )
  return math.min(min, va), math.max(max, vb)
end
local maxx, maxy = math.huge, math.huge
local minx, miny = -math.huge, -math.huge
for i,v in ipairs( rects ) do -- or whatever floats your boat
  minx, maxx = minmax( minx, maxx, v.x, v.x+v.w )
  miny, maxy = minmax( miny, maxy, v.y, v.y+v.h )
---- or ----
  minx = math.min( minx, v.x )
  miny = math.min ( miny, v.y )
  maxx = math.max( maxx, v.x+v.w )
  maxy = math.max( maxy, v.y+v.h )
end

Code: Select all

local function getVisibleArea(self, scale)
  scale = scale or self.scale
  local sin, cos = abs(self.sin), abs(self.cos)
  local w,h = self.w / scale, self.h / scale
  w,h = cos*w + sin*h, sin*w + cos*h
  return min(w,self.ww), min(h, self.wh)
end

Code: Select all

local function adjustPosition(self)
  local wl,wt,ww,wh = self.wl, self.wt, self.ww, self.wh
  local w,h = getVisibleArea(self)
  local w2,h2 = w*0.5, h*0.5

  local left, right  = wl + w2, wl + ww - w2
  local top,  bottom = wt + h2, wt + wh - h2

  self.x, self.y = clamp(self.x, left, right), clamp(self.y, top, bottom)
end

Code: Select all

if cam.checkBounds then

	-- scale the viewport
	local dx = viewport.width  / cam.s
	local dy = viewport.height / cam.s

	-- calculate half of that
	local hx = dx / 2
	local hy = dy / 2

	-- this would be your w,h = cos*w + sin*h, sin*w+cos*h code from getVisibleArea(), along with the line below it, and
	-- the line local w2,h2 = w*0.5, h*0.5 from adjustPosition()
	local ax = math.min((math.abs(math.cos(cam.o))*dx + math.abs(math.sin(cam.o))*dy),world.width ) / 2
	local ay = math.min((math.abs(math.sin(cam.o))*dx + math.abs(math.cos(cam.o))*dy),world.height) / 2

	-- from adjustPosition()
	local left, right = 0 + ax, 0 + world.width  - ax
	local top, bottom = 0 + ay, 0 + world.height - ay

	-- quick and dirty inline, for test purposes only
	local clamp = function(n,min,max)
		if min>max then min, max = max, min end
		return math.min(math.max(n, min), max)
	end

	cam.x = clamp(cam.x,left,right)
	cam.y = clamp(cam.y,top,bottom)

end