Skip to content

Component GPU

Jump to bottom
Vexatos edited this page Jul 13, 2014 · 5 revisions

For those that don't like images: the wiki has moved to a new place, http://ocdoc.cil.li/.
This wiki will no longer be updated.

This is the component provided by graphics cards. For simple programs the term API will usually all you need. For more complex operations, or to get a bit more performance, you may wish to interact with the GPU directly, though.

Component name: gpu.
Callbacks:

  • bind(address: string): boolean[, string]
    Tries to bind the GPU to a screen with the specified address. Returns true on success, false and an error message on failure.
    A GPU can only be bound to one screen at a time. All operations on it will work on the bound screen. If you wish to control multiple screens at once, you'll need to put more than one graphics card into your computer.
  • getBackground(): number
    Gets the current background color. This background color is applied to all "pixels" that get changed by other operations.
    Note that the returned number is an RGB value in hexadecimal format, i.e. 0xRRGGBB. This is to allow uniform color operations regardless of color depth supported by the screen and GPU.
  • setBackground(color: number): number
    Sets the background color to apply to "pixels" modified by other operations from now on. The returned value is the old background color, as the actual value it was set to (i.e. not compressed to the color space currently set). Note that the color is expected to be specified in hexadecimal RGB format, i.e. 0xRRGGBB. This is to allow uniform color operations regardless of the color depth supported by the screen and GPU.
  • getForeground(): number
    Like getBackground, but for the foreground color.
  • setForeground(color: number): number
    Like setBackground, but for the foreground color.
  • maxDepth(): number
    Gets the maximum supported color depth supported by the GPU and the screen it is bound to (minimum of the two).
  • getDepth(): number
    The currently set color depth of the GPU/screen, in bits. Can be 1, 4 or 8.
  • setDepth(bit: number): boolean
    Sets the color depth to use. Can be up to the maximum supported color depth. If a larger or invalid value is provided it will throw an error. Returns true if the depth was set, false otherwise.
  • maxResolution(): number, number
    Gets the maximum resolution supported by the GPU and the screen it is bound to (minimum of the two).
  • getResolution(): number, number
    Gets the currently set resolution.
  • setResolution(width: number, height: number): boolean
    Sets the specified resolution. Can be up to the maximum supported resolution. If a larger or invalid resolution is provided it will throw an error. Returns true if the resolution was set, false otherwise.
  • getSize(): number, number
    Gets the size in blocks of the screen the graphics card is bound to. For simple screens and robots this will be one by one.
  • get(x: number, y: number): string
    Gets the character currently being displayed at the specified coordinates.
  • set(x: number, y: number, value: string): boolean
    Writes a string to the screen, starting at the specified coordinates. The string will be copied to the screen's buffer directly, in a single row. This means even if the specified string contains line breaks, these will just be printed as special characters, the string will not be displayed over multiple lines. Returns true if the string was set to the buffer, false otherwise.
  • copy(x: number, y: number, width: number, height: number, tx: number, ty: number): boolean
    Copies a portion of the screens buffer to another location. The source rectangle is specified by the x, y, width and height parameters. The target rectangle is defined by x + tx, y + ty, width and height. Returns true on success, false otherwise.
  • fill(x: number, y: number, width: number, height: number, char: string): boolean
    Fills a rectangle in the screen buffer with the specified character. The target rectangle is specified by the x and y coordinates and the rectangle's width and height. The fill character char must be a string of length one, i.e. a single character. Returns true on success, false otherwise.
    Note that filling screens with spaces ( ) is usually less expensive, i.e. consumes less energy, because it is considered a "clear" operation (see config).

Example use:

local component = require("component")
local gpu = component.gpu -- get primary gpu component
local w, h = gpu.getResolution()
gpu.fill(1, 1, w, h, " ") -- clears the screen
gpu.setForeground(0x000000)
gpu.setBackground(0xFFFFFF)
gpu.fill(1, 1, w/2, h/2, "X") -- fill top left quarter of screen
gpu.copy(1, 1, w/2, h/2, w/2, h/2) -- copy top left quarter of screen to lower right
Clone this wiki locally