love.getVersion

Obtém a versão atual de LÖVE.

major, minor, revision, codename = love.getVersion()

love.conf

Se um arquivo chamado conf.lua estiver presente na pasta do seu jogo (ou arquivo .love), ele será executado antes que os módulos LÖVE sejam carregados. Você pode usar este arquivo para substituir a função love.conf, que é mais tarde chamada pelo script LÖVE boot '. Usando a função love.conf, você pode definir algumas opções de configuração e alterar coisas como o tamanho padrão da janela, quais módulos são carregados e outras coisas.

love.conf( t )

love.directorydropped

A função Callback é disparada quando um diretório é arrastado e caiu para a janela.

love.directorydropped( path )

love.draw

Função de callback usada para desenhar na tela a cada quadro.

love.draw()

love.errhand

O manipulador de erros, usado para exibir mensagens de erro.

love.errhand( msg )

love.filedropped

A função Callback é disparada quando um arquivo é arrastado e caiu para a janela.

love.filedropped( file )

love.focus

Função de callback executada sempre que a janela recebe ou perde o foco.

love.focus( focus )

love.gamepadaxis

Chamado quando o eixo de um gamepad virtual do Joystick é movido.

love.gamepadaxis( joystick, axis )

love.gamepadpressed

Chamado quando o botão do gamepad virtual de um Joystick é pressionado.

love.gamepadpressed( joystick, button )

love.gamepadreleased

Chamado quando o botão do gamepad virtual de um Joystick é liberado.

love.gamepadreleased( joystick, button )

love.joystickadded

Chamado quando um Joystick está conectado.

Este retorno de chamada também é ativado após love.load para cada joystick que já estava conectado quando o jogo começou.

love.joystickadded( joystick )

love.joystickaxis

Chamado quando um eixo do joystick se move.

love.joystickaxis( joystick, axis, value )

love.joystickhat

Chamado quando uma direção do chapéu do joystick muda.

love.joystickhat( joystick, hat, direction )

love.joystickpressed

Chamada quando um botão no joystick é pressionado.

love.joystickpressed( joystick, button )

love.joystickreleased

Chamada quando um botão do joystick é liberado.

love.joystickreleased( joystick, button )

love.joystickremoved

Chamado quando um Joystick é desconectado.

love.joystickremoved( joystick )

love.keypressed

Função de callback executada sempre que uma tecla é pressionada.

love.keypressed( key, scancode, isrepeat )

love.keyreleased

Função de callback executada sempre que uma tecla é liberada.

love.keyreleased( key, scancode )

love.load

Esta função é chamada exatamente uma única vez no início do jogo.

love.load( arg )

love.lowmemory

A função Callback é disparada quando o sistema está sem memória em dispositivos móveis.

 Os sistemas operacionais móveis podem matar com força o jogo se ele usar muita memória, portanto, qualquer recurso não crítico deve ser removido se possível (definindo todas as variáveis ​​que fazem referência aos recursos para nulo e chamando collectgarbage ()), quando este evento for acionado. Os sons e as imagens, em particular, tendem a usar a maior parte da memória.

love.lowmemory()

love.mousefocus

A função de retorno de chamada é disparada quando a janela recebe ou perde o foco do mouse.

love.mousefocus( focus )

love.mousemoved

A função Callback é disparada quando o mouse é movido.

love.mousemoved( x, y, dx, dy, istouch )

love.mousepressed

Função de callback executada sempre que um botão do mouse é pressionado.

love.mousepressed( x, y, button, isTouch )

love.mousereleased

Função de callback executada sempre que um botão do mouse é liberado.

love.mousereleased( x, y, button, isTouch )

love.quit

Função callback executada sempre que um jogo é fechado.

r = love.quit()

love.resize

Chamado quando a janela é redimensionada, por exemplo, se o usuário redimensionar a janela, ou se love.window.setMode é chamado com uma largura ou altura não suportada em tela cheia e a janela escolhe o tamanho apropriado mais próximo.

As chamadas para love.window.setMode só ativarão esse evento se a largura ou a altura da janela após a chamada não coincidirem com a largura e altura solicitadas. Isso pode acontecer se for solicitado um modo de tela cheia que não corresponda a nenhum modo suportado, ou se o tipo de tela cheia for 'desktop' e a largura ou a altura solicitada não coincidem com a resolução da área de trabalho.

love.resize( w, h )

love.run

A função principal, que contém o loop principal.

love.run()

love.textedited

Chamado quando o texto do candidato para um IME (Input Method Editor) mudou.

O texto candidato não é o texto final que o usuário escolherá eventualmente. Use love.textinput para isso.

love.textedited( text, start, length )

love.textinput

Chamado quando o texto foi inserido pelo usuário. Por exemplo, se shift-2 for pressionado em um layout de teclado americano, o texto "@" será gerado.

love.textinput( text )

love.threaderror

A função Callback é disparada quando um Thread encontra um erro.

love.threaderror( thread, errorstr )

love.touchmoved

A função de retorno de chamada é ativada quando uma pressão de toque se move dentro da tela de toque.

love.touchmoved( id, x, y, dx, dy, pressure )

love.touchpressed

A função de retorno de chamada é ativada quando a tela de toque é tocada.

love.touchpressed( id, x, y, dx, dy, pressure )

love.touchreleased

A função de retorno de chamada é disparada quando a tela de toque pára de ser tocada.

love.touchreleased( id, x, y, dx, dy, pressure )

love.update

Função de callback usada para atualizar o estado do jogo a cada quadro.

love.update( dt )

love.visible

Função de retorno de chamada desencadeada quando a janela é minimizada / escondida ou desimpedida pelo usuário.

love.visible( visible )

love.wheelmoved

A função de retorno de chamada disparou quando a roda do mouse é movida.

love.wheelmoved( x, y )

Data

A superclasse de todos os dados.

Functions

Data:getPointer Obtém um ponteiro para o dado.

Data:getSize Obtém o tamanho do dado em bytes.

Data:getString Obtém o dado todo como um string.

Supertypes

Object A superclasse de todos os tipos do LÖVE.

Subtypes

CompressedData Representa dados de bytes compactados usando um algoritmo específico.

CompressedImageData Representa os dados de imagem comprimidos projetados para permanecerem compactados na RAM.

FileData Data (Português) representando o conteúdo de um arquivo.

ImageData Dados de imagens brutos (decodificados).

SoundData Contém amostras de áudio bruto.

Data:getPointer

Obtém um ponteiro para o dado. Pode ser usada com bibliotecas, como o FFI do LuaJIT.

pointer = Data:getPointer()

Data:getSize

Obtém o tamanho do dado em bytes.

size = Data:getSize()

Data:getString

Obtém o dado todo como um string.

data = Data:getString()

Drawable

Superclasse para tudo que pode ser desenhado na tela. Este é um tipo abstrato que não pode ser diretamente criado.

Supertypes

Object A superclasse de todos os tipos do LÖVE.

Subtypes

Canvas Uma tela é usada para renderização fora da tela.

Image Tipo de imagens que podem ser desenhadas.

Mesh Uma malha de polígono 2D usada para desenhar formas texturizadas arbitrárias.

ParticleSystem Usado para criar efeitos legais, como fogo.

SpriteBatch Armazena uma geometria em um buffer e desenha em uma única chamada.

Text Texto desenhável.

Texture Superclasse para objetos desenháveis ​​que representam uma textura.

Video Um vídeo desenhável.

Object

A superclasse de todos os tipos do LÖVE.

Functions

Object:type Obtém o tipo do objeto como um string.

Object:typeOf Verifica se um objeto é de um certo tipo.

Subtypes

BezierCurve Um objeto de curvatura de Bézier que pode avaliar e render as curvas de Béryier de grau arbitrário.

Body Corpos são objetos com velocidade e posição.

Canvas Uma tela é usada para renderização fora da tela.

ChainShape Um ChainShape consiste em múltiplos segmentos de linha.

Channel Um objeto que pose ser usado para enviar e receber dados entre diferentes threads.

CircleShape Círculo estende Forma e adiciona um raio e a posição local.

CompressedData Representa dados de bytes compactados usando um algoritmo específico.

CompressedImageData Representa os dados de imagem comprimidos projetados para permanecerem compactados na RAM.

Contact Contatos são objetos criados para gerenciar as colisões no mundo.

Cursor Representa um cursor de hardware.

Data A superclasse de todos os dados.

DistanceJoint Mantém dois corpos a uma mesma distância.

Drawable Superclasse para tudo que pode ser desenhado na tela.

EdgeShape A EdgeShape é um segmento de linha.

File Representa um arquivo no sistema de arquivos.

FileData Data (Português) representando o conteúdo de um arquivo.

Fixture As peças fixam formas aos corpos.

Font Pode ser usado para desenhar texto na tela.

FrictionJoint Um FrictionJoint aplica fricção a um corpo.

GearJoint Mantém corpos juntos de tal forma que eles atual como engrenagens.

Image Tipo de imagens que podem ser desenhadas.

ImageData Dados de imagens brutos (decodificados).

Joint Junta múltiplos corpos para interagirem de uma forma conjunta.

Joystick Representa um joystick físico.

Mesh Uma malha de polígono 2D usada para desenhar formas texturizadas arbitrárias.

MotorJoint Controla o movimento relativo entre dois Corpos.

MouseJoint Para controlar objetos com o mouse.

ParticleSystem Usado para criar efeitos legais, como fogo.

PolygonShape Polígonos são convexos com até 8 lados.

PrismaticJoint Restringe movimentos relativos entre corpos para somente um eixo compartilhado.

PulleyJoint Permite simular concessões entre corpos através de polias.

Quad Um quadrilátero com informações coordenadas de textura.

RandomGenerator Um objeto de geração de números aleatórios que tem seu próprio estado aleatório.

RevoluteJoint Permite que dois corpos rotacionem sobre um ponto fixo compartilhado.

RopeJoint O RopeJoint impõe uma distância máxima entre dois pontos em dois corpos.

Shader Um Shader é usado para manipulação acelerada de pixel ou vertex acelerado por hardware.

