LÖVE

Code: Select all

-- ALL CAPS variables are globals
-- The rest are lowercase if they're local
-- This is just for demonstration

-- Set up some globals to start with
DRAW_WIDTH	= 512
DRAW_HEIGHT	= 448
CANVAS_MODE = false
SCISSOR_MODE = false

function love.load()
	-- Create the canvas in case you're using canvas mode
	MY_CANVAS = love.graphics.newCanvas(DRAW_WIDTH, DRAW_HEIGHT)
	-- Make sure to set the filter to "nearest" to draw crisp clean tasty pixels
	MY_CANVAS:setFilter("nearest")

	-- Set up the window. Fullscreen Type is "desktop" which will resize the actual content
	-- instead of changing the screen resolution if fullscreen is enabled. This will keep a lot
	-- of people happy. And the Resizable flag is set to true because it will let you size the
	-- window yourself and gives it the neat "Lion Fullscreen" option on OS X which is very much
	-- appreciated. I set the initial window size to 720p for the heck of it. It gives you a good
	-- idea of how the letterboxing will be working for you. And the HighDPI option is enabled
	-- because why not. Now that you're independent, it doesnt matter if it's on or not. See
	-- love.resize() below for more information.
	local success = love.window.setMode( 1280, 720, {
						resizable = true,
						fullscreentype = "desktop",
						highdpi = true
					} )

	-- Make sure to recalculate everything. Or rather calculate everything for the first time...
	love.resize()
end

function love.update(dt)
	-- LOL, this isnt needed here! So why is it here? Hahaha. Why did I even put it here?
end

function love.draw()
	-- Set the scissor
	-- For the purposes of this example, I included an option to disable and reenable the scissor.
	-- When SCISSOR is turned off, the background will be purple. This is just for demonstration.
	if SCISSOR_MODE then
		love.graphics.setScissor(LEFT_OFFSET, TOP_OFFSET, DRAW_WIDTH * DRAW_SCALE, DRAW_HEIGHT * DRAW_SCALE)
	end


	-- For demonstration to demonstrate the scissor being disabled
	love.graphics.setColor(150,0,255)
	love.graphics.rectangle("fill", 0, 0, love.graphics.getWidth(), love.graphics.getHeight())

	if CANVAS_MODE then

		-- IF USING CANVASES this code should do the trick nicely
		-- Clear the canvas first, then draw everything to it,
		-- then draw the canvas (Make sure to set the color to white)
		MY_CANVAS:clear(0,0,0,0)
		MY_CANVAS:renderTo(drawAllTheThings)
		love.graphics.setColor(255,255,255)
		love.graphics.draw(MY_CANVAS, LEFT_OFFSET, TOP_OFFSET, 0, DRAW_SCALE, DRAW_SCALE)

	else

		-- IF NOT USING CANVASES then this is the method to use
		-- Use the push and pop stuff to move the drawing coordinates into place
		-- IMPORTANT: Translate MUST be before the Scaling or else it will not draw correctly
		love.graphics.push()
		love.graphics.translate(LEFT_OFFSET, TOP_OFFSET)
		love.graphics.scale(DRAW_SCALE)

		drawAllTheThings()

		love.graphics.pop()

	end

	-- Reset the Scissor
	love.graphics.setScissor()

	-- NOTE: If you're using a canvas, you won't need a scissor at all. As the canvas will act
	-- like a scissor in and of itself. But I kept the scissor outside the canvas area just for
	-- the heck of it


	-- For the example, print whether the canvas and scissor are enabled
	love.graphics.push()
	love.graphics.scale(PIXEL_SCALE)
	love.graphics.setColor(255,255,255)
	love.graphics.print("Canvas Mode: " .. tostring(CANVAS_MODE), 10, 10)
	love.graphics.print("Scissors: " .. tostring(SCISSOR_MODE), 10, 25)
	love.graphics.print("Press S to enable/disable scissor and C for the canvas", 10, 50)
	love.graphics.pop()
end

function love.resize(w, h)
	-- This is where the magic happens

	-- First we get the width and height of the window. It will usually be passed as w and h
	-- into love.resize but in case you're calling it naked then this will save you the trouble
	-- of having to grab the width and height yourself
	local w = w or love.graphics.getWidth()
	local h = h or love.graphics.getHeight()

	-- Figure out the scaling for both width- and height-based scaling. It's not required,
	-- but it's just to make it easier to figure out. Most of the time you'll usually be using
	-- the DRAW_SCALE variable instead which will be defined below
	SCALE_HORIZONTAL, SCALE_VERTICAL = w / DRAW_WIDTH, h / DRAW_HEIGHT

	-- For the next part we need the aspect of both the game drawing area and the window draw area...
	local aspect_game = w / h
	local aspect_window = DRAW_WIDTH / DRAW_HEIGHT

	-- ...which will now be used thusly...
	if aspect_window <= aspect_game then
		-- ...If the aspect of the window is smaller than the aspect of the game,
		-- i.e. if the window is wider, then use the vertical value...
		DRAW_SCALE = SCALE_VERTICAL
	else
		-- ...But if the window is taller, then use the horizontal value.
		DRAW_SCALE = SCALE_HORIZONTAL
	end

	-- And lastly, calculate the offsets for where to draw the image.
	LEFT_OFFSET	= (w - (DRAW_WIDTH * DRAW_SCALE)) / 2
	TOP_OFFSET	= (h - (DRAW_HEIGHT * DRAW_SCALE)) / 2

	-- The following only applies if you plan on using HighDPI mode. Even though you're using pixel
	-- graphics, I still recommend enabling this flag (See the setMode command at the top) because
	-- it keeps the sub-pixels crisp. It's a small detail but it'll make Retina MacBook users very
	-- happy that you cared enough. I store the pixel scale in a variable just for simplicities sake.
	-- This returns 1 if HighDPI is off, 2 if it's on. You use it for scaling other elements on the
	-- screen. Like for example, the overlaying text at the end of love.draw() above.
	PIXEL_SCALE = love.window.getPixelScale()
end

function love.keypressed(k, r)
	if k == "s" then
		SCISSOR_MODE = not SCISSOR_MODE
	elseif k == "c" then
		CANVAS_MODE = not CANVAS_MODE
	end
end

-- Just draw something!
function drawAllTheThings()
	love.graphics.setColor(0,160,200)
	love.graphics.rectangle("fill", 0, 0, DRAW_WIDTH, DRAW_HEIGHT)

	love.graphics.setColor(255,0,0)
	love.graphics.circle("fill", 0, 0, 20)
	love.graphics.setColor(0,255,0)
	love.graphics.circle("fill", DRAW_WIDTH, 0, 20)
	love.graphics.setColor(0,0,255)
	love.graphics.circle("fill", 0, DRAW_HEIGHT, 20)
	love.graphics.setColor(255,255,0)
	love.graphics.circle("fill", DRAW_WIDTH, DRAW_HEIGHT, 20)
end

-- Goin' crazy with the comments!

Code: Select all

function love.load()
    -- your code
end

function love.draw()
    -- your code
end

-- etc

local rescale = require 'awesomerescalinglibrary'
rescale(512, 448)