LÖVE

Code: Select all

function body:calculatePolyShadow(light)
  if self.castsNoShadow then
    return nil
  end

  local curPolygon = self.data
  local edgeFacingTo = {}
-- for each edge check if the light strikes it
  for k = 1, #curPolygon, 2 do
    local indexOfNextVertex = (k + 2) % #curPolygon
-- get the unit vector of the edge
    local normal = {-curPolygon[indexOfNextVertex+1] + curPolygon[k + 1], curPolygon[indexOfNextVertex] - curPolygon[k]}
    normal = vector.normalize(normal)
-- get the unit vector of the light pointing at the current point we are examing
-- [hint] we are looking for the outter most edges of the polygon that the light hits
    local lightToPoint = {curPolygon[k] - light.x, curPolygon[k + 1] - light.y}
    lightToPoint = vector.normalize(lightToPoint)

--get the dot product of the two vectors to see if it faces the light
    local dotProduct = vector.dot(normal, lightToPoint)
-- if the dot product is greater than 0 it faces the light
    if dotProduct > 0 then 
      table.insert(edgeFacingTo, true)
-- if the dot product is 0 it is perpendicular
-- if it is less than 0 it faces away from the light
    else 
      table.insert(edgeFacingTo, false) 
    end
  end

--now we have a table that tells us which edges are hit by the light

  local curShadowGeometry = {}
-- for each point in the polygon again but referencing the edges
  for k = 1, #edgeFacingTo do
    local nextIndex = (k + 1) % #edgeFacingTo
    if nextIndex == 0 then nextIndex = #edgeFacingTo end
-- if this edge is in the light but not the next 
-- create the first 2 points of the polygon we have found an edge of the shadow
    if edgeFacingTo[k] and not edgeFacingTo[nextIndex] then
      curShadowGeometry[1] = curPolygon[nextIndex*2-1]
      curShadowGeometry[2] = curPolygon[nextIndex*2]

--cast the edge beyond the shape in the direction of the vector from the light to the point
      local lightVecFrontBack = vector.normalize({curPolygon[nextIndex*2-1] - light.x, curPolygon[nextIndex*2] - light.y})
      curShadowGeometry[3] = curShadowGeometry[1] + lightVecFrontBack[1] * shadowLength
      curShadowGeometry[4] = curShadowGeometry[2] + lightVecFrontBack[2] * shadowLength
-- if this edfe is not in the light but the next one is the we found the last 2 points of the shadow
    elseif not edgeFacingTo[k] and edgeFacingTo[nextIndex] then
      curShadowGeometry[7] = curPolygon[nextIndex*2-1]
      curShadowGeometry[8] = curPolygon[nextIndex*2]

--cast the edge beyond the shape in the direction of the vector from the light to the point
      local lightVecBackFront = vector.normalize({curPolygon[nextIndex*2-1] - light.x, curPolygon[nextIndex*2] - light.y})
      curShadowGeometry[5] = curShadowGeometry[7] + lightVecBackFront[1] * shadowLength
      curShadowGeometry[6] = curShadowGeometry[8] + lightVecBackFront[2] * shadowLength
    end
  end
--we only draw long rectangular shadows
--so they must have 4 points
  if  curShadowGeometry[1]
    and curShadowGeometry[2]
    and curShadowGeometry[3]
    and curShadowGeometry[4]
    and curShadowGeometry[5]
    and curShadowGeometry[6]
    and curShadowGeometry[7]
    and curShadowGeometry[8]
  then
    curShadowGeometry.alpha = self.alpha
    curShadowGeometry.red = self.red
    curShadowGeometry.green = self.green
    curShadowGeometry.blue = self.blue
    return curShadowGeometry
  else
    return nil
  end
end

Code: Select all

local LightWorld = require "lib"

	local lightworld = LightWorld({
			drawBackground = drawBackground,
			drawForeground = drawForeground,
			ambient = {50,50,50},
		})
		
Camera = require "hump.camera"
function love.load()
	fthis = 0
	this2 = 0
	cx = 360 
	cy = 350
	px = 400
	py = 300
	camera = Camera(0,0)
	a = lightworld:newLight(love.mouse.getX(),love.mouse.getY(),155,155,20,200)
	b = lightworld:newRectangle(px,py,200,200)
end
function love.draw()
	if this2 == 1 then
		x,y = camera:worldCoords(10,10)
	elseif this2 == 2 then
		x,y = camera:cameraCoords(10,10)
	elseif this2 == 3 then
	  local tx,ty = love.graphics.getWidth()/(2*camera.scale), love.graphics.getHeight()/(2*camera.scale)
                --the previous method from old light v shadow
		x = tx-10
		y = ty-10
	else
		x = 0
		y = 0
	end
	love.graphics.push()
	love.graphics.translate(x,y)
	-- I am currently on default scale which is 1 so I assume there isn't a need to translate by love.graphics.scale().
	lightworld:draw(x,y,1)
	love.graphics.pop()
	
	love.graphics.setColor(126,85,98)
	love.graphics.rectangle("fill",0,100,300,20)
	if fthis == 1 then
		love.graphics.setColor(240,200,200)
	end
	love.graphics.rectangle("fill",0,120,300,20)
	love.graphics.setColor(126,85,98)
	if fthis == 2 then 
		love.graphics.setColor(240,200,200)
	end
	love.graphics.rectangle("fill",0,140,300,20)
	love.graphics.setColor(126,85,98)
	if fthis == 3 then
		love.graphics.setColor(240,200,200)
	end
	love.graphics.rectangle("fill",0,160,300,20)
	love.graphics.setColor(126,85,98)
	
	love.graphics.setColor(255,255,255)
	love.graphics.print("The current translation is: "..this2,0,100)
	love.graphics.print("1:Set translation to camera:worldCoords()",0,120)
	love.graphics.print("2:Set translation to camera:camCoords()",0,140)
	love.graphics.print("3:Set translation to light v shadow v1",0,160)
	love.graphics.print("camera x:"..camera.x,0,180)
	love.graphics.print("camera y:"..camera.y,0,190)
end
function love.keypressed(key)
	-- movement and selection of translation
	if key == "a" then
		px = px + 40
	elseif key == "d" then
		px = px - 40
	end
	if key == "w" then
		py = py + 40
	elseif key == "s" then
		py = py - 40
	end
	if fthis < 4 and fthis > 0 then
		if key == "up" then
			fthis = fthis + 1
		end
		if key == "return" then
			this2 = fthis
		end
	else
		fthis = 1
	end
end
function love.update(dt)
	a:setPosition(love.mouse.getX(),love.mouse.getY())
	love.window.setTitle(""..love.timer.getFPS())
	camera:lookAt(px,py)
end
function lightworld:drawBackground()
		love.graphics.setColor(152,150,97)
		love.graphics.rectangle("fill",0,0,800,600)
		love.graphics.setColor(255,255,255)
	camera:attach()
	camera:detach()
end
function lightworld:drawForeground()
	camera:attach()
		--cx2,cy2 = camera:worldCoords(cx,cy)
		--b:setPosition(cx2,cy2)
		b:setPosition(cx,cy)
		love.graphics.setColor(100,100,190)
		love.graphics.rectangle("fill",cx,cy,200,200)
		love.graphics.setColor(200,200,200)
		love.graphics.rectangle("fill",px,py,20,20) -- illustrated the point at which camera looks at
		love.graphics.setColor(255,255,255)
	camera:detach()
end