Shape Formas são objetos usados para controlar massas e colisões.

SoundData Contém amostras de áudio bruto.

Source Um Source representa áudio que pode ser tocado.

SpriteBatch Armazena uma geometria em um buffer e desenha em uma única chamada.

Text Texto desenhável.

Texture Superclasse para objetos desenháveis ​​que representam uma textura.

Thread Um Thread é um pedaço de código que pode ser executado em paralelo à outros threads.

Video Um vídeo desenhável.

WeldJoint Um WeldJoint cola dois corpos em conjunto.

WheelJoint Restringe um ponto no segundo corpo para uma linha no primeiro corpo.

World Um mundo é um objeto que contem corpos e juntas.

Object:type

Obtém o tipo do objeto como um string.

type = Object:type()

Object:typeOf

Verifica se um objeto é de um certo tipo. Se a função tem o tipo com o nome especificado em sua hierarquia, esta função retornará verdadeiro.

b = Object:typeOf( name )

love.audio

Types

Source Um Source representa áudio que pode ser tocado.

Functions

love.audio.getSourceCount Obtém o número de fontes tocando atualmente.

love.audio.pause Pauses all audio.

love.audio.play Toca a Fonte especificada.

love.audio.resume Despausa todo o áudio.

love.audio.rewind Rebobina todo o áudio que estiver tocando.

love.audio.get/setDistanceModel Define o modelo de atenuação por distância.

love.audio.get/setDopplerScale Define um fator de escala global para efeitos doppler baseados em velocidade.

love.audio.get/setOrientation Configura a orientação do ouvinte.

love.audio.get/setPosition Configura a posição do ouvinte, o que determina como os sons irão tocar.

love.audio.get/setVelocity Define a velocidade do ouvinte.

love.audio.get/setVolume Define o volume mestre.

love.audio.stop Para todo o áudio que estiver tocando.

Enums

DistanceModel Os diferentes modelos de distância.

SourceType Tipos de Sources de áudio.

TimeUnit Unidades que representam o tempo.

love.audio.getDistanceModel

Retorna o modelo de atenuação por distância.

model = love.audio.getDistanceModel()

love.audio.getDopplerScale

Obtém o fator de escala global atual para efeitos doppler baseados em velocidade.

scale = love.audio.getDopplerScale()

love.audio.getSourceCount

Obtém o número de fontes tocando atualmente.

numSources = love.audio.getSourceCount()

love.audio.getOrientation

Retorna a orientação do ouvinte.

fx, fy, fz, ux, uy, uz = love.audio.getOrientation()

love.audio.getPosition

Retorna a posição do ouvinte.

x, y, z = love.audio.getPosition()

love.audio.getVelocity

Retorna a velocidade do ouvinte.

x, y, z = love.audio.getVelocity()

love.audio.getVolume

Retorna o volume mestre.

volume = love.audio.getVolume()

love.audio.newSource

Cria uma nova Fonte a partir de um caminho de arquivo, Arquivo, Decodificador ou DadoDeSom.

Fontes criadas a partir de SoundData são sempre estáticas.

source = love.audio.newSource( file, type )

source = love.audio.newSource( soundData )

love.audio.pause

Pauses all audio.

love.audio.pause()

Esta função irá interromper todos atualmente ativa Sources.

love.audio.pause( source )

Esta função só interromperá o especificado Source.

love.audio.play

Toca a Fonte especificada.

love.audio.play( source )

love.audio.resume

Despausa todo o áudio.

love.audio.resume()

love.audio.resume( source )

love.audio.rewind

Rebobina todo o áudio que estiver tocando.

love.audio.rewind()

love.audio.rewind( source )

love.audio.setDistanceModel

Define o modelo de atenuação por distância.

love.audio.setDistanceModel( model )

love.audio.setDopplerScale

Define um fator de escala global para efeitos doppler baseados em velocidade. O valor da escala padrão é 1.

love.audio.setDopplerScale( scale )

love.audio.setOrientation

Configura a orientação do ouvinte.

love.audio.setOrientation( fx, fy, fz, ux, uy, uz )

love.audio.setPosition

Configura a posição do ouvinte, o que determina como os sons irão tocar.

love.audio.setPosition( x, y, z )

love.audio.setVelocity

Define a velocidade do ouvinte.

love.audio.setVelocity( x, y, z )

love.audio.setVolume

Define o volume mestre.

love.audio.setVolume( volume )

love.audio.stop

Para todo o áudio que estiver tocando.

love.audio.stop()

Esta função irá parar todas as fontes ativas no momento.

love.audio.stop( source )

Esta função só vai parar a fonte especificada.

DistanceModel

none

Sources não são atenuados.

inverse

Atenuação de distância inversa.

inverseclamped

Atenuação de distância inversa. O ganho é apertado. Na versão 0.9.2 e superior, isso é chamado de bloqueio inverso.

linear

Atenuação linear.

linearclamped

Atenuação linear. O ganho é apertado. Na versão 0.9.2 e superior, isso é chamado de fixação linear.

exponent

Atenuação exponencial.

exponentclamped

Atenuação exponencial. O ganho é apertado. Na versão 0.9.2 e mais velha, isso é chamado de expoente apertado.

SourceType

static

Decodifica todo o som de uma vez.

stream

Transmite o áudio; decodifica gradualmente.

TimeUnit

seconds

Segundos normais.

samples

Amostras de áudio.

Source

Um Source representa áudio que pode ser tocado.

Você pode fazer coisas interessantes com Sources, como ajustar o volume, o tom e sua posição em relação ao ouvinte.

Os controles do Source (play/pause/etc) agem de acordo com a seguinte tabela de estados.

Constructors

love.audio.newSource Cria uma nova Fonte a partir de um caminho de arquivo, Arquivo, Decodificador ou DadoDeSom.

Functions

Source:play Começa a tocar um Source.

Source:stop Para um Source.

Source:pause Pausa um Source.

Source:resume Retorna a tocar um Source.

Source:rewind Rebobina um Source.

Source:tell/seek Define a posição atual do fluxo de áudio do Source.

Source:is/setLooping Configura se um Source deverá repetir.

Source:get/setPitch Configura o tom do Source.

Source:get/setVolume Define o volume atual do Source.

Source:isPlaying Retorna se o Source está tocando ou não.

Source:isStopped Retorna se o Source está parado ou não.

Source:isPaused Retorna se o Source está pausado ou não.

Source:get/setPosition Define a posição do Source.

Source:get/setDirection Configura o vetor direcional do Source.

Source:get/setRolloff Configura o fator de decaimento.

Source:get/setVelocity Configura a velocidade do Source.

Source:get/setCone Configura os cones de volume direcional do Source.

Source:get/setAttenuationDistances Define as distâncias de atenuação referencial e máxima do Source.

Source:get/setVolumeLimits Define os limites de volume do Source.

Source:getType Obtém o tipo (estático ou de fluxo) da Fonte.

Source:getChannels Obtém o número de canais de um Source.

Source:getDuration Obtém a duração da Fonte.

Source:clone Cria uma cópia idêntica da Fonte no estado parado.

Supertypes

Object A superclasse de todos os tipos do LÖVE.

Source:clone

Cria uma cópia idêntica da Fonte no estado parado.

Fontes estáticas usarão significativamente menos memória e levarão muito menos tempo para serem criadas se Source: clone é usado para criá-las em vez de love.audio.newSource, então este método deve ser preferido ao fazer várias fontes que reproduzem o mesmo som.

Fontes clonadas herdam todo o estado configurável da fonte original, mas são inicializadas paradas.

source = Source:clone()

Source:getAttenuationDistances

Obtém as distâncias de atenuação referencial e máxima do Source. Os valores, combinados com o DistanceModel atual, afetam a maneira como o volume do Source é atenuado, baseado na distância do ouvinte.

ref, max = Source:getAttenuationDistances()

Source:getChannels

Obtém o número de canais de um Source. Apenas Sources de 1 canal (mono) podem usar efeitos direcionais e posicionais.

channels = Source:getChannels()

Source:getCone

Obtém os cones de volume direcional do Source. Usados com Source:setDirection, os ângulos dos cones permitem que o volume do Source varie de acordo com sua direção.

innerAngle, outerAngle, outerVolume = Source:getCone()

Source:getDirection

Obtém a direção de um Source.

x, y, z = Source:getDirection()

Source:getDuration

Obtém a duração da Fonte. Para fontes de transmissão, nem sempre pode ser exato e pode retornar -1 se a duração não puder ser determinada.

duration = Source:getDuration( unit )

Source:getPitch

Obtém o tom atual do Source.

pitch = Source:getPitch()

Source:getPosition

Obtém a posição do Source.

x, y, z = Source:getPosition()

Source:getRolloff

Retorna o valor de decaimento do Source.

rolloff = Source:getRolloff()

Source:getType

Obtém o tipo (estático ou de fluxo) da Fonte.

sourcetype = Source:getType()

Source:getVelocity

Obtém a velocidade do Source.

x, y, z = Source:getVelocity()

Source:getVolume

Obtém o volume atual do Source.

volume = Source:getVolume()

Source:getVolumeLimits

Retorna os limites de volume do Source.

min, max = Source:getVolumeLimits()

Source:isLooping

Retorna se o Source vai se repetir ciclicamente ou não.

loop = Source:isLooping()

Source:isPaused

Retorna se o Source está pausado ou não.

paused = Source:isPaused()

Source:isPlaying

Retorna se o Source está tocando ou não.

playing = Source:isPlaying()

Source:isStopped

Retorna se o Source está parado ou não.

stopped = Source:isStopped()

Source:pause

Pausa um Source.

Source:pause()

Source:play

Começa a tocar um Source.

success = Source:play()

Source:resume

Retorna a tocar um Source.

Source:resume()

Source:rewind

Rebobina um Source.

Source:rewind()

Source:seek

Define a posição atual do fluxo de áudio do Source.

Source:seek( position, unit )

Source:setDirection

Configura o vetor direcional do Source. Um vetor zero torna o Source não direcional.

