love-graphics

name	love-graphics
description	The primary responsibility for the love.graphics module is the drawing of lines, shapes, text, Images and other Drawable objects onto the screen. Its secondary responsibilities include loading external files (including Images and Fonts) into memory, creating specialized objects (such as ParticleSystems or Canvases) and managing screen geometry. LÖVE's coordinate system is rooted in the upper-left corner of the screen, which is at location (0, 0). The x axis is horizontal: larger values are further to the right. The y axis is vertical: larger values are further towards the bottom. In many cases, you draw images or shapes in terms of their upper-left corner. Many of the functions are used to manipulate the graphics coordinate system, which is essentially the way coordinates are mapped to the display. You can change the position, scale, and even rotation in this way. Use this skill when working with drawing operations, sprites, animations, shaders, or any visual rendering in LÖVE games.
license	MIT
metadata	{"author":"Ron Dekker <rondekker.nl>"}

When to use this skill

The primary responsibility for the love.graphics module is the drawing of lines, shapes, text, Images and other Drawable objects onto the screen. Its secondary responsibilities include loading external files (including Images and Fonts) into memory, creating specialized objects (such as ParticleSystems or Canvases) and managing screen geometry. LÖVE's coordinate system is rooted in the upper-left corner of the screen, which is at location (0, 0). The x axis is horizontal: larger values are further to the right. The y axis is vertical: larger values are further towards the bottom. In many cases, you draw images or shapes in terms of their upper-left corner. Many of the functions are used to manipulate the graphics coordinate system, which is essentially the way coordinates are mapped to the display. You can change the position, scale, and even rotation in this way. Use this skill when working with drawing operations, sprites, animations, shaders, or any visual rendering in LÖVE games.

Common use cases

• Drawing shapes, images, and text
• Creating animations and particle effects
• Implementing custom shaders and post-processing effects
• Managing sprites and sprite batches
• Handling screen transitions and visual effects

Functions

• love.graphics.applyTransform(transform: Transform): Applies the given Transform object to the current coordinate transformation. This effectively multiplies the existing coordinate transformation's matrix with the Transform object's internal matrix to produce the new coordinate transformation.
• love.graphics.arc - Draws a filled or unfilled arc at position (x, y). The arc is drawn from angle1 to angle2 in radians. The segments parameter determines how many segments are used to draw the arc. The more segments, the smoother the edge.
  • love.graphics.arc(drawmode: DrawMode, x: number, y: number, radius: number, angle1: number, angle2: number, segments: number): Draws an arc using the 'pie' ArcType.
  • love.graphics.arc(drawmode: DrawMode, arctype: ArcType, x: number, y: number, radius: number, angle1: number, angle2: number, segments: number):
• love.graphics.captureScreenshot - Creates a screenshot once the current frame is done (after love.draw has finished). Since this function enqueues a screenshot capture rather than executing it immediately, it can be called from an input callback or love.update and it will still capture all of what's drawn to the screen in that frame.
  • love.graphics.captureScreenshot(filename: string): Capture a screenshot and save it to a file at the end of the current frame.
  • love.graphics.captureScreenshot(callback: function): Capture a screenshot and call a callback with the generated ImageData at the end of the current frame.
  • love.graphics.captureScreenshot(channel: Channel): Capture a screenshot and push the generated ImageData to a Channel at the end of the current frame.
• love.graphics.circle - Draws a circle.
  • love.graphics.circle(mode: DrawMode, x: number, y: number, radius: number): No description
  • love.graphics.circle(mode: DrawMode, x: number, y: number, radius: number, segments: number): No description
• love.graphics.clear - Clears the screen or active Canvas to the specified color. This function is called automatically before love.draw in the default love.run function. See the example in love.run for a typical use of this function. Note that the scissor area bounds the cleared region. In versions prior to 11.0, color component values were within the range of 0 to 255 instead of 0 to 1. In versions prior to background color instead.
  • love.graphics.clear(): Clears the screen to the background color in 0.9.2 and earlier, or to transparent black (0, 0, 0, 0) in LÖVE 0.10.0 and newer.

Types

• Canvas: A Canvas is used for off-screen rendering. Think of it as an invisible screen that you can draw to, but that will not be visible until you draw it to the actual visible screen. It is also known as "render to texture". By drawing things that do not change position often (such as background items) to the Canvas, and then drawing the entire Canvas instead of each item, you can reduce the number of draw operations performed each frame. In versions prior to love.graphics.isSupported("canvas") could be used to check for support at runtime.

  • love.Canvas.generateMipmaps(): Generates mipmaps for the Canvas, based on the contents of the highest-resolution mipmap level. The Canvas must be created with mipmaps set to a MipmapMode other than 'none' for this function to work. It should only be called while the Canvas is not the active render target. If the mipmap mode is set to 'auto', this function is automatically called inside love.graphics.setCanvas when switching from this Canvas to another Canvas or to the main screen.
  • love.Canvas.getMSAA() -> samples: number: Gets the number of multisample antialiasing (MSAA) samples used when drawing to the Canvas. This may be different than the number used as an argument to love.graphics.newCanvas if the system running LÖVE doesn't support that number.
  • love.Canvas.getMipmapMode() -> mode: MipmapMode: Gets the MipmapMode this Canvas was created with.
  • love.Canvas.newImageData() -> data: ImageData: Generates ImageData from the contents of the Canvas.
  • love.Canvas.renderTo(func: function, ...: any): Render to the Canvas using a function. This is a shortcut to love.graphics.setCanvas: canvas:renderTo( func ) is the same as love.graphics.setCanvas( canvas ) func() love.graphics.setCanvas()

• Drawable: Superclass for all things that can be drawn on screen. This is an abstract type that can't be created directly.

• Font: Defines the shape of characters that can be drawn onto the screen.

  • love.Font.getAscent() -> ascent: number: Gets the ascent of the Font. The ascent spans the distance between the baseline and the top of the glyph that reaches farthest from the baseline.
  • love.Font.getBaseline() -> baseline: number: Gets the baseline of the Font. Most scripts share the notion of a baseline: an imaginary horizontal line on which characters rest. In some scripts, parts of glyphs lie below the baseline.
  • love.Font.getDPIScale() -> dpiscale: number: Gets the DPI scale factor of the Font. The DPI scale factor represents relative pixel density. A DPI scale factor of 2 means the font's glyphs have twice the pixel density in each dimension (4 times as many pixels in the same area) compared to a font with a DPI scale factor of 1. The font size of TrueType fonts is scaled internally by the font's specified DPI scale factor. By default, LÖVE uses the screen's DPI scale factor when creating TrueType fonts.