Source:setDirection( x, y, z )

Source:setAttenuationDistances

Define as distâncias de atenuação referencial e máxima do Source. Os parâmetros, combinados com o DistanceModel atual, afetam a maneira como o volume do Source é atenuado, baseado na distância.

Source:setAttenuationDistances( ref, max )

Source:setCone

Configura os cones de volume direcional do Source. Usados com Source:setDirection, os ângulos dos cones permitem que o volume do Source varie de acordo com sua direção.

Source:setCone( innerAngle, outerAngle, outerVolume )

Source:setLooping

Configura se um Source deverá repetir.

Source:setLooping( loop )

Source:setPitch

Configura o tom do Source.

Source:setPitch( pitch )

Source:setPosition

Define a posição do Source.

Source:setPosition( x, y, z )

Source:setRolloff

Configura o fator de decaimento.

Source:setRolloff( rolloff )

Source:setVelocity

Configura a velocidade do Source.

Isto '''não''' muda a posição do Source, mas permite ao programa saber como calcular o efeito doppler.

Source:setVelocity( x, y, z )

Source:setVolume

Define o volume atual do Source.

Source:setVolume( volume )

Source:setVolumeLimits

Define os limites de volume do Source. Os limites devem ser números de 0 a 1.

Source:setVolumeLimits( min, max )

Source:stop

Para um Source.

Source:stop()

Source:tell

Obtém a posição atual do fluxo de áudio do Source.

position = Source:tell( unit )

love.event

Functions

love.event.clear Limpa a fila de eventos.

love.event.poll Retorna um iterador para mensagens na fila de eventos.

love.event.pump Adiciona eventos à fila de eventos.

love.event.push Adiciona um evento à fila de eventos.

love.event.quit Adiciona o evento quit à fila.

love.event.wait Como love.event.poll(), mas bloqueia a execução até existir um evento na fila.

Enums

Event Argumentos para love.event.push() e similares.

love.event.clear

Limpa a fila de eventos.

love.event.clear()

love.event.poll

Retorna um iterador para mensagens na fila de eventos.

i = love.event.poll()

love.event.pump

Adiciona eventos à fila de eventos.

Esta é uma função de baixo nível, e normalmente não é chama pelo usuário, e sim por love.run.

Repare que ela precisa ser chamada para o sistema operacional saber que o programa está rodando,

e é necessária para lidar com eventos gerados pelo sistema operacional (isso é, callbacks).

love.event.pump()

love.event.push

Adiciona um evento à fila de eventos.

love.event.push( e, a, b, c, d )

love.event.quit

Adiciona o evento quit à fila.

O evento quit é um sinal para o manipulador de eventos fechar o LÖVE. É possível abortar o processo de saída com o callback love.quit.

love.event.quit()

love.event.quit( exitstatus )

love.event.quit( "restart" )

love.event.wait

Como love.event.poll(), mas bloqueia a execução até existir um evento na fila.

e, a, b, c, d = love.event.wait()

Event

focus

O foco da janela ganhou ou perdeu

joystickaxis

Movimento do eixo do joystick

joystickhat

Joystick chapéu pressionado

joystickpressed

Joystick pressionado

joystickreleased

Joystick lançado

keypressed

Tecla pressionada

keyreleased

Chave liberada

mousefocus

Janela foco do mouse obtido ou perdido

mousepressed

Mouse pressionado

mousereleased

Rato liberado

resize

Tamanho da janela alterada pelo usuário

threaderror

Ocorreu um erro Lua em um segmento.

quit

Sair

visible

A janela é minimizada ou não minimizada pelo usuário

love.filesystem

Types

File Representa um arquivo no sistema de arquivos.

FileData Data (Português) representando o conteúdo de um arquivo.

Functions

love.filesystem.append Acrescentar dados a um arquivo existente.

love.filesystem.createDirectory Cria um diretório recursivamente.

love.filesystem.exists Verifica se um arquivo ou diretório existe.

love.filesystem.getAppdataDirectory Retorna o diretório de dados do aplicativo (pode ser o mesmo de getUserDirectory).

love.filesystem.getDirectoryItems Retorna uma tabela com os nomes de arquivos e subdiretórios do caminho especificado.

love.filesystem.getLastModified Obtém a última data de modificação de um arquivo.

love.filesystem.getRealDirectory Obtém o caminho absoluto específico da plataforma do diretório que contém um caminho de arquivo.

love.filesystem.getSaveDirectory Obtém o caminho completo do diretório de escrita designado.

love.filesystem.getSize Obtém o tamanho de um arquivo em bytes.

love.filesystem.getSourceBaseDirectory Obtém o caminho completo para o diretório que contém o arquivo .love.

love.filesystem.getUserDirectory Retorna o caminho do diretório do usuário

love.filesystem.getWorkingDirectory Obtém o diretório de trabalho atual.

love.filesystem.init Inicializa o módulo love.filesystem, será chamada internamente, por isso não deve ser chamada explicitamente.

love.filesystem.isDirectory Verifica se algo é um diretório.

love.filesystem.isFile Verifica se algo é um arquivo.

love.filesystem.isFused Descobre se um jogo está em modo fundido ou não.

love.filesystem.isSymlink Obtém se um caminho de arquivo é realmente um link simbólico.

love.filesystem.lines Itera pelas linhas de um arquivo.

love.filesystem.load Carrega um arquivo lua (mas não executa).

love.filesystem.mount Monta um arquivo zip ou uma pasta no diretório de escrita do jogo para leitura.

love.filesystem.read Ler o conteúdo de um arquivo

love.filesystem.remove Remove um diretório vazio ou arquivo.

love.filesystem.get/setIdentity Configura o diretório de escrita para seu jogo.

love.filesystem.get/setRequirePath Define os caminhos do sistema de arquivos que serão pesquisados ​​quando necessário é chamado.

love.filesystem.get/setSource Configura a fonte do jogo, onde o código está.

love.filesystem.are/setSymlinksEnabled Define se love.filesystem segue links simbólicos.

love.filesystem.unmount Desmonta um arquivo zip ou pasta anteriormente montados para leitura com love.filesystem.mount.

love.filesystem.write Escreve dados em um arquivo no diretório de escrita.

Enums

BufferMode Modos de buffer para objetos File.

FileDecoder Como decodificar um dado FileData (Português).

FileMode Os diferentes modos em que um File pode ser aberto.

love.filesystem.append

Acrescentar dados a um arquivo existente.

success, errormsg = love.filesystem.append( name, data, size )

love.filesystem.areSymlinksEnabled

Obtém se love.filesystem segue links simbólicos.

enable = love.filesystem.areSymlinksEnabled()

love.filesystem.createDirectory

Cria um diretório recursivamente.

Quando invocado com "a/b", cria tanto "a" quanto "a/b", se eles não existirem.

success = love.filesystem.createDirectory( name )

love.filesystem.exists

Verifica se um arquivo ou diretório existe.

exists = love.filesystem.exists( filename )

love.filesystem.getAppdataDirectory

Retorna o diretório de dados do aplicativo (pode ser o mesmo de getUserDirectory).

path = love.filesystem.getAppdataDirectory()

love.filesystem.getDirectoryItems

Retorna uma tabela com os nomes de arquivos e subdiretórios do caminho especificado. A tabela não é organizada de modo nenhum; a ordem é indefinida.

Se o caminho dado à função existir nos diretórios de jogo e de escrita, serão listados arquivos e diretórios de ambos lugares.

items = love.filesystem.getDirectoryItems( dir )

love.filesystem.getIdentity

Obtém o diretório de escrita do seu jogo.

Repare que isso apenas retorna o nome da pasta para guardar seus arquivos, não a localização completa.

love.filesystem.getIdentity( name )

love.filesystem.getLastModified

Obtém a última data de modificação de um arquivo.

modtime, errormsg = love.filesystem.getLastModified( filename )

love.filesystem.getRealDirectory

Obtém o caminho absoluto específico da plataforma do diretório que contém um caminho de arquivo.

Isso pode ser usado para determinar se um arquivo está dentro do diretório de salvamento ou a fonte do jogo .amor.

realdir = love.filesystem.getRealDirectory( filepath )

love.filesystem.getRequirePath

Obtém os caminhos do sistema de arquivos que serão pesquisados ​​quando necessário é chamado.

A cadeia de caminhos retornada por esta função é uma seqüência de modelos de caminho separados por ponto e vírgula. O argumento passado para exigir será inserido no lugar de qualquer caractere de ponto de interrogação ("?") Em cada modelo (após os caracteres de ponto no argumento passado exigir são substituídos por separadores de diretório.)

Os caminhos são relativos à fonte do jogo e salvam diretórios, bem como quaisquer caminhos montados com love.filesystem.mount.

paths = love.filesystem.getRequirePath()

love.filesystem.getSaveDirectory

Obtém o caminho completo do diretório de escrita designado.

Isso pode ser útil se você deseja utilizar a biblioteca de io padrão (ou alguma outra coisa) para

ler ou escrever no diretório de escrita.

path = love.filesystem.getSaveDirectory()

love.filesystem.getSize

Obtém o tamanho de um arquivo em bytes.

size, errormsg = love.filesystem.getSize( filename )

love.filesystem.getSource

Obtém o caminho completo para o arquivo ou diretório .love. Se o jogo estiver fundido no executável LÖVE, o executável retorna.

path = love.filesystem.getSource()

love.filesystem.getSourceBaseDirectory

Obtém o caminho completo para o diretório que contém o arquivo .love. Se o jogo estiver fundido no executável LÖVE, o diretório que contém o executável é retornado.

Se love.filesystem.isFused é verdadeiro, o caminho retornado por esta função pode ser passado para love.filesystem.mount, o que tornará o diretório que contém o jogo principal legível pelo love.filesystem.

path = love.filesystem.getSourceBaseDirectory()

love.filesystem.getUserDirectory

Retorna o caminho do diretório do usuário

path = love.filesystem.getUserDirectory()

love.filesystem.getWorkingDirectory

Obtém o diretório de trabalho atual.

path = love.filesystem.getWorkingDirectory()

love.filesystem.init

Inicializa o módulo love.filesystem, será chamada internamente, por isso não deve ser chamada explicitamente.

love.filesystem.init( appname )

love.filesystem.isDirectory

Verifica se algo é um diretório.

isDir = love.filesystem.isDirectory( path )

love.filesystem.isFile

Verifica se algo é um arquivo.

isFile = love.filesystem.isFile( path )

love.filesystem.isFused

Descobre se um jogo está em modo fundido ou não.

Se um jogo estiver em modo fundido, seu diretório de escrita será diretamente no diretório Appdata (Dados de Aplicativo), em vez de em Appdata/LOVE/. O jogo também será capaz de carregar bibliotecas dinâmicas C Lua localizadas no diretório de escrita.

Um jogo está em modo fundido se a fonte .love tiver sido fundida com o executável (veja Distribuição de Jogos), ou se "--fused" tiver sido usado como argumento de linha de comando ao iniciar o jogo.

fused = love.filesystem.isFused()

love.filesystem.isSymlink

Obtém se um caminho de arquivo é realmente um link simbólico.

Se os links simbólicos não estiverem ativados (via love.filesystem.setSymlinksEnabled), esta função sempre retornará falsa.

symlink = love.filesystem.isSymlink( path )

love.filesystem.lines

Itera pelas linhas de um arquivo.

iterator = love.filesystem.lines( name )

love.filesystem.load

Carrega um arquivo lua (mas não executa).

chunk = love.filesystem.load( name, errormsg )

love.filesystem.mount

Monta um arquivo zip ou uma pasta no diretório de escrita do jogo para leitura.

success = love.filesystem.mount( archive, mountpoint, appendToPath )

love.filesystem.newFile

Cria um novo objeto Arquivo.

É necessário que seja aberto antes que possa ser acessado.

file, errorstr = love.filesystem.newFile( filename, mode )

love.filesystem.newFileData

Cria um novo objeto DadoDeArquivo.

data = love.filesystem.newFileData( contents, name, decoder )

data, err = love.filesystem.newFileData( filepath )

Cria um novo DadoDeArquivo a partir de um arquivo no disco rígido.

love.filesystem.read

Ler o conteúdo de um arquivo

contents, size = love.filesystem.read( name, bytes )

love.filesystem.remove

Remove um diretório vazio ou arquivo.

success = love.filesystem.remove( name )

love.filesystem.setIdentity

Configura o diretório de escrita para seu jogo.

Note que é possível somente configurar o nome da pasta que armazenará os arquivos, não a sua localização.

love.filesystem.setIdentity( name, appendToPath )

love.filesystem.setRequirePath

Define os caminhos do sistema de arquivos que serão pesquisados ​​quando necessário é chamado.

A cadeia de caminhos dada a esta função é uma seqüência de modelos de caminho separados por ponto e vírgula. O argumento passado para exigir será inserido no lugar de qualquer caractere de ponto de interrogação ("?") Em cada modelo (após os caracteres de ponto no argumento passado exigir são substituídos por separadores de diretório.)

Os caminhos são relativos à fonte do jogo e salvam diretórios, bem como quaisquer caminhos montados com love.filesystem.mount.

love.filesystem.setRequirePath( paths )

love.filesystem.setSource

Configura a fonte do jogo, onde o código está. Essa função só pode ser chamada uma única vez, e o normal é que isso seja feito automaticamente pelo LÖVE.

love.filesystem.setSource( path )

love.filesystem.setSymlinksEnabled

Define se love.filesystem segue links simbólicos. É habilitado por padrão na versão 0.10.0 e mais recente e desabilitado por padrão em 0.9.2.

love.filesystem.setSymlinksEnabled( enable )

love.filesystem.unmount

Desmonta um arquivo zip ou pasta anteriormente montados para leitura com love.filesystem.mount.

success = love.filesystem.unmount( archive )

love.filesystem.write

Escreve dados em um arquivo no diretório de escrita. Se o arquivo já existia, será totalmente substituído pelo conteúdo novo.

success, message = love.filesystem.write( name, data, size )

success, message = love.filesystem.write( name, data, size )

BufferMode

none

Sem buffer. O resultado de escritas e acréscimos aparecerá imediatamente.

line

Buffer por linha. Operações de escrita e de acréscimo vão pro buffer até que uma nova linha seja enviada ou o tamanho limite do buffer seja atingido.

full

Buffer completo. Operações de escrita e de acréscimo vão pro buffer até que o tamanho limite do buffer seja atingido.

FileDecoder

file

Os dados estão decodificados.

base64

Os dados estão codificados (base64).

FileMode

r

Abre um arquivo para leitura.

w

Abre um arquivo para escrita.

a

Abre um arquivo para acréscimo.

c

Não abre um arquivo (representa um arquivo fechado).

File

Representa um arquivo no sistema de arquivos.

Constructors

love.filesystem.newFile Cria um novo objeto Arquivo.

Functions

File:open Abre um arquivo para escrita, leitura ou acréscimo.

File:close Fecha um arquivo

File:read Lê uma quantidade de bytes de um arquivo.

File:lines Iterage por todas as linhas de um arquivo

File:write Escreve dados no arquivo.

File:get/setBuffer Configura o modo de buffer para um arquivo aberto para escrita ou acréscimo.

File:flush Descarrega qualquer dado escrito no buffer para o disco.

File:getMode Obtém o FileMode com o qual o arquivo foi aberto.

File:isOpen Descobre se o arquivo está aberto.

File:isEOF Obtém se o fim do arquivo foi atingido.

File:getFilename Obtém o nome do arquivo com o qual o objeto File foi criado.

File:getSize Retorna o tamanho do arquivo

File:tell/seek Vai para uma posição no arquivo.

Supertypes

Object A superclasse de todos os tipos do LÖVE.

File:close

Fecha um arquivo

success = File:close()

File:flush

Descarrega qualquer dado escrito no buffer para o disco.

success, err = File:flush()

File:getBuffer

Obtém o modo de buffer de um arquivo.

mode, size = File:getBuffer()

File:getFilename

Obtém o nome do arquivo com o qual o objeto File foi criado. Se o objeto do arquivo se originou do retorno de chamada love.filedropped, o nome do arquivo será o caminho completo do arquivo dependente da plataforma.

filename = File:getFilename()

File:getMode

Obtém o FileMode com o qual o arquivo foi aberto.

mode = File:getMode()

File:getSize

Retorna o tamanho do arquivo

size = File:getSize()

File:isEOF

Obtém se o fim do arquivo foi atingido.

eof = File:isEOF()

File:isOpen

Descobre se o arquivo está aberto.

open = File:isOpen()

File:lines

Iterage por todas as linhas de um arquivo

iterator = File:lines()

File:open

Abre um arquivo para escrita, leitura ou acréscimo.

success = File:open( mode )

File:read

Lê uma quantidade de bytes de um arquivo.

contents, size = File:read( bytes )

File:seek

Vai para uma posição no arquivo.

success = File:seek( position )

File:setBuffer

Configura o modo de buffer para um arquivo aberto para escrita ou acréscimo. Arquivos com buffer habilitado não vão escrever dados no disco até que tamanho limite do buffer seja atingido, dependendo do modo de buffer.

File:flush forçará qualquer dado do buffer a ser escrito no disco.

success, errorstr = File:setBuffer( mode, size )

File:tell

Retorna a posição atual no arquivo.

pos = File:tell()

File:write

Escreve dados no arquivo.

success = File:write( data, size )

FileData

Data (Português) representando o conteúdo de um arquivo.

Constructors

love.filesystem.newFileData Cria um novo objeto DadoDeArquivo.

Functions

FileData:getFilename Obtém o nome de arquivo de um FileData.

FileData:getExtension Obtém a extensão do FileData.

Supertypes

Data A superclasse de todos os dados.

Object A superclasse de todos os tipos do LÖVE.

FileData:getExtension

Obtém a extensão do FileData.

ext = FileData:getExtension()

FileData:getFilename

Obtém o nome de arquivo de um FileData.

name = FileData:getFilename()

love.graphics

Types

Canvas Uma tela é usada para renderização fora da tela.

Font Pode ser usado para desenhar texto na tela.

Mesh Uma malha de polígono 2D usada para desenhar formas texturizadas arbitrárias.

Image Tipo de imagens que podem ser desenhadas.

ParticleSystem Usado para criar efeitos legais, como fogo.

Quad Um quadrilátero com informações coordenadas de textura.

Shader Um Shader é usado para manipulação acelerada de pixel ou vertex acelerado por hardware.

SpriteBatch Armazena uma geometria em um buffer e desenha em uma única chamada.

Text Texto desenhável.

Texture Superclasse para objetos desenháveis ​​que representam uma textura.

Video Um vídeo desenhável.

Functions

love.graphics.draw Desenha um objeto Desenhável (uma Imagem, uma Pintura, um LoteDeSprites, um SistemaDePartículas, ou uma Malha) na tela, com rotação, redimensionamento e inclinação opcionais.

love.graphics.print Desenha texto na tela.

love.graphics.printf Desenha texto formatado, com quebra de linha e alinhamento.

love.graphics.line Desenha linhas entre pontos.

love.graphics.polygon Desenha um polígono.

love.graphics.rectangle Desenha um retângulo.

love.graphics.circle Desenha um círculo.

love.graphics.ellipse Desenha uma elipse.

love.graphics.arc Desenha um arco preenchido ou não preenchido na posição (x, y).

love.graphics.points Desenha um ou mais pontos.

love.graphics.stencil Desenha a geometria como um estêncil.

love.graphics.get/setStencilTest Configura ou desativa o teste do estêncil.

love.graphics.push Copia e empilha a transformação de coordenadas atual na pilha de transformações.

love.graphics.pop Desempilha a transformação de coordenadas atual da pilha de transformações.

love.graphics.reset Reinicia as configurações gráficas atuais.

love.graphics.get/setFont Configura como fonte atual uma Fonte já carregada ou cria e carrega uma nova a partir do arquivo e do tamanho.

love.graphics.get/setBackgroundColor Configura a cor de fundo.

love.graphics.get/setBlendMode Configura o modo de mistura.

love.graphics.get/setCanvas Captura as operações de desenho em uma tela.

love.graphics.get/setColor Configura a cor a ser utilizada para desenhar.

love.graphics.get/setColorMask Configura a máscara de cor.

love.graphics.get/setDefaultFilter Configura os filtros de redimensionamento padrão usados com Imagens, Pinturas e Fontes.

love.graphics.get/setLineJoin Configura o estilo de junção de linha.

love.graphics.get/setLineStyle Configura o estilo de linha.

love.graphics.get/setLineWidth Configura a espessura da linha.

love.graphics.get/setShader Configura ou desconfigura um Shader como o efeito de pixel ou shader de vértice atual.

love.graphics.get/setPointSize Configura o tamanho de ponto.

love.graphics.get/setScissor Configura ou desativa o recorte.

love.graphics.intersectScissor Define a tesoura para o retângulo criado pela interseção do retângulo especificado com a tesoura existente.

love.graphics.origin Reinicia a transformação de coordenadas atual.

love.graphics.rotate Rotaciona o sistema de coordenadas em duas dimensões.

love.graphics.scale Redimensiona o sistema de coordenadas em duas dimensões.

love.graphics.shear Inclina o sistema de coordenadas.

love.graphics.translate Translada o sistema de coordenadas em duas dimensões.

love.graphics.getDimensions Obtém a largura e a altura da janela.

love.graphics.getHeight Obtém a altura da janela.

love.graphics.getWidth Obtém a largura da janela.

love.graphics.getCanvasFormats Obtém os formatos de Canvas disponíveis e se cada um é suportado.

love.graphics.getCompressedImageFormats Obtém os formatos de imagem comprimidos disponíveis e se cada um é suportado.

love.graphics.getStats Obtém estatísticas de renderização relacionadas ao desempenho.

love.graphics.getSystemLimits Obtém os valores máximos dependentes do sistema para recursos de love.graphics.

love.graphics.getRendererInfo Obtém informações sobre a placa de vídeo e os drivers do sistema.

love.graphics.getSupported Obtém os recursos gráficos opcionais e se eles são suportados no sistema.

love.graphics.isGammaCorrect Obtém se a renderização correta de gama é suportada e habilitada.

love.graphics.newScreenshot Captura a tela e retorna o dado de imagem.

love.graphics.is/setWireframe Configura se o modo de estrutura de arame será usado ou não ao desenhar.

love.graphics.clear Limpa a tela, pinta com a cor de fundo e restaura o sistema de coordenadas padrão.

love.graphics.discard Descartes (trashes) o conteúdo da tela ou o Canvas ativo.

love.graphics.present Mostra os resultados de operações de desenho na tela.

Enums

AlignMode Alinhamento do texto.

ArcType Diferentes tipos de arcos que podem ser desenhados.

AreaSpreadDistribution Tipos de distribuição de área de partículas espalhadas.

BlendAlphaMode Diferentes formas de alfa afetam a mistura de cores.

BlendMode Diferentes maneiras de fazer a mistura do alfa.

CanvasFormat Formatos de lona.

CompareMode Diferentes tipos de comparações de teste de estêncil por pixel.

DrawMode Como as formas são desenhadas.

FilterMode Como uma imagem é filtrada quando escalada.

GraphicsFeature Recursos de gráficos que podem ser verificados com love.graphics.getSupported.

GraphicsLimit Tipos de limites de gráficos dependentes do sistema verificados para usar love.graphics.getSystemLimits.

LineJoin Estilo de junção de linha.

LineStyle O estilo com o qual as linhas são desenhadas.

MeshDrawMode Como os vértices de um Mesh são usados ​​ao desenhar.

ParticleInsertMode Como as partículas recém-criadas são adicionadas ao ParticleSystem.

SpriteBatchUsage Dicas de uso para SpriteBatches e Meshes para otimizar o armazenamento e acesso de dados.

StackType Tipos de pilha de estado gráficos usados ​​com love.graphics.push.

StencilAction Como uma função de estêncil modifica os valores de estêncil de pixels que ele toca.

WrapMode Como uma imagem será acondicionada dentro de um Quad largo.

love.graphics.arc

Desenha um arco preenchido ou não preenchido na posição (x, y). O arco é desenhado do angulo1 até o angulo2 em radianos. O parâmetro segmentos determina quantos segmentos são usados para desenhar o arco. Quanto mais segmentos, mais suave a borda.

love.graphics.arc( drawmode, arctype, x, y, radius, angle1, angle2, segments )

love.graphics.circle

Desenha um círculo.

love.graphics.circle( mode, x, y, radius )

love.graphics.circle( mode, x, y, radius, segments )

love.graphics.clear

Limpa a tela, pinta com a cor de fundo e restaura o sistema de coordenadas padrão.

Esta função é chamada automaticamente antes de love.draw na função love.run padrão. Veja o exemplo em love.run de um uso típico dessa função.

Note que área de recorte limita a região a ser limpa.

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.

love.graphics.clear( r, g, b, a )

Limpa a tela ou activa Canvas para a cor especificada.

love.graphics.clear( color, ... )

Limpa múltipla ativa Canvases para cores diferentes, se múltiplos Canvases são activo de uma só vez através de love.graphics.setCanvas.

love.graphics.discard

Descartes (trashes) o conteúdo da tela ou o Canvas ativo. Esta é uma função de otimização de desempenho com casos de uso de nicho.

Se o Canvas ativo acabou de ser alterado e o "substituir" BlendMode está prestes a ser usado para desenhar algo que cobre toda a tela, chamando love.graphics.discard em vez de chamar love.graphics.clear ou não fazer nada pode melhorar o desempenho no celular dispositivos.

Em alguns sistemas de desktop, esta função pode não fazer nada.

love.graphics.discard( discardcolor, discardstencil )

love.graphics.discard( discardcolors, discardstencil )

love.graphics.draw

Desenha um objeto Desenhável (uma Imagem, uma Pintura, um LoteDeSprites, um SistemaDePartículas, ou uma Malha) na tela, com rotação, redimensionamento e inclinação opcionais.

Objetos são desenhados em relação ao seu sistema de coordenadas local. Por padrão, a origem se encontra no canto superior esquerdo da Imagem e da Pintura. Todos os argumentos de tamanho, inclinação e rotação transformam o objeto em relação a esse ponto. Além disso, a posição de origem pode ser especificada no sistema de coordenadas da tela.

É possível girar um objeto em torno de seu centro deslocando a origem para o centro. Para a rotação, ângulos devem ser dados em radianos. Também se pode usar um fator de redimensionamento negativo para virar a partir do centro.

Repare que os deslocamentos são aplicados antes de rotação, redimensionamento ou inclinação; redimensionamento e inclinação são aplicados antes da rotação.

Os limites da direita e debaixo do objeto são deslocados num ângulo definido pelos fatores de inclinação.

love.graphics.draw( drawable, x, y, r, sx, sy, ox, oy, kx, ky )

love.graphics.draw( texture, quad, x, y, r, sx, sy, ox, oy, kx, ky )

love.graphics.ellipse

Desenha uma elipse.

love.graphics.ellipse( mode, x, y, radiusx, radiusy, segments )

love.graphics.getBackgroundColor

Obtém a cor atual do fundo de tela.

r, g, b, a = love.graphics.getBackgroundColor()

love.graphics.getBlendMode

Obtém o modo de mistura.

mode, alphamode = love.graphics.getBlendMode()

love.graphics.getCanvas

Obtém a Pintura alvo atual.

canvas = love.graphics.getCanvas()

love.graphics.getCanvasFormats

Obtém os formatos de Canvas disponíveis e se cada um é suportado.

formats = love.graphics.getCanvasFormats()

love.graphics.getColor

Obtém a cor atual.

r, g, b, a = love.graphics.getColor()

love.graphics.getColorMask

Obtém os componentes de cor ativos usados ao desenhar. Normalmente todos os 4 componentes estão ativos, a não ser que love.graphics.setColorMask tenha sido usada.

A máscara de cor determina se os componentes individuais das cores de objetos desenhados afetarão a cor da tela ou não. Também afeta love.graphics.clear e Pintura:clear.

r, g, b, a = love.graphics.getColorMask()

love.graphics.getCompressedImageFormats

Obtém os formatos de imagem comprimidos disponíveis e se cada um é suportado.

formats = love.graphics.getCompressedImageFormats()

love.graphics.getDefaultFilter

Retorna os filtros de redimensionamento padrão usados com Imagens, Pinturas e Fontes.

min, mag, anisotropy = love.graphics.getDefaultFilter()

love.graphics.getDimensions

Obtém a largura e a altura da janela.

width, height = love.graphics.getDimensions()

love.graphics.getFont

Obtém o objeto Fonte atual.

font = love.graphics.getFont()

love.graphics.getHeight

Obtém a altura da janela.

height = love.graphics.getHeight()

love.graphics.getLineJoin

Obtém o estilo de junção de linha.

join = love.graphics.getLineJoin()

love.graphics.getLineStyle

Obtém o estilo de linha.

style = love.graphics.getLineStyle()

love.graphics.getLineWidth

Obtém a espessura atual da linha.

width = love.graphics.getLineWidth()

love.graphics.getShader

Obtém o Shader atual. Retorna nil se nenhum tiver sido definido.

shader = love.graphics.getShader()

love.graphics.getStats

Obtém estatísticas de renderização relacionadas ao desempenho.

stats = love.graphics.getStats()

love.graphics.getStencilTest

Obtém se o teste do estêncil está habilitado.

Quando o teste do estêncil é habilitado, a geometria de tudo que é desenhado será cortada / colocada de acordo com a interação com o que foi anteriormente desenhado para o buffer do estêncil.

Cada tela tem seu próprio buffer de gabarito.

enabled, inverted = love.graphics.getStencilTest()

love.graphics.getSupported

Obtém os recursos gráficos opcionais e se eles são suportados no sistema.

Alguns sistemas mais antigos ou de baixo custo nem sempre suportam todos os recursos gráficos.

features = love.graphics.getSupported()

love.graphics.getSystemLimits

Obtém os valores máximos dependentes do sistema para recursos de love.graphics.

limits = love.graphics.getSystemLimits()

love.graphics.getPointSize

Obtém o tamanho de ponto.

size = love.graphics.getPointSize()

love.graphics.getRendererInfo

Obtém informações sobre a placa de vídeo e os drivers do sistema.

name, version, vendor, device = love.graphics.getRendererInfo()

love.graphics.getScissor

Obtém a área de recorte atual.

x, y, width, height = love.graphics.getScissor()

love.graphics.getWidth

Obtém a largura da janela.

width = love.graphics.getWidth()

love.graphics.intersectScissor

Define a tesoura para o retângulo criado pela interseção do retângulo especificado com a tesoura existente. Se nenhuma tesoura ainda está ativa, ela se comporta como love.graphics.setScissor.

A tesoura limita a área de desenho a um retângulo especificado. Isso afeta todas as chamadas gráficas, incluindo love.graphics.clear.

As dimensões da tesoura não são afetadas por transformações gráficas (traduz, escala, ...).

love.graphics.intersectScissor( x, y, width, height )

Limits the drawing area to a specified rectangle.

love.graphics.intersectScissor()

Disables scissor.

love.graphics.isGammaCorrect

Obtém se a renderização correta de gama é suportada e habilitada. Pode ser ativado configurando t.gammacorrect = true em love.conf.

Nem todos os dispositivos suportam a renderização compatível com a gama, caso em que será desativado automaticamente e esta função retornará falsa. É suportado em sistemas de desktop que possuem placas gráficas capazes de usar o OpenGL 3 / DirectX 10 e dispositivos iOS que podem usar o OpenGL ES 3.

gammacorrect = love.graphics.isGammaCorrect()

love.graphics.isWireframe

Descobre se o modo de estrutura de arame está sendo usado ao desenhar.

wireframe = love.graphics.isWireframe()

love.graphics.line

Desenha linhas entre pontos.

love.graphics.line( x1, y1, x2, y2, ... )

love.graphics.line( points )

love.graphics.newCanvas

Cria um novo objeto Pintura para renderização fora da tela.

canvas = love.graphics.newCanvas( width, height, format, msaa )

love.graphics.newFont

Cria uma nova Fonte.

font = love.graphics.newFont( file, size )

font = love.graphics.newFont( file, imagefilename )

font = love.graphics.newFont( size )

Esta variante usa a fonte padrão (Vera Sans) com um tamanho personalizado.

love.graphics.newMesh

Cria uma nova Malha.

mesh = love.graphics.newMesh( vertexformat, vertices, mode, usage )

Creates a Mesh with custom vertex attributes and the specified vertex data.

mesh = love.graphics.newMesh( vertexformat, vertexcount, mode, usage )

Creates a Mesh with custom vertex attributes and the specified number of vertices.

love.graphics.newImage

Cria uma nova imagem de um caminho de arquivo, FileData, um ImageData ou um CompressedImageData e, opcionalmente, gera ou especifica mipmaps para a imagem.

As imagens que usam CompressedImageData o usarão para recarregar-se quando o love.window.setMode for chamado.

image = love.graphics.newImage( file, flags )

love.graphics.newImageFont

Cria uma nova Fonte carregando uma imagem no formato apropriado. Pode ter até 256 glifos.

font = love.graphics.newImageFont( file, glyphs, extraspacing )

love.graphics.newParticleSystem

Cria um novo SistemaDePartículas.

system = love.graphics.newParticleSystem( texture, buffer )

love.graphics.newShader

Cria um novo objeto Shader para efeitos de vértice e de pixel com aceleração de hardware. Um Shader contém código de shader de vértice, código de shader de pixel, ou ambos.

Shaders são pequenos programas que rodam na placa de vídeo ao desenhar. Shaders de vértice são rodados uma vez para cada vértice (por exemplo, uma imagem tem 4 vértices - um em cada canto. Uma Malha pode ter muito mais.) Shaders de pixel rodam uma vez para cada pixel na tela que o objeto desenhado toca. O código do shader de pixel é executado depois que todos os vértices do objeto tenham sido processados pelo shader de vértice.

shader = love.graphics.newShader( code )

shader = love.graphics.newShader( pixelcode, vertexcode )

love.graphics.newText

Cria uma nova fonte.

text = love.graphics.newText( font, textstring )

love.graphics.newQuad

Cria um novo Quad.

quad = love.graphics.newQuad( x, y, width, height, sw, sh )

love.graphics.newScreenshot

Captura a tela e retorna o dado de imagem.

screenshot = love.graphics.newScreenshot( copyAlpha )

love.graphics.newSpriteBatch

Cria um novo objeto LoteDeSprites.

spriteBatch = love.graphics.newSpriteBatch( texture, maxsprites, usage )

love.graphics.newVideo

Cria um novo vídeo desenhável. Atualmente, apenas os arquivos de vídeo Ogg Theora são suportados.

video = love.graphics.newVideo( file, loadaudio )

love.graphics.origin

Reinicia a transformação de coordenadas atual.

Esta função é sempre usada para reverter quaisquer chamadas anteriores a love.graphics.rotate, love.graphics.scale, love.graphics.shear ou love.graphics.translate. Retorna o estado de transformação atual ao estado padrão.

love.graphics.origin()

love.graphics.points

Desenha um ou mais pontos.

love.graphics.points( x, y, ... )

love.graphics.points( points )

love.graphics.points( points )

love.graphics.polygon

Desenha um polígono.

Após o argumento modo, esta função pode aceitar múltiplos argumentos numéricos ou uma única tabela de argumentos numéricos. Em ambos casos, os argumentos são interpretados alternadamente como coordenadas x e y dos vértices do polígono.

''Nota: quando no modo '''fill''', o polígono deve ser convexo e simples ou poderão ocorrer artefatos de renderização. love.math.triangulate e love.math.isConvex podem ser usados no 0.9.0 ou posteriores.''

love.graphics.polygon( mode, ... )

love.graphics.polygon( mode, vertices )

love.graphics.pop

Desempilha a transformação de coordenadas atual da pilha de transformações.

Esta função é sempre usada para reverter uma operação de empilhamento anterior. Ela retorna o estado de transformações atual ao que era antes do empilhamento mais recente.

love.graphics.pop()

love.graphics.present

Mostra os resultados de operações de desenho na tela.

Esta função é usada quando você está escrevendo sua própria função love.run. Ela apresenta todos os resultados das suas operações de desenho na tela. Veja o exemplo em love.run de um uso típico dessa função.

love.graphics.present()

love.graphics.print

Desenha texto na tela. Se nenhuma Fonte estiver configurada, uma irá ser criada e configurada (uma vez) se necessário.

Desde o LOVE 0.7.1, quando se usam funções de translação e redimensionamento ao desenhar texto, esta função supõe que o redimensionamento ocorra primeiro. Se você não programar com isso em mente, o texto não ficará na posição certa, ou talvez nem apareça na tela.

Ambos love.graphics.print e love.graphics.printf suportam codificação UTF-8. Você também vai precisar de uma Fonte apropriada para caracteres especiais.

love.graphics.print( text, x, y, r, sx, sy, ox, oy, kx, ky )

love.graphics.print( coloredtext, x, y, angle, sx, sy, ox, oy, kx, ky )

love.graphics.printf

Desenha texto formatado, com quebra de linha e alinhamento.

Veja notas adicionais em love.graphics.print.

love.graphics.printf( text, x, y, limit, align, r, sx, sy, ox, oy, kx, ky )

love.graphics.printf( coloredtext, x, y, wraplimit, align, angle, sx, sy, ox, oy, kx, ky )

love.graphics.push

Copia e empilha a transformação de coordenadas atual na pilha de transformações.

Esta função é sempre usada para preparar uma operação de desempilhamento posterior correspondente. Ela salva o estado de transformação de coordenadas atual na pilha de transformações e o mantém ativo. Mudanças posteriores à transformação podem ser desfeitas usando a operação de desempilhamento, que retorna a transformação de coordenadas ao estado em que estava antes de se chamar o empilhamento.

love.graphics.push( stack )

love.graphics.rectangle

Desenha um retângulo.

love.graphics.rectangle( mode, x, y, width, height, rx, ry, segments )

Chama a um rectângulo com cantos arredondados.

love.graphics.reset

Reinicia as configurações gráficas atuais.

Chamar o reset torna branca a cor de desenho atual, preta a cor de fundo atual, desativa todas Pinturas ou Shaders, e remove todas configurações de recorte. Configura o ModoDeMistura como <tt>alfa</tt>, ativa todas máscaras de componente de cor, desativa o modo de estrutura de arame e reconfigura o modo de transformação gráfica atual de volta à origem. Também configura ambos modos de desenho de ponto e de linha como <tt>smooth</tt> (suave) e seus tamanhos como <tt>1.0</tt>.

love.graphics.reset()

love.graphics.rotate

Rotaciona o sistema de coordenadas em duas dimensões.

A chamada desta função afeta todas as operações futuras de desenho, rotacionando o sistema de coordenadas em torno da origem, de acordo com a medida em radianos. Essa mudança dura até a saída da função love.draw().

love.graphics.rotate( angle )

love.graphics.scale

Redimensiona o sistema de coordenadas em duas dimensões.

Por padrão, o sistema de coordenadas do LÖVE corresponde aos pixels da tela nas direções horizontal e vertical, na proporção de um para um, e o eixo x cresce para a direita, enquanto o eixo y cresce para baixo. Redimensionar o sistema de coordenadas muda essa relação.

Depois de alterar a escala em ex e ey, tratam-se todas as coordenadas como se fossem multiplicadas por ex e ey. Todos os resultados de operações de desenho também são redimensionados proporcionalmente, então uma escala de (2, 2) por exemplo significaria desenhar tudo com o dobro do tamanho tanto na direção x quanto na y. Redimensionar de acordo com um valor negativo vira o sistema de coordenadas na direção correspondente, o que significa que tudo será desenhado virado ou de ponta cabeça, ou ambos. Redimensionar por zero não é uma operação útil.

Redimensionamento e translação não são operações comutativas, portanto chamá-las em ordens diferentes afetará o resultado.

O redimensionamento dura até a saída da função love.draw().

love.graphics.scale( sx, sy )

love.graphics.setBackgroundColor

Configura a cor de fundo.

love.graphics.setBackgroundColor( r, g, b, a )

love.graphics.setBackgroundColor( rgba )

love.graphics.setBlendMode

Configura o modo de mistura.

love.graphics.setBlendMode( mode, alphamode )

love.graphics.setCanvas

Captura as operações de desenho em uma tela.

love.graphics.setCanvas( canvas )

Configura a Pintura especificada como alvo da renderização. Todas operações de desenho até a próxima chamada de ''love.graphics.setCanvas'' serão redirecionadas à Pintura e não serão mostradas na tela.

love.graphics.setCanvas()

Reconfigura a tela como alvo da renderização, isso é, reabilita o desenho na tela.

love.graphics.setCanvas( canvas1, canvas2, ... )

Configura Pinturas múltiplas como alvo de renderização simultânea. Todas operações de desenho até a próxima chamada de ''love.graphics.setCanvas'' serão redirecionadas às Pinturas e não serão mostradas na tela.

Normalmente, a mesma coisa será desenhada em cada tela, mas isso pode ser mudado se um shader de pixel for usado com a função effects, em vez do effect comum.

Todos os argumentos pintura precisam ter a mesma largura e altura e o mesmo tipo de textura. Nem todos computadores que suportam Pinturas suportam alvos de renderização múltiplos. Se love.graphics.isSupported("multicanvas") retornar verdadeiro, pelo menos 4 pinturas ativas simultâneas são suportadas.

love.graphics.setColor

Configura a cor a ser utilizada para desenhar.

love.graphics.setColor( red, green, blue, alpha )

love.graphics.setColor( rgba )

love.graphics.setColorMask

Configura a máscara de cor. Ativa ou desativa componentes de cor específicos ao renderizar e limpar a tela. Por exemplo, se '''vermelho''' estiver configurado como '''falso''', não será feita mais nenhuma mudança no componente vermelho de qualquer pixel.

love.graphics.setColorMask( red, green, blue, alpha )

Permite mascaramento de cor para os componentes de cor especificados.

love.graphics.setColorMask()

Ativa todos componentes de cor.

love.graphics.setDefaultFilter

Configura os filtros de redimensionamento padrão usados com Imagens, Pinturas e Fontes.

love.graphics.setDefaultFilter( min, mag, anisotropy )

love.graphics.setFont

Configura como fonte atual uma Fonte já carregada ou cria e carrega uma nova a partir do arquivo e do tamanho.

É recomendado criar objetos Fonte com love.graphics.newFont no estágio de carregamento e então passá-los a esta função no estágio de desenho.

love.graphics.setFont( font )

love.graphics.setLineJoin

Configura o estilo de junção de linha. Veja em JunçãoDeLinha as opções possíveis.

love.graphics.setLineJoin( join )

love.graphics.setLineStyle

Configura o estilo de linha.

love.graphics.setLineStyle( style )

love.graphics.setLineWidth

Configura a espessura da linha.

love.graphics.setLineWidth( width )

love.graphics.setNewFont

Cria e configura uma nova Fonte.

font = love.graphics.setNewFont( filename, size )

love.graphics.setShader

Configura ou desconfigura um Shader como o efeito de pixel ou shader de vértice atual. Todas operações de desenho até o próximo ''love.graphics.setShader'' serão desenhadas usando o objeto Shader especificado.

love.graphics.setShader()

love.graphics.setShader( shader )

love.graphics.setPointSize

Configura o tamanho de ponto.

love.graphics.setPointSize( size )

love.graphics.setScissor

Configura ou desativa o recorte.

O recorte limita a área de desenho a um retângulo especificado. Isso afeta todas as chamadas gráficas, incluindo love.graphics.clear.

As dimensões do recorte não são afetadas por transformações gráficas (translação, redimensionamento, ...).

love.graphics.setScissor( x, y, width, height )

limita a área de desenho para um retângulo especificado.

love.graphics.setScissor()

Desativa recorte.

love.graphics.setStencilTest

Configura ou desativa o teste do estêncil.

Quando o teste do estêncil é habilitado, a geometria de tudo que é desenhado depois será cortada / colocada em uma base de comparação entre os argumentos desta função e o valor do estêncil de cada pixel que a geometria toca. Os valores do estêncil dos pixels são afetados via love.graphics.stencil.

Cada Canvas possui seus próprios valores de estêncil por pixel.

love.graphics.setStencilTest( comparemode, comparevalue )

love.graphics.setStencilTest()

desativa o teste de estêncil.

love.graphics.setWireframe

Configura se o modo de estrutura de arame será usado ou não ao desenhar.

love.graphics.setWireframe( enable )

love.graphics.shear

Inclina o sistema de coordenadas.

love.graphics.shear( kx, ky )

love.graphics.stencil

Desenha a geometria como um estêncil.

A geometria desenhada pela função fornecida define valores invisíveis do estêncil de pixels, em vez de configurar cores de pixels. Os valores do estêncil dos pixels podem atuar como uma máscara / estêncil - love.graphics.setStencilTest pode ser usado posteriormente para determinar como a renderização adicional é afetada pelos valores do estêncil em cada pixel.

Cada Canvas possui seus próprios valores de estêncil por pixel. Os valores do estêncil estão dentro do intervalo de {0, 255}.

love.graphics.stencil( stencilfunction, action, value, keepvalues )

love.graphics.translate

Translada o sistema de coordenadas em duas dimensões.

Quando esta função é chamada com dois números, dx e dy, todas as operações de desenho seguintes funcionam como se suas coordenadas x e y fossem x+dx e y+dy.

Redimensionamento e translação não são operações comutativas, portanto chamá-las em ordens diferentes afetará o resultado.

Essa mudança dura até a saída de love.draw ou então até que um love.graphics.pop restabeleça um love.graphics.push anterior.

Transladar usando números inteiros evitará a distorção de imagens e fontes desenhadas depois da translação.

love.graphics.translate( dx, dy )

AlignMode

center

Alinhamento centralizado.

left

Alinhamento à esquerda.

right

Alinhamento à direita.

justify

Alinhe o texto à esquerda e à direita.

ArcType

pie

O arco é desenhado como uma fatia de torta, com o círculo de arco conectado ao centro em seus pontos finais.

open

Os dois pontos finais do círculo do arco não estão conectados quando o arco é desenhado como uma linha. Comporta como o tipo de arco "fechado" quando o arco é desenhado no modo preenchido.

closed

Os dois pontos finais do círculo de arco estão conectados entre si.

AreaSpreadDistribution

uniform

Distribuição uniforme.

normal

Distribuição normal (gaussiana).

ellipse

Distribuição uniforme em uma elipse.

none

Nenhuma distribuição - área espalhada é desativada.

BlendAlphaMode

alphamultiply

Os valores RGB do que é desenhado são multiplicados pelos valores alfa dessas cores durante a mistura. Este é o modo alfa padrão.

premultiplied

Os valores RGB do que é desenhado não são multiplicados pelos valores alfa dessas cores durante a mistura. Para que a maioria dos modos de mistura funcione corretamente com este modo alfa, as cores de um objeto desenhado precisam ter seus valores RGB multiplicados por seus valores alfa em algum ponto anteriormente ("alfa pré-explicada").

BlendMode

alpha

Mode de mistura alfa ('normal').

replace

As cores do que é desenhado substituem completamente o que estava na tela, sem mistura adicional. O BlendAlphaMode especificado no love.graphics.setBlendMode ainda afeta o que acontece.

screen

Mistura de "tela".

add

As cores de pixels do que é desenhado são adicionadas às cores de pixels já na tela. O alfa da tela não é modificado.

subtract

As cores de pixels do desenho são subtraídas das cores de pixels já na tela. O alfa da tela não é modificado.

multiply

As cores de pixels do que é desenhado são multiplicadas com as cores de pixels já na tela (escurecendo-as). O alfa dos objetos desenhados é multiplicado pelo alfa da tela ao invés de determinar o quanto as cores na tela são afetadas, mesmo quando o "BlindAlphaMode" alfamultiplicado é usado.

lighten

As cores de pixels do que é desenhado são comparadas às cores de pixels existentes e o maior dos dois valores para cada componente de cor é usado. Só funciona quando o BlendAlphaMode "premultiplicado" é usado em love.graphics.setBlendMode.

darken

As cores de pixels do que é desenhado são comparadas às cores de pixels existentes e o menor dos dois valores para cada componente de cor é usado. Só funciona quando o BlendAlphaMode "premultiplicado" é usado em love.graphics.setBlendMode.

CanvasFormat

normal

O formato de Canvas padrão - geralmente um alias para o formato rgba8, ou o formato srgb se a renderização correta por gama estiver ativada no LÖVE 0.10.0 e mais recente.

hdr

Um formato adequado para alto conteúdo de alcance dinâmico - um alias para o formato rgba16f, normalmente.

rgba8

8 bits por canal (32 bpp) RGBA. Os valores dos canais de cores variam de 0-255 (0-1 em sombreadores).

rgba4

4 bits por canal (16 bpp) RGBA.

rgb5a1

RGB com 5 bits cada, e um canal alfa de 1 bit (16 bpp).

rgb565

RGB com 5, 6 e 5 bits cada, respectivamente (16 bpp). Não existe um canal alfa nesse formato.

rgb10a2

RGB com 10 bits por canal e um canal alfa de 2 bits (32 bpp).

rgba16f

Ponto RGB flutuante com 16 bits por canal (64 bpp). Os valores de cor podem variar de {-65504, +65504}.

rgba32f

Ponto RGB flutuante com 32 bits por canal (128 bpp).

rg11b10f

Ponto flutuante RGB com 11 bits nos canais vermelho e verde e 10 bits no canal azul (32 bpp). Não há canal alfa. Os valores de cores podem variar de {0, +65024}.

srgb

O mesmo que o rgba8, mas o Canvas é interpretado como sendo no espaço de cores sRGB. Tudo desenhado para o Canvas será convertido de RGB linear para sRGB. Quando o Canvas é desenhado (ou usado em um sombreador), ele será decodificado de sRGB para RGB linear. Isso reduz a faixa de cores ao fazer renderização compatível com a gama, uma vez que a codificação sRGB tem mais precisão que RGB linear para cores mais escuras.

r8

Formato de canal único (componente vermelho) (8 bpp).

rg8

Dois canais (componentes vermelhos e verdes) com 8 bits por canal (16 bpp).

r16f

Formato de canal único de ponto flutuante (16 bpp). Os valores de cor podem variar de {-65504, +65504}.

rg16f

Formato de dois canais de ponto flutuante com 16 bits por canal (32 bpp). Os valores de cor podem variar de {-65504, +65504}.

r32f

Formato de canal único de ponto flutuante (32 bpp).

rg32f

Formato de dois canais de ponto flutuante com 32 bits por canal (64 bpp).

CompareMode

equal

O valor do estêncil do pixel deve ser igual ao valor fornecido.

notequal

O valor do estêncil do pixel não deve ser igual ao valor fornecido.

less

O valor do estêncil do pixel deve ser menor do que o valor fornecido.

lequal

O valor do estêncil do pixel deve ser menor ou igual ao valor fornecido.

gequal

O valor do estêncil do pixel deve ser maior ou igual ao valor fornecido.

greater

O valor do estêncil do pixel deve ser maior do que o valor fornecido.

DrawMode

fill

Desenha as formas preenchidas.

line

Desenha o contorno das formas.

FilterMode

linear

Escala uma imagem com interpolação linear.

nearest

Escala uma imagem com interpolação com relação aos vizinhos.

GraphicsFeature

clampzero

Se o WrapMode "clampzero" é suportado.

lighten

Se o BlendModes "iluminar" e "escurecer" é suportado.

multicanvasformats

Se várias telas com diferentes formatos podem ser usadas na mesma chamada love.graphics.setCanvas.

GraphicsLimit

pointsize

O tamanho máximo dos pontos.

texturesize

A largura ou altura máxima de imagens e telas.

multicanvas

O número máximo de telas simultaneamente ativas (via love.graphics.setCanvas).

canvasmsaa

O número máximo de amostras de antialias para uma tela.

LineJoin

miter

As extremidades dos segmentos de linha chanfaram em um ângulo para que eles se juntem perfeitamente.

bevel

Nenhuma tampa aplicada nas extremidades dos segmentos da linha.

none

Aplique o ponto onde os segmentos de linha se juntam.

LineStyle

rough

Desenha linhas rudes.

smooth

Desenha linhas suaves.

MeshDrawMode

fan

Os vértices criam uma forma de "fã" com o primeiro vértice que atua como o ponto do cubo. Pode ser facilmente usado para desenhar polígonos convexos simples.

strip

Os vértices criam uma série de triângulos conectados usando os vértices 1, 2, 3, depois 3, 2, 4 (observe a ordem), depois 3, 4, 5 e assim por diante.

triangles

Os vértices criam triângulos não conectados.

points

Os vértices são desenhados como pontos desconectados (veja love.graphics.setPointSize).

ParticleInsertMode

top

As partículas são inseridas na parte superior da lista de partículas do ParticleSystem.

bottom

As partículas são inseridas na parte inferior da lista de partículas do ParticleSystem.

random

As partículas são inseridas em posições aleatórias na lista de partículas do ParticleSystem.

SpriteBatchUsage

dynamic

Os dados do objeto mudarão ocasionalmente durante sua vida útil.

static

O objeto não será modificado depois que sprites ou vértices iniciais sejam adicionados.

stream

Os dados do objeto sempre mudarão entre os sorteios.

StackType

transform

A pilha de transformação (love.graphics.translate, love.graphics.rotate, etc.)

all

Todo o estado de love.graphics, incluindo o estado de transformação.

StencilAction

replace

O valor do estêncil de um pixel será substituído pelo valor especificado em love.graphics.stencil, se algum objeto tocar o pixel.

increment

O valor do estêncil de um pixel será incrementado em 1 para cada objeto que toque o pixel. Se o valor do estêncil atingir 255 ele permanecerá em 255.

decrement

O valor do estêncil de um pixel será diminuído em 1 para cada objeto que toque o pixel. Se o valor do estêncil atingir 0 ele permanecerá em 0.

incrementwrap

O valor do estêncil de um pixel será incrementado em 1 para cada objeto que toque o pixel. Se um valor de stencil de 255 for incrementado, ele será definido como 0.

decrementwrap

O valor do estêncil de um pixel será diminuído em 1 para cada objeto que toque o pixel. Se o valor do estêncil de 0 for diminuído, ele será definido como 255.

invert

O valor do estêncil de um pixel será invertido no bit para cada objeto que toque o pixel. Se um valor de estêncil de 0 for invertido, ele se tornará 255.

WrapMode

clamp

Pinça a imagem. Aparece somente uma.

repeat

Repete a imagem. Preenche todo extensão do espaço disponível.

mirroredrepeat

Repita a textura, folheando-a sempre que repete. Pode produzir melhores resultados visuais do que o modo de repetição quando a textura não é de forma transparente.

clampzero

Aperte a textura. Preenche a área fora da faixa normal da textura com preto transparente (ou preto opaco para texturas sem canal alfa).

Canvas

Uma tela é usada para renderização fora da tela. Pense nisso como uma tela invisível que você pode desenhar, mas isso não será visível até você desenhá-lo para a tela visível real. Também é conhecido como "render to texture".

Ao desenhar coisas que não mudam a posição com freqüência (como itens de plano de fundo) para o Canvas, e, em seguida, desenhando todo o Canvas em vez de cada item, você pode reduzir o número de operações de desenho executadas em cada quadro.

Em versões anteriores a 0,10.0, nem todas as placas gráficas que a LÖVE aceitas podem usar telas. love.graphics.isSupported ("canvas") pode ser usado para verificar o suporte em tempo de execução.

Constructors

love.graphics.newCanvas Cria um novo objeto Pintura para renderização fora da tela.

Functions

Canvas:getFormat Obtém o formato de textura da tela.

Canvas:getMSAA Obtém o número de amostras multisample antialiasing (MSAA) usadas ao desenhar para o Canvas.

Canvas:get/setFilter Define o filtro da tela.

Canvas:get/setWrap Define as propriedades de embrulho de uma tela.

Canvas:newImageData Gera ImageData do conteúdo da tela.

Canvas:renderTo Render para o Canvas usando uma função.

Canvas:getDimensions Obtém a largura e altura da tela.

Canvas:getWidth Obtém a largura da tela.

Canvas:getHeight Obtém o alto da tela.

Supertypes

Object A superclasse de todos os tipos do LÖVE.

Drawable Superclasse para tudo que pode ser desenhado na tela.

Texture Superclasse para objetos desenháveis ​​que representam uma textura.

Canvas:getDimensions

Obtém a largura e altura da tela.

width, height = Canvas:getDimensions()

Canvas:getFilter

Obtém o modo de filtro da tela.

min, mag, anisotropy = Canvas:getFilter()

Canvas:getFormat

Obtém o formato de textura da tela.

format = Canvas:getFormat()

Canvas:getHeight

Obtém o alto da tela.

height = Canvas:getHeight()

Canvas:getMSAA

Obtém o número de amostras multisample antialiasing (MSAA) usadas ao desenhar para o Canvas.

Isso pode ser diferente do número usado como argumento para love.graphics.newCanvas se o sistema que está executando LÖVE não suporta esse número.

samples = Canvas:getMSAA()

Canvas:getWidth

Obtém a largura da tela.

width = Canvas:getWidth()

Canvas:getWrap

Obtém as propriedades de embrulho de uma tela.

Esta função retorna os modos de envolvimento horizontal e vertical atualmente configurados para o Canvas.

horizontal, vertical = Canvas:getWrap()

Canvas:newImageData

Gera ImageData do conteúdo da tela.

data = Canvas:newImageData()

data = Canvas:newImageData( x, y, width, height )

Canvas:renderTo

Render para o Canvas usando uma função.

Canvas:renderTo( func )

Canvas:setFilter

Define o filtro da tela.

Canvas:setFilter( min, mag, anisotropy )

Canvas:setWrap

Define as propriedades de embrulho de uma tela.

Esta função define a forma como as bordas de um Canvas são tratadas se forem dimensionadas ou giradas. Se o WrapMode estiver configurado para "apertar", a borda não será interpolada. Se configurado para "repetir", a borda será interpolada com os pixels no lado oposto do framebuffer.

Canvas:setWrap( horizontal, vertical )

Font

Pode ser usado para desenhar texto na tela.

Constructors

love.graphics.newFont Cria uma nova Fonte.

love.graphics.newImageFont Cria uma nova Fonte carregando uma imagem no formato apropriado.

love.graphics.setNewFont Cria e configura uma nova Fonte.

Functions

Font:get/setFilter Define o modo de filtro para uma fonte.

Font:hasGlyphs Obtém se a fonte pode renderizar um caractere específico.

Font:setFallbacks Define as fontes de retorno.

Font:getWrap Obtém informações de formatação para texto, dado um limite de enrolamento.

Font:get/setLineHeight Configura a altura da linha.

Font:getWidth Obtém o tamanho horizontal que uma linha de texto precisa.

Font:getHeight Obtém a altura da Fonte.

Font:getBaseline Obtém a linha de base da Fonte.

Font:getAscent Obtém a subida da Fonte.

Font:getDescent Obtém a descida da Fonte.

Supertypes