love

audio

event

filesystem

graphics

image

joystick

keyboard

math

mouse

physics

sound

system

thread

timer

touch

video

window

love

Types

Callbacks

Functions

love.getVersion

Obtient la version actuelle de LÖVE.

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

majornumberLa version majeure de LÖVE, c'est-à-dire 0 pour la version 0.9.1.
minornumberLa version mineure de LÖVE, c'est-à-dire 9 pour la version 0.9.1.
revisionnumberLa version de révision de LÖVE, c'est-à-dire 1 pour la version 0.9.1.
codenamestringLe nom de code de la version actuelle, c'est-à-dire "Baby Inspector" pour la version 0.9.1.

love.conf

Si un fichier appelé conf.lua est présent dans votre dossier de jeu (ou .love), il est exécuté avant que les modules LÖVE ne soient chargés. Vous pouvez utiliser ce fichier pour écraser la fonction love.conf, qui est ensuite appelée par le script LÖVE boot '. En utilisant la fonction love.conf, vous pouvez définir certaines options de configuration, et modifier des choses comme la taille par défaut de la fenêtre, les modules chargés et autres.

love.conf( t )

ttableLa fonction love.conf prend un argument: une table remplie de toutes les valeurs par défaut que vous pouvez écraser à votre convenance. Si vous souhaitez modifier la taille de la fenêtre par défaut, par exemple, procédez comme suit: function love.conf (t)     t.window.width = 1024     t.window.height = 768 fin Si vous n'avez pas besoin du module physique ou du module joystick, procédez comme suit. function love.conf (t)     t.modules.joystick = false     t.modules.physics = false fin Définir des modules inutilisés à faux est encouragé lorsque vous libérez votre jeu. Il réduit légèrement le temps de démarrage (surtout si le module joystick est désactivé) et réduit l'utilisation de la mémoire (légèrement). Notez que vous ne pouvez pas désactiver love.filesystem; il est obligatoire. Il en va de même pour le module d'amour lui-même. love.graphics a besoin que love.window soit activé.
t.identity (nil)stringCe drapeau détermine le nom du répertoire de sauvegarde pour votre jeu. Notez que vous ne pouvez spécifier le nom, pas l'emplacement où il sera créé: t.identity = "gabe_HL3" - Correct t.identity = "c: / Users / gabe / HL3" - Incorrect Alternativement, love.filesystem.setIdentity peut être utilisé pour définir le répertoire de sauvegarde en dehors du fichier de configuration.
t.version ("0.10.2")stringt.version devrait être une chaîne, représentant la version de LÖVE pour laquelle votre jeu a été créé. Il devrait être formaté comme "X.Y.Z" où X est le numéro de version majeur, Y le mineur et Z le niveau de patch. Il permet à LÖVE d'afficher un avertissement s'il n'est pas compatible. Par défaut, la version de LÖVE est en cours d'exécution.
t.console (false)booleanDétermine si une console doit être ouverte à côté de la fenêtre du jeu (Windows uniquement) ou non. Remarque: Sur OSX, vous pouvez obtenir la sortie de la console en exécutant LÖVE à travers le terminal.
t.accelerometerjoystick (true)booleanDéfinit si l'accéléromètre du périphérique sur iOS et Android doit être exposé comme un joystick à 3 axes. La désactivation de l'accéléromètre lorsqu'il n'est pas utilisé peut réduire l'utilisation du processeur.
t.externalstorage (false)booleanDéfinit si les fichiers sont enregistrés dans un stockage externe (true) ou un stockage interne (false) sur Android.
t.gammacorrect (false)booleanDétermine si le rendu gamma-correct est activé, lorsque le système le prend en charge.
t.windowtableIl est possible de différer la création de la fenêtre jusqu'à ce que love.window.setMode soit d'abord appelé dans votre code. Pour ce faire, définissez t.window = nil in love.conf (ou t.screen = nil dans les anciennes versions.) Si cela se fait, LÖVE peut se bloquer si une fonction de love.graphics est appelée avant le premier amour. window.setMode dans votre code. La table t.window a été nommée t.screen dans les versions antérieures à 0.9.0. La table t.screen n'existe pas dans love.conf dans 0.9.0, et la table t.window n'existe pas dans love.conf en 0.8.0. Cela signifie que love.conf ne parviendra pas à exécuter (donc il retombera sur les valeurs par défaut) si l'on ne prend pas soin d'utiliser la table correcte pour la version LÖVE utilisée.
t.modulestableOptions du module.

love.directorydropped

La fonction de rappel déclenché lorsqu'un répertoire est traîné et déposé sur la fenêtre.

love.directorydropped( path )

pathstringLe chemin dépendant de la plate-forme complète vers le répertoire. Il peut être utilisé comme argument pour love.filesystem.mount, afin d'obtenir un accès en lecture au répertoire avec love.filesystem.

love.draw

Fonction de rappel utilisée pour dessiner sur l'écran de chaque image.

love.draw()

love.errhand

Le gestionnaire d'erreur, utilisé pour afficher les messages d'erreur.

love.errhand( msg )

msgstringLe message d'erreur.

love.filedropped

La fonction de rappel déclenché lorsqu'un fichier est traîné et déposé sur la fenêtre.

love.filedropped( file )

fileFileL'objet Fichier non ouvert représentant le fichier qui a été supprimé.

love.focus

Fonction de rappel déclenchée lorsque la fenêtre reçoit ou perd la mise au point.

love.focus( focus )

focusbooleanVrai si la fenêtre gagne en focus, est fausse si elle perd son focus.

love.gamepadaxis

Appelé lorsque l'axe du jeu virtuel d'un joystick est déplacé.

love.gamepadaxis( joystick, axis )

joystickJoystickL'objet joystick.
axisGamepadAxisL'axe du jeu virtuel.

love.gamepadpressed

Appelé lorsque le bouton du jeu virtuel d'un joystick est appuyé.

love.gamepadpressed( joystick, button )

joystickJoystickL'objet joystick.
buttonGamepadButtonLe bouton du gamepad virtuel.

love.gamepadreleased

Appelé lorsque le bouton du jeu virtuel d'un Joystick est diffusé.

love.gamepadreleased( joystick, button )

joystickJoystickL'objet joystick.
buttonGamepadButtonLe bouton du gamepad virtuel.

love.joystickadded

Appelé lorsqu'un Joystick est connecté.

Ce rappel est également déclenché après love.load pour chaque Joystick qui était déjà connecté lors du démarrage du jeu.

love.joystickadded( joystick )

joystickJoystickL'objet Joystick nouvellement connecté.

love.joystickaxis

Appelé lorsqu'un axe de joystick se déplace.

love.joystickaxis( joystick, axis, value )

joystickJoystickL'objet joystick.
axisnumberLe numéro d'axe.
valuenumberLa nouvelle valeur d'axe.

love.joystickhat

Appelé lorsque la direction d'un joystick change.

love.joystickhat( joystick, hat, direction )

joystickJoystickL'objet joystick.
hatnumberLe numéro du chapeau.
directionJoystickHatLa nouvelle direction du chapeau.

love.joystickpressed

Appelé lorsque vous appuyez sur un bouton de joystick.

love.joystickpressed( joystick, button )

joysticknumberLe numéro du joystick.
buttonnumberLe numéro du bouton.

love.joystickreleased

Appelé lorsqu'un bouton de joystick est relâché.

love.joystickreleased( joystick, button )

joysticknumberLe numéro du joystick.
buttonnumberLe numéro du bouton.

love.joystickremoved

Appelé lorsqu'un joystick est déconnecté.

love.joystickremoved( joystick )

joystickJoystickL'objet joystick maintenant déconnecté.

love.keypressed

La fonction de rappel déclenché lorsqu'une touche est enfoncée.

love.keypressed( key, scancode, isrepeat )

keyKeyConstantCaractère de la touche pressée.
scancodeScancodeLe scancode représentant la touche enfoncée.
isrepeatbooleanQue cet événement de pression de touche soit une répétition. Le délai entre les répétitions des touches dépend des paramètres système de l'utilisateur.

love.keyreleased

Fonction de rappel déclenchée lorsqu'une touche de clavier est relâchée.

love.keyreleased( key, scancode )

keyKeyConstantCaractère de la clé relâchée.
scancodeScancodeLe scancode représentant la clé relâchée.

love.load

Cette fonction s'appelle exactement une fois au début du jeu.

love.load( arg )

argtableArguments de ligne de commande donnés au jeu.

love.lowmemory

La fonction de rappel déclenché lorsque le système manque de mémoire sur les appareils mobiles.

 Les systèmes d'exploitation mobiles peuvent tuer le jeu en force s'il utilise trop de mémoire, de sorte que toute ressource non essentielle devrait être supprimée si possible (en définissant toutes les variables référant les ressources au néant et en appelant collectgarbage ()) lorsque cet événement est déclenché. Les sons et les images en particulier ont tendance à utiliser le plus de mémoire.

love.lowmemory()

love.mousefocus

La fonction de rappel déclenché lorsque la fenêtre reçoit ou perd la mise au point de la souris.

love.mousefocus( focus )

focusbooleanQue la fenêtre ait un focus sur la souris ou non.

love.mousemoved

Fonction de rappel déclenchée lorsque la souris est déplacée.

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

xnumberLa position de la souris sur l'axe des abscisses.
ynumberLa position de la souris sur l'axe des y.
dxnumberLa quantité a été déplacée le long de l'axe des abscisses depuis la dernière fois que l'amour a été appelé.
dynumberLa quantité a évolué le long de l'axe des y depuis la dernière fois que l'amour a été appelé.
istouchbooleanVrai si le bouton de la souris appuyait sur une touche à l'aide d'une touche tactile.

love.mousepressed

Fonction de rappel déclenchée lorsqu'un bouton de la souris est pressé.

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

xnumberPosition de la souris x, en pixels.
ynumberPosition de la souris y, en pixels.
buttonnumberL'index du bouton qui a été pressé. 1 est le bouton principal de la souris, 2 est le bouton secondaire de la souris et 3 est le bouton du milieu. D'autres boutons dépendent de la souris
isTouchbooleanVrai si le bouton de la souris appuyait sur une touche à l'aide d'une touche tactile.

love.mousereleased

La fonction de rappel déclenché lorsqu'un bouton de la souris est relâché.

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

xnumberPosition de la souris x, en pixels.
ynumberPosition de la souris y, en pixels.
buttonnumberL'index du bouton qui a été publié. 1 est le bouton principal de la souris, 2 est le bouton secondaire de la souris et 3 est le bouton du milieu. D'autres boutons dépendent de la souris.
isTouchbooleanVrai si le bouton de la souris appuyait à partir d'une version tactile touch-release.

love.quit

Fonction de rappel déclenchée lorsque le jeu est fermé.

r = love.quit()

rbooleanAnnuler l'abandon. Si c'est vrai, ne fermez pas le jeu.

love.resize

Appelé lorsque la fenêtre est redimensionnée, par exemple si l'utilisateur redimensionne la fenêtre ou si love.window.setMode est appelé avec une largeur ou une hauteur sans support en plein écran et la fenêtre choisit la taille la plus proche appropriée.

Les appels à love.window.setMode déclencheront uniquement cet événement si la largeur ou la hauteur de la fenêtre après l'appel ne correspond pas à la largeur et à la hauteur requises. Cela peut se produire si un mode en plein écran est demandé qui ne correspond à aucun mode pris en charge, ou si le type d'écran complet est «ordinateur de bureau» et la largeur ou la hauteur requises ne correspondent pas à la résolution du bureau.

love.resize( w, h )

wnumberLa nouvelle largeur.
hnumberLa nouvelle hauteur.

love.run

La fonction principale, contenant la boucle principale. Un défaut raisonnable est utilisé lorsqu'il est laissé de côté.

love.run()

love.textedited

Appelé lorsque le texte candidat pour un IME (Input Method Editor) a changé.

Le texte candidat n'est pas le texte final que l'utilisateur choisira éventuellement. Utilisez love.textinput pour cela.

love.textedited( text, start, length )

textstringLe texte candidat codé Unicode UTF-8.
startnumberLe curseur de début du texte candidat sélectionné.
lengthnumberLa longueur du texte candidat sélectionné. Peut être 0.

love.textinput

Appelé lorsque le texte a été saisi par l'utilisateur. Par exemple, si shift-2 est pressé sur une disposition de clavier américaine, le texte "@" sera généré.

love.textinput( text )

textstringLe texte Unicode codé UTF-8.

love.threaderror

La fonction de rappel déclenché lorsqu'un thread rencontre une erreur.

love.threaderror( thread, errorstr )

threadThreadLe thread qui a produit l'erreur.
errorstrstringLe message d'erreur.

love.touchmoved

La fonction de rappel déclenchée lorsqu'une touche appuie se déplace dans l'écran tactile.

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

idlight userdataL'identifiant de la presse tactile.
xnumberLa position de l'axe des x du contact à l'intérieur de la fenêtre, en pixels.
ynumberLa position de l'axe y du contact à l'intérieur de la fenêtre, en pixels.
dxnumberLe mouvement de l'axe des x du contact à l'intérieur de la fenêtre, en pixels.
dynumberLe mouvement de l'axe y du contact à l'intérieur de la fenêtre, en pixels.
pressurenumberLa quantité de pression appliquée. La plupart des écrans tactiles ne sont pas sensibles à la pression, auquel cas la pression sera de 1.

love.touchpressed

Fonction de rappel déclenchée lorsque l'écran tactile est touché.

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

idlight userdataL'identifiant de la presse tactile.
xnumberLa position de l'axe des x de la touche tactile à l'intérieur de la fenêtre, en pixels.
ynumberLa position de l'axe des y appuie dans la fenêtre, en pixels.
dxnumberLe mouvement de l'axe des x de la pression tactile à l'intérieur de la fenêtre, en pixels. Cela devrait toujours être nul.
dynumberLe mouvement de l'axe des y appuie dans la fenêtre, en pixels. Cela devrait toujours être nul.
pressurenumberLa quantité de pression appliquée. La plupart des écrans tactiles ne sont pas sensibles à la pression, auquel cas la pression sera de 1.

love.touchreleased

Fonction de rappel déclenchée lorsque l'écran tactile cesse d'être touché.

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

idlight userdataL'identifiant de la presse tactile.
xnumberLa position de l'axe des x du contact à l'intérieur de la fenêtre, en pixels.
ynumberLa position de l'axe y du contact à l'intérieur de la fenêtre, en pixels.
dxnumberLe mouvement de l'axe des x du contact à l'intérieur de la fenêtre, en pixels.
dynumberLe mouvement de l'axe y du contact à l'intérieur de la fenêtre, en pixels.
pressurenumberLa quantité de pression appliquée. La plupart des écrans tactiles ne sont pas sensibles à la pression, auquel cas la pression sera de 1.

love.update

Fonction de rappel utilisée pour mettre à jour l'état du jeu de chaque image.

love.update( dt )

dtnumberTemps écoulé depuis la dernière mise à jour en quelques secondes.

love.visible

Fonction de rappel déclenchée lorsque la fenêtre est minimisée / cachée ou non modifiée par l'utilisateur.

love.visible( visible )

visiblebooleanVrai si la fenêtre est visible, fausse si ce n'est pas le cas.

love.wheelmoved

Fonction de rappel déclenchée lorsque la molette de la souris est déplacée.

love.wheelmoved( x, y )

xnumberMontant du mouvement horizontal de la roue de la souris. Les valeurs positives indiquent un mouvement vers la droite.
ynumberMontant du mouvement vertical de la roue de la souris. Les valeurs positives indiquent un mouvement ascendant.

Data

La superclasse de toutes les données.

Functions

Supertypes

Subtypes

Data:getPointer

Obtient un pointeur vers les Données.

pointer = Data:getPointer()

pointerlight userdataUn pointeur brut vers les données.

Data:getSize

Obtient la taille des données.

size = Data:getSize()

sizenumberLa taille des données en octets.

Data:getString

Obtient les données complètes en tant que chaîne.

data = Data:getString()

datastringLes données brutes.

Drawable

Superclasse pour toutes les choses qui peuvent être dessinées à l'écran. Il s'agit d'un type abstrait qui ne peut pas être créé directement.

Supertypes

Subtypes

Object

La superclasse de tous les types LÖVE.

Functions

Subtypes

Object:type

Obtient le type de l'objet en tant que chaîne.

type = Object:type()

typestringLe type en tant que chaîne.

Object:typeOf

Accute si un objet est d'un certain type. Si l'objet a le type avec le nom spécifié dans sa hiérarchie, cette fonction renverra true.

b = Object:typeOf( name )

bbooleanVrai si l'objet est du type spécifié, false sinon.
namestringLe nom du type à vérifier.

love.audio

Types

Functions

Enums

love.audio.getDistanceModel

Obtient le modèle d'atténuation de la distance.

model = love.audio.getDistanceModel()

modelDistanceModelLe modèle de distance actuel. La valeur par défaut est 'inverseclamped'.

love.audio.getDopplerScale

Obtient le facteur d'échelle global actuel pour les effets Doppler basés sur la vitesse.

scale = love.audio.getDopplerScale()

scalenumberLe facteur d'échelle doppler actuel.

love.audio.getSourceCount

Obtient le nombre de sources en cours de lecture ou de pause.

numSources = love.audio.getSourceCount()

numSourcesnumberLe nombre de sources en cours de lecture ou de pause.

love.audio.getOrientation

Obtient l'orientation de l'auditeur.

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

fxnumberLe composant X du vecteur avant de l'orientation de l'auditeur.
fynumberLe composant Y du vecteur avant de l'orientation de l'auditeur.
fznumberLe composant Z du vecteur avant de l'orientation de l'auditeur.
uxnumberLe composant X du vecteur up de l'orientation de l'auditeur.
uynumberLe composant Y du vecteur up de l'orientation de l'auditeur.
uznumberLe composant Z du vecteur up de l'orientation de l'auditeur.

love.audio.getPosition

Obtient la position de l'auditeur.

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

xnumberLa position X de l'auditeur.
ynumberLa position Y de l'auditeur.
znumberLa position Z de l'auditeur.

love.audio.getVelocity

Obtient la vitesse de l'auditeur.

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

xnumberLa vitesse X de l'auditeur.
ynumberLa vitesse Y de l'auditeur.
znumberLa vitesse Z de l'auditeur.

love.audio.getVolume

Obtient le volume principal.

volume = love.audio.getVolume()

volumenumberLe volume principal actuel.

love.audio.newSource

Crée une nouvelle source à partir d'un fichier ou de SoundData. Les sources créées à partir de SoundData sont toujours statiques.

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

sourceSourceUne nouvelle source qui peut lire l'audio spécifié.
filestring / FileLe chemin d'accès / Fichier pour créer une source à partir de.
type ("stream")SourceTypeStreaming ou source statique.

source = love.audio.newSource( soundData )

sourceSourceUne nouvelle source qui peut lire l'audio spécifié. Le type source de l'audio retourné est "statique".
soundDataSoundData / FileDataThe SoundData / FileData pour créer une source à partir de.

love.audio.pause

Les pauses jouent actuellement aux Sources.

love.audio.pause()

This function will pause all currently active Sources.

love.audio.pause( source )

This function will only pause the specified Source.

sourceSourceLa source pour interrompre la lecture.

love.audio.play

Lit la source spécifiée.

love.audio.play( source )

sourceSourceLa source à jouer.

love.audio.resume

Rédige tout audio

love.audio.resume()

love.audio.resume( source )

sourceSourceLa source pour reprendre la lecture.

love.audio.rewind

Rembobine tous les écoutes audio.

love.audio.rewind()

love.audio.rewind( source )

sourceSourceLa source à rebobiner.

love.audio.setDistanceModel

Définit le modèle d'atténuation de la distance.

love.audio.setDistanceModel( model )

modelDistanceModelLe nouveau modèle de distance.

love.audio.setDopplerScale

Définit un facteur d'échelle global pour les effets Doppler basés sur la vitesse. La valeur d'échelle par défaut est 1.

love.audio.setDopplerScale( scale )

scalenumberLe nouveau facteur d'échelle Doppler. L'échelle doit être supérieure à 0.

love.audio.setOrientation

Définit l'orientation de l'auditeur.

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

fxnumberLe composant X du vecteur avant de l'orientation de l'auditeur.
fynumberLe composant Y du vecteur avant de l'orientation de l'auditeur.
fznumberLe composant Z du vecteur avant de l'orientation de l'auditeur.
uxnumberLe composant X du vecteur up de l'orientation de l'auditeur.
uynumberLe composant Y du vecteur up de l'orientation de l'auditeur.
uznumberLe composant Z du vecteur up de l'orientation de l'auditeur.

love.audio.setPosition

Définit la position de l'auditeur, ce qui détermine la manière dont les sons fonctionnent.

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

xnumberLa position X de l'auditeur.
ynumberLa position Y de l'auditeur.
znumberLa position Z de l'auditeur.

love.audio.setVelocity

Définit la vitesse de l'auditeur.

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

xnumberLa vitesse X de l'auditeur.
ynumberLa vitesse Y de l'auditeur.
znumberLa vitesse Z de l'auditeur.

love.audio.setVolume

Définit le volume principal.

love.audio.setVolume( volume )

volumenumber1.0f est max. Et 0.0f est désactivé.

love.audio.stop

Arrête les sources actuellement jouées.

love.audio.stop()

This function will stop all currently active sources.

love.audio.stop( source )

This function will only stop the specified source.

sourceSourceLa source pour arrêter la lecture.

DistanceModel

none

Les sources ne sont pas atténuées.

inverse

Atténuation de distance inversée.

inverseclamped

Atténuation de distance inversée. Le gain est serré. Dans la version 0.9.2 et plus ancienne, cela s'appelle serré inverse.

linear

Atténuation linéaire.

linearclamped

Atténuation linéaire. Le gain est serré. Dans la version 0.9.2 et plus ancienne, cela s'appelle serré linéaire.

exponent

Atténuation exponentielle.

exponentclamped

Atténuation exponentielle. Le gain est serré. Dans la version 0.9.2 et plus ancienne, cela s'appelle expoire serré.

SourceType

static

Décodez tout le son à la fois.

stream

Transmettre le son; décodez-le progressivement.

TimeUnit

seconds

Secondes régulières

samples

Échantillons audio.

Source

Une source représente l'audio que vous pouvez lire. Vous pouvez faire des choses intéressantes avec Sources, comme définir le volume, le pitch et sa position par rapport à l'auditeur.

Constructors

Functions

Supertypes

Source:clone

Crée une copie identique de la source à l'état arrêté.

Les sources statiques utilisent beaucoup moins de mémoire et prennent beaucoup moins de temps pour être créées si Source: clone est utilisé pour les créer au lieu de love.audio.newSource, donc cette méthode devrait être préférée lors de la création de plusieurs Sources qui jouent le même son.

Les sources clonées héritent de l'état stable de la source d'origine, mais elles sont initialisées.

source = Source:clone()

sourceSourceLa nouvelle copie identique de cette Source.

Source:getAttenuationDistances

Obtient la référence et la distance maximale de la source.

ref, max = Source:getAttenuationDistances()

refnumberLa distance de référence.
maxnumberLa distance maximale.

Source:getChannels

Obtient le nombre de canaux dans la Source. Seules les sources 1 canal (mono) peuvent utiliser des effets directionnels et positionnels.

channels = Source:getChannels()

channelsnumber1 pour mono, 2 pour stéréo.

Source:getCone

Obtient les cones de volume directionnel de la Source. Ensemble avec Source: setDirection, les angles coniques permettent que le volume de la Source varie selon sa direction.

innerAngle, outerAngle, outerVolume = Source:getCone()

innerAnglenumberAngle intérieur de la direction de la Source, en radians. La Source jouera au volume normal si l'auditeur se trouve dans le cône défini par cet angle.
outerAnglenumberL'angle extérieur par rapport à la direction de la Source, en radians. La Source joue à un volume entre les volumes normal et externe, si l'auditeur est entre les cônes définis par les angles intérieur et extérieur.
outerVolumenumberLe volume de la source lorsque l'auditeur est à l'extérieur des angles de cône interne et externe.

Source:getDirection

Obtient la direction de la Source.

x, y, z = Source:getDirection()

xnumberLa partie X du vecteur de direction.
ynumberLa partie Y du vecteur de direction.
znumberLa partie Z du vecteur de direction.

Source:getDuration

Obtient la durée de la Source. Pour les sources en continu, il peut ne pas toujours être précis, et peut revenir -1 si la durée ne peut être déterminée du tout.

duration = Source:getDuration( unit )

durationnumberLa durée de la Source, ou -1 si elle ne peut être déterminée.
unit ("seconds")TimeUnitL'unité de temps pour la valeur de retour.

Source:getPitch

Obtient le pitch actuel de la Source.

pitch = Source:getPitch()

pitchnumberLe pitch, où 1.0 est normal.

Source:getPosition

Obtient la position de la Source.

x, y, z = Source:getPosition()

xnumberLa position X de la Source.
ynumberLa position Y de la Source.
znumberLa position Z de la Source.

Source:getRolloff

Obtient le facteur de retournement de la source.

rolloff = Source:getRolloff()

rolloffnumberLe facteur de retournement.

Source:getType

Obtient le type (statique ou flux) de la Source.

sourcetype = Source:getType()

sourcetypeSourceTypeLe type de source.

Source:getVelocity

Obtient la vitesse de la Source.

x, y, z = Source:getVelocity()

xnumberLa partie X du vecteur vitesse.
ynumberLa partie Y du vecteur vitesse.
znumberLa partie Z du vecteur vitesse.

Source:getVolume

Obtient le volume actuel de la Source.

volume = Source:getVolume()

volumenumberLe volume de la source, dont 1.0 est le volume normal.

Source:getVolumeLimits

Obtient les limites de volume de la source.

min, max = Source:getVolumeLimits()

minnumberLe volume minimum.
maxnumberLe volume maximum.

Source:isLooping

Détermine si la source sera en boucle.

loop = Source:isLooping()

loopbooleanVrai si la source est en boucle, false sinon.

Source:isPaused

Obtient si la Source est en pause.

paused = Source:isPaused()

pausedbooleanVrai si la Source est en pause, false sinon.

Source:isPlaying

Obtient si la source est en cours de lecture.

playing = Source:isPlaying()

playingbooleanVrai si la source est en cours de lecture, false sinon.

Source:isStopped

Détermine si la source est arrêtée.

stopped = Source:isStopped()

stoppedbooleanVrai si la source est arrêtée, false sinon.

Source:pause

Pause la source.

Source:pause()

Source:play

Démarre la lecture de la Source.

success = Source:play()

successbooleanVrai si la Source a commencé à jouer avec succès, false sinon.

Source:resume

Reprend une source en pause.

Source:resume()

Source:rewind

Rembobine une source.

Source:rewind()

Source:seek

Définit la position de jeu de la Source.

Source:seek( position, unit )

positionnumberLe poste pour chercher à
unit ("seconds")TimeUnitL'unité de la valeur de position.

Source:setDirection

Définit le vecteur de direction de la Source. Un vecteur zéro rend la source non directionnelle.

Source:setDirection( x, y, z )

xnumberLa partie X du vecteur de direction.
ynumberLa partie Y du vecteur de direction.
znumberLa partie Z du vecteur de direction.

Source:setAttenuationDistances

Définit la référence et la distance maximale de la source.

Source:setAttenuationDistances( ref, max )

refnumberLa nouvelle distance de référence.
maxnumberLa nouvelle distance maximale.

Source:setCone

Définit les cônes de volume directionnels de la Source. Ensemble avec Source: setDirection, les angles coniques permettent que le volume de la Source varie selon sa direction.

Source:setCone( innerAngle, outerAngle, outerVolume )

innerAnglenumberAngle intérieur de la direction de la Source, en radians. La Source jouera au volume normal si l'auditeur se trouve dans le cône défini par cet angle.
outerAnglenumberL'angle extérieur par rapport à la direction de la Source, en radians. La Source joue à un volume entre les volumes normal et externe, si l'auditeur est entre les cônes définis par les angles intérieur et extérieur.
outerVolume (0)numberLe volume de la source lorsque l'auditeur est à l'extérieur des angles de cône interne et externe.

Source:setLooping

Définit si la source doit se boucler.

Source:setLooping( loop )

loopbooleanVrai si la source devrait boucler, false sinon.

Source:setPitch

Définit le pitch de la Source.

Source:setPitch( pitch )

pitchnumberCalculé en ce qui concerne 1 étant le pas de base. Chaque réduction de 50 pour cent est égale à un décalage de hauteur de -12 demi-tons (une réduction d'une octave). Chaque doublement équivaut à un décalage de hauteur de 12 demi-tons (augmentation d'une octave). Zero n'est pas une valeur légale.

Source:setPosition

Définit la position de la Source.

Source:setPosition( x, y, z )

xnumberLa position X de la Source.
ynumberLa position Y de la Source.
znumberLa position Z de la Source.

Source:setRolloff

Définit le facteur de retournement qui affecte la résistance de l'atténuation de distance utilisée.

Vous trouverez des informations étendues et des formules détaillées dans le chapitre "3.4 Atténuation par distance" de la spécification OpenAL 1.1.

Source:setRolloff( rolloff )

rolloffnumberLe nouveau facteur de retournement.

Source:setVelocity

Définit la vitesse de la Source.

Cela ne change pas la position de la source, mais est utilisé pour calculer l'effet doppler.

Source:setVelocity( x, y, z )

xnumberLa partie X du vecteur vitesse.
ynumberLa partie Y du vecteur vitesse.
znumberLa partie Z du vecteur vitesse.

Source:setVolume

Définit le volume de la Source.

Source:setVolume( volume )

volumenumberLe volume de la source, dont 1.0 est le volume normal.

Source:setVolumeLimits

Définit les limites de volume de la source. Les limites doivent être de 0 à 1.

Source:setVolumeLimits( min, max )

minnumberLe volume minimum.
maxnumberLe volume maximum.

Source:stop

Arrête une source.

Source:stop()

Source:tell

Obtient la position actuelle de la Source.

position = Source:tell( unit )

positionnumberLa position actuelle de la Source.
unit ("seconds")TimeUnitLe type d'unité pour la valeur de retour.

love.event

Functions

Enums

love.event.clear

Efface la file d'attente des événements.

love.event.clear()

love.event.poll

Obtient un itérateur pour les messages dans la file d'attente des événements.

i = love.event.poll()

ifunctionFonction itérative utilisable dans une boucle for.

love.event.pump

Pomper les événements dans la file d'attente des événements. Il s'agit d'une fonction de bas niveau, et n'est généralement pas appelée par l'utilisateur, mais par love.run. Notez qu'il faut appeler un système d'exploitation pour penser que vous exécutez toujours, et si vous souhaitez gérer les événements générés par le système d'exploitation (pensez à des rappels). love.event.pump ne peut être appelé à partir du thread principal, mais ensuite, le reste de love.event peut être utilisé à partir de n'importe quel autre thread.

love.event.pump()

love.event.push

Ajoute un événement à la file d'attente des événements.

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

eEventLe nom de l'événement.
a (nil)VariantPremier argument d'événement.
b (nil)VariantDeuxième argument d'événement.
c (nil)VariantTroisième argument d'événement.
d (nil)VariantQuatrième argument de l'événement.

love.event.quit

Ajoute l'événement quit à la file d'attente.

L'événement quit est un signal pour le gestionnaire d'événements pour fermer LÖVE. Il est possible d'interrompre le processus de sortie avec le rappel d'amour.

love.event.quit()

love.event.quit( exitstatus )

exitstatus (0)numberL'état de sortie du programme à utiliser lors de la fermeture de l'application.

love.event.quit( "restart" )

"restart"stringRedémarre le jeu sans relancer l'exécutable. Cela supprime proprement l'instance principale de l'état de Lua et crée une toute nouvelle.

love.event.wait

Comme love.event.poll mais bloque jusqu'à ce qu'il y ait un événement dans la file d'attente.

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

eEventLe type d'événement.
aVariantPremier argument d'événement.
bVariantDeuxième argument d'événement.
cVariantTroisième argument d'événement.
dVariantQuatrième argument de l'événement.

Event

focus

Mise au point de la fenêtre gagnée ou perdue

joystickaxis

Mouvement d'axe de joystick

joystickhat

Casque de joystick pressé

joystickpressed

Joystick pressé

joystickreleased

Joystick sorti

keypressed

Touche pressée

keyreleased

Clé libérée

mousefocus

Mise au point de la souris activée ou perdue

mousepressed

Souris pressée

mousereleased

Souris libérée

resize

Taille de fenêtre modifiée par l'utilisateur

threaderror

Une erreur Lua s'est produite dans un thread.

quit

Quitter

visible

La fenêtre est minimisée ou non minimisée par l'utilisateur

love.filesystem

Types

Functions

Enums

love.filesystem.append

Ajouter des données à un fichier existant.

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

successbooleanVrai si l'opération a réussi, ou néant s'il y avait une erreur.
errormsgstringLe message d'erreur en cas d'échec.
namestringLe nom (et le chemin d'accès) du fichier.
datastringLes données qui doivent être écrites dans le fichier
size (all)numberCombien d'octets à écrire.

love.filesystem.areSymlinksEnabled

Obtient si love.filesystem suit les liens symboliques.

enable = love.filesystem.areSymlinksEnabled()

enablebooleanSi love.filesystem suit les liens symboliques.

love.filesystem.createDirectory

Crée un répertoire.

success = love.filesystem.createDirectory( name )

successbooleanVrai si le répertoire a été créé, faux sinon.
namestringLe répertoire à créer.

love.filesystem.exists

Vérifiez si un fichier ou un répertoire existe.

exists = love.filesystem.exists( filename )

existsbooleanVrai s'il existe un fichier ou un répertoire avec le nom spécifié. Faux sinon.
filenamestringLe chemin d'accès à un fichier ou un répertoire potentiel.

love.filesystem.getAppdataDirectory

Obtient le répertoire des données de l'application (pourrait être identique à getUserDirectory)

path = love.filesystem.getAppdataDirectory()

pathstringLe chemin du répertoire des données de l'application.

love.filesystem.getDirectoryItems

Obtient une table avec les noms des fichiers et des sous-répertoires dans le chemin spécifié. La table n'est pas classée de quelque manière que ce soit; l'ordre est indéfini.

Si le chemin passé à la fonction existe dans le jeu et le répertoire de sauvegarde, il répertorie les fichiers et les répertoires des deux endroits.

items = love.filesystem.getDirectoryItems( dir )

itemstableUne séquence avec les noms de tous les fichiers et sous-répertoires en tant que chaînes.
dirstringLe répertoire.

love.filesystem.getIdentity

Obtient le nom du répertoire d'écriture pour votre jeu. Notez que cela ne renvoie que le nom du dossier pour stocker vos fichiers, et non l'emplacement complet.

love.filesystem.getIdentity( name )

namestringL'identité utilisée comme répertoire d'écriture.

love.filesystem.getLastModified

Obtient le dernier moment de modification d'un fichier.

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

modtimenumberLe dernier temps de modification en secondes depuis l'époque unix ou nul sur une panne.
errormsgstringLe message d'erreur en cas d'échec.
filenamestringLe chemin d'accès et le nom d'un fichier.

love.filesystem.getRealDirectory

Obtient le chemin absolu spécifique à la plate-forme du répertoire contenant un chemin de fichier.

Cela peut être utilisé pour déterminer si un fichier se trouve dans le répertoire d'enregistrement ou la source du jeu .love.

realdir = love.filesystem.getRealDirectory( filepath )

realdirstringLe chemin complet spécifique à la plate-forme du répertoire contenant le chemin de fichier.
filepathstringLe chemin du fichier pour obtenir le répertoire de.

love.filesystem.getRequirePath

Obtient les chemins du système de fichiers qui seront recherchés lorsque requis est appelé.

La chaîne de chemins renvoyée par cette fonction est une séquence de modèles de chemins séparés par des points-virgules. L'argument passé à exiger sera inséré à la place d'un caractère d'interrogation ("?") Dans chaque modèle (après que les caractères de point dans l'argument passé à exiger sont remplacés par des séparateurs de répertoires).

Les chemins sont relatifs à la source du jeu et les annuaires de sauvegarde, ainsi que tous les chemins montés avec love.filesystem.mount.

paths = love.filesystem.getRequirePath()

pathsstringLes chemins que la fonction requiert vérifiera dans le système de fichiers de l'amour.

love.filesystem.getSaveDirectory

Obtient le chemin d'accès complet au répertoire de sauvegarde désigné. Cela peut être utile si vous souhaitez utiliser la bibliothèque io standard (ou autre chose) pour lire ou écrire dans le répertoire de sauvegarde.

path = love.filesystem.getSaveDirectory()

pathstringLe chemin absolu vers le répertoire de sauvegarde.

love.filesystem.getSize

Obtient la taille en octets d'un fichier.

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

sizenumberTaille en octets du fichier, ou néant en cas d'échec.
errormsgstringLe message d'erreur en cas d'échec.
filenamestringLe chemin d'accès et le nom d'un fichier.

love.filesystem.getSource

Obtient le chemin d'accès complet au fichier ou au répertoire .love. Si le jeu est fusionné à l'exécutable LÖVE, l'exécutable est renvoyé.

path = love.filesystem.getSource()

pathstringLe chemin complet dépendant de la plate-forme du fichier ou dossier .love.

love.filesystem.getSourceBaseDirectory

Obtient le chemin d'accès complet au répertoire contenant le fichier .love. Si le jeu est fusionné à l'exécutable LÖVE, le répertoire contenant l'exécutable est renvoyé.

Si love.filesystem.isFused est vrai, le chemin retourné par cette fonction peut être transmis à love.filesystem.mount, ce qui rendra le répertoire contenant le jeu principal lisible par love.filesystem.

path = love.filesystem.getSourceBaseDirectory()

pathstringLe chemin complet dépendant de la plate-forme du répertoire contenant le fichier .love.

love.filesystem.getUserDirectory

Obtient le chemin d'accès du répertoire de l'utilisateur.

path = love.filesystem.getUserDirectory()

pathstringLe chemin d'accès du répertoire de l'utilisateur.

love.filesystem.getWorkingDirectory

Obtient le répertoire de travail actuel.

path = love.filesystem.getWorkingDirectory()

pathstringLe répertoire de travail actuel.

love.filesystem.init

Initialise love.filesystem, sera appelé en interne, donc ne doit pas être utilisé explicitement.

love.filesystem.init( appname )

appnamestringLe nom de l'application binaire, généralement l'amour.

love.filesystem.isDirectory

Vérifiez si quelque chose est un répertoire.

isDir = love.filesystem.isDirectory( path )

isDirbooleanVrai s'il existe un répertoire avec le nom spécifié. Faux sinon.
pathstringLe chemin d'accès à un répertoire potentiel.

love.filesystem.isFile

Vérifiez si quelque chose est un fichier.

isFile = love.filesystem.isFile( path )

isFilebooleanVrai s'il existe un fichier avec le nom spécifié. Faux sinon.
pathstringLe chemin d'accès à un fichier potentiel.

love.filesystem.isFused

Détermine si le jeu est en mode fusionné ou non.

Si un jeu est en mode fusionné, son répertoire de sauvegarde sera directement dans le répertoire Appdata au lieu d'Appdata / LOVE /. Le jeu pourra également charger des bibliothèques dynamiques C Lua situées dans le répertoire de sauvegarde.

Un jeu est en mode fusionné si la source .love a été fusionnée à l'exécutable (voir Game Distribution) ou si "-fused" a été donné comme argument de ligne de commande lors du démarrage du jeu.

fused = love.filesystem.isFused()

fusedbooleanVrai si le jeu est en mode fusionné, faux sinon.

love.filesystem.isSymlink

Obtient si un chemin de fichier est en fait un lien symbolique.

Si les liens symboliques ne sont pas activés (via love.filesystem.setSymlinksEnabled), cette fonction renverra toujours false.

symlink = love.filesystem.isSymlink( path )

symlinkbooleanVrai si le chemin est un lien symbolique, false sinon.
pathstringLe chemin du fichier ou du répertoire à vérifier.

love.filesystem.lines

Iterate sur les lignes dans un fichier.

iterator = love.filesystem.lines( name )

iteratorfunctionUne fonction qui itère sur toutes les lignes du fichier.
namestringLe nom (et le chemin d'accès) du fichier.

love.filesystem.load

Charge un fichier Lua (mais ne l'exécute pas).

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

chunkfunctionLe morceau chargé.
namestringLe nom (et le chemin d'accès) du fichier.
errormsg (nil)stringLe message d'erreur si le fichier n'a pas pu être ouvert.

love.filesystem.mount

Montre un fichier zip ou un dossier dans le répertoire de sauvegarde du jeu pour la lecture.

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

successbooleanVrai si l'archive a été montée avec succès, false sinon.
archivestringLe dossier ou le fichier zip dans le répertoire de sauvegarde du jeu à monter.
mountpointstringLe nouveau chemin vers lequel l'archive sera installée.
appendToPath (false)stringQue l'archive soit recherchée lors de la lecture d'un chemin de fichier avant ou après les archives déjà montées. Cela inclut les sources et les annuaires de sauvegarde du jeu.

love.filesystem.newFile

Crée un nouvel objet Fichier. Il doit être ouvert avant d'être consulté.

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

fileFileLe nouvel objet File, ou nil si une erreur s'est produite.
errorstrstringLa chaîne d'erreur si une erreur s'est produite.
filenamestringLe nom du fichier à lire.
mode ("c")FileModeLe mode pour ouvrir le fichier dans.

love.filesystem.newFileData

Crée un nouvel objet FileData.

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

dataFileDataVotre nouveau fichierData.
contentsstringLe contenu du fichier.
namestringLe nom du fichier.
decoder ("file")FileDecoderLa méthode à utiliser lors du décodage du contenu.

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

Creates a new FileData from a file on the storage device.

dataFileDataLe nouveau FileData, ou nil si une erreur s'est produite.
errstringLa chaîne d'erreur, si une erreur s'est produite.
filepathstringChemin d'accès au fichier.

love.filesystem.read

Lisez le contenu d'un fichier.

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

contentsstringContenu du fichier.
sizenumberCombien d'octets ont été lus.
namestringLe nom (et le chemin d'accès) du fichier.
bytes (all)numberCombien d'octets à lire.

love.filesystem.remove

Supprime un fichier ou un répertoire.

success = love.filesystem.remove( name )

successbooleanVrai si le fichier / répertoire a été supprimé, false sinon.
namestringLe fichier ou le répertoire à supprimer.

love.filesystem.setIdentity

Définit le répertoire d'écriture pour votre jeu. Notez que vous ne pouvez définir que le nom du dossier pour stocker vos fichiers, pas l'emplacement.

love.filesystem.setIdentity( name, appendToPath )

namestringLa nouvelle identité qui sera utilisée comme répertoire d'écriture.
appendToPath (false)booleanQue le répertoire d'identité soit recherché lors de la lecture d'un chemin de fichier avant ou après le répertoire source du jeu et les archives actuellement montées.

love.filesystem.setRequirePath

Définit les chemins du système de fichiers qui seront recherchés lorsque l'appel est appelé.

La chaîne de chemins donnée à cette fonction est une séquence de modèles de chemins séparés par des points-virgules. L'argument passé à exiger sera inséré à la place d'un caractère d'interrogation ("?") Dans chaque modèle (après que les caractères de point dans l'argument passé à exiger sont remplacés par des séparateurs de répertoires).

Les chemins sont relatifs à la source du jeu et les annuaires de sauvegarde, ainsi que tous les chemins montés avec love.filesystem.mount.

love.filesystem.setRequirePath( paths )

pathsstringLes chemins que la fonction requiert vérifiera dans le système de fichiers de l'amour.

love.filesystem.setSource

Définit la source du jeu, où le code est présent. Cette fonction ne peut être appelée qu'une seule fois, et est normalement effectuée automatiquement par LÖVE.

love.filesystem.setSource( path )

pathstringChemin absolu du dossier source du jeu.

love.filesystem.setSymlinksEnabled

Définit si love.filesystem suit les liens symboliques. Il est activé par défaut dans la version 0.10.0 et plus récente, et est désactivé par défaut dans 0.9.2.

love.filesystem.setSymlinksEnabled( enable )

enablebooleanLe système love.files devrait-il suivre des liens symboliques.

love.filesystem.unmount

Dépose un fichier zip ou un dossier précédemment monté pour la lecture avec love.filesystem.mount.

success = love.filesystem.unmount( archive )

successbooleanVrai si l'archive a été démontée avec succès, false sinon.
archivestringLe dossier ou le fichier zip dans le répertoire de sauvegarde du jeu qui est actuellement monté.

love.filesystem.write

Écrivez des données dans un fichier.

Si vous obtenez le message d'erreur «Impossible de définir le répertoire d'écriture», essayez de définir le répertoire de sauvegarde. Cela se fait soit avec love.filesystem.setIdentity ou en définissant le champ d'identité dans love.conf.

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

successbooleanSi l'opération a réussi.
messagestringMessage d'erreur si l'opération a échoué.
namestringLe nom (et le chemin d'accès) du fichier.
datastringLes données de chaîne à écrire dans le fichier.
size (all)numberCombien d'octets à écrire.

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

successbooleanSi l'opération a réussi.
messagestringMessage d'erreur si l'opération a échoué.
namestringLe nom (et le chemin d'accès) du fichier.
dataDataObjet de données à écrire dans le fichier.
size (all)numberCombien d'octets à écrire.

BufferMode

none

Pas de mise en mémoire tampon. Le résultat des opérations d'écriture et d'ajout apparaît immédiatement.

line

Tampon de ligne. Les opérations d'écriture et d'ajout sont mises en mémoire tampon jusqu'à ce qu'une nouvelle ligne soit sortie ou que la limite de la taille du tampon soit atteinte.

full

Tamponnement complet. Les opérations d'écriture et d'ajout sont toujours sauvegardées jusqu'à ce que la limite de la taille du tampon soit atteinte.

FileDecoder

file

Les données sont non codées.

base64

Les données sont codées en base64.

FileMode

r

Ouvrez un fichier pour lire.

w

Ouvrez un fichier pour l'écriture.

a

Ouvrez un fichier pour ajouter.

c

N'ouvrez pas un fichier (représente un fichier fermé).

File

Représente un fichier sur le système de fichiers.

Constructors

Functions

Supertypes

File:close

Ferme un fichier.

success = File:close()

successbooleanLa fermeture a-t-elle réussi.

File:flush

Rince toutes les données écrites tamponnées dans le fichier sur le disque.

success, err = File:flush()

successbooleanQue le fichier ait réussi à rincer les données tamponnées sur le disque.
errstringLa chaîne d'erreur, si une erreur s'est produite et que le fichier n'a pas pu être rincé.

File:getBuffer

Obtient le mode tampon d'un fichier.

mode, size = File:getBuffer()

modeBufferModeLe mode de mémoire tampon actuel du fichier.
sizenumberLa taille maximale en octets du tampon du fichier.

File:getFilename

Obtient le nom de fichier avec lequel l'objet Fichier a été créé. Si l'objet du fichier provient du rappel d'amour.filedropped, le nom de fichier sera le chemin de fichier dépendant de la plate-forme.

filename = File:getFilename()

filenamestringLe nom de fichier du fichier.

File:getMode

Obtient le type de fichier avec lequel le fichier a été ouvert.

mode = File:getMode()

modeFileModeLe mode avec lequel ce fichier a été ouvert.

File:getSize

Obtient la taille du fichier.

size = File:getSize()

sizenumberLa taille du fichier

File:isEOF

Obtient si la fin du fichier a été atteinte.

eof = File:isEOF()

eofbooleanSi EOF a été atteint.

File:isOpen

Obtient si le fichier est ouvert.

open = File:isOpen()

openbooleanVrai si le fichier est actuellement ouvert, false sinon.

File:lines

Iterate sur toutes les lignes d'un fichier

iterator = File:lines()

iteratorfunctionL'itérateur (peut être utilisé dans les boucles)

File:open

Ouvrez le fichier pour écrire, lire ou ajouter.

Si vous obtenez le message d'erreur «Impossible de définir le répertoire d'écriture», essayez de définir le répertoire de sauvegarde. Cela se fait soit avec love.filesystem.setIdentity ou en définissant le champ d'identité dans love.conf.

success = File:open( mode )

successbooleanVrai sur le succès, faux sinon.
modeFileModeLe mode pour ouvrir le fichier dans.

File:read

Lisez un certain nombre d'octets à partir d'un fichier.

contents, size = File:read( bytes )

contentsstringLe contenu des octets de lecture.
sizenumberCombien d'octets ont été lus.
bytes (all)numberLe nombre d'octets à lire

File:seek

Rechercher un poste dans un fichier.

success = File:seek( position )

successbooleanQue l'opération ait réussi.
positionnumberLe poste pour chercher à

File:setBuffer

Définit le mode tampon pour un fichier ouvert pour l'écriture ou l'ajout. Les fichiers avec tampon activé n'écrivent pas de données sur le disque jusqu'à ce que la limite de la taille du tampon soit atteinte, en fonction du mode tampon.

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

successbooleanLe mode tampon a-t-il été défini avec succès.
errorstrstringLa chaîne d'erreur, si le mode tampon n'a pas pu être défini et une erreur s'est produite.
modeBufferModeLe mode tampon à utiliser.
size (0)numberLa taille maximale en octets du tampon du fichier.

File:tell

Obtient la position dans le fichier.

pos = File:tell()

posnumberLe poste actuel.

File:write

Écrivez des données dans un fichier.

success = File:write( data, size )

successbooleanQue l'opération ait réussi.
datastringLes données à écrire.
size (all)numberCombien d'octets à écrire.

FileData

Données représentant le contenu d'un fichier.

Constructors

Functions

Supertypes

FileData:getExtension

Obtient l'extension de FileData.

ext = FileData:getExtension()

extstringL'extension du fichier FileData représente.

FileData:getFilename

Obtient le nom de fichier de FileData.

name = FileData:getFilename()

namestringLe nom du fichier que FileData représente.

love.graphics

Types

Functions

Enums

love.graphics.arc

Dessine un arc rempli ou non rempli en position (x, y). L'arc est tiré de l'angle1 à l'angle2 en radians. Le paramètre de segments détermine le nombre de segments utilisés pour dessiner l'arc. Les segments les plus, plus lisse le bord.

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

drawmodeDrawModeComment dessiner l'arc.
arctype ("pie")ArcTypeLe type d'arc à dessiner.
xnumberLa position du centre sur l'axe des abscisses.
ynumberLa position du centre suivant l'axe des y.
radiusnumberRayon de l'arc.
angle1numberL'angle auquel l'arc commence.
angle2numberL'angle auquel l'arc se termine.
segments (10)numberNombre de segments utilisés pour dessiner l'arc.

love.graphics.circle

Dessine un cercle.

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

modeDrawModeComment dessiner le cercle.
xnumberLa position du centre sur l'axe des abscisses.
ynumberLa position du centre suivant l'axe des y.
radiusnumberLe rayon du cercle.

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

modeDrawModeComment dessiner le cercle.
xnumberLa position du centre sur l'axe des abscisses.
ynumberLa position du centre suivant l'axe des y.
radiusnumberLe rayon du cercle.
segmentsnumberLe nombre de segments utilisés pour dessiner le cercle. Remarque: La variable par défaut pour le paramètre de segments varie selon les différentes versions de LÉ VE.

love.graphics.clear

Efface l'écran à la couleur d'arrière-plan dans LÖVE 0.9.2 et plus tôt, ou à la couleur spécifiée dans 0.10.0 et plus récent.

Cette fonction s'appelle automatiquement avant love.draw dans la fonction love.run par défaut. Voir l'exemple dans love.run pour une utilisation typique de cette fonction.

Notez que la zone de ciseaux limite la région dégagée.

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 )

Clears the screen or active Canvas to the specified color.

rnumberLe canal rouge de la couleur pour effacer l'écran.
gnumberLe canal vert de la couleur pour effacer l'écran.
bnumberLe canal bleu de la couleur pour effacer l'écran.
a (255)numberLe canal alpha de la couleur pour effacer l'écran.

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

Clears multiple active Canvases to different colors, if multiple Canvases are active at once via love.graphics.setCanvas.

colortableUne table sous la forme de {r, g, b, a} contenant la couleur pour effacer la première Toile active.
...tableTableaux supplémentaires pour chaque Canvas active.

love.graphics.discard

Débarque (déchets) le contenu de l'écran ou le Canvas actif. Il s'agit d'une fonction d'optimisation des performances avec des cas d'utilisation de niche.

Si le Canvas actif vient d'être changé et que le BlendMode "remplacer" est sur le point d'être utilisé pour dessiner quelque chose qui couvre l'écran entier, appelant love.graphics.discard plutôt que d'appeler love.graphics.clear ou rien ne peut améliorer les performances sur le mobile dispositifs.

Sur certains systèmes de bureau, cette fonction ne peut rien faire.

love.graphics.discard( discardcolor, discardstencil )

discardcolor (true)booleanQue ce soit pour rejeter la (les) texture (s) de la (les) Canvas (s) active (s) (le contenu de l'écran si aucun Canvas n'est actif).
discardstencil (true)booleanQue ce soit pour éliminer le contenu du tampon stencil de l'écran / Canvas actif.

love.graphics.discard( discardcolors, discardstencil )

discardcolorstableUn tableau contenant des valeurs booléennes indiquant s'il faut rejeter la texture de chaque Canvas active, lorsque plusieurs Toiles simultanées sont actives.
discardstencil (true)booleanQue ce soit pour éliminer le contenu du tampon stencil de l'écran / Canvas actif.

love.graphics.draw

Dessine un objet portatif (image, toile, SpriteBatch, ParticleSystem, Mesh ou Vidéo) à l'écran avec une rotation, une mise à l'échelle et un cisaillement optionnels.

Les objets sont dessinés par rapport à leur système de coordonnées local. L'origine est par défaut située dans le coin supérieur gauche de Image and Canvas. Tous les arguments de mise à l'échelle, de cisaillement et de rotation transforment l'objet par rapport à ce point. En outre, la position de l'origine peut être spécifiée sur le système de coordonnées de l'écran.

Il est possible de faire pivoter un objet sur son centre en compensant l'origine vers le centre. Les angles doivent être donnés en radians pour la rotation. On peut également utiliser un facteur d'échelle négatif pour basculer autour de son axe.

Notez que les décalages sont appliqués avant la rotation, la mise à l'échelle ou le cisaillement; la mise à l'échelle et le cisaillement sont appliqués avant la rotation.

Les bords droit et inférieur de l'objet sont décalés à un angle défini par les facteurs de cisaillement.

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

drawableDrawableUn objet étirable.
x (0)numberLa position pour dessiner l'objet (axe des x).
y (0)numberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x). Peut être négatif.
sy (sx)numberFacteur d'échelle (axe des y). Peut être négatif.
ox (0)numberDécalage d'origine (axe des x). (Une valeur de 20 déplacerait effectivement votre objet étirable de 20 pixels vers la gauche).
oy (0)numberDécalage d'origine (axe des y). (Une valeur de 20 déplacerait efficacement votre objet étirable de 20 pixels vers le haut).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

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

textureTextureUne texture (image ou toile) pour la texture du Quad avec.
quadQuadLe Quad à dessiner à l'écran.
x (0)numberLa position pour dessiner l'objet (axe des x).
y (0)numberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x). Peut être négatif.
sy (sx)numberFacteur d'échelle (axe des y). Peut être négatif.
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y)
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

love.graphics.ellipse

Dessine une ellipse.

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

modeDrawModeComment dessiner l'ellipse.
xnumberLa position du centre sur l'axe des abscisses.
ynumberLa position du centre suivant l'axe des y.
radiusxnumberLe rayon de l'ellipse le long de l'axe des x (la moitié de la largeur de l'ellipse).
radiusynumberLe rayon de l'ellipse le long de l'axe des y (la moitié de la hauteur de l'ellipse).
segments (based on size)numberLe nombre de segments utilisés pour dessiner l'ellipse.

love.graphics.getBackgroundColor

Obtient la couleur d'arrière-plan actuelle.

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

rnumberLe composant rouge (0-255).
gnumberLa composante verte (0-255).
bnumberLe composant bleu (0-255).
anumberLe composant alpha (0-255).

love.graphics.getBlendMode

Obtient le mode de fusion.

mode, alphamode = love.graphics.getBlendMode()

modeBlendModeLe mode de fusion actuel.
alphamodeBlendAlphaModeLe mode alpha de mélange actuel - détermine comment l'alpha des objets dessinés affecte le mélange.

love.graphics.getCanvas

Obtient la cible cible actuelle.

canvas = love.graphics.getCanvas()

canvasCanvasLa toile définie par setCanvas. Renvoie néant si vous dessinez l'écran réel.

love.graphics.getCanvasFormats

Obtient les formats de Canvas disponibles et si chacun est pris en charge.

formats = love.graphics.getCanvasFormats()

formatstableUne table contenant CanvasFormats comme clé, et un booléen indiquant si le format est pris en charge en tant que valeurs. Tous les systèmes ne sont pas compatibles avec tous les formats.

love.graphics.getColor

Obtient la couleur actuelle.

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

rnumberLe composant rouge (0-255).
gnumberLe composant rouge (0-255).
bnumberLe composant bleu (0-255).
anumberLe composant alpha (0-255).

love.graphics.getColorMask

Obtient les composants de couleur actifs utilisés lors du dessin. Normalement, tous les 4 composants sont actifs à moins que love.graphics.setColorMask ait été utilisé.

Le masque de couleur détermine si les composants individuels des couleurs des objets dessinés affecteront la couleur de l'écran. Ils affectent love.graphics.clear et Canvas: clear also.

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

rbooleanQue le composant de couleur rouge soit actif lors du rendu.
gbooleanQue le composant de couleur verte soit actif lors du rendu.
bbooleanQue le composant de couleur bleue soit actif lors du rendu.
abooleanQue le composant de couleur alpha soit actif lors du rendu.

love.graphics.getCompressedImageFormats

Obtient les formats d'image compressés disponibles et si chacun est pris en charge.

formats = love.graphics.getCompressedImageFormats()

formatstableUne table contenant CompressedFormats en tant que clés et un booléen indiquant si le format est pris en charge en tant que valeurs. Tous les systèmes ne sont pas compatibles avec tous les formats.

love.graphics.getDefaultFilter

Obtient les filtres de mise à l'échelle par défaut utilisés avec les images, les toiles et les polices.

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

minFilterModeMode de filtrage utilisé lors de la mise à l'échelle de l'image vers le bas.
magFilterModeMode filtre utilisé lors de la mise à l'échelle de l'image.
anisotropynumberQuantité maximale de filtrage anisotrope utilisé.

love.graphics.getDimensions

Obtient la largeur et la hauteur de la fenêtre.

width, height = love.graphics.getDimensions()

widthnumberLa largeur de la fenêtre.
heightnumberLa hauteur de la fenêtre.

love.graphics.getFont

Obtient l'objet Police courant.

font = love.graphics.getFont()

fontFontLa police actuelle, ou nul si aucune n'est définie.

love.graphics.getHeight

Obtient la hauteur de la fenêtre.

height = love.graphics.getHeight()

heightnumberLa hauteur de la fenêtre.

love.graphics.getLineJoin

Obtient le style de jointure de ligne.

join = love.graphics.getLineJoin()

joinLineJoinLe style LineJoin.

love.graphics.getLineStyle

Obtient le style de ligne.

style = love.graphics.getLineStyle()

styleLineStyleLe style de ligne actuel.

love.graphics.getLineWidth

Obtient la largeur de ligne actuelle.

width = love.graphics.getLineWidth()

widthnumberLa largeur actuelle de la ligne.

love.graphics.getShader

Obtient le Shader actuel. Renvoie néant si aucun n'est défini.

shader = love.graphics.getShader()

shaderShaderLe Shader actuel.

love.graphics.getStats

Obtient des statistiques de rendu liées à la performance.

stats = love.graphics.getStats()

statstableUne table avec les champs suivants:
stats.drawcallsnumberLe nombre d'appels de tirage effectués jusqu'à présent pendant la trame actuelle.
stats.canvasswitchesnumberLe nombre de fois que le Canvas actif a été changé jusqu'à présent pendant la trame actuelle.
stats.texturememorynumberLa taille totale estimée en octets de la mémoire vidéo utilisée par toutes les images, les toiles et les polices chargées.
stats.imagesnumberLe nombre d'objets Image actuellement chargés.
stats.canvasesnumberLe nombre d'objets de Canvas actuellement chargés.
stats.fontsnumberLe nombre d'objets Font actuellement chargés.
stats.shaderswitchesnumberLe nombre de fois où le Shader actif a été modifié jusqu'à présent pendant la trame actuelle.

love.graphics.getStencilTest

Obtient si les tests de stencil sont activés.

Lorsque les tests de stencil sont activés, la géométrie de tout ce qui est dessiné sera découpée / décalée en fonction de la présence de ce qui a été précédemment attiré sur le tampon stencil.

Chaque Canvas a son propre tampon stencil.

enabled, inverted = love.graphics.getStencilTest()

enabledbooleanQue le test du stencil soit activé.
invertedbooleanQue le test du pochoir soit inversé ou non.

love.graphics.getSupported

Obtient les fonctionnalités graphiques optionnelles et si elles sont prises en charge sur le système.

Certains systèmes anciens ou bas ne supportent pas toujours toutes les fonctions graphiques.

features = love.graphics.getSupported()

featurestableUne table contenant des clés GraphicsFeature et des valeurs booléennes indiquant si chaque fonctionnalité est prise en charge.

love.graphics.getSystemLimits

Obtient les valeurs maximales dépendantes du système pour les fonctionnalités love.graphics.

limits = love.graphics.getSystemLimits()

limitstableUne table contenant des clés GraphicsLimit et des valeurs numériques.

love.graphics.getPointSize

Obtient la taille du point.

size = love.graphics.getPointSize()

sizenumberLa taille actuelle du point.

love.graphics.getRendererInfo

Obtient des informations sur la carte vidéo et les pilotes du système.

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

namestringLe nom du représentant, par ex. "OpenGL" ou "OpenGL ES".
versionstringLa version du processeur avec des informations de version supplémentaires dépendantes du pilote, p.ex. "2.1 INTEL-8.10.44".
vendorstringLe nom du fournisseur de carte graphique, par ex. "Intel Inc".
devicestringLe nom de la carte graphique, par ex. "Intel HD Graphics 3000 OpenGL Engine".

love.graphics.getScissor

Obtient la boîte à ciseaux actuelle.

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

xnumberLe composant x du point supérieur gauche de la boîte.
ynumberLe composant y du point supérieur gauche de la boîte.
widthnumberLa largeur de la boîte.
heightnumberLa hauteur de la boîte.

love.graphics.getWidth

Obtient la largeur de la fenêtre.

width = love.graphics.getWidth()

widthnumberLa largeur de la fenêtre.

love.graphics.intersectScissor

Définit le ciseau sur le rectangle créé par l'intersection du rectangle spécifié avec le ciseau existant. Si aucun ciseau n'est encore actif, il se comporte comme love.graphics.setScissor.

Le ciseau limite la zone de dessin à un rectangle spécifié. Cela affecte tous les appels graphiques, y compris love.graphics.clear.

Les dimensions du ciseau ne sont pas affectées par des transformations graphiques (traduction, échelle, ...).

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

Limits the drawing area to a specified rectangle.

xnumberLa coordonnée x du coin supérieur gauche du rectangle se croise avec le rectangle de ciseau existant.
ynumberLa coordonnée y du coin supérieur gauche du rectangle pour se croiser avec le rectangle existant du ciseau.
widthnumberLa largeur du rectangle pour se croiser avec le rectangle de ciseau existant.
heightnumberLa hauteur du rectangle pour se croiser avec le rectangle de ciseau existant.

love.graphics.intersectScissor()

Disables scissor.

love.graphics.isGammaCorrect

Obtient si le rendu correct de gamma est pris en charge et activé. Il peut être activé en configurant t.gammacorrect = true dans love.conf.

Tous les appareils ne prennent pas en charge un rendu gamma correct, auquel cas il sera automatiquement désactivé et cette fonction renverra fausses. Il est pris en charge sur les systèmes de bureau qui possèdent des cartes graphiques capables d'utiliser OpenGL 3 / DirectX 10 et les périphériques iOS qui peuvent utiliser OpenGL ES 3.

gammacorrect = love.graphics.isGammaCorrect()

gammacorrectbooleanVrai si un rendu gamma-correct est pris en charge et a été activé dans love.conf, false sinon.

love.graphics.isWireframe

Obtient si le mode wireframe est utilisé lors du dessin.

wireframe = love.graphics.isWireframe()

wireframebooleanVrai si les lignes de fil métallique sont utilisées lors du dessin, fausses si ce n'est pas le cas.

love.graphics.line

Dessine les lignes entre les points.

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

x1numberLa position du premier point sur l'axe des abscisses.
y1numberLa position du premier point sur l'axe des y.
x2numberLa position du deuxième point sur l'axe des abscisses.
y2numberLa position du deuxième point sur l'axe des y.
...numberVous pouvez continuer à passer des points pour dessiner une polyligne.

love.graphics.line( points )

pointstableUn tableau des positions ponctuelles.

love.graphics.newCanvas

Crée un nouvel objet Canvas pour le rendu hors écran.

Les toiles antialiases ont des exigences système légèrement plus élevées que les toiles normales. De plus, le nombre maximal supporté d'échantillons MSAA varie en fonction du système. Utilisez love.graphics.getSystemLimit pour vérifier.

Si le nombre d'échantillons MSAA spécifiés est supérieur au maximum pris en charge par le système, le Canvas sera toujours créé mais uniquement en utilisant le montant maximal supporté (ceci inclut 0.)

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

canvasCanvasUn nouvel objet Canvas.
width (window width)numberLa largeur de la Toile.
height (window height)numberLa hauteur de la toile.
format ("normal")CanvasFormatLe mode de texture souhaité de la Toile.
msaa (0)numberLe nombre souhaité d'échantillons anti-altération utilisés lors du dessin sur le Toile.

love.graphics.newFont

Crée une nouvelle police à partir d'une police TrueType ou d'un fichier BMFont. Les polices créées ne sont pas mises en cache, car l'appel de cette fonction avec les mêmes arguments créera toujours un nouvel objet Font.

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

fontFontUn objet Police qui peut être utilisé pour dessiner du texte à l'écran.
filestring / File / FileDataLe fichier / File / FileData du fichier de police TrueType.
size (12)numberLa taille de la police en pixels.

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

fontFontUn objet Police qui peut être utilisé pour dessiner du texte à l'écran.
filestring / File / FileDataLe chemin / Fichier / FichierDonnées du fichier BMFont.
imagefilename (path inside BMFont file)string / File / FileDataLe chemin d'accès / File / FileData du fichier image BMFont.

font = love.graphics.newFont( size )

Create a new instance of the default font (Vera Sans) with a custom size.

fontFontUn objet Police qui peut être utilisé pour dessiner du texte à l'écran.
sizenumberLa taille de la police en pixels.

love.graphics.newMesh

Crée un nouveau maillage.

Utilisez Mesh: setTexture si le Mesh doit être texturé avec une image ou un canevas lorsqu'il est dessiné.

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

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

meshMeshLe nouveau maillage.
vertexformat (none)tableUne table sous la forme de {attribute, ...}. Chaque attribut est une table qui spécifie un attribut vertex personnalisé utilisé pour chaque sommet.
vertexformat.attributetableUne table contenant le nom de l'attribut, son type de données et le nombre de composants dans l'attribut, sous la forme de {nom, type de données, composants}.
vertexformat....tableTableaux de format d'attribut de vertex supplémentaires.
verticestableLa table remplie de tables d'informations de sommet pour chaque sommet, sous la forme de {vertex, ...} où chaque sommet est une table sous la forme de {componentcomponent, ...}.
vertices.attributecomponentnumberLe premier composant du premier attribut vertex dans le sommet.
vertices....numberComposants supplémentaires de tous les attributs de vertex dans le sommet.
mode ("fan")MeshDrawModeComment les sommets sont utilisés lors du tirage. Le mode par défaut "ventilateur" est suffisant pour les polygones convexes simples.
usage ("dynamic")SpriteBatchUsageL'utilisation prévue du Mesh. Le mode d'utilisation spécifié affecte l'utilisation et les performances de la mémoire Mesh.

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

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

meshMeshLe nouveau maillage.
vertexformat (none)tableUne table sous la forme de {attribute, ...}. Chaque attribut est une table qui spécifie un attribut vertex personnalisé utilisé pour chaque sommet.
vertexformat.attributetableUne table contenant le nom de l'attribut, son type de données et le nombre de composants dans l'attribut, sous la forme de {nom, type de données, composants}.
vertexformat....tableTableaux de format d'attribut de vertex supplémentaires.
vertexcountnumberLe nombre total de sommets que le maillage utilisera.
mode ("fan")MeshDrawModeComment les sommets sont utilisés lors du tirage. Le mode par défaut "ventilateur" est suffisant pour les polygones convexes simples.
usage ("dynamic")SpriteBatchUsageL'utilisation prévue du Mesh. Le mode d'utilisation spécifié affecte l'utilisation et les performances de la mémoire Mesh.

love.graphics.newImage

Crée une nouvelle image à partir d'un chemin de fichier, FileData, d'un ImageData ou d'un CompressedImageData, et génère ou spécifie éventuellement des mipmaps pour l'image.

Les images utilisant CompressedImageData l'utiliseront pour se recharger lorsque love.window.setMode est appelé.

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

imageImageUn objet Image qui peut être dessiné à l'écran.
filepath / File / FileData / ImageData / CompressedImageDataLe chemin du fichier / File / FileData / ImageData / CompressedImageData de l'image.
flagstableUn tableau contenant les champs suivants:
flags.linear (false)booleanVrai si les pixels de l'image doivent être interprétés comme étant linéaire RVB plutôt que sRGB-encodé, si le rendu correct gamma est activé. Cela n'a pas d'effet autrement.
flags.mipmaps (false)boolean or tableSi c'est vrai, les mipmaps pour l'image seront générés automatiquement (ou retirés du fichier des images, si possible, si l'image provient d'un CompressedImageData). Si cette valeur est une table, elle doit contenir une liste d'autres noms de fichiers d'images du même format qui ont progressivement des dimensions de taille moyenne, jusqu'à 1x1. Ces images seront utilisées comme niveaux de mipmap de cette image.

love.graphics.newImageFont

Crée une nouvelle police en chargeant une image formatée spécifiquement.

Dans les versions antérieures à 0.9.0, LÖVE s'attend à un codage ISO 8859-1 pour la chaîne de glyphes.

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

fontFontUn objet Police qui peut être utilisé pour dessiner du texte à l'écran.
filepath / File / FileDataLe chemin du fichier / File / FileData du fichier image.
glyphsstringUne chaîne de caractères dans l'image dans l'ordre de gauche à droite.
extraspacing (0)numberEspacement supplémentaire (positif ou négatif) à appliquer à chaque glyphe dans la police.

love.graphics.newParticleSystem

Crée un nouveau système de particules.

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

systemParticleSystemUn nouveau système de particules.
textureTextureL'image ou le canevas à utiliser.
buffer (1000)numberLe nombre maximal de particules en même temps.

love.graphics.newShader

Crée un nouvel objet Shader pour les effets de sommet et de pixel accélérés par le matériel. Un Shader contient soit un code de masque de vertex, un code de masque de pixels, soit les deux.

Le code de masque Vertex doit contenir au moins une fonction, nommée position, qui est la fonction qui produira des positions de vertex transformées d'objets dessinés dans l'espace d'écran.

Le code pixel du masque doit contenir au moins une fonction, l'effet nommé, qui est la fonction qui produira la couleur qui est mélangée sur l'écran pour chaque pixel qu'un objet dessiné touche.

shader = love.graphics.newShader( code )

shaderShaderUn objet Shader à utiliser dans les opérations de dessin.
codestring / File / FileDataLe pixel shader ou le code de masque de vertex, ou un fichier avec le code.

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

shaderShaderUn objet Shader à utiliser dans les opérations de dessin.
pixelcodestring / File / FileDataLe code pixel shader, ou un fichier avec le code.
vertexcodestring / File / FileDataLe code du masque de vertex ou un fichier avec le code.

love.graphics.newText

Crée une nouvelle police.

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

textTextLe nouvel objet de texte dessiné.
fontFontLa police à utiliser pour le texte.
textstring (nil)stringLa chaîne de texte initiale que le nouvel objet Texte contiendra. Peut être nile.

love.graphics.newQuad

Crée un nouveau Quad.

Le but d'un Quad est de décrire le résultat de la transformation suivante sur tout objet pouvant être dessiné. L'objet est d'abord dimensionné aux dimensions sw * sh. Le Quad décrit ensuite la zone rectangulaire de dimensions largeur * hauteur dont le coin supérieur gauche est en position (x, y) à l'intérieur de l'objet mis à l'échelle.

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

quadQuadLe nouveau Quad.
xnumberLa position supérieure gauche selon l'axe des abscisses.
ynumberLa position supérieure gauche selon l'axe des y.
widthnumberLa largeur du Quad.
heightnumberLa hauteur du Quad.
swnumberLa largeur de référence, la largeur de l'image.
shnumberLa hauteur de référence, la hauteur de l'image.

love.graphics.newScreenshot

Crée une capture d'écran et renvoie les données d'image.

screenshot = love.graphics.newScreenshot( copyAlpha )

screenshotImageDataLes données d'image de la capture d'écran.
copyAlpha (false)booleanQue ce soit pour inclure le canal alpha de l'écran dans ImageData. Si c'est faux, la capture d'écran sera totalement opaque.

love.graphics.newSpriteBatch

Crée un nouvel objet SpriteBatch.

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

spriteBatchSpriteBatchLe nouveau SpriteBatch.
textureTextureL'image ou la toile à utiliser pour les sprites.
maxsprites (1000)numberLe nombre maximum de sprites.
usage ("dynamic")SpriteBatchUsageL'utilisation prévue du SpriteBatch. Le mode d'utilisation spécifié affecte l'utilisation et les performances de la mémoire de SpriteBatch.

love.graphics.newVideo

Crée une nouvelle vidéo dessinable. Actuellement, seuls les fichiers vidéo Ogg Theora sont pris en charge.

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

videoVideoUne nouvelle vidéo.
filestring / FileLe chemin du fichier / Fichier du fichier vidéo Ogg Theora.
loadaudio (nil)booleanQue ce soit pour essayer de charger l'audio de la vidéo dans une source audio. Si elle n'est pas explicitement définie sur true ou false, elle tentera sans provoquer une erreur si la vidéo n'a pas d'audio.

love.graphics.origin

Réinitialise la transformation de coordonnées actuelle.

Cette fonction est toujours utilisée pour inverser les appels précédents à love.graphics.rotate, love.graphics.scale, love.graphics.shear ou love.graphics.translate. Il renvoie l'état de transformation actuel à ses valeurs par défaut.

love.graphics.origin()

love.graphics.points

Dessine un ou plusieurs points.

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

xnumberLa position du premier point sur l'axe des abscisses.
ynumberLa position du premier point sur l'axe des y.
...numberLes coordonnées x et y de points supplémentaires.

love.graphics.points( points )

pointstableUne table contenant plusieurs positions de point, sous la forme de {x, y, ...}.
points.xnumberLa position du premier point sur l'axe des abscisses.
points.ynumberLa position du premier point sur l'axe des y.
points....numberLes coordonnées x et y de points supplémentaires.

love.graphics.points( points )

pointstableUne table contenant plusieurs points de couleur individuelle, sous la forme de {point, ...}. Chaque table contient la position et la couleur d'un point sous la forme de {x, y, r, g, b, a}. Les composants couleur sont optionnels.
points.pointtableUne table contenant la position et la couleur du premier point, sous la forme de {x, y, r, g, b, a}. Les composants couleur sont optionnels.
points....tableDes tableaux supplémentaires contenant la position et la couleur de plus de points, sous la forme de {x, y, r, g, b, a}. Les composants couleur sont optionnels.

love.graphics.polygon

Dessinez un polygone.

En suivant l'argument de mode, cette fonction peut accepter plusieurs arguments numériques ou une seule table d'arguments numériques. Dans les deux cas, les arguments sont interprétés comme des coordonnées alternées x et y des sommets du polygone.

En mode de remplissage, le polygone doit être convexe et simple ou des artefacts de rendu peuvent se produire.

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

modeDrawModeComment dessiner le polygone.
...numberLes sommets du polygone.

love.graphics.polygon( mode, vertices )

modeDrawModeComment dessiner le polygone.
verticestableLes sommets du polygone comme table.

love.graphics.pop

Pops la transformation de coordonnées actuelle de la pile de transformation.

Cette fonction est toujours utilisée pour inverser une opération de poussée précédente. Il renvoie l'état de transformation actuel à ce qu'il était avant la dernière pression précédente. Pour un exemple, voir la description de love.graphics.push.

love.graphics.pop()

love.graphics.present

Affiche les résultats des opérations de dessin sur l'écran.

Cette fonction est utilisée lors de l'écriture de votre propre fonction love.run. Il présente tous les résultats de vos opérations de dessin sur l'écran. Voir l'exemple dans love.run pour une utilisation typique de cette fonction.

love.graphics.present()

love.graphics.print

Dessine le texte à l'écran. Si aucune police n'est définie, une sera créée et définie (une fois) si nécessaire.

À partir de LOVE 0.7.1, lorsque vous utilisez des fonctions de traduction et de mise à l'échelle lors du dessin du texte, cette fonction suppose que l'échelle se produit en premier. Si vous ne faites pas un script dans cet esprit, le texte ne sera pas dans la bonne position, ni même sur l'écran.

love.graphics.print et love.graphics.printf supporte tous les deux l'encodage UTF-8. Vous aurez également besoin d'une police appropriée pour les caractères spéciaux.

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

textstringLe texte à dessiner.
xnumberLa position pour dessiner l'objet (axe des x).
ynumberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

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

coloredtexttableUne table contenant des couleurs et des chaînes à ajouter à l'objet, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.
xnumberLa position du nouveau texte sur l'axe des x.
ynumberLa position du nouveau texte sur l'axe des y.
angle (0)numberL'orientation de l'objet en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

love.graphics.printf

Dessine un texte formaté, avec une enveloppe et un alignement de mots.

Voir les notes supplémentaires dans love.graphics.print.

Dans la version 0.9.2 et antérieure, l'emballage a été implémenté en divisant les mots par des espaces et en les regroupant pour s'assurer que les choses s'intègrent bien dans la limite fournie. Cependant, en raison de la façon dont cela se fait, les espaces supplémentaires entre les mots finiraient par disparaître lors de l'impression sur l'écran, et certaines lignes pourraient déborder après la limite d'enveloppe fournie. Dans la version 0.10.0 et plus récente, ce n'est plus le cas.

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

textstringUne chaîne de texte.
xnumberLa position sur l'axe des abscisses.
ynumberLa position sur l'axe des y.
limitnumberEnroulez la ligne après plusieurs pixels horizontaux.
align ("left")AlignModeL'alignement.
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

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

coloredtexttableUne table contenant des couleurs et des chaînes à ajouter à l'objet, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.
xnumberLa position du nouveau texte sur l'axe des x.
ynumberLa position du nouveau texte sur l'axe des y.
wraplimitnumberLa largeur maximale en pixels du texte avant qu'il ne soit automatiquement enroulé sur une nouvelle ligne.
alignAlignModeL'alignement du texte.
angle (0)numberL'orientation de l'objet en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

love.graphics.push

Copie et pousse la transformation de coordonnées actuelle à la pile de transformation.

Cette fonction est toujours utilisée pour préparer une opération pop correspondante plus tard. Il stocke l'état de transformation de coordonnées actuel dans la pile de transformation et la maintient active. Les modifications ultérieures apportées à la transformation peuvent être annulées en utilisant l'opération pop, qui renvoie la transformation de coordonnées à l'état où elle se trouvait avant d'appeler push.

love.graphics.push( stack )

stack ("transform")StackTypeLe type de pile à pousser (par exemple, l'état de transformation juste, ou tout l'état love.graphics).

love.graphics.rectangle

Dessine un rectangle.

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

Draws a rectangle with rounded corners.

modeDrawModeComment dessiner le rectangle.
xnumberLa position du coin supérieur gauche le long de l'axe des abscisses.
ynumberLa position du coin supérieur gauche le long de l'axe des y.
widthnumberLargeur du rectangle.
heightnumberHauteur du rectangle.
rx (0)numberLe rayon de l'axe des x de chaque angle rond. Ne peut pas dépasser la moitié de la largeur du rectangle.
ry (rx)numberLe rayon de l'axe des Y de chaque angle rond. Ne peut pas dépasser la moitié de la hauteur du rectangle.
segments (based on size)numberLe nombre de segments utilisés pour dessiner les coins ronds.

love.graphics.reset

Réinitialise les paramètres graphiques actuels.

L'appel à la réinitialisation rend la couleur de dessin actuelle en blanc, la couleur d'arrière-plan actuelle est noire, réinitialise tout Canvas ou Shader actif et supprime les réglages de ciseaux. Il définit le BlendMode comme alpha. Il définit également les modes de dessin de point et de ligne pour lisser et leurs dimensions en 1.0.

love.graphics.reset()

love.graphics.rotate

Rotation du système de coordonnées en deux dimensions.

L'appel de cette fonction affecte toutes les futures opérations de dessin en faisant pivoter le système de coordonnées autour de l'origine par la quantité donnée de radians. Ce changement dure jusqu'à ce que love.draw sort.

love.graphics.rotate( angle )

anglenumberLa quantité de rotation du système de coordonnées en radians.

love.graphics.scale

Échelle le système de coordonnées en deux dimensions.

Par défaut, le système de coordonnées de LÖVE correspond aux pixels d'affichage dans les directions horizontale et verticale un à l'autre, et l'axe des x augmente vers la droite tandis que l'axe des y augmente vers le bas. La mise à l'échelle du système de coordonnées change cette relation.

Après la mise à l'échelle par sx et sy, toutes les coordonnées sont traitées comme si elles étaient multipliées par sx et sy. Chaque résultat d'une opération de dessin est également dimensionné de manière correspondante, de sorte que la mise à l'échelle par (2, 2) signifie par exemple rendre tout deux fois aussi important dans les directions x et y. La mise à l'échelle par une valeur négative retourne le système de coordonnées dans la direction correspondante, ce qui signifie également que tout sera tiré à l'envers ou à l'envers, ou les deux. La mise à l'échelle par zéro n'est pas une opération utile.

L'échelle et la traduction ne sont pas des opérations commutatives, par conséquent, les appeler dans différentes commandes modifieront le résultat.

La mise à l'échelle dure jusqu'à ce que love.draw quitte.

love.graphics.scale( sx, sy )

sxnumberLa mise à l'échelle dans le sens de l'axe des abscisses.
sy (sx)numberLa mise à l'échelle dans le sens de l'axe des y. Si elle est omise, elle est par défaut égale au paramètre sx.

love.graphics.setBackgroundColor

Définit la couleur d'arrière-plan.

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

rnumberLe composant rouge (0-255).
gnumberLa composante verte (0-255).
bnumberLe composant bleu (0-255).
a (255)numberLe composant alpha (0-255).

love.graphics.setBackgroundColor( rgba )

rgbatableUne table indexée numérique avec les valeurs rouge, vert et bleu en chiffres. Alpha est 255 si ce n'est pas dans la table

love.graphics.setBlendMode

Définit le mode de fusion.

love.graphics.setBlendMode( mode, alphamode )

modeBlendModeLe mode mélange à utiliser.
alphamode ("alphamultiply")BlendAlphaModeQue faire avec l'alpha des objets dessinés lors du mélange.

love.graphics.setCanvas

Capture les opérations de dessin sur un Canvas.

love.graphics.setCanvas( canvas )

Sets the render target to a specified Canvas. All drawing operations until the next love.graphics.setCanvas call will be redirected to the Canvas and not shown on the screen.

canvasCanvasUne cible de rendu.

love.graphics.setCanvas()

Resets the render target to the screen, i.e. re-enables drawing to the screen.

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

Sets the render target to multiple simultaneous Canvases. All drawing operations until the next love.graphics.setCanvas call will be redirected to the specified canvases and not shown on the screen.

canvas1CanvasLa première cible de rendu.
canvas2CanvasLa deuxième cible de rendu.
...CanvasPlus de toiles.

love.graphics.setColor

Définit la couleur utilisée pour le dessin.

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

rednumberLa quantité de rouge.
greennumberLa quantité de vert.
bluenumberLa quantité de bleu.
alphanumberLa quantité d'alpha. La valeur alpha sera appliquée à toutes les opérations de tirage ultérieures, même au dessin d'une image.

love.graphics.setColor( rgba )

rgbatableUne table indexée numérique avec les valeurs rouge, vert, bleu et alpha comme chiffres. L'alpha est facultatif et par défaut de 255 s'il est laissé de côté.

love.graphics.setColorMask

Définit le masque de couleur. Active ou désactive des composants de couleur spécifiques lors du rendu et de l'effacement de l'écran. Par exemple, si le rouge est défini sur faux, aucune modification supplémentaire ne sera apportée au composant rouge de n'importe quel pixel.

Active tous les composants de couleur lorsqu'ils sont appelés sans arguments.

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

Enables color masking for the specified color components.

redbooleanRendre le composant rouge.
greenbooleanRendre le composant vert.
bluebooleanRendre le composant bleu.
alphabooleanRender le composant alpha.

love.graphics.setColorMask()

Disables color masking.

love.graphics.setDefaultFilter

Définit les filtres de mise à l'échelle par défaut utilisés avec les images, les toiles et les polices.

Cette fonction ne s'applique pas rétroactivement aux images chargées.

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

minFilterModeMode de filtrage utilisé lors de la mise à l'échelle de l'image vers le bas.
mag (min)FilterModeMode filtre utilisé lors de la mise à l'échelle de l'image.
anisotropy (1)numberQuantité maximale de filtrage anisotrope utilisé.

love.graphics.setFont

Définissez une police déjà chargée comme police actuelle ou créez et chargez une nouvelle du fichier et de la taille.

Il est recommandé que les objets Font soient créés avec love.graphics.newFont dans la phase de chargement, puis passés à cette fonction au stade du dessin.

love.graphics.setFont( font )

fontFontL'objet Font à utiliser.

love.graphics.setLineJoin

Définit le style de jointure de ligne.

love.graphics.setLineJoin( join )

joinLineJoinThe LineJoin à utiliser.

love.graphics.setLineStyle

Définit le style de ligne.

love.graphics.setLineStyle( style )

styleLineStyleThe LineStyle à utiliser.

love.graphics.setLineWidth

Définit la largeur de la ligne.

love.graphics.setLineWidth( width )

widthnumberLa largeur de la ligne.

love.graphics.setNewFont

Crée et définit une nouvelle police.

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

fontFontLa nouvelle police.
filenamestring / File / FileDataLe chemin du fichier / Fichier / FichierDonnées de la police.
size (12)numberLa taille de la police.

love.graphics.setShader

Définit ou réinitialise un Shader comme effet de pixel actuel ou shaders de vertex. Toutes les opérations de dessin jusqu'à ce que le prochain love.graphics.setShader soit dessiné à l'aide de l'objet Shader spécifié.

Désactive les shaders lorsqu'ils sont appelés sans arguments.

love.graphics.setShader()

love.graphics.setShader( shader )

shaderShaderLe nouveau shader.

love.graphics.setPointSize

Définit la taille du point.

love.graphics.setPointSize( size )

sizenumberLa nouvelle taille de point.

love.graphics.setScissor

Définit ou désactive le ciseau.

Le ciseau limite la zone de dessin à un rectangle spécifié. Cela affecte tous les appels graphiques, y compris love.graphics.clear.

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

Limits the drawing area to a specified rectangle.

xnumberLa coordonnée X du coin supérieur gauche.
ynumberLa coordonnée Y du coin supérieur gauche.
widthnumberLa largeur du rectangle d'écrêtage.
heightnumberLa hauteur du rectangle d'écrêtage.

love.graphics.setScissor()

Disables scissor.

love.graphics.setStencilTest

Configure ou désactive le test du stencil.

Lorsque le test du stencil est activé, la géométrie de tout ce qui est dessiné après sera découpée / décalée en fonction d'une comparaison entre les arguments de cette fonction et la valeur du pochoir de chaque pixel que la géométrie touche. Les valeurs de pochoir des pixels sont affectées via love.graphics.stencil.

Chaque Canvas possède ses propres valeurs de pochoir par pixel.

love.graphics.setStencilTest( comparemode, comparevalue )

comparemodeCompareModeLe type de comparaison à effectuer pour chaque pixel.
comparevaluenumberLa valeur à utiliser lors de la comparaison avec la valeur du pochoir de chaque pixel. Doit être compris entre 0 et 255.

love.graphics.setStencilTest()

Disables stencil testing.

love.graphics.setWireframe

Définit si les lignes de fil métallique seront utilisées lors du tirage.

Le mode Wireframe ne doit être utilisé que pour le débogage. Les lignes tracées avec elle activées ne se comportent pas comme des lignes d'amour. Graphique: leurs largeurs ne s'allument pas avec les transformations de coordonnées ou avec love.graphics.setLineWidth, et elles n'utilisent pas le LineStyle lisse.

love.graphics.setWireframe( enable )

enablebooleanFacile à activer le mode wireframe lors du dessin, faux pour le désactiver.

love.graphics.shear

Cise le système de coordonnées.

love.graphics.shear( kx, ky )

kxnumberLe facteur de cisaillement sur l'axe des abscisses.
kynumberLe facteur de cisaillement sur l'axe des y.

love.graphics.stencil

Dessine la géométrie comme un pochoir.

La géométrie dessinée par la fonction fournie définit des valeurs de pixels invisibles de pixels, au lieu de définir des couleurs de pixels. Les valeurs de pochoir des pixels peuvent agir comme un masque / stencil - love.graphics.setStencilTest peut être utilisé ensuite pour déterminer comment un rendu supplémentaire est affecté par les valeurs de stencil dans chaque pixel.

Chaque Canvas possède ses propres valeurs de pochoir par pixel. Les valeurs de Stencil se situent dans la plage de {0, 255}.

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

stencilfunctionfunctionFonction qui trace la géométrie. Les valeurs de pochoir des pixels, plutôt que la couleur de chaque pixel, seront affectées par la géométrie.
action ("replace")StencilActionComment modifier toutes les valeurs de pochoir des pixels qui sont touchés par ce qui est tiré dans la fonction stencil.
value (1)numberLa nouvelle valeur de stencil à utiliser pour les pixels si l'action de remplacement "remplacer" est utilisée. N'a aucun effet avec d'autres actions de stencil. Doit être compris entre 0 et 255.
keepvalues (false)booleanFidèle à la préservation des anciennes valeurs de pixels, false pour réinitialiser la valeur de chaque pixel à 0 avant d'exécuter la fonction stencil. love.graphics.clear va également redéfinir toutes les valeurs de stencil.

love.graphics.translate

Traduire le système de coordonnées en deux dimensions.

Lorsque cette fonction est appelée avec deux nombres, dx et dy, toutes les opérations de dessin suivantes prennent effet comme si leurs coordonnées x et y étaient x + dx et y + dy.

L'échelle et la traduction ne sont pas des opérations commutatives, par conséquent, les appeler dans différentes commandes modifieront le résultat.

Ce changement dure jusqu'à ce que love.graphics.clear soit appelé (ce qui s'appelle automatiquement avant love.draw dans la fonction love.run par défaut) ou un love.graphics.pop revient à un état précédent du système de coordonnées.

La traduction en utilisant des nombres entiers empêchera le déchirement / flou d'images et les polices dessinent après la traduction.

love.graphics.translate( dx, dy )

dxnumberLa traduction par rapport à l'axe des abscisses.
dynumberLa traduction par rapport à l'axe des y.

AlignMode

center

Aligner le centre de texte.

left

Alignez du texte à gauche.

right

Alignez le texte correctement.

justify

Alignez le texte à la fois à gauche et à droite.

ArcType

pie

L'arc est dessiné comme une tranche de tarte, avec le cercle d'arc connecté au centre à ses extrémités.

open

Les deux points d'extrémité du cercle d'arc ne sont pas connectés lorsque l'arc est tracé en ligne. Se comporte comme le type d'arc "fermé" lorsque l'arc est dessiné en mode rempli.

closed

Les deux extrémités du cercle d'arc sont reliées entre elles.

AreaSpreadDistribution

uniform

Distribution uniforme.

normal

Distribution normale (gaussienne).

ellipse

Distribution uniforme dans une ellipse.

none

Aucune répartition - zone de diffusion n'est désactivée.

BlendAlphaMode

alphamultiply

Les valeurs RVB de ce qui est tiré sont multipliées par les valeurs alpha de ces couleurs pendant le mélange. C'est le mode alpha par défaut.

premultiplied

Les valeurs RVB de ce qui est tiré ne sont pas multipliées par les valeurs alpha de ces couleurs pendant le mélange. Pour que la plupart des modes de fusion fonctionnent correctement avec ce mode alpha, les couleurs d'un objet dessiné doivent avoir leurs valeurs RVB multipliées par leurs valeurs alpha à un moment donné ("alpha prémultiplié").

BlendMode

alpha

Mélange Alpha (normal). L'alpha de ce qui est tiré détermine son opacité.

replace

Les couleurs de ce qui est dessiné remplacent complètement ce qui était sur l'écran, sans mélange supplémentaire. Le BlendAlphaMode spécifié dans love.graphics.setBlendMode affecte toujours ce qui se passe.

screen

Mélange "écran".

add

Les couleurs des pixels de ce qui est dessiné sont ajoutées aux couleurs des pixels déjà présentes sur l'écran. L'alpha de l'écran n'est pas modifié.

subtract

Les couleurs des pixels de ce qui est dessiné sont soustraites des couleurs des pixels déjà présentes sur l'écran. L'alpha de l'écran n'est pas modifié.

multiply

Les couleurs des pixels de ce qui est tiré sont multipliées par les pixels déjà affichés sur l'écran (les assombrir). L'alpha des objets dessinés est multiplié par l'alpha de l'écran plutôt que de déterminer dans quelle mesure les couleurs sur l'écran sont affectées, même lorsque le "BlendAlphaMode" alphamultiplé est utilisé.

lighten

Les couleurs des pixels de ce qui est dessiné sont comparées aux couleurs de pixels existantes, et la plus grande des deux valeurs pour chaque composant de couleur est utilisée. Fonctionne uniquement lorsque le BlendAlphaMode "prémultiplié" est utilisé dans love.graphics.setBlendMode.

darken

Les couleurs des pixels de ce qui est dessiné sont comparées aux couleurs de pixels existantes, et la plus petite des deux valeurs pour chaque composant de couleur est utilisée. Fonctionne uniquement lorsque le BlendAlphaMode "prémultiplié" est utilisé dans love.graphics.setBlendMode.

CanvasFormat

normal

Le format de Canvas par défaut - généralement un alias pour le format rgba8, ou le format srgb si le rendu gamma-correct est activé dans LÖVE 0.10.0 et plus récent.

hdr

Un format adapté au contenu de la gamme dynamique élevée - un alias pour le format rgba16f, normalement.

rgba8

8 bits par canal (32 bpp) RGBA. Les valeurs de canal couleur varient de 0-255 (0-1 dans les shaders).

rgba4

4 bits par canal (16 bpp) RGBA.

rgb5a1

RVB avec 5 bits chacun, et un canal alpha 1 bit (16 bpp).

rgb565

RVB avec 5, 6 et 5 bits chacun, respectivement (16 bpp). Il n'y a pas de canal alpha dans ce format.

rgb10a2

RVB avec 10 bits par canal et un canal alpha 2 bits (32 bpp).

rgba16f

Point flottant RGBA avec 16 bits par canal (64 bpp). Les valeurs de couleur peuvent aller de {-65504, +65504}.

rgba32f

Point flottant RGBA avec 32 bits par canal (128 bpp).

rg11b10f

Point flottant RVB avec 11 bits dans les canaux rouge et vert et 10 bits dans le canal bleu (32 bpp). Il n'y a pas de canal alpha. Les valeurs de couleur peuvent aller de {0, +65024}.

srgb

Le même que rgba8, mais le Canvas est interprété comme étant dans l'espace de couleur sRGB. Tout dessiné sur le Canvas sera converti de RVB linéaire en sRGB. Lorsque le Canvas est dessiné (ou utilisé dans un shader), il sera décodé de sRGB en RGB linéaire. Cela réduit les bandes de couleurs lors d'un rendu gamma-correct, car l'encodage sRGB a plus de précision que RVB linéaire pour des couleurs plus foncées.

r8

Format à une seule chaîne (composante rouge) (8 bpp).

rg8

Deux canaux (composants rouge et vert) avec 8 bits par canal (16 bpp).

r16f

Format flottant à un seul canal (16 bpp). Les valeurs de couleur peuvent aller de {-65504, +65504}.

rg16f

Format flottant à deux canaux avec 16 bits par canal (32 bpp). Les valeurs de couleur peuvent aller de {-65504, +65504}.

r32f

Format à canal unique à point flottant (32 bpp).

rg32f

Format flottant à deux canaux avec 32 bits par canal (64 bpp).

CompareMode

equal

La valeur du pochoir du pixel doit être égale à la valeur fournie.

notequal

La valeur du pochoir du pixel ne doit pas être égale à la valeur fournie.

less

La valeur du pochoir du pixel doit être inférieure à la valeur fournie.

lequal

La valeur du pochoir du pixel doit être inférieure ou égale à la valeur fournie.

gequal

La valeur du pochoir du pixel doit être supérieure ou égale à la valeur fournie.

greater

La valeur du pochoir du pixel doit être supérieure à la valeur fournie.

DrawMode

fill

Dessinez la forme remplie.

line

Dessinez la forme décrite.

FilterMode

linear

Scale image avec interpolation linéaire.

nearest

Échelle d'image avec l'interpolation voisine la plus proche.

GraphicsFeature

clampzero

Que le WrapMode "clampzero" soit pris en charge.

lighten

Que les BlendModes «éclaircis» et «obscurs» soient pris en charge.

multicanvasformats

Que les Toiles multiples avec différents formats puissent être utilisées dans le même appel love.graphics.setCanvas.

GraphicsLimit

pointsize

La taille maximale des points.

texturesize

La largeur ou la hauteur maximale des images et des toiles.

multicanvas

Le nombre maximal de toiles simultanément actives (via love.graphics.setCanvas).

canvasmsaa

Le nombre maximal d'échantillons antialiasing pour un Canvas.

LineJoin

miter

Les extrémités des segments de ligne sont biseautés dans un angle afin de rejoindre de façon transparente.

bevel

Aucun cap appliqué aux extrémités des segments de ligne.

none

Ajoute le point où les segments de ligne se rejoignent.

LineStyle

rough

Dessinez des lignes grossières.

smooth

Dessinez des lignes lisses.

MeshDrawMode

fan

Les sommets créent une forme de "ventilateur" avec le premier sommet agissant comme point central. Peut être facilement utilisé pour dessiner des polygones convexes simples.

strip

Les sommets créent une série de triangles connectés en utilisant les sommets 1, 2, 3, puis 3, 2, 4 (notez l'ordre), puis 3, 4, 5 et ainsi de suite.

triangles

Les sommets créent des triangles non connectés.

points

Les sommets sont dessinés comme des points non connectés (voir love.graphics.setPointSize).

ParticleInsertMode

top

Les particules sont insérées au sommet de la liste de particules du ParticleSystem.

bottom

Les particules sont insérées au bas de la liste de particules du ParticleSystem.

random

Les particules sont insérées dans des positions aléatoires dans la liste des particules du ParticleSystem.

SpriteBatchUsage

dynamic

Les données de l'objet changeront de temps en temps pendant toute sa durée de vie.

static

L'objet ne sera pas modifié après l'ajout de sprites ou sommets initiaux.

stream

Les données de l'objet vont toujours changer entre tirages.

StackType

transform

La pile de transformation (love.graphics.translate, love.graphics.rotate, etc.)

all

Tout l'état de love.graphics, y compris l'état de transformation.

StencilAction

replace

La valeur du stencil d'un pixel sera remplacée par la valeur spécifiée dans love.graphics.stencil, si un objet touche le pixel.

increment

La valeur du stencil d'un pixel sera incrémentée de 1 pour chaque objet qui touche le pixel. Si la valeur du stencil atteint 255, elle restera à 255.

decrement

La valeur du pochoir d'un pixel sera décrémentée de 1 pour chaque objet qui touche le pixel. Si la valeur du stencil atteint 0, elle restera à 0.

incrementwrap

La valeur du stencil d'un pixel sera incrémentée de 1 pour chaque objet qui touche le pixel. Si une valeur de stencil de 255 est incrémentée, elle sera définie sur 0.

decrementwrap

La valeur du pochoir d'un pixel sera décrémentée de 1 pour chaque objet qui touche le pixel. Si la valeur du pochoir de 0 est décrémentée, elle sera définie sur 255.

invert

La valeur du pochoir d'un pixel sera inversée par bit pour chaque objet qui touche le pixel. Si une valeur de pochoir de 0 est inversée, elle deviendra 255.

WrapMode

clamp

Comment l'image s'emballe dans un Quad avec une taille de quad plus grande que la taille de l'image. Cela affecte également la façon dont les mailles avec des coordonnées de texture qui sont en dehors de la plage de {0, 1} sont dessinées et la couleur renvoyée par la fonction Texel Shader lors de l'utilisation pour échantillonner à partir de coordonnées de texture en dehors de la plage de {0, 1}.

repeat

Répétez l'image. Remplit toute l'étendue disponible.

mirroredrepeat

Répétez la texture, la bascule chaque fois qu'elle se répète. Peut produire de meilleurs résultats visuels que le mode répétitif lorsque la texture ne se présente pas correctement.

clampzero

Serrer la texture. Remplit la zone en dehors de la plage normale de la texture avec un noir transparent (ou noir opaque pour les textures sans canal alpha).

Canvas

Un Toile est utilisé pour le rendu hors écran. Pensez-y comme un écran invisible que vous pouvez dessiner, mais cela ne sera visible que lorsque vous l'attirez sur l'écran réel visible. Il est également connu sous le nom de "render to texture".

En dessinant des éléments qui ne changent pas souvent la position (tels que les éléments d'arrière-plan) sur le canevas, puis en dessinant l'ensemble de la Toile au lieu de chaque élément, vous pouvez réduire le nombre d'opérations de tirage exécutées à chaque image.

Dans les versions antérieures à 0,10.0, toutes les cartes graphiques que Là-VE n'a pas supportées pourraient utiliser des Toiles. love.graphics.isSupported ("canvas") pourrait être utilisé pour vérifier le support au moment de l'exécution.

Constructors

Functions

Supertypes

Canvas:getDimensions

Obtient la largeur et la hauteur de la Toile.

width, height = Canvas:getDimensions()

widthnumberLa largeur de la Toile, en pixels.
heightnumberLa hauteur de la toile, en pixels.

Canvas:getFilter

Obtient le mode de filtrage du Canvas.

min, mag, anisotropy = Canvas:getFilter()

minFilterModeMode de filtrage utilisé lors de la minification du canevas.
magFilterModeMode de filtrage utilisé lors de l'agrandissement du canevas.
anisotropynumberQuantité maximale de filtrage anisotrope utilisé.

Canvas:getFormat

Obtient le format de texture du Canvas.

format = Canvas:getFormat()

formatCanvasFormatLe format de la Toile.

Canvas:getHeight

Obtient la hauteur de la toile.

height = Canvas:getHeight()

heightnumberLa hauteur de la toile, en pixels.

Canvas:getMSAA

Obtient le nombre d'échantillons multisample antialiasing (MSAA) utilisés lors du dessin sur le Canvas.

Cela peut être différent du nombre utilisé comme argument pour aimer.graphics.newCanvas si le système qui exécute LÉV ne prend pas en charge ce numéro.

samples = Canvas:getMSAA()

samplesnumberLe nombre d'échantillons anti-altération multisample utilisés par la toile lors du dessin.

Canvas:getWidth

Obtient la largeur de la Toile.

width = Canvas:getWidth()

widthnumberLa largeur de la Toile, en pixels.

Canvas:getWrap

Obtient les propriétés d'emballage d'un Canvas.

Cette fonction renvoie les modes d'emballage horizontal et vertical actuellement définis pour le Canvas.

horizontal, vertical = Canvas:getWrap()

horizontalWrapModeMode d'emballage horizontal du Canvas.
verticalWrapModeMode d'emballage vertical du Canvas.

Canvas:newImageData

Génère ImageData à partir du contenu de la Canvas.

data = Canvas:newImageData()

dataImageDataLes données d'image stockées dans le Canvas.

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

dataImageDataLe nouveau ImageData fait à partir du contenu de Canvas.
xnumberL'axe des x du coin supérieur gauche de la zone dans le Canvas à capturer.
ynumberL'axe des y du coin supérieur gauche de la zone située dans le canevas à capturer.
widthnumberLa largeur de la zone dans le Canvas à capturer.
heightnumberLa hauteur de la zone dans la toile à capturer.

Canvas:renderTo

Rendez-vous sur le canevas en utilisant une fonction.

Canvas:renderTo( func )

funcfunctionUne fonction effectuant des opérations de dessin.

Canvas:setFilter

Définit le filtre de la Toile.

Canvas:setFilter( min, mag, anisotropy )

minFilterModeComment étaler une toile vers le bas.
mag (min)FilterModeComment mettre à l'échelle une toile.
anisotropy (1)numberQuantité maximale de filtrage anisotrope utilisé.

Canvas:setWrap

Définit les propriétés d'emballage d'un Canvas.

Cette fonction définit la façon dont les bords d'une toile sont traités si elle est mise à l'échelle ou tournée. Si le WrapMode est réglé sur "clamp", le bord ne sera pas interpolé. Si elle est définie pour "répéter", le bord sera interpolé avec les pixels du côté opposé du framebuffer.

Canvas:setWrap( horizontal, vertical )

horizontalWrapModeMode d'emballage horizontal du Canvas.
vertical (horizontal)WrapModeMode d'emballage vertical du Canvas.

Font

Définit la forme des caractères que l'on peut tirer sur l'écran.

Constructors

Functions

Supertypes

Font:getAscent

Obtient l'ascension de la police. L'ascension s'étend sur la distance entre la ligne de base et le sommet du glyphe qui atteint le plus loin de la ligne de base.

ascent = Font:getAscent()

ascentnumberL'ascension de la police en pixels.

Font:getBaseline

Obtient la ligne de base de la police. La plupart des scripts partagent la notion de ligne de base: une ligne horizontale imaginaire sur laquelle les personnages restent. Dans certains scripts, les parties des glyphes se situent en dessous de la ligne de base.

baseline = Font:getBaseline()

baselinenumberLa ligne de base de la police en pixels.

Font:getDescent

Obtient la descente de la police. La descente s'étend sur la distance entre la ligne de base et le glyphe descendant le plus bas dans une police de caractères.

descent = Font:getDescent()

descentnumberLa descente de la police en pixels.

Font:getFilter

Obtient le mode de filtrage pour une police.

min, mag, anisotropy = Font:getFilter()

minFilterModeMode de filtrage utilisé lors de la minification de la police.
magFilterModeMode de filtrage utilisé lors de l'agrandissement de la police.
anisotropynumberQuantité maximale de filtrage anisotrope utilisé.

Font:getHeight

Obtient la hauteur de la police. La taille de la police est la taille, y compris l'espacement; la hauteur dont il aura besoin.

height = Font:getHeight()

heightnumberLa hauteur de la police en pixels.

Font:getLineHeight

Obtient la hauteur de la ligne. Ce sera la valeur définie par Font: setLineHeight ou 1.0 par défaut.

height = Font:getLineHeight()

heightnumberLa hauteur actuelle de la ligne.

Font:getWidth

Détermine la taille horizontale requise par une ligne de texte. Ne prend pas en charge les pauses de ligne.

width = Font:getWidth( line )

widthnumberLa largeur de la ligne.
linestringUne ligne de texte.

Font:getWrap

Obtient la mise en forme des informations pour le texte, compte tenu d'une limite d'enveloppement.

Cette fonction explique correctement les nouvelles lignes (c.-à-d. '\ N').

width, wrappedtext = Font:getWrap( text, wraplimit )

widthnumberLa largeur maximale du texte enveloppé.
wrappedtexttableUne séquence contenant chaque ligne de texte qui a été enveloppée.
textstringLe texte sera enroulé.
wraplimitnumberLa largeur maximale en pixels de chaque ligne que le texte est autorisé avant l'enroulement.

Font:hasGlyphs

Obtient si la police peut rendre un caractère particulier.

hasglyph = Font:hasGlyphs( character )

hasglyphbooleanQue la police puisse rendre le glyphe représenté par le personnage.
characterstringUn caractère unicode.

hasglyph = Font:hasGlyphs( codepoint )

hasglyphbooleanQue la police puisse rendre le glyphe représenté par le numéro du codepoint.
codepointnumberUn numéro de code-code unicode.

Font:setFallbacks

Définit les polices de secours. Lorsque la police ne contient pas de glyphe, elle remplacera le glyphe des polices de repli suivantes. Ceci est semblable à la définition d'une "pile de polices" dans les feuilles de style en cascade (CSS).

Font:setFallbacks( fallbackfont1, ... )

fallbackfont1FontLa première police de secours à utiliser.
...FontPolices de rechange supplémentaires.

Font:setFilter

Définit le mode de filtrage pour une police.

Font:setFilter( min, mag, anisotropy )

minFilterModeComment faire basculer une police vers le bas.
mag (min)FilterModeComment étaler une police vers le haut.
anisotropy (1)numberQuantité maximale de filtrage anisotrope utilisé.

Font:setLineHeight

Définit la hauteur de la ligne. Lors du rendu de la police dans les lignes, la hauteur réelle sera déterminée par la hauteur de la ligne multipliée par la hauteur de la police. La valeur par défaut est 1.0.

Font:setLineHeight( height )

heightnumberLa nouvelle hauteur de ligne.

Mesh

Un maillage de polygone 2D utilisé pour dessiner des formes texturées arbitraires.

Constructors

Functions

Supertypes

Mesh:attachAttribute

Attache un attribut vertex d'un Mesh différent sur ce Mesh, pour l'utiliser lors du dessin. Cela peut être utilisé pour partager des données d'attribut vertex entre plusieurs différents modèles.

Mesh:attachAttribute( name, mesh )

namestringLe nom de l'attribut vertex à attacher.
meshMeshThe Mesh pour obtenir l'attribut vertex.

Mesh:getDrawMode

Obtient le mode utilisé lors du dessin du maillage.

mode = Mesh:getDrawMode()

modeMeshDrawModeLe mode utilisé lors du dessin du maillage.

Mesh:getDrawRange

Obtient la gamme des sommets utilisés lors du dessin du maillage.

Si la plage de tirage du Mesh n'a pas été définie précédemment avec Mesh: setDrawRange, cette fonction renverra nile.

min, max = Mesh:getDrawRange()

minnumberL'index du premier sommet utilisé lors du dessin, ou l'index de la première valeur dans la carte vertex utilisée si l'on est configuré pour ce Mesh.
maxnumberL'index du dernier sommet utilisé lors du dessin, ou l'indice de la dernière valeur dans la carte de sommet utilisé si l'on est défini pour ce maillage.

Mesh:getTexture

Obtient la texture (Image ou Toile) utilisée lors du dessin du Mesh.

texture = Mesh:getTexture()

textureTextureL'image ou le canevas pour texturer le maillage lors du dessin, ou nul si aucun n'est défini.

Mesh:getVertex

Obtient les propriétés d'un sommet dans le maillage.

attributecomponent, ... = Mesh:getVertex( index )

attributecomponentnumberLe premier composant du premier attribut vertex dans le sommet spécifié.
...numberComposants supplémentaires de tous les attributs de vertex dans le sommet spécifié.
indexnumberL'index du sommet pour lequel vous souhaitez récupérer l'information.

x, y, u, v, r, g, b, a = Mesh:getVertex( index )

xnumberLa position du sommet sur l'axe des abscisses.
ynumberLa position du sommet sur l'axe des y.
unumberLe composant horizontal de la coordonnée de texture.
vnumberLa composante verticale de la coordonnée de texture.
rnumberLe composant rouge de la couleur du sommet.
gnumberLe composant vert de la couleur du sommet.
bnumberLa composante bleue de la couleur du sommet.
anumberLa composante alpha de la couleur du sommet.
indexnumberL'index du sommet pour lequel vous souhaitez récupérer l'information.

Mesh:getVertexAttribute

Obtient les propriétés d'un attribut spécifique dans un sommet dans le Mesh.

Meshes sans un format de sommet personnalisé spécifié dans love.graphics.newMesh ont la position comme leur premier attribut, les coordonnées de texture comme leur second attribut et la couleur comme leur troisième attribut.

value1, value2, ... = Mesh:getVertexAttribute( vertexindex, attributeindex )

value1numberLa valeur du premier composant de l'attribut.
value2numberLa valeur de la deuxième composante de l'attribut.
...numberTous les composants supplémentaires de l'attribut vertex.
vertexindexnumberL'index du sommet à modifier.
attributeindexnumberL'index de l'attribut dans le sommet à modifier.

Mesh:getVertexCount

Obtient le nombre total de sommets dans le maillage.

num = Mesh:getVertexCount()

numnumberLe nombre total de sommets dans ce maillage.

Mesh:getVertexFormat

Obtient le format de sommet avec lequel le maillage a été créé.

format = Mesh:getVertexFormat()

formattableLe format de vertex du Mesh, qui est une table contenant des tables pour chaque attribut de vertex, le Mesh a été créé avec, sous la forme de {attribute, ...}.
format.attributetableUne table contenant le nom de l'attribut, son type de données et le nombre de composants dans l'attribut, sous la forme de {nom, type de données, composants}.
format....tableAttributs de vertex supplémentaires dans le Mesh.

Mesh:getVertexMap

Obtient la carte vertex pour le Mesh. La carte vertex décrit l'ordre dans lequel les sommets sont utilisés lorsque le maillage est dessiné. Les sommets, la carte des sommets et le mode de dessin en moustaches fonctionnent ensemble pour déterminer ce qui s'affiche exactement sur l'écran.

Si aucune carte vertex n'a été définie précédemment via Mesh: setVertexMap, cette fonction retournera nile dans LÖVE 0.10.0+ ou une table vide en 0.9.2 et plus ancien.

map = Mesh:getVertexMap()

maptableUne table contenant une liste des indices de sommet utilisés lors du tirage.

Mesh:isAttributeEnabled

Obtient si un attribut vertex spécifique dans le Mesh est activé. Les données Vertex des attributs désactivés ne sont pas utilisées lors du dessin du Mesh.

enabled = Mesh:isAttributeEnabled( name )

enabledbooleanQue l'attribut vertex soit utilisé lors du dessin de ce maillage.
namestringLe nom de l'attribut vertex pour activer ou désactiver.

Mesh:setAttributeEnabled

Active ou désactive un attribut de vertex spécifique dans le Mesh. Les données Vertex des attributs désactivés ne sont pas utilisées lors du dessin du Mesh.

Mesh:setAttributeEnabled( name, enable )

namestringLe nom de l'attribut vertex pour activer ou désactiver.
enablebooleanQue l'attribut vertex soit utilisé lors du dessin de ce maillage.

Mesh:setDrawMode

Définit le mode utilisé lors du dessin du maillage.

Mesh:setDrawMode( mode )

modeMeshDrawModeLe mode à utiliser lors du dessin du maillage.

Mesh:setDrawRange

Limite les sommets dessinés du maillage à un sous-ensemble du total.

Si une carte de sommet est utilisée avec le maillage, cette méthode définira un sous-ensemble des valeurs dans le tableau de la carte de sommet à utiliser, au lieu d'un sous-ensemble des sommets totaux dans le maillage.

Par exemple, si Mesh: setVertexMap (1, 2, 3, 1, 3, 4) et Mesh: setDrawRange (4, 6) sont appelés, les sommets 1, 3 et 4 seront dessinés.

Mesh:setDrawRange( min, max )

minnumberL'index du premier sommet à utiliser lors du dessin ou l'index de la première valeur dans la carte de sommet à utiliser si l'on est configuré pour ce maillage.
maxnumberL'index du dernier sommet à utiliser lors du dessin, ou l'index de la dernière valeur dans la carte de sommet à utiliser si l'on est configuré pour ce maillage.

Mesh:setDrawRange()

Allows all vertices in the Mesh to be drawn.

Mesh:setTexture

Définit la texture (image ou toile) utilisée lors du dessin du maillage.

Lorsqu'on l'appelle sans argument désactive la texture. Les maillages non texturés ont une couleur blanche par défaut.

Mesh:setTexture()

Mesh:setTexture( texture )

textureTextureL'image ou le canevas pour la texture du maillage lors du dessin.

Mesh:setVertex

Définit les propriétés d'un sommet dans le maillage.

Mesh:setVertex( index, attributecomponent, ... )

indexnumberL'index du sommet que vous souhaitez modifier.
attributecomponentnumberLe premier composant du premier attribut vertex dans le sommet spécifié.
...numberComposants supplémentaires de tous les attributs de vertex dans le sommet spécifié.

Mesh:setVertex( index, vertex )

indexnumberL'index du sommet que vous souhaitez modifier.
vertextableUne table avec des informations de vertex, sous la forme de {attributecomponent, ...}.
vertex.attributecomponentnumberLe premier composant du premier attribut vertex dans le sommet spécifié.
vertex....numberComposants supplémentaires de tous les attributs de vertex dans le sommet spécifié.

Mesh:setVertex( index, x, y, u, v, r, g, b, a )

Sets the vertex components of a Mesh that wasn't created with a custom vertex format.

indexnumberL'index du sommet que vous souhaitez modifier.
xnumberLa position du sommet sur l'axe des abscisses.
ynumberLa position du sommet sur l'axe des y.
unumberLe composant horizontal de la coordonnée de texture.
vnumberLa composante verticale de la coordonnée de texture.
r (255)numberLe composant rouge de la couleur du sommet.
g (255)numberLe composant vert de la couleur du sommet.
b (255)numberLa composante bleue de la couleur du sommet.
a (255)numberLa composante alpha de la couleur du sommet.

Mesh:setVertex( index, vertex )

Sets the vertex components of a Mesh that wasn't created with a custom vertex format.

indexnumberL'index du sommet que vous souhaitez modifier.
vertextableUne table avec des informations de vertex.
vertex.[1]numberLa position du sommet sur l'axe des abscisses.
vertex.[2]numberLa position du sommet sur l'axe des y.
vertex.[3]numberLe composant horizontal de la coordonnée de texture.
vertex.[4]numberLa composante verticale de la coordonnée de texture.
vertex.[5] (255)numberLe composant rouge de la couleur du sommet.
vertex.[6] (255)numberLe composant vert de la couleur du sommet.
vertex.[7] (255)numberLa composante bleue de la couleur du sommet.
vertex.[8] (255)numberLa composante alpha de la couleur du sommet.

Mesh:setVertexAttribute

Définit les propriétés d'un attribut spécifique dans un sommet dans le maillage.

Meshes sans un format de sommet personnalisé spécifié dans love.graphics.newMesh ont la position comme leur premier attribut, les coordonnées de texture comme leur second attribut et la couleur comme leur troisième attribut.

Mesh:setVertexAttribute( vertexindex, attributeindex, value1, value2, ... )

vertexindexnumberL'index du sommet à modifier.
attributeindexnumberL'index de l'attribut dans le sommet à modifier.
value1numberLa valeur du premier composant de l'attribut.
value2numberLa valeur de la deuxième composante de l'attribut.
...numberTous les composants supplémentaires de l'attribut vertex.

Mesh:setVertexMap

Définit la carte vertex pour le Mesh. La carte vertex décrit l'ordre dans lequel les sommets sont utilisés lorsque le maillage est dessiné. Les sommets, la carte des sommets et le mode de dessin en moustaches fonctionnent ensemble pour déterminer ce qui s'affiche exactement sur l'écran.

La carte vertex vous permet de réorganiser ou de réutiliser les sommets lors du dessin sans modifier les paramètres de vertex réels ou les verbes en double. Il est particulièrement utile lorsqu'il est combiné avec différents modes de traction de maillage.

Mesh:setVertexMap( map )

maptableUne table contenant une liste d'indices de sommet à utiliser lors du dessin. Les valeurs doivent être comprises dans {1, Mesh: getVertexCount ()}.

Mesh:setVertexMap( vi1, vi2, vi3 )

vi1numberL'index du premier sommet à utiliser lors du dessin. Doit être dans la plage de {1, Mesh: getVertexCount ()}.
vi2numberL'index du second sommet à utiliser lors du dessin.
vi3numberL'index du troisième sommet à utiliser lors du dessin.

Mesh:setVertices

Remplace une gamme de sommets dans le Mesh par de nouveaux. Le nombre total de sommets dans un Mesh ne peut pas être modifié après sa création.

Mesh:setVertices( vertices )

verticestableLa table remplie de tables d'informations de sommet pour chaque sommet, sous la forme de {vertex, ...} où chaque sommet est une table sous la forme de {componentcomponent, ...}.
vertices.attributecomponentnumberLe premier composant du premier attribut vertex dans le sommet.
vertices....numberComposants supplémentaires de tous les attributs de vertex dans le sommet.
vertices.startvertex (1)numberL'index du premier sommet à remplacer.

Mesh:setVertices( vertices )

Sets the vertex components of a Mesh that wasn't created with a custom vertex format.

verticestableLa table remplie de tables d'informations de sommet pour chaque sommet comme suit:
vertices.[1]numberLa position du sommet sur l'axe des abscisses.
vertices.[2]numberLa position du sommet sur l'axe des y.
vertices.[3]numberLe composant horizontal de la coordonnée de texture. Les coordonnées de texture sont normalement dans la plage de {0, 1}, mais peuvent être supérieures ou inférieures (voir WrapMode).
vertices.[4]numberLa composante verticale de la coordonnée de texture. Les coordonnées de texture sont normalement dans la plage de {0, 1}, mais peuvent être supérieures ou inférieures (voir WrapMode).
vertices.[5] (255)numberLe composant couleur rouge.
vertices.[6] (255)numberLa composante couleur verte.
vertices.[7] (255)numberLa composante couleur bleue.
vertices.[8] (255)numberLe composant de couleur alpha.

Image

Type d'image desséchable.

Constructors

Functions

Supertypes

Image:getData

Obtient ImageData original ou CompressedImageData utilisé pour créer l'image.

Toutes les images contiennent une référence aux données utilisées pour créer l'image. Les données sont utilisées pour rafraîchir l'image lorsque love.window.setMode ou Image: refresh est appelé.

data = Image:getData()

dataImageDataImageData d'origine utilisée pour créer l'image, si l'image n'est pas compressée.

data = Image:getData()

dataCompressedImageDataL'original CompressedImageData utilisé pour créer l'image, si l'image est compressée.

Image:getDimensions

Obtient la largeur et la hauteur de l'image.

width, height = Image:getDimensions()

widthnumberLa largeur de l'image, en pixels.
heightnumberHauteur de l'image, en pixels.

Image:getFilter

Obtient le mode de filtrage pour une image.

min, mag = Image:getFilter()

minFilterModeLe mode Filtre utilisé lors de la minification de l'image.
magFilterModeMode de filtrage utilisé lors de la grossissement de l'image.

Image:getFlags

Obtient les drapeaux utilisés lors de la création de l'image.

flags = Image:getFlags()

flagstableUne table avec les clés ImageFlag.

Image:getHeight

Obtient la hauteur de l'image.

height = Image:getHeight()

heightnumberHauteur de l'image, en pixels.

Image:getMipmapFilter

Obtient le mode filtre mipmap pour une image.

mode, sharpness = Image:getMipmapFilter()

modeFilterModeLe mode de filtrage utilisé entre les niveaux mipmap. néant si le filtrage mipmap n'est pas activé.
sharpnessnumberValeur utilisée pour déterminer si l'image doit utiliser des niveaux de mipmap plus ou moins détaillés que la normale lors du dessin.

Image:getWidth

Obtient la largeur de l'image.

width = Image:getWidth()

widthnumberLa largeur de l'image, en pixels.

Image:getWrap

Obtient les propriétés d'emballage d'une image.

Cette fonction renvoie les modes d'emballage horizontal et vertical actuellement définis pour l'image.

horizontal, vertical = Image:getWrap()

horizontalWrapModeMode d'emballage horizontal de l'image.
verticalWrapModeMode d'emballage vertical de l'image.

Image:refresh

Recharge le contenu de l'Image depuis ImageData ou CompressedImageData utilisé pour créer l'image.

Image:refresh()

Image:refresh( x, y, width, height )

xnumberL'axe des x du coin supérieur gauche de la zone à l'intérieur de l'image pour recharger.
ynumberL'axe des y du coin supérieur gauche de la zone de l'image à recharger.
widthnumberLa largeur de la zone à l'intérieur de l'image à recharger.
heightnumberLa hauteur de la zone à l'intérieur de l'image à recharger.

Image:setFilter

Définit le mode de filtrage pour une image.

Image:setFilter( min, mag )

minFilterModeComment réduire une image vers le bas.
mag (min)FilterModeComment étaler une image vers le haut.

Image:setMipmapFilter

Définit le mode de filtre mipmap pour une image.

Le mipmapping est utile lors du dessin d'une image à une échelle réduite. Il peut améliorer les performances et réduire les problèmes d'alias.

En 0.10.0 et plus récent, l'image doit être créée avec l'indicateur mipmaps activé pour que le filtre mipmap ait un effet quelconque.

Image:setMipmapFilter( filtermode, sharpness )

filtermodeFilterModeLe mode de filtrage à utiliser entre les niveaux mipmap. "plus proche" donnera souvent une meilleure performance.
sharpness (0)numberUne valeur de netteté positive permet à l'image d'utiliser un niveau mipmap plus détaillé lors du dessin, au détriment des performances. Une valeur négative est inversée.

Image:setMipmapFilter()

Disables mipmap filtering.

Image:setWrap

Définit les propriétés d'emballage d'une image.

Cette fonction définit la façon dont une image est répétée lorsqu'elle est dessinée avec un Quad qui est plus grand que l'étendue de l'image. Une image peut être serrée ou configurée pour répéter dans les directions horizontale et verticale. Les images serrées apparaissent une seule fois, mais les répétitions répètent autant de fois qu'il y a de place dans le Quad.

Si vous utilisez un Quad qui est plus grand que l'étendue de l'image et n'utilisez pas de carreaux répétés, il peut y avoir un effet visuel indésirable de l'étirement de l'image tout le chemin pour remplir le Quad. Si c'est le cas, définissez Image: getWrap ("repeat", "repeat") pour toutes les images à répéter, et en utilisant Quad de taille appropriée, vous obtiendrez le meilleur aspect visuel.

Image:setWrap( horizontal, vertical )

horizontalWrapModeMode d'emballage horizontal de l'image.
vertical (horizontal)WrapModeMode d'emballage vertical de l'image.

ParticleSystem

Utilisé pour créer des effets intéressants, comme le feu. Les systèmes de particules sont créés et dessinés sur l'écran à l'aide de fonctions amoureuses. Ils doivent également être mis à jour dans le rappel de mise à jour (dt) pour que vous voyiez toute modification des particules émises.

Constructors

Functions

Supertypes

ParticleSystem:clone

Crée une copie identique du ParticleSystem à l'état arrêté.

Clunked ParticleSystem hérite de tout l'état stable du ParticleSystem d'origine, mais ils sont initialisés arrêtés.

particlesystem = ParticleSystem:clone()

particlesystemParticleSystemLa nouvelle copie identique de ce ParticleSystem.

ParticleSystem:emit

Émette un éclat de particules de l'émetteur de particules.

ParticleSystem:emit( numparticles )

numparticlesnumberLa quantité de particules à émettre. Le nombre de particules émises sera tronqué si la taille maximale du tampon du système de particules est atteinte.

ParticleSystem:getCount

Obtient la quantité de particules qui se trouvent actuellement dans le système.

count = ParticleSystem:getCount()

countnumberLe nombre actuel de particules vivantes.

ParticleSystem:getAreaSpread

Obtient les paramètres de spawn basés sur la zone pour les particules.

distribution, dx, dy = ParticleSystem:getAreaSpread()

distributionAreaSpreadDistributionLe type de distribution pour les nouvelles particules.
dxnumberLa distance de propagation maximale de l'émetteur le long de l'axe des abscisses pour une distribution uniforme, ou l'écart type selon l'axe des abscisses pour une distribution normale.
dynumberLa distance de propagation maximale de l'émetteur le long de l'axe des y pour une distribution uniforme, ou l'écart type selon l'axe des y pour la distribution normale.

ParticleSystem:getBufferSize

Obtient la taille du tampon (la quantité maximale de particules autorisée dans le système).

buffer = ParticleSystem:getBufferSize()

buffernumberLa taille du tampon.

ParticleSystem:getColors

Obtient une série de couleurs à appliquer au sprite de particules. Le système de particules interpolera entre chaque couleur uniformément sur la durée de vie de la particule. La modulation de couleur doit être activée pour que cette fonction ait un effet quelconque.

Les arguments sont transmis en groupes de quatre, représentant les composants de la valeur RGBA souhaitée. Au moins une couleur doit être spécifiée. Un maximum de huit peut être utilisé.

r1, g1, b1, a1, r2, g2, b2, a2, ... = ParticleSystem:getColors()

r1numberPremière couleur, composant rouge (0-255).
g1numberPremière couleur, composant vert (0-255).
b1numberPremière couleur, composant bleu (0-255).
a1numberPremière couleur, composant alpha (0-255).
r2numberDeuxième couleur, composant rouge (0-255).
g2numberDeuxième couleur, composant vert (0-255).
b2numberDeuxième couleur, composant bleu (0-255).
a2numberDeuxième couleur, composant alpha (0-255).
...numberEtc.

ParticleSystem:getDirection

Obtient la direction dans laquelle les particules seront émises.

direction = ParticleSystem:getDirection()

directionnumberLa direction des particules (en radians).

ParticleSystem:getEmissionRate

Obtient la quantité de particules émises par seconde.

rate = ParticleSystem:getEmissionRate()

ratenumberLa quantité de particules par seconde.

ParticleSystem:getInsertMode

Obtient le mode à utiliser lorsque le ParticleSystem ajoute de nouvelles particules.

mode = ParticleSystem:getInsertMode()

modeParticleInsertModeLe mode à utiliser lorsque le ParticleSystem ajoute de nouvelles particules.

ParticleSystem:getLinearAcceleration

Obtient l'accélération linéaire (accélération le long des axes x et y) pour les particules.

Chaque particule créée accélérera le long des axes x et y entre xmin, ymin et xmax, ymax.

xmin, ymin, xmax, ymax = ParticleSystem:getLinearAcceleration()

xminnumberL'accélération minimale le long de l'axe des x.
yminnumberL'accélération minimale le long de l'axe y.
xmaxnumberL'accélération maximale le long de l'axe des x.
ymaxnumberL'accélération maximale selon l'axe y.

ParticleSystem:getLinearDamping

Obtient la quantité d'amortissement linéaire (décélération constante) pour les particules.

min, max = ParticleSystem:getLinearDamping()

minnumberLa quantité minimale d'amortissement linéaire appliquée aux particules.
maxnumberLa quantité maximale d'amortissement linéaire appliquée aux particules.

ParticleSystem:getEmitterLifetime

Obtient combien de temps le système de particules doit émettre des particules (si -1 puis émet des particules pour toujours).

life = ParticleSystem:getEmitterLifetime()

lifenumberLa durée de vie de l'émetteur (en secondes).

ParticleSystem:getOffset

Obtenez la position offget que le sprite de particule tourne autour. Si cette fonction n'est pas utilisée, les particules tournent autour de leur centre.

x, y = ParticleSystem:getOffset()

xnumberLa coordonnée x de l'arrêt de rotation.
ynumberLa coordonnée y de l'arrêt de rotation.

ParticleSystem:getParticleLifetime

Permet la vie des particules.

min, max = ParticleSystem:getParticleLifetime()

minnumberLa durée de vie minimale des particules (secondes).
max (min)numberLa durée de vie maximale des particules (secondes).

ParticleSystem:getQuads

Obtient la série de Quads utilisée pour les sprites de particules.

quads = ParticleSystem:getQuads()

quadstableUne table contenant les Quads utilisée.

ParticleSystem:getPosition

Obtient la position de l'émetteur.

x, y = ParticleSystem:getPosition()

xnumberPosition le long de l'axe des abscisses.
ynumberPosition le long de l'axe des y.

ParticleSystem:getRadialAcceleration

Obtenez l'accélération radiale (loin de l'émetteur).

min, max = ParticleSystem:getRadialAcceleration()

minnumberL'accélération minimale.
max (min)numberL'accélération maximale.

ParticleSystem:getRotation

Obtient la rotation de l'image lors de la création de particules (en radians).

min, max = ParticleSystem:getRotation()

minnumberL'angle initial minimum (radians).
max (min)numberL'angle initial maximal (radians).

ParticleSystem:getSizes

Obtient une série de tailles permettant d'étaler un sprite de particules. 1.0 est la taille normale. Le système de particules interpolera entre chaque taille uniformément sur la durée de vie de la particule.

Au moins une taille doit être spécifiée. Un maximum de huit peut être utilisé.

size1, size2, ... = ParticleSystem:getSizes()

size1numberLa première taille.
size2numberLa deuxième taille.
...numberEtc.

ParticleSystem:getSizeVariation

Obtient le degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

variation = ParticleSystem:getSizeVariation()

variationnumberLe degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:getSpeed

Permet la vitesse des particules.

min, max = ParticleSystem:getSpeed()

minnumberLa vitesse linéaire minimale des particules.
max (min)numberLa vitesse linéaire maximale des particules.

ParticleSystem:getSpin

Obtient le spin du sprite.

min, max = ParticleSystem:getSpin()

minnumberLe spin minimum (radians par seconde).
max (min)numberLe spin maximum (radians par seconde).

ParticleSystem:getSpinVariation

Obtient le degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

variation = ParticleSystem:getSpinVariation()

variationnumberLe degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:getSpread

Obtient la quantité de spread pour le système.

spread = ParticleSystem:getSpread()

spreadnumberLa quantité de propagation (radians).

ParticleSystem:getTexture

Obtient l'image ou le canevas qui doit être émis.

texture = ParticleSystem:getTexture()

textureTextureUne image ou une toile à utiliser pour la particule.

ParticleSystem:getTangentialAcceleration

Obtient l'accélération tangentielle (accélération perpendiculaire à la direction de la particule).

min, max = ParticleSystem:getTangentialAcceleration()

minnumberL'accélération minimale.
max (min)numberL'accélération maximale.

ParticleSystem:hasRelativeRotation

Comprend si les angles et les rotations des particules sont relatifs à leurs vitesses. Si activé, les particules sont alignées sur l'angle de leurs vitesses et tournent par rapport à cet angle.

enabled = ParticleSystem:hasRelativeRotation()

enabledbooleanVrai si la rotation relative des particules est activée, false si elle est désactivée.

ParticleSystem:isActive

Vérifie si le système de particules émet activement des particules.

active = ParticleSystem:isActive()

activebooleanVrai si le système est actif, false sinon.

ParticleSystem:isPaused

Vérifie si le système de particules est en pause.

paused = ParticleSystem:isPaused()

pausedbooleanVrai si le système est en pause, faux sinon.

ParticleSystem:isStopped

Vérifie si le système de particules est arrêté.

stopped = ParticleSystem:isStopped()

stoppedbooleanVrai si le système est arrêté, faux sinon.

ParticleSystem:moveTo

Déplace la position de l'émetteur. Il en résulte un comportement de propagation des particules plus lisse que si ParticleSystem: setPosition est utilisé à chaque image.

ParticleSystem:moveTo( x, y )

xnumberPosition le long de l'axe des abscisses.
ynumberPosition le long de l'axe des y.

ParticleSystem:pause

Interrompt l'émetteur de particules.

ParticleSystem:pause()

ParticleSystem:reset

Réinitialise l'émetteur de particules, supprime les particules existantes et réinitialise le compteur de durée de vie.

ParticleSystem:reset()

ParticleSystem:setAreaSpread

Définit les paramètres de spawn basés sur les zones pour les particules. Les particules créées récemment engendreront dans une zone autour de l'émetteur en fonction des paramètres de cette fonction.

ParticleSystem:setAreaSpread( distribution, dx, dy )

distributionAreaSpreadDistributionLe type de distribution pour les nouvelles particules.
dxnumberLa distance de propagation maximale de l'émetteur le long de l'axe des abscisses pour une distribution uniforme, ou l'écart type selon l'axe des abscisses pour une distribution normale.
dynumberLa distance de propagation maximale de l'émetteur le long de l'axe des y pour une distribution uniforme, ou l'écart type selon l'axe des y pour la distribution normale.

ParticleSystem:setBufferSize

Définit la taille du tampon (la quantité maximale de particules autorisée dans le système).

ParticleSystem:setBufferSize( buffer )

buffernumberLa taille du tampon.

ParticleSystem:setColors

Définit une série de couleurs pour appliquer au sprite de particules. Le système de particules interpolera entre chaque couleur uniformément sur la durée de vie de la particule. La modulation de couleur doit être activée pour que cette fonction ait un effet quelconque.

Les arguments sont transmis en groupes de quatre, représentant les composants de la valeur RGBA souhaitée. Au moins une couleur doit être spécifiée. Un maximum de huit peut être utilisé.

ParticleSystem:setColors( r1, g1, b1, a1, r2, g2, b2, a2, ... )

r1numberPremière couleur, composant rouge (0-255).
g1numberPremière couleur, composant vert (0-255).
b1numberPremière couleur, composant bleu (0-255).
a1numberPremière couleur, composant alpha (0-255).
r2numberDeuxième couleur, composant rouge (0-255).
g2numberDeuxième couleur, composant vert (0-255).
b2numberDeuxième couleur, composant bleu (0-255).
a2numberDeuxième couleur, composant alpha (0-255).
...numberEtc.

ParticleSystem:setDirection

Définit la direction dans laquelle les particules seront émises.

ParticleSystem:setDirection( direction )

directionnumberLa direction des particules (en radians).

ParticleSystem:setEmissionRate

Définit la quantité de particules émises par seconde.

ParticleSystem:setEmissionRate( rate )

ratenumberLa quantité de particules par seconde.

ParticleSystem:setEmitterLifetime

Définit combien de temps le système de particules doit émettre des particules (si -1 puis émet des particules pour toujours).

ParticleSystem:setEmitterLifetime( life )

lifenumberLa durée de vie de l'émetteur (en secondes).

ParticleSystem:setInsertMode

Définit le mode à utiliser lorsque le ParticleSystem ajoute de nouvelles particules.

ParticleSystem:setInsertMode( mode )

modeParticleInsertModeLe mode à utiliser lorsque le ParticleSystem ajoute de nouvelles particules.

ParticleSystem:setLinearAcceleration

Définit l'accélération linéaire (accélération selon les axes x et y) pour les particules.

Chaque particule créée accélérera le long des axes x et y entre xmin, ymin et xmax, ymax.

ParticleSystem:setLinearAcceleration( xmin, ymin, xmax, ymax )

xminnumberL'accélération minimale le long de l'axe des x.
ymin (0)numberL'accélération minimale le long de l'axe y.
xmax (xmin)numberL'accélération maximale le long de l'axe des x.
ymax (ymin)numberL'accélération maximale selon l'axe y.

ParticleSystem:setLinearDamping

Définit la quantité d'amortissement linéaire (décélération constante) pour les particules.

ParticleSystem:setLinearDamping( min, max )

minnumberLa quantité minimale d'amortissement linéaire appliquée aux particules.
maxnumberLa quantité maximale d'amortissement linéaire appliquée aux particules.

ParticleSystem:setOffset

Réglez la position décalée sur laquelle le sprite de particule est tourné autour. Si cette fonction n'est pas utilisée, les particules tournent autour de leur centre.

ParticleSystem:setOffset( x, y )

xnumberLa coordonnée x du décalage de la rotation.
ynumberLa coordonnée y du décalage de la rotation.

ParticleSystem:setParticleLifetime

Définit la durée de vie des particules.

ParticleSystem:setParticleLifetime( min, max )

minnumberLa durée de vie minimale des particules (secondes).
max (min)numberLa durée de vie maximale des particules (secondes).

ParticleSystem:setPosition

Définit la position de l'émetteur.

ParticleSystem:setPosition( x, y )

xnumberPosition le long de l'axe des abscisses.
ynumberPosition le long de l'axe des y.

ParticleSystem:setQuads

Définit une série de Quads à utiliser pour les sprites de particules. Les particules choisiront un Quad de la liste en fonction de la durée de vie actuelle de la particule, permettant l'utilisation de feuilles de sprite animées avec ParticleSystems.

ParticleSystem:setQuads( quad1, quad2 )

quad1QuadLe premier Quad à utiliser.
quad2QuadLe deuxième Quad à utiliser.

ParticleSystem:setQuads( quads )

quadstableUne table contenant les Quads à utiliser.

ParticleSystem:setRadialAcceleration

Réglez l'accélération radiale (loin de l'émetteur).

ParticleSystem:setRadialAcceleration( min, max )

minnumberL'accélération minimale.
max (min)numberL'accélération maximale.

ParticleSystem:setRelativeRotation

Définit si les angles et les rotations des particules sont relatifs à leurs vitesses. Si activé, les particules sont alignées sur l'angle de leurs vitesses et tournent par rapport à cet angle.

ParticleSystem:setRelativeRotation( enable )

enablebooleanFacile à activer la rotation relative des particules, faux de le désactiver.

ParticleSystem:setRotation

Définit la rotation de l'image lors de la création de la particule (en radians).

ParticleSystem:setRotation( min, max )

minnumberL'angle initial minimum (radians).
max (min)numberL'angle initial maximal (radians).

ParticleSystem:setSizes

Définit une série de tailles permettant d'étaler un sprite de particules. 1.0 est la taille normale. Le système de particules interpolera entre chaque taille uniformément sur la durée de vie de la particule.

Au moins une taille doit être spécifiée. Un maximum de huit peut être utilisé.

ParticleSystem:setSizes( size1, size2, ... )

size1numberLa première taille.
size2numberLa deuxième taille.
...numberEtc.

ParticleSystem:setSizeVariation

Définit le degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:setSizeVariation( variation )

variationnumberLe degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:setSpeed

Définit la vitesse des particules.

ParticleSystem:setSpeed( min, max )

minnumberLa vitesse linéaire minimale des particules.
max (min)numberLa vitesse linéaire maximale des particules.

ParticleSystem:setSpin

Définit le spin du sprite.

ParticleSystem:setSpin( min, max )

minnumberLe spin minimum (radians par seconde).
max (min)numberLe spin maximum (radians par seconde).

ParticleSystem:setSpinVariation

Définit le degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:setSpinVariation( variation )

variationnumberLe degré de variation (0 signifiant aucune variation et 1 signifiant variation complète entre début et fin).

ParticleSystem:setSpread

Définit la quantité de spread pour le système.

ParticleSystem:setSpread( spread )

spreadnumberLa quantité de propagation (radians).

ParticleSystem:setTexture

Définit l'image ou la toile qui doit être émise.

ParticleSystem:setTexture( texture )

textureTextureUne image ou une toile à utiliser pour la particule.

ParticleSystem:setTangentialAcceleration

Définit l'accélération tangentielle (accélération perpendiculaire à la direction de la particule).

ParticleSystem:setTangentialAcceleration( min, max )

minnumberL'accélération minimale.
max (min)numberL'accélération maximale.

ParticleSystem:start

Commence l'émetteur de particules.

ParticleSystem:start()

ParticleSystem:stop

Arrête l'émetteur de particules, réinitialisant le compteur de durée de vie.

ParticleSystem:stop()

ParticleSystem:update

Mises à jour du système de particules; déplacer, créer et tuer des particules.

ParticleSystem:update( dt )

dtnumberL'heure (secondes) depuis la dernière image.

Quad

Un quadrilatère (un polygone à quatre côtés et quatre coins) avec des informations de coordonnées de texture.

Quads peut être utilisé pour sélectionner une partie d'une texture à dessiner. De cette façon, un atlas de grande texture peut être chargé, puis divisé en sous-images.

Constructors

Functions

Supertypes

Quad:getTextureDimensions

Obtient des dimensions de texture de référence initialement spécifiées dans love.graphics.newQuad.

sw, sh = Quad:getTextureDimensions()

swnumberLa largeur de texture utilisée par le Quad.
shnumberLa hauteur de texture utilisée par le Quad.

Quad:getViewport

Obtient la fenêtre actuelle de ce Quad.

x, y, w, h = Quad:getViewport()

xnumberLe coin supérieur gauche le long de l'axe des abscisses.
ynumberLe coin supérieur droit le long de l'axe des y.
wnumberLa largeur de la fenêtre.
hnumberLa hauteur de la fenêtre.

Quad:setViewport

Définit les coordonnées de texture en fonction d'une fenêtre.

Quad:setViewport( x, y, w, h )

xnumberLe coin supérieur gauche le long de l'axe des abscisses.
ynumberLe coin supérieur droit le long de l'axe des y.
wnumberLa largeur de la fenêtre.
hnumberLa hauteur de la fenêtre.

Shader

Un Shader est utilisé pour la manipulation avancée de pixels ou de verges accélérée par le matériel. Ces effets sont écrits dans une langue basée sur GLSL (OpenGL Shading Language) avec quelques éléments simplifiés pour faciliter le codage.

Les utilisations potentielles pour les shaders incluent HDR / bloom, flou de mouvement, niveaux de gris / inverser / sépia / tout type d'effet de couleur, réflexion / réfraction, distorsions, cartographie de bosses et bien plus encore! Voici une collection d'ombres de base et un bon point de départ pour apprendre: https://github.com/vrld/shine

Constructors

Functions

Supertypes

Shader:getExternVariable

Obtient des informations sur une variable «externe» («uniforme») dans le shader.

type, components, arrayelements = Shader:getExternVariable( name )

typeShaderVariableTypeLe type de base de la variable.
componentsnumberLe nombre de composants dans la variable (par exemple 2 pour un vec2 ou mat2).
arrayelementsnumberLe nombre d'éléments dans le tableau si la variable est un tableau, ou 1 sinon.
namestringLe nom de la variable externe.

Shader:getWarnings

Obtient tout message d'avertissement et d'erreur de la compilation du code du masque. Cela peut être utilisé pour déboguer vos shaders s'il y a quelque chose que le matériel graphique n'aime pas.

warnings = Shader:getWarnings()

warningsstringMessages d'avertissement (le cas échéant).

Shader:send

Envoie une ou plusieurs valeurs à une variable spéciale (uniforme) dans le shader. Les variables uniformes doivent être marquées à l'aide du mot-clé uniforme ou externe.

Shader:send( name, number, ... )

namestringNom du numéro à envoyer au shader.
numbernumberNuméro à envoyer en magasin dans la variable uniforme.
...numberNuméros supplémentaires à envoyer si la variable uniforme est un tableau.

Shader:send( name, vector, ... )

namestringNom du vecteur à envoyer au shader.
vectortableNuméros à envoyer à la variable uniforme en tant que vecteur. Le nombre d'éléments dans le tableau détermine le type du vecteur (par exemple, deux nombres -> vec2). Au moins deux et au plus quatre chiffres peuvent être utilisés.
...tableDes vecteurs supplémentaires à envoyer si la variable uniforme est un tableau. Tous les vecteurs doivent être de la même taille (par exemple, uniquement vec3).

Shader:send( name, matrix, ... )

namestringNom de la matrice à envoyer au shader.
matrixtable2x2, 3x3 ou 4x4 pour envoyer à la variable uniforme. En utilisant la forme de la table: {{a, b, c, d}, {e, f, g, h}, ...}.
...tableMatrices supplémentaires du même type que matrice pour stocker dans un tableau uniforme.

Shader:send( name, texture )

namestringNom de la texture à envoyer au shader.
textureTextureTexture (Image ou Toile) pour envoyer à la variable uniforme.

Shader:send( name, boolean, ... )

namestringNom du boolean à envoyer au shader.
booleanbooleanBoolean à envoyer en magasin dans la variable uniforme.
...booleanBooléos supplémentaires à envoyer si la variable uniforme est un tableau.

Shader:sendColor

Envoie une ou plusieurs couleurs à une variable vec3 ou vec4 spéciale (externe / uniforme) à l'intérieur du shader. Les composants de couleur doivent être dans la plage de {0, 255}, contrairement à Shader: envoyer. Les couleurs sont corrigées en fonction de gamma si la correction gamma globale est activée.

Shader:sendColor( name, color, ... )

namestringLe nom de la variable externe de couleur à envoyer dans le shader.
colortableUne table avec des composants de couleur alpha rouge, vert, bleu et facultatif dans la plage de {0, 255} pour envoyer à l'extérieur en tant que vecteur.
...tableDes couleurs supplémentaires à envoyer dans le cas où extern est un tableau. Toutes les couleurs doivent être de la même taille (par exemple, uniquement vec3).

SpriteBatch

En utilisant une seule image, tracez un nombre quelconque de copies identiques de l'image en utilisant un seul appel à love.graphics.draw. Cela peut être utilisé, par exemple, pour dessiner des copies répétées d'une seule image d'arrière-plan.

Un SpriteBatch peut être encore plus utile lorsque l'image sous-jacente est un Atlas de texture (un fichier image unique contenant de nombreuses images indépendantes); en ajoutant Quad au lot, différentes sous-images de l'atlas peuvent être dessinées.

Constructors

Functions

Supertypes

SpriteBatch:add

Ajoutez un sprite au lot.

id = SpriteBatch:add( x, y, r, sx, sy, ox, oy, kx, ky )

idnumberUn identifiant pour le sprite ajouté.
xnumberLa position pour dessiner l'objet (axe des x).
ynumberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

id = SpriteBatch:add( quad, x, y, r, sx, sy, ox, oy, kx, ky )

idnumberUn identifiant pour le sprite ajouté.
quadQuadLe Quad à ajouter.
xnumberLa position pour dessiner l'objet (axe des x).
ynumberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

SpriteBatch:attachAttribute

Attache un attribut per-vertex d'un Mesh sur ce SpriteBatch, pour l'utiliser lors du dessin. Cela peut être combiné avec un Shader pour augmenter un SpriteBatch avec des informations per-vertex ou per-sprite supplémentaires au lieu de simplement avoir des couleurs par sprite.

Chaque sprite dans un SpriteBatch comporte 4 sommets dans l'ordre suivant: en haut à gauche, en bas à gauche, en haut à droite, en bas à droite. L'index renvoyé par SpriteBatch: ajouter (et utilisé par SpriteBatch: set) peut être multiplié par 4 pour déterminer le premier sommet dans un sprite spécifique.

SpriteBatch:attachAttribute( name, mesh )

namestringLe nom de l'attribut vertex à attacher.
meshMeshThe Mesh pour obtenir l'attribut vertex.

SpriteBatch:clear

Supprime tous les sprites du tampon.

SpriteBatch:clear()

SpriteBatch:flush

Envoie immédiatement toutes les données de sprite nouvelles et modifiées dans le lot à la carte graphique.

SpriteBatch:flush()

SpriteBatch:getBufferSize

Obtient le nombre maximum de sprites que le SpriteBatch peut contenir.

size = SpriteBatch:getBufferSize()

sizenumberLe nombre maximum de sprites que le lot peut contenir.

SpriteBatch:getColor

Obtient la couleur qui sera utilisée pour les opérations suivantes d'ajout et de réglage.

Si aucune couleur n'a été définie avec SpriteBatch: setColor ou la couleur SpriteBatch actuelle a été effacée, cette méthode renverra néant.

r, g, b, a = SpriteBatch:getColor()

rnumberLe composant rouge (0-255).
gnumberLa composante verte (0-255).
bnumberLe composant bleu (0-255).
anumberLe composant alpha (0-255).

SpriteBatch:getCount

Obtient la quantité de sprites actuellement dans SpriteBatch.

count = SpriteBatch:getCount()

countnumberLa quantité de sprites actuellement dans le lot.

SpriteBatch:getTexture

Obtient l'image ou la toile utilisée par SpriteBatch.

texture = SpriteBatch:getTexture()

textureTextureL'image ou la toile pour les sprites.

SpriteBatch:set

Modifie un sprite dans le lot. Cela nécessite l'identifiant renvoyé par add et addq.

SpriteBatch:set( id, x, y, r, sx, sy, ox, oy, kx, ky )

idnumberL'identifiant du sprite qui sera modifié.
xnumberLa position pour dessiner l'objet (axe des x).
ynumberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

SpriteBatch:set( id, quad, x, y, r, sx, sy, ox, oy, kx, ky )

idnumberL'identifiant du sprite qui sera modifié.
quadQuadLe quad utilisé sur l'image du lot.
xnumberLa position pour dessiner l'objet (axe des x).
ynumberLa position pour dessiner l'objet (axe des y).
r (0)numberOrientation (radians).
sx (1)numberFacteur d'échelle (axe des x).
sy (sx)numberFacteur d'échelle (axe des y).
ox (0)numberDécalage d'origine (axe des x).
oy (0)numberDécalage d'origine (axe des y).
kx (0)numberFacteur de cisaillement (axe des abscisses).
ky (0)numberFacteur de cisaillement (axe des y).

SpriteBatch:setBufferSize

Définit le nombre maximal de sprites que SpriteBatch peut contenir. Les sprites existants dans le lot (jusqu'au nouveau maximum) ne seront pas effacés lorsque cette fonction est appelée.

SpriteBatch:setBufferSize( size )

sizenumberLe nouveau nombre maximum de sprites que le lot peut contenir.

SpriteBatch:setColor

Définit la couleur qui sera utilisée pour les opérations suivantes d'ajout et de réglage. L'appel de la fonction sans arguments effacera la couleur.

Dans la version {{0.9.2}} et plus ancienne, la couleur globale définie avec love.graphics.setColor ne fonctionnera pas sur SpriteBatch si l'un des sprites a sa propre couleur.

SpriteBatch:setColor( r, g, b, a )

rnumberLa quantité de rouge.
gnumberLa quantité de vert.
bnumberLa quantité de bleu.
a (255)numberLa quantité d'alpha.

SpriteBatch:setColor()

Disables all per-sprite colors for this SpriteBatch.

SpriteBatch:setTexture

Remplace l'image ou la toile utilisée pour les sprites.

SpriteBatch:setTexture( texture )

textureTextureLa nouvelle image ou toile à utiliser pour les sprites.

Text

Texte dessiné.

Constructors

Functions

Supertypes

Text:add

Ajoute du texte coloré supplémentaire à l'objet Texte à la position spécifiée.

index = Text:add( textstring, x, y, angle, sx, sy, ox, oy, kx, ky )

indexnumberUn numéro d'index qui peut être utilisé avec Text: getWidth ou Text: getHeight.
textstringstringLe texte à ajouter à l'objet.
x (0)numberLa position du nouveau texte sur l'axe des x.
y (0)numberLa position du nouveau texte sur l'axe des y.
angle (0)numberL'orientation du nouveau texte en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

index = Text:add( coloredtext, x, y, angle, sx, sy, ox, oy, kx, ky )

indexnumberUn numéro d'index qui peut être utilisé avec Text: getWidth ou Text: getHeight.
coloredtexttableUne table contenant des couleurs et des chaînes à utiliser comme nouveau texte, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.
x (0)numberLa position du nouveau texte sur l'axe des x.
y (0)numberLa position du nouveau texte sur l'axe des y.
angle (0)numberL'orientation du nouveau texte en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

Text:addf

Ajoute du texte formaté / coloré supplémentaire à l'objet Texte à la position spécifiée.

index = Text:addf( textstring, wraplimit, align, x, y, angle, sx, sy, ox, oy, kx, ky )

indexnumberUn numéro d'index qui peut être utilisé avec Text: getWidth ou Text: getHeight.
textstringstringLe texte à ajouter à l'objet.
wraplimitnumberLa largeur maximale en pixels du texte avant qu'il ne soit automatiquement enroulé sur une nouvelle ligne.
alignAlignModeL'alignement du texte.
xnumberLa position du nouveau texte sur l'axe des x.
ynumberLa position du nouveau texte sur l'axe des y.
angle (0)numberL'orientation de l'objet en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

index = Text:addf( coloredtext, wraplimit, align, x, y, angle, sx, sy, ox, oy, kx, ky )

indexnumberUn numéro d'index qui peut être utilisé avec Text: getWidth ou Text: getHeight.
coloredtexttableUne table contenant des couleurs et des chaînes à utiliser comme nouveau texte, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.
wraplimitnumberLa largeur maximale en pixels du texte avant qu'il ne soit automatiquement enroulé sur une nouvelle ligne.
alignAlignModeL'alignement du texte.
xnumberLa position du nouveau texte sur l'axe des x.
ynumberLa position du nouveau texte sur l'axe des y.
angle (0)numberL'orientation de l'objet en radians.
sx (1)numberFacteur d'échelle sur l'axe des x.
sy (sx)numberFacteur d'échelle sur l'axe des y.
ox (0)numberDécalage d'origine sur l'axe des abscisses.
oy (0)numberDécalage d'origine sur l'axe des y.
kx (0)numberFacteur de cisaillement / contournement sur l'axe des abscisses.
ky (0)numberFacteur de cisaillement / égarement sur l'axe des y.

Text:clear

Efface le contenu de l'objet Texte.

Text:clear()

Text:getDimensions

Obtient la largeur et la hauteur du texte en pixels.

width, height = Text:getDimensions()

widthnumberLa largeur du texte. Si plusieurs sous-chaînes ont été ajoutées avec Text: add, la largeur de la dernière sous-chaîne est renvoyée.
heightnumberLa hauteur du texte. Si plusieurs sous-chaînes ont été ajoutées avec Text: add, la hauteur de la dernière sous-chaîne est renvoyée.

width, height = Text:getDimensions( index )

Gets the width and height of a specific sub-string that was previously added to the Text object.

widthnumberLa largeur de la sous-chaîne (avant mise à l'échelle et autres transformations).
heightnumberHauteur de la sous-chaîne (avant mise à l'échelle et autres transformations).
indexnumberUn numéro d'index renvoyé par Text: add ou Text: addf.

Text:getFont

Obtient la police utilisée avec l'objet Texte.

font = Text:getFont()

fontFontLa police utilisée avec cet objet Texte.

Text:getHeight

Obtient la hauteur du texte en pixels.

height = Text:getHeight()

heightnumberLa hauteur du texte. Si plusieurs sous-chaînes ont été ajoutées avec Text: add, la hauteur de la dernière sous-chaîne est renvoyée.

height = Text:getHeight( index )

Gets the height of a specific sub-string that was previously added to the Text object.

heightnumberHauteur de la sous-chaîne (avant mise à l'échelle et autres transformations).
indexnumberUn numéro d'index renvoyé par Text: add ou Text: addf.

Text:getWidth

Obtient la largeur du texte en pixels.

width = Text:getWidth()

widthnumberLa largeur du texte. Si plusieurs sous-chaînes ont été ajoutées avec Text: add, la largeur de la dernière sous-chaîne est renvoyée.

width = Text:getWidth( index )

Gets the width of a specific sub-string that was previously added to the Text object.

widthnumberLa largeur de la sous-chaîne (avant mise à l'échelle et autres transformations).
indexnumberUn numéro d'index renvoyé par Text: add ou Text: addf.

Text:set

Remplace le contenu de l'objet Texte par une nouvelle chaîne non formatée.

Text:set( textstring )

textstringstringLa nouvelle chaîne de texte à utiliser.

Text:set( coloredtext )

coloredtexttableUne table contenant des couleurs et des chaînes à utiliser comme nouveau texte, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.

Text:set()

Clears the contents of the Text object.

Text:setf

Remplace le contenu de l'objet Texte par une nouvelle chaîne formatée.

Text:setf( textstring, wraplimit, align )

textstringstringLa nouvelle chaîne de texte à utiliser.
wraplimitnumberLa largeur maximale en pixels du texte avant qu'il ne soit automatiquement enroulé sur une nouvelle ligne.
align ("left")AlignModeL'alignement du texte.

Text:setf( coloredtext, wraplimit, align )

coloredtexttableUne table contenant des couleurs et des chaînes à utiliser comme nouveau texte, sous la forme de {color1, string1, color2, string2, ...}.
coloredtext.color1tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string1stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext.color2tableUne table contenant des composants alpha rouges, verts, bleus et optionnels pour utiliser comme couleur pour la prochaine chaîne dans le tableau, sous la forme de {rouge, vert, bleu, alpha}.
coloredtext.string2stringUne chaîne de texte qui a une couleur spécifiée par la couleur précédente.
coloredtext....tables and stringsCouleurs et cordes supplémentaires.
wraplimitnumberLa largeur maximale en pixels du texte avant qu'il ne soit automatiquement enroulé sur une nouvelle ligne.
align ("left")AlignModeL'alignement du texte.

Text:setf()

Clears the contents of the Text object.

Text:setFont

Remplace la police utilisée avec le texte.

Text:setFont( font )

fontFontLa nouvelle police à utiliser avec cet objet Texte.

Texture

Superclasse pour objets étirables qui représentent une texture. Toutes les textures peuvent être dessinées avec des Quads. Il s'agit d'un type abstrait qui ne peut pas être créé directement.

Supertypes

Subtypes

Video

Une vidéo dessiné.

Constructors

Functions

Supertypes

Video:getDimensions

Obtient la largeur et la hauteur de la vidéo en pixels.

width, height = Video:getDimensions()

widthnumberLa largeur de la vidéo.
heightnumberLa hauteur de la vidéo.

Video:getFilter

Permet d'utiliser les filtres de mise à l'échelle lors du dessin de la vidéo.

min, mag, anisotropy = Video:getFilter()

minFilterModeLe mode filtre utilisé lors de la mise à l'échelle de la vidéo vers le bas.
magFilterModeLe mode filtre utilisé lors de la mise à l'échelle de la vidéo.
anisotropy (1)numberQuantité maximale de filtrage anisotrope utilisé.

Video:getHeight

Obtient la hauteur de la vidéo en pixels.

height = Video:getHeight()

heightnumberLa hauteur de la vidéo.

Video:getSource

Obtient la source audio utilisée pour lire l'audio de la vidéo. Peut renvoyer tout si la vidéo n'a pas d'audio, ou si Video: setSource s'appelle avec un argument nul.

source = Video:getSource()

sourceSourceLa source audio utilisée pour la lecture audio, ou nile si la vidéo n'a pas d'audio.

Video:getWidth

Obtient la largeur de la vidéo en pixels.

width = Video:getWidth()

widthnumberLa largeur de la vidéo.

Video:isPlaying

Obtient si la vidéo est en cours de lecture.

playing = Video:isPlaying()

playingbooleanQue la vidéo joue.

Video:pause

Pause la vidéo.

Video:pause()

Video:play

Démarre la lecture de la vidéo. Pour que la vidéo apparaisse à l'écran, elle doit être dessinée avec love.graphics.draw.

Video:play()

Video:rewind

Rebote la vidéo au début.

Video:rewind()

Video:seek

Définit la position de lecture actuelle de la vidéo.

Video:seek( offset )

offsetnumberLe temps en secondes depuis le début de la vidéo.

Video:setFilter

Définit les filtres de mise à l'échelle utilisés lors du dessin de la vidéo.

Video:setFilter( min, mag, anisotropy )

minFilterModeLe mode filtre utilisé lors de la mise à l'échelle de la vidéo vers le bas.
magFilterModeLe mode filtre utilisé lors de la mise à l'échelle de la vidéo.
anisotropy (1)numberQuantité maximale de filtrage anisotrope utilisé.

Video:setSource

Définit la source audio utilisée pour lire le son de la vidéo. La source audio contrôle également la vitesse de lecture et la synchronisation.

Video:setSource( source )

source (nil)SourceLa source audio utilisée pour la lecture audio, ou nul pour désactiver la synchronisation audio.

Video:tell

Obtient la position de lecture actuelle de la vidéo.

Video:tell( seconds )

secondsnumberLe temps en secondes depuis le début de la vidéo.

love.image

Types

Functions

Enums

love.image.isCompressed

Détermine si un fichier peut être chargé en tant que CompressedImageData.

compressed = love.image.isCompressed( filename )

compressedbooleanQue le fichier puisse être chargé comme CompressedImageData ou non.
filenamestringLe nom de fichier du fichier image potentiellement compressé.

compressed = love.image.isCompressed( fileData )

compressedbooleanQue le FileData puisse être chargé comme CompressedImageData ou non.
fileDataFileDataA FileData contenant potentiellement une image compressée.

love.image.newCompressedData

Créez un nouvel objet CompressedImageData à partir d'un fichier d'image compressé. Là-VE prend en charge plusieurs formats de texture compressée, énumérés dans la page CompressedImageFormat.

compressedImageData = love.image.newCompressedData( file )

compressedImageDataCompressedImageDataLe nouvel objet CompressedImageData.
filestring / File / FileDataLe chemin du fichier / File / FileData du fichier d'image compressé.

love.image.newImageData

Créez un nouvel objet ImageData.

imageData = love.image.newImageData( width, height, data )

imageDataImageDataLe nouvel objet ImageData vierge. Les valeurs de couleur de chaque pixel (y compris les valeurs alpha!) Seront mises à zéro.
widthnumberLa largeur de ImageData.
heightnumberLa hauteur de ImageData.
data (none)stringLes données à charger dans ImageData (octets RGBA, de gauche à droite et de haut en bas).

imageData = love.image.newImageData( file )

imageDataImageDataLe nouvel objet ImageData.
filestring / File / FileDataLe chemin du fichier / File / FileData du fichier image.

CompressedImageFormat

DXT1

Le format DXT1. Données RVB à 4 bits par pixel (par rapport à 32 bits pour ImageData et Images régulières). Convient aux images entièrement opaques. Convient pour des images entièrement opaques sur les systèmes de bureau.

DXT3

Le format DXT3. Données RGBA à 8 bits par pixel. Les variations lisses de l'opacité ne se combinent pas bien avec ce format.

DXT5

Le format DXT5. Données RGBA à 8 bits par pixel. Recommandé pour les images avec une opacité variable sur les systèmes de bureau.

BC4

Le format BC4 (également appelé 3Dc + ou ATI1.) Stocke uniquement le canal rouge, à 4 bits par pixel.

BC4s

La variante signée du format BC4. Comme ci-dessus, mais les valeurs de pixels dans la texture se situent dans la plage de {-1, 1} au lieu de {0, 1} dans les shaders.

BC5

Le format BC5 (également appelé 3Dc ou ATI2.) Stocke les canaux rouges et verts à 8 bits par pixel.

BC5s

La variante signée du format BC5.

BC6h

Le format BC6H. Stocke des données RVB à virgule flottante à demi-précision dans la plage de {0, 65504} à 8 bits par pixel. Convient pour les images HDR sur les systèmes de bureau.

BC6hs

La variante signée du format BC6H. Stocke les données RVB dans la plage de {-65504, +65504}.

BC7

Le format BC7 (également appelé BPTC.) Stocke les données RGB ou RGBA à 8 bits par pixel.

ETC1

Le format ETC1. Données RVB à 4 bits par pixel. Convient pour des images entièrement opaques sur des appareils Android plus anciens.

ETC2rgb

La variante RVB du format ETC2. Données RVB à 4 bits par pixel. Convient pour des images entièrement opaques sur les nouveaux appareils mobiles.

ETC2rgba

Variante RGBA du format ETC2. Données RGBA à 8 bits par pixel. Recommandé pour les images avec une opacité variable sur les nouveaux appareils mobiles.

ETC2rgba1

La variante RGBA du format ETC2 où les pixels sont entièrement transparents ou totalement opaques. Données RGBA à 4 bits par pixel.

EACr

La variante à un seul canal du format EAC. Stocke juste le canal rouge, à 4 bits par pixel.

EACrs

La variante monocanal signée du format EAC. Identique à ce qui précède, mais les valeurs de pixels dans la texture se situent dans la plage de {-1, 1} au lieu de {0, 1} dans les shaders.

EACrg

La variante à deux canaux du format EAC. Stocke les canaux rouge et vert à 8 bits par pixel.

EACrgs

La variante signée de deux canaux du format EAC.

PVR1rgb2

La variante RVB 2 bits par pixel du format PVRTC1. Stocke les données RVB à 2 bits par pixel. Les textures compressées avec les formats PVRTC1 doivent être de taille carrée et de puissance de deux.

PVR1rgb4

La variante RVB de 4 bits par pixel du format PVRTC1. Stocke les données RVB à 4 bits par pixel.

PVR1rgba2

Variante RGBA 2 bit par pixel du format PVRTC1.

PVR1rgba4

La variante RGBA 4 bit par pixel du format PVRTC1.

ASTC4x4

La variante 4x4 pixels par bloc du format ASTC. Données RGBA à 8 bits par pixel.

ASTC5x4

La variante de 5x4 pixels par bloc du format ASTC. Données RGBA à 6,4 bits par pixel.

ASTC5x5

La variante de 5x5 pixels par bloc du format ASTC. Données RGBA à 5,12 bits par pixel.

ASTC6x5

La variante 6x5 pixels par bloc du format ASTC. Données RGBA à 4,27 bits par pixel.

ASTC6x6

La variante 6x6 pixels par bloc du format ASTC. Données RGBA à 3,56 bits par pixel.

ASTC8x5

La variante 8x5 pixels par bloc du format ASTC. Données RGBA à 3,2 bits par pixel.

ASTC8x6

La variante 8x6 pixels par bloc du format ASTC. Données RGBA à 2,67 bits par pixel.

ASTC8x8

La variante 8x8 pixels par bloc du format ASTC. Données RGBA à 2 bits par pixel.

ASTC10x5

La variante de 10x5 pixels par bloc du format ASTC. Données RGBA à 2,56 bits par pixel.

ASTC10x6

La variante de 10x6 pixels par bloc du format ASTC. Données RGBA à 2,13 bits par pixel.

ASTC10x8

La variante de 10x8 pixels par bloc du format ASTC. Données RGBA à 1,6 bit par pixel.

ASTC10x10

La variante de 10x10 pixels par bloc du format ASTC. Données RGBA à 1,28 bit par pixel.

ASTC12x10

La variante 12x10 pixels par bloc du format ASTC. Données RGBA à 1.07 bits par pixel.

ASTC12x12

La variante 12x12 pixels par bloc du format ASTC. Données RGBA à 0,89 bit par pixel.

ImageFormat

tga

Format d'image Targa.

png

Format d'image PNG.

CompressedImageData

Représente les données d'images compressées conçues pour rester compressées en RAM.

CompressedImageData englobe des formats de texture comprimés standard tels que DXT1, DXT5 et BC5 / 3Dc.

Vous ne pouvez pas dessiner CompressedImageData directement sur l'écran. Voir l'image pour cela.

Constructors

Functions

Supertypes

CompressedImageData:getDimensions

Obtient la largeur et la hauteur de CompressedImageData.

width, height = CompressedImageData:getDimensions()

widthnumberLa largeur du CompressedImageData.
heightnumberLa hauteur de la CompressedImageData.

width, height = CompressedImageData:getDimensions( level )

widthnumberLa largeur du CompressedImageData.
heightnumberLa hauteur de la CompressedImageData.
levelnumberUn niveau mipmap. Doit être dans la plage de {1, CompressedImageData: getMipmapCount ()}.

CompressedImageData:getFormat

Obtient le format de CompressedImageData.

format = CompressedImageData:getFormat()

formatCompressedImageFormatLe format de CompressedImageData.

CompressedImageData:getHeight

Obtient la hauteur de CompressedImageData.

height = CompressedImageData:getHeight()

heightnumberLa hauteur de la CompressedImageData.

height = CompressedImageData:getHeight( level )

heightnumberLa hauteur de la CompressedImageData.
levelnumberUn niveau mipmap. Doit être dans la plage de {1, CompressedImageData: getMipmapCount ()}.

CompressedImageData:getMipmapCount

Obtient le nombre de niveaux mipmap dans CompressedImageData. Le niveau base mipmap (image originale) est inclus dans le compte.

mipmaps = CompressedImageData:getMipmapCount()

mipmapsnumberLe nombre de niveaux mipmap stockés dans CompressedImageData.

CompressedImageData:getWidth

Obtient la largeur de CompressedImageData.

width = CompressedImageData:getWidth()

widthnumberLa largeur du CompressedImageData.

width = CompressedImageData:getWidth( level )

widthnumberLa largeur du CompressedImageData.
levelnumberUn niveau mipmap. Doit être dans la plage de {1, CompressedImageData: getMipmapCount ()}.

ImageData

Données d'image brutes (décodées).

Vous ne pouvez pas dessiner ImageData directement sur l'écran. Voir l'image pour cela.

Constructors

Functions

Supertypes

ImageData:encode

Encode l'ImageData et l'écrit facultativement dans le répertoire de sauvegarde.

filedata = ImageData:encode( format, filename )

filedataFileDataL'image codée est un nouvel objet FileData.
formatImageFormatLe format pour coder l'image en tant que.
filename (nil)stringLe nom du fichier pour écrire le fichier. Si néant, aucun fichier ne sera écrit, mais FileData sera encore retourné.

ImageData:getDimensions

Obtient la largeur et la hauteur de l'ImageData en pixels.

width, height = ImageData:getDimensions()

widthnumberLa largeur du ImageData en pixels.
heightnumberHauteur du ImageData en pixels.

ImageData:getHeight

Obtient la hauteur du ImageData en pixels.

height = ImageData:getHeight()

heightnumberHauteur du ImageData en pixels.

ImageData:getPixel

Obtient la couleur d'un pixel à une position spécifique dans l'image.

Les valeurs x et y valides commencent à 0 et atteignent la largeur et la hauteur de l'image moins 1. Les valeurs non entières sont en panne.

r, g, b, a = ImageData:getPixel( x, y )

rnumberLe composant rouge (0-255).
gnumberLa composante verte (0-255).
bnumberLe composant bleu (0-255).
anumberLe composant alpha (0-255).
xnumberLa position du pixel sur l'axe des x.
ynumberLa position du pixel sur l'axe des y.

ImageData:getWidth

Obtient la largeur du ImageData en pixels.

width = ImageData:getWidth()

widthnumberLa largeur du ImageData en pixels.

ImageData:mapPixel

Transformez une image en appliquant une fonction à chaque pixel.

Cette fonction est une fonction de commande supérieure. Il prend une autre fonction en tant que paramètre et l'appelle une fois pour chaque pixel dans ImageData.

Le paramètre de fonction est appelé avec six paramètres pour chaque pixel à tour de rôle. Les paramètres sont des nombres qui représentent les coordonnées x et y du pixel et ses valeurs rouge, vert, bleu et alpha. Le paramètre de fonction peut renvoyer jusqu'à quatre valeurs de nombre, ce qui devient le nouveau r, g, b et les valeurs du pixel. Si la fonction renvoie moins de valeurs, les composants restants sont définis sur 0.

ImageData:mapPixel( pixelFunction )

pixelFunctionfunctionParamètre de fonction à appliquer à chaque pixel.

ImageData:paste

Collez dans ImageData à partir d'une autre source ImageData.

ImageData:paste( source, dx, dy, sx, sy, sw, sh )

sourceImageDataSource ImageData à partir de laquelle copier.
dxnumberDestination de la position supérieure gauche sur l'axe des x.
dynumberDestination de la position supérieure gauche sur l'axe des y.
sxnumberSource de la partie supérieure gauche sur l'axe des x.
synumberSource en haut à gauche sur l'axe des y.
swnumberLargeur de la source.
shnumberHauteur de la source.

ImageData:setPixel

Définit la couleur d'un pixel dans une position spécifique de l'image.

Les valeurs x et y valides commencent à 0 et atteignent la largeur et l'hauteur de l'image moins 1.

ImageData:setPixel( x, y, r, g, b, a )

xnumberLa position du pixel sur l'axe des x.
ynumberLa position du pixel sur l'axe des y.
rnumberLe composant rouge (0-255).
gnumberLa composante verte (0-255).
bnumberLe composant bleu (0-255).
anumberLe composant alpha (0-255).

love.joystick

Types

Functions

Enums

love.joystick.getJoystickCount

Obtient le nombre de joysticks connectés.

joystickcount = love.joystick.getJoystickCount()

joystickcountnumberLe nombre de joystick connecté.

love.joystick.getJoysticks

Obtient une liste de Joysticks connectés.

joysticks = love.joystick.getJoysticks()

joystickstableLa liste des Joysticks actuellement connectés.

love.joystick.loadGamepadMappings

Charge une chaîne de mappages de gamepad ou un fichier créé avec love.joystick.saveGamepadMappings.

love.joystick.loadGamepadMappings( filename )

filenamestringNom de fichier pour charger la chaîne de mappages.

love.joystick.loadGamepadMappings( mappings )

mappingsstringLa chaîne de mappages à charger.

love.joystick.saveGamepadMappings

Enregistre les mappages du gamepad virtuel de tous les Joysticks reconnus comme gamepads et ont été récemment utilisés ou leurs liens de gamepad ont été modifiés.

mappings = love.joystick.saveGamepadMappings( filename )

mappingsstringLa chaîne de mappages qui a été écrite dans le fichier.
filename (no file)stringLe nom de fichier pour sauvegarder les mappings dans la chaîne.

love.joystick.setGamepadMapping

Lié une entrée de jeu de jeu virtuel à un bouton, un axe ou un chapeau pour tous les Joysticks d'un certain type. Par exemple, si cette fonction est utilisée avec un GUID renvoyé par un contrôleur Dualshock 3 dans OS X, la liaison affectera Joystick: getGamepadAxis et Joystick: isGamepadDown pour tous les contrôleurs Dualshock 3 utilisés avec le jeu lorsqu'il est exécuté dans OS X.

LÖVE inclut des liens intégrés au gamepad pour de nombreux contrôleurs communs. Cette fonction vous permet de modifier les liaisons ou d'en ajouter de nouveaux pour les types de Joysticks qui ne sont pas reconnus comme jeux par défaut.

Les boutons et les axes du jeu de jeu virtuel sont conçus autour de la disposition du contrôleur Xbox 360.

success = love.joystick.setGamepadMapping( guid, button, inputtype, inputindex, hatdirection )

successbooleanQue le bouton du jeu virtuel ait été lié avec succès.
guidstringLe GUID dépendant du système d'exploitation pour le type de joystick de la liaison affectera.
buttonGamepadButtonLe bouton du jeu virtuel pour lier.
inputtypeJoystickInputTypeLe type d'entrée pour lier le bouton du gamepad virtuel à.
inputindexnumberL'index de l'axe, du bouton ou du chapeau pour lier le bouton du jeu virtuel au.
hatdirectionJoystickHatLa direction du chapeau, si le bouton du gamepad virtuel sera lié à un chapeau. sinon autrement.

success = love.joystick.setGamepadMapping( guid, axis, inputtype, inputindex, hatdirection )

successbooleanQue le bouton du jeu virtuel ait été lié avec succès.
guidstringLe GUID dépendant du système d'exploitation pour le type de joystick de la liaison affectera.
axisGamepadAxisL'axe du gamepad virtuel à lier.
inputtypeJoystickInputTypeLe type d'entrée pour lier l'axe du gamepad virtuel à.
inputindexnumberL'index de l'axe, du bouton ou du chapeau pour lier l'axe du gamepad virtuel à.
hatdirectionJoystickHatLa direction du chapeau, si l'axe du jeu virtuel sera lié à un chapeau. sinon autrement.

GamepadAxis

leftx

L'axe des x du levier gauche.

lefty

L'axe y du levier gauche.

rightx

L'axe des abscisses du pictogramme droit.

righty

L'axe des y du pictogramme droit.

triggerleft

Déclencheur analogique à gauche.

triggerright

Déclencheur analogique droit.

GamepadButton

a

Bouton du fond du visage (A).

b

Bouton du visage droit (B).

x

Bouton de face gauche (X).

y

Touche face supérieure (Y).

back

Bouton Retour.

guide

Guide button.

start

Bouton Start.

leftstick

Bouton de clic gauche.

rightstick

Bouton de clic droit.

leftshoulder

Pare-choc gauche.

rightshoulder

Pare-chocs droit.

dpup

D-pad up.

dpdown

D-pad vers le bas.

dpleft

D-pad à gauche.

dpright

D-pad droit.

JoystickHat

c

Centré

d

Vers le bas

l

La gauche

ld

Gauche + Bas

lu

Gauche + Haut

r

Droite

rd

Droite + Bas

ru

Droite + Haut

u

En haut

JoystickInputType

axis

Axe analogique.

button

Bouton.

hat

Valeur du chapeau à 8 directions.

Joystick

Représente un joystick physique.

Constructors

Functions

Supertypes

Joystick:getAxes

Obtient la direction de chaque axe.

axisDir1, axisDir2, axisDirN = Joystick:getAxes()

axisDir1numberDirection de l'axe1.
axisDir2numberDirection de l'axe2.
axisDirNnumberDirection de l'axeN.

Joystick:getAxis

Obtient la direction d'un axe.

direction = Joystick:getAxis( axis )

directionnumberValeur actuelle de l'axe.
axisnumberL'index de l'axe à contrôler.

Joystick:getAxisCount

Obtient le nombre d'axes sur le joystick.

axes = Joystick:getAxisCount()

axesnumberLe nombre d'axes disponibles.

Joystick:getButtonCount

Obtient le nombre de boutons sur le joystick.

buttons = Joystick:getButtonCount()

buttonsnumberLe nombre de boutons disponibles.

Joystick:getGUID

Obtient un GUID stable unique au type de joystick physique qui ne change pas avec le temps. Par exemple, tous les contrôleurs Sony Dualshock 3 dans OS X ont le même GUID. La valeur dépend de la plate-forme.

guid = Joystick:getGUID()

guidstringIdentificateur unique dépendant du système de type Joystick.

Joystick:getGamepadAxis

Obtient la direction d'un axe de jeu de jeu virtuel. Si le Joystick n'est pas reconnu comme un gamepad ou n'est pas connecté, cette fonction renverra toujours 0.

direction = Joystick:getGamepadAxis( axis )

directionnumberValeur actuelle de l'axe.
axisGamepadAxisL'axe virtuel à contrôler.

Joystick:getGamepadMapping

Obtient le bouton, l'axe ou le chapeau auquel une entrée virtuelle du jeu de jeu est liée.

inputtype, inputindex, hatdirection = Joystick:getGamepadMapping( axis )

inputtypeJoystickInputTypeLe type d'entrée auquel l'axe du jeu virtuel est lié.
inputindexnumberL'index du bouton, de l'axe ou du chapeau du joystick auquel l'axe du jeu virtuel est lié.
hatdirectionJoystickHatLa direction du chapeau, si l'axe du jeu virtuel est lié à un chapeau. sinon autrement.
axisGamepadAxisL'axe du jeu virtuel pour obtenir la liaison.

inputtype, inputindex, hatdirection = Joystick:getGamepadMapping( button )

inputtypeJoystickInputTypeLe type d'entrée auquel le bouton du jeu de jeu virtuel est lié.
inputindexnumberL'index du bouton, de l'axe ou du chapeau du joystick auquel le bouton du jeu virtuel est lié.
hatdirectionJoystickHatLa direction du chapeau, si le bouton du gamepad virtuel est lié à un chapeau. sinon autrement.
buttonGamepadAxisLe bouton du jeu virtuel pour obtenir la liaison.

Joystick:getHat

Gets la direction du chapeau du joystick.

direction = Joystick:getHat( hat )

directionJoystickHatLa direction du chapeau est poussée.
hatnumberL'indice du chapeau à contrôler.

Joystick:getHatCount

Obtient le nombre de chapeaux sur le joystick.

hats = Joystick:getHatCount()

hatsnumberCombien de chapeaux le joystick a-t-il.

Joystick:getID

Obtient l'identifiant unique du joystick. L'identifiant restera le même pour la vie du jeu, même si le Joystick est déconnecté et reconnecté, mais il changera quand le jeu sera relancé.

id, instanceid = Joystick:getID()

idnumberL'identifiant unique du Joystick. Reste le même que le jeu en cours.
instanceidnumberIdentificateur d'instance unique. Change chaque fois que le joystick est reconnecté. Néant si le joystick n'est pas connecté.

Joystick:getName

Obtient le nom du joystick.

name = Joystick:getName()

namestringLe nom du joystick.

Joystick:getVibration

Obtient les solides du moteur vibratoire actuel sur un Joystick avec un support de grumeau.

left, right = Joystick:getVibration()

leftnumberForce actuelle du moteur de vibration gauche sur le joystick.
rightnumberPuissance actuelle du bon moteur de vibration sur le joystick.

Joystick:isConnected

Obtient si le Joystick est connecté.

connected = Joystick:isConnected()

connectedbooleanVrai si le Joystick est actuellement connecté, false sinon.

Joystick:isDown

Vérifie si un bouton du joystick est pressé.

Là-VE 0.9.0 avait un bug qui exigeait que les index des boutons passaient à Joystick: isDown pour être basé sur 0, au lieu de 1, par exemple, le bouton 1 serait 0 pour cette fonction. Il a été corrigé en 0.9.1.

anyDown = Joystick:isDown( ... )

anyDownbooleanVrai si un bouton fourni est en panne, faux sinon.
...numberL'index d'un bouton à vérifier.

Joystick:isGamepad

Obtient si le Joystick est reconnu comme un gamepad. Si tel est le cas, les boutons et les axes du joystick peuvent être utilisés de manière standardisée dans différents systèmes d'exploitation et modèles de joystick via Joystick: getGamepadAxis et fonctions connexes.

Là-VE reconnaît automatiquement les contrôleurs les plus populaires avec une disposition similaire au contrôleur Xbox 360 en tant que gamepads, mais vous pouvez ajouter plus avec love.joystick.setGamepadMapping.

isgamepad = Joystick:isGamepad()

isgamepadbooleanVrai si le Joystick est reconnu comme un gamepad, false sinon.

Joystick:isGamepadDown

Vérifie si un bouton du jeu de jeu virtuel sur le joystick est pressé. Si le Joystick n'est pas reconnu comme un Gamepad ou n'est pas connecté, cette fonction renverra toujours false.

anyDown = Joystick:isGamepadDown( ... )

anyDownbooleanVrai si un bouton fourni est en panne, faux sinon.
...GamepadButtonLe bouton du pavé tactile pour vérifier.

Joystick:isVibrationSupported

Obtient si le joystick prend en charge les vibrations.

supported = Joystick:isVibrationSupported()

supportedbooleanVrai si la vibration de retour de grondement / force est supportée sur ce joystick, faux sinon.

Joystick:setVibration

Définit la vitesse du moteur vibratoire sur un Joystick avec un support de grumeau.

success = Joystick:setVibration( left, right, duration )

successbooleanVrai si la vibration a été appliquée avec succès, fausse sinon.
leftnumberForce du moteur de vibration gauche sur le joystick. Doit être dans la plage de {0, 1}.
rightnumberForce du bon moteur de vibration sur le joystick. Doit être dans la plage de {0, 1}.
duration (-1)numberLa durée de la vibration en secondes. Une valeur négative signifie durée infinie.

love.keyboard

Functions

Enums

love.keyboard.getKeyFromScancode

Obtient la clé correspondant au scanné matériel fourni.

Contrairement aux constantes clés, les Scancodes sont indépendants de la configuration du clavier. Par exemple, le scancode "w" sera généré si la touche au même endroit que la touche "w" sur un clavier américain est pressée, quelle que soit la clé ou quel sont les paramètres du système d'exploitation de l'utilisateur.

Les scancodes sont utiles pour créer des contrôles par défaut qui ont les mêmes emplacements physiques sur tous les systèmes.

key = love.keyboard.getKeyFromScancode( scancode )

keyKeyConstantLa clé correspondant au scancode donné ou "inconnue" si le scancode ne correspond pas à un KeyConstant sur le système actuel.
scancodeScancodeLe scancode pour obtenir la clé.

love.keyboard.getScancodeFromKey

Obtient le scannage matériel correspondant à la clé donnée.

Contrairement aux constantes clés, les Scancodes sont indépendants de la configuration du clavier. Par exemple, le scancode "w" sera généré si la touche au même endroit que la touche "w" sur un clavier américain est pressée, quelle que soit la clé ou quel sont les paramètres du système d'exploitation de l'utilisateur.

Les scancodes sont utiles pour créer des contrôles par défaut qui ont les mêmes emplacements physiques sur tous les systèmes.

scancode = love.keyboard.getScancodeFromKey( key )

scancodeScancodeLe scancode correspondant à la clé donnée, ou "inconnu" si la clé donnée n'a pas de représentation physique connue sur le système actuel.
keyKeyConstantLa clé pour obtenir le scancode.

love.keyboard.hasKeyRepeat

Obtient si la répétition de la touche est activée.

enabled = love.keyboard.hasKeyRepeat()

enabledbooleanSi la répétition de la touche est activée.

love.keyboard.hasTextInput

Obtient si les événements de saisie de texte sont activés.

enabled = love.keyboard.hasTextInput()

enabledbooleanQue les événements de saisie de texte soient activés.

love.keyboard.isDown

Vérifie si une certaine clé est en panne. À ne pas confondre avec l'amour. Cliqué ou aimé.

anyDown = love.keyboard.isDown( key, ... )

anyDownbooleanVrai si une clé fournie est en panne, fausse sinon.
keyKeyConstantUne clé à vérifier.
...KeyConstantTouches supplémentaires à vérifier.

love.keyboard.isScancodeDown

Vérifie si les Scancodes spécifiés sont pressés. À ne pas confondre avec l'amour. Cliqué ou aimé.

Contrairement aux KeyConstants réguliers, les Scancodes sont indépendants de la configuration du clavier. Le scancode "w" est utilisé si la touche au même endroit que la touche "w" sur un clavier américain est pressée, quelle que soit la clé ou quel sont les paramètres du système d'exploitation de l'utilisateur.

down = love.keyboard.isScancodeDown( scancode, ... )

downbooleanVrai si le Scancode fourni est en panne, faux sinon.
scancodeScancodeUn Scancode à vérifier.
...ScancodeScannodes supplémentaires à vérifier.

love.keyboard.setKeyRepeat

Active ou désactive la répétition de la touche. Il est désactivé par défaut.

L'intervalle entre les répétitions dépend des paramètres système de l'utilisateur.

love.keyboard.setKeyRepeat( enable )

enablebooleanQue les événements répétés de la touche soient activés lorsqu'une touche est maintenue enfoncée.

love.keyboard.setTextInput

Active ou désactive les événements de saisie de texte. Il est activé par défaut sur Windows, Mac et Linux, et est désactivé par défaut sur iOS et Android.

love.keyboard.setTextInput( enable )

enablebooleanQue les événements de saisie de texte soient activés.

love.keyboard.setTextInput( enable, x, y, w, h )

enablebooleanQue les événements de saisie de texte soient activés.
xnumberPosition sur le clavier x sur l'écran.
ynumberPosition écran et écran à l'écran.
wnumberLargeur du clavier à l'écran.
hnumberHauteur du clavier à l'écran.

KeyConstant

a

La clé A

b

La touche B

c

La touche C

d

La touche D

e

La touche E

f

La touche F

g

La touche G

h

La touche H

i

La touche I

j

La touche J

k

La touche K

l

La touche L

m

La touche M

n

La touche N

o

La touche O

p

La touche P

q

La touche Q

r

La touche R

s

La touche S

t

La touche T

u

La touche U

v

La touche V

w

La touche W

x

La touche X

y

La touche Y

z

La touche Z

0

La touche zéro

1

La seule clé

2

Les deux clés

3

Les trois clés

4

Les quatre clés

5

Les cinq clés

6

Les six clés

7

Les sept clés

8

La touche huit

9

Les neuf clés

space

Touche Space

!

Clé d'exclamation

"

Clé de devis double

#

Touche dièse

$

Clé Dollar

&

Touche Ampersand

'

Clé de citation unique

(

Clé parenthèse

)

Clé de parenthèse droite

*

Touche Asterisk

+

Touche Plus

,

Clé de virgule

-

Touche Hyphen-minus

.

Clé d'arrêt complète

/

Touche Slash

:

Clé Colon

;

Clé virgule

<

Moins de clé

=

Touche égale

>

Grande clé

?

Touche de point d'interrogation

@

À la clé de signe

[

Touche de crochet gauche

\

Touche de barre oblique inverse

]

Clé de crochet droite

^

Touche Caret

_

Clé de soulignement

`

Clé d'accent grave

kp0

La touche zéro numérique

kp1

La touche numérique d'un clavier

kp2

La touche numérique du clavier

kp3

Le clavier trois touches

kp4

Le clavier numérique quatre touches

kp5

Le numéro de clavier cinq touches

kp6

Le clavier numérique six touches

kp7

Le clavier numérique sept touches

kp8

La touche numérique numéro huit

kp9

La touche numpad neuf

kp.

La clé de numéro décimale numérique

kp/

La clé de division numpad

kp*

La clé de multiplication numpad

kp-

La touche de soustraction du clavier numérique

kp+

La touche d'addition du clavier numérique

kpenter

Le pavé numérique entre la clé

kp=

Le clavier numérique est égal à la touche

up

Touche de curseur vers le haut

down

Touche de curseur vers le bas

right

Touche de curseur droite

left

Touche de curseur gauche

home

Clé de la maison

end

Clé de fin

pageup

Clé de mise en page

pagedown

Clé vers le bas

insert

Insérer la clé

backspace

Clé de retrait

tab

Touche d'onglet

clear

Clé claire

return

Touche de retour

delete

Touche de suppression

f1

La 1ère touche de fonction

f2

La 2ème touche de fonction

f3

La 3ème touche de fonction

f4

La 4ème touche de fonction

f5

La 5ème touche de fonction

f6

La 6ème touche de fonction

f7

La 7ème touche de fonction

f8

La 8ème touche de fonction

f9

La 9ème touche de fonction

f10

La 10ème touche de fonction

f11

La 11ème touche de fonction

f12

La 12ème touche de fonction

f13

La 13ème touche de fonction

f14

La 14ème touche de fonction

f15

La 15ème touche de fonction

numlock

Clé de verrouillage numérique

capslock

Clé Caps-Lock

scrollock

Clé de défilement

rshift

Clé de changement de vitesse

lshift

Touche de décalage de gauche

rctrl

Touche de contrôle de droite

lctrl

Touche de contrôle de gauche

ralt

Touche alt correcte

lalt

Touche Alt gauche

rmeta

Touche méta droite

lmeta

Touche méta gauche

lsuper

Super clé

rsuper

Super clé

mode

Touche de mode

compose

Composer la clé

pause

Touche Pause

escape

Clé d'échappement

help

Clé d'aide

print

Touche d'impression

sysreq

Touche de demande du système

break

Break key

menu

Touche de menu

power

Clé d'alimentation

euro

Touche Euro (€ euro;)

undo

Annuler la clé

www

Clé WWW

mail

Clé de messagerie

calculator

Touche Calculatrice

appsearch

Touche de recherche d'application

apphome

Touche d'accueil de l'application

appback

Retour arrière de l'application

appforward

Touche d'avance de l'application

apprefresh

Clé de rafraîchissement d'application

appbookmarks

Clé des favoris de l'application

Scancode

a

La touche «A» sur une disposition américaine.

b

La touche 'B' sur une disposition américaine.

c

La touche 'C' sur une disposition américaine.

d

La touche 'D' sur une disposition américaine.

e

La touche 'E' sur une disposition américaine.

f

La touche 'F' sur une disposition américaine.

g

La touche 'G' sur une disposition américaine.

h

La touche «H» sur une disposition américaine.

i

La touche «I» sur une disposition américaine.

j

La touche 'J' sur une disposition américaine.

k

La touche 'K' sur une disposition américaine.

l

La touche 'L' sur une disposition américaine.

m

La touche «M» sur une disposition américaine.

n

La touche 'N' sur une disposition américaine.

o

La touche 'O' sur une disposition américaine.

p

La touche 'P' sur une disposition américaine.

q

La touche «Q» sur une disposition américaine.

r

La touche 'R' sur une disposition américaine.

s

La touche 'S' sur une disposition américaine.

t

La touche 'T' sur une disposition américaine.

u

La touche 'U' sur une disposition américaine.

v

La touche 'V' sur une disposition américaine.

w

La touche 'W' sur une disposition américaine.

x

La touche 'X' sur une disposition américaine.

y

La touche 'Y' sur une disposition américaine.

z

La touche «Z» sur une disposition américaine.

1

La touche «1» sur une disposition américaine.

2

La touche '2' sur une disposition américaine.

3

La touche '3' sur une disposition américaine.

4

La touche «4» sur une disposition américaine.

5

La touche «5» sur une disposition américaine.

6

La touche «6» sur une disposition américaine.

7

La touche «7» sur une disposition américaine.

8

La touche «8» sur une disposition américaine.

9

La touche '9' sur une disposition américaine.

0

La touche '0' sur une disposition américaine.

return

La touche 'retour' / 'entrer' sur une mise en page américaine.

escape

La touche 'escape' sur une disposition américaine.

backspace

La touche 'backspace' sur une disposition américaine.

tab

La touche 'onglet' sur une disposition américaine.

space

La barre d'espace sur une disposition américaine.

-

La touche moins sur une disposition américaine.

=

La touche égale à une disposition américaine.

[

La clé de gauche sur une disposition américaine.

]

La clé de droite sur une disposition américaine.

\

La touche de barre oblique inverse sur une disposition américaine.

nonus#

Le scannode de hash non-U.S.

;

Le point-virgule sur une disposition américaine.

'

La clé d'apostrophe sur une disposition américaine.

`

La touche arrière / tige sur une disposition américaine.

,

La clé de virgule sur une disposition américaine.

.

La période clé sur une disposition américaine.

/

La touche de barre oblique sur une disposition américaine.

capslock

La touche capslock sur une disposition américaine.

f1

La touche F1 sur une disposition américaine.

f2

La touche F2 sur une disposition américaine.

f3

La touche F3 sur une disposition américaine.

f4

La touche F4 sur une disposition américaine.

f5

La touche F5 sur une disposition américaine.

f6

La touche F6 sur une disposition américaine.

f7

La touche F7 sur une disposition américaine.

f8

La touche F8 sur une disposition américaine.

f9

La touche F9 sur une disposition américaine.

f10

La touche F10 sur une disposition américaine.

f11

La touche F11 sur une disposition américaine.

f12

La touche F12 sur une disposition américaine.

f13

La touche F13 sur une disposition américaine.

f14

La touche F14 sur une disposition américaine.

f15

La touche F15 sur une disposition américaine.

f16

La clé F16 sur une disposition américaine.

f17

La touche F17 sur une disposition américaine.

f18

La touche F18 sur une disposition américaine.

f19

La touche F19 sur une disposition américaine.

f20

La touche F20 sur une disposition américaine.

f21

La clé F21 sur une disposition américaine.

f22

La touche F22 sur une disposition américaine.

f23

La touche F23 sur une disposition américaine.

f24

La touche F24 sur une disposition américaine.

lctrl

La touche de contrôle de gauche sur une disposition américaine.

lshift

La touche Maj de gauche sur une disposition américaine.

lalt

La touche alt / option gauche sur une disposition américaine.

lgui

La clé de gauche (commande / windows / super) sur une disposition américaine.

rctrl

La touche de contrôle de droite sur une disposition américaine.

rshift

La touche de changement de droite sur une disposition américaine.

ralt

La droite / option sur une disposition américaine.

rgui

La clé GUI (commande / windows / super) sur une disposition américaine.

printscreen

La touche de l'écran d'impression sur une disposition américaine.

scrolllock

La touche de verrouillage de défilement sur une disposition américaine.

pause

La touche de pause sur une disposition américaine.

insert

La touche d'insertion sur une disposition américaine.

home

La clé d'accueil sur une disposition américaine.

numlock

La touche numlock / clear sur une mise en page américaine.

pageup

La touche de page sur une disposition américaine.

delete

La touche de suppression directe sur une mise en page américaine.

end

La touche de fin sur une disposition américaine.

pagedown

La touche de page vers le bas sur une disposition américaine.

right

La flèche vers la droite sur une disposition américaine.

left

La flèche gauche sur une disposition américaine.

down

La flèche vers le bas sur une disposition américaine.

up

La touche de flèche vers le haut sur une disposition américaine.

nonusbackslash

Le scanné de la barre oblique inverse des États-Unis.

application

La clé d'application sur une disposition américaine. Menu contextuel Windows, clé de composition.

execute

La touche "exécuter" sur une disposition américaine.

help

La touche «aide» sur une disposition américaine.

menu

La touche 'menu' sur une disposition américaine.

select

La touche 'select' sur une mise en page américaine.

stop

La touche 'stop' sur une disposition américaine.

again

La touche 'à nouveau' sur une disposition américaine.

undo

La touche 'annuler' sur une disposition américaine.

cut

La touche «coupé» sur une disposition américaine.

copy

La touche 'Copier' sur une disposition américaine.

paste

La touche "coller" sur une disposition américaine.

find

La touche «trouver» sur une disposition américaine.

kp/

La touche de barre oblique du clavier sur une disposition américaine.

kp*

La touche '*' du clavier sur une disposition américaine.

kp-

La touche minuscule clavier sur une disposition américaine.

kp+

La touche clavier plus sur une disposition américaine.

kp=

Le clavier est égal à la clé sur une disposition américaine.

kpenter

Le clavier entre en entrée sur une disposition américaine.

kp1

La touche '1' du clavier sur une disposition américaine.

kp2

La touche '2' du clavier sur une disposition américaine.

kp3

La touche '3' du clavier sur une disposition américaine.

kp4

La touche '4' du clavier sur une disposition américaine.

kp5

La touche '5' du clavier sur une disposition américaine.

kp6

La touche '6' du clavier sur une disposition américaine.

kp7

La touche '7' du clavier sur une disposition américaine.

kp8

La touche '8' du clavier sur une disposition américaine.

kp9

La touche '9' du clavier sur une disposition américaine.

kp0

Clé du clavier '0' sur une disposition américaine.

kp.

La clé de la période du clavier sur une disposition américaine.

international1

La 1ère clé internationale sur une disposition américaine. Utilisé sur les claviers asiatiques.

international2

La 2ème clé internationale sur une disposition américaine.

international3

La 3ème clé internationale sur une mise en page américaine. Yen.

international4

La 4ème clé internationale sur une disposition américaine.

international5

La 5ème clé internationale sur une disposition américaine.

international6

La 6ème clé internationale sur une disposition américaine.

international7

La septième clé internationale sur une disposition américaine.

international8

La 8ème clé internationale sur une disposition américaine.

international9

La 9ème clé internationale sur une disposition américaine.

lang1

Hangul / English toggle scancode.

lang2

Hanja conversion scancode.

lang3

Katakana scancode.

lang4

Hiragana scancode.

lang5

Scénario Zenkaku / Hankaku.

mute

La touche mute sur une disposition américaine.

volumeup

La touche de volume vers le haut sur une disposition américaine.

volumedown

La touche de réduction de volume sur une disposition américaine.

audionext

La touche de suivi de l'audio sur une disposition américaine.

audioprev

La touche de piste précédente audio sur une disposition américaine.

audiostop

La touche d'arrêt audio sur une disposition américaine.

audioplay

La touche de lecture audio sur une disposition américaine.

audiomute

La touche mute audio sur une disposition américaine.

mediaselect

La touche de sélection des médias sur une disposition américaine.

www

La touche «WWW» sur une disposition américaine.

mail

La touche Mail sur une disposition américaine.

calculator

La clé de la calculatrice sur une disposition américaine.

computer

La touche «ordinateur» sur une disposition américaine.

acsearch

La touche AC Search sur une mise en page américaine.

achome

La touche AC Home sur une disposition américaine.

acback

La touche AC Back sur une mise en page américaine.

acforward

La touche AC Forward sur une mise en page américaine.

acstop

La touche AC Stop sur une disposition américaine.

acrefresh

La touche AC Refresh sur une mise en page américaine.

acbookmarks

La touche AC Bookmarks sur une mise en page américaine.

power

Scancode d'alimentation du système.

brightnessdown

Le scannode de luminosité.

brightnessup

Le scannode de luminosité.

displayswitch

Le commutateur d'affichage scancode.

kbdillumtoggle

L'éclairage du clavier permet de basculer le scannage.

kbdillumdown

L'illumination du clavier down scancode.

kbdillumup

L'illumination du clavier jusqu'à scancode.

eject

Le scalé d'éjection.

sleep

Le système de scalode de sommeil.

alterase

La touche alt-erase sur une disposition américaine.

sysreq

La clé sysreq sur une mise en page américaine.

cancel

La touche 'annuler' sur une mise en page américaine.

clear

La touche «claire» sur une disposition américaine.

prior

La touche «précédente» sur une disposition américaine.

return2

La touche 'return2' sur une disposition américaine.

separator

La touche «séparateur» sur une disposition américaine.

out

La touche 'out' sur une présentation américaine.

oper

La touche 'oper' sur une disposition américaine.

clearagain

La touche 'clearagain' sur une disposition américaine.

crsel

La touche 'crsel' sur une disposition américaine.

exsel

La touche 'exsel' sur une disposition américaine.

kp00

La touche clavier 00 sur une disposition américaine.

kp000

La clé du clavier 000 sur une disposition américaine.

thsousandsseparator

La clé de milliers de séparateurs sur une disposition américaine.

decimalseparator

La clé du séparateur décimal sur une disposition américaine.

currencyunit

La clé de l'unité de change sur une disposition américaine.

currencysubunit

La sous-unité de la devise sur une disposition américaine.

app1

Le scalode 'app1'.

app2

Le scalode 'app2'.

unknown

Une clé inconnue.

love.math

Types

Functions

Enums

love.math.compress

Compresse une chaîne ou des données à l'aide d'un algorithme de compression spécifique.

compressedData = love.math.compress( rawstring, format, level )

compressedDataCompressedDataUn nouvel objet Data contenant la version compressée de la chaîne.
rawstringstringLa chaîne brute (non compressée) à compresser.
format ("lz4")CompressedDataFormatLe format à utiliser lors de la compression de la chaîne.
level (-1)numberLe niveau de compression à utiliser, entre 0 et 9. -1 indique le niveau par défaut. La signification de cet argument dépend du format de compression utilisé.

compressedData = love.math.compress( data, format, level )

compressedDataCompressedDataUn nouvel objet Data contenant la version compressée des données brutes.
dataDataUn objet Data contenant les données brutes (non compressées) à comprimer.
format ("lz4")CompressedDataFormatLe format à utiliser lors de la compression des données.
level (-1)numberLe niveau de compression à utiliser, entre 0 et 9. -1 indique le niveau par défaut. La signification de cet argument dépend du format de compression utilisé.

love.math.decompress

Décompresse un CompressedData ou une chaîne ou un objet de données précédemment compressé.

rawstring = love.math.decompress( compressedData )

rawstringstringUne chaîne contenant les données décompressées brutes.
compressedDataCompressedDataLes données compressées à décompresser.

rawstring = love.math.decompress( compressedString, format )

rawstringstringUne chaîne contenant les données décompressées brutes.
compressedStringstringUne chaîne contenant des données précédemment compressées avec love.math.compress.
formatCompressedDataFormatLe format utilisé pour compresser la chaîne donnée.

rawstring = love.math.decompress( data, format )

rawstringstringUne chaîne contenant les données décompressées brutes.
dataDataUn objet Data contenant des données précédemment compressées avec love.math.compress.
formatCompressedDataFormatLe format utilisé pour compresser les données données.

love.math.gammaToLinear

Convertit une couleur de gamma-space (sRGB) en espace linéaire (RGB). Ceci est utile lors d'un rendu gamma-correct et vous devez faire des calculs en RGB linéaire dans les quelques cas où LÖVE ne gère pas automatiquement les conversions.

lr, lg, lb = love.math.gammaToLinear( r, g, b )

lrnumberLe canal rouge de la couleur convertie dans l'espace RGB linéaire.
lgnumberLe canal vert de la couleur convertie dans l'espace RGB linéaire.
lbnumberLe canal bleu de la couleur convertie dans l'espace RGB linéaire.
rnumberLe canal rouge de la couleur sRGB à convertir.
gnumberLe canal vert de la couleur sRGB à convertir.
bnumberLe canal bleu de la couleur sRGB à convertir.

lr, lg, lb = love.math.gammaToLinear( color )

lrnumberLe canal rouge de la couleur convertie dans l'espace RGB linéaire.
lgnumberLe canal vert de la couleur convertie dans l'espace RGB linéaire.
lbnumberLe canal bleu de la couleur convertie dans l'espace RGB linéaire.
colortableUn tableau avec les canaux rouge, vert et bleu de la couleur sRGB à convertir.

lc = love.math.gammaToLinear( c )

lcnumberLa valeur du canal de couleur dans l'espace RGB linéaire.
cnumberLa valeur d'un canal de couleur dans l'espace sRGB à convertir.

love.math.getRandomSeed

Obtient la graine du générateur de nombres aléatoires.

L'état est divisé en deux nombres en raison de l'utilisation de doubles de Lua pour toutes les valeurs numériques. Les doubles ne peuvent pas représenter avec précision des valeurs entières supérieures à 2 ^ 53.

low, high = love.math.getRandomSeed()

lownumberNuméro entier représentant les 32 bits inférieurs de la valeur d'état de 64 bits du générateur de nombres aléatoires.
highnumberNuméro entier représentant les 32 bits supérieurs de la valeur d'état de 64 bits du générateur de nombres aléatoires.

love.math.getRandomState

Obtient l'état actuel du générateur de nombres aléatoires. Cela renvoie une chaîne opaque dépendant de la mise en œuvre qui n'est utile que pour une utilisation ultérieure avec RandomGenerator: setState.

Ceci est différent de RandomGenerator: getSeed dans que getState reçoit l'état actuel de RandomGenerator, alors que getSeed obtient le nombre de graines précédemment défini.

La valeur de la chaîne d'état ne dépend pas du système d'exploitation actuel.

state = love.math.getRandomState()

statestringL'état actuel de l'objet RandomGenerator, représenté en chaîne.

love.math.isConvex

Vérifie si un polygone est convexe.

PolygonShapes in love.physics, certaines formes de Mesh et les polygones dessinés avec love.graphics.polygon doivent être des polygones convexes simples.

convex = love.math.isConvex( vertices )

convexbooleanQue le polygone donné soit convexe.
verticestableLes sommets du polygone comme tableau sous la forme de {x1, y1, x2, y2, x3, y3, ...}.

convex = love.math.isConvex( x1, y1, x2, y2, x3, y3, ... )

convexbooleanQue le polygone donné soit convexe.
x1numberLa position du premier sommet du polygone sur l'axe des abscisses.
y1numberLa position du premier sommet du polygone sur l'axe des y.
x2numberLa position du second sommet du polygone sur l'axe des abscisses.
y2numberLa position du second sommet du polygone sur l'axe des y.
x3numberLa position du troisième sommet du polygone sur l'axe des abscisses.
y3numberLa position du troisième sommet du polygone sur l'axe des y.
...numberSommets supplémentaires.

love.math.linearToGamma

Convertit une couleur de l'espace linéaire (RVB) en gamma-espace (sRGB). Ceci est utile lorsque vous stockez des valeurs linéaires de couleur RVB dans une image, car l'espace linéaire de couleur RVB a moins de précision que sRGB pour les couleurs foncées, ce qui peut entraîner une bande de couleur notable lors du dessin.

En général, les couleurs choisies en fonction de leur apparence à l'écran sont déjà en zone gamma et ne doivent pas être converties en double. Les couleurs calculées à l'aide de mathématiques sont souvent dans l'espace RVB linéaire.

cr, cg, cb = love.math.linearToGamma( lr, lg, lb )

crnumberLe canal rouge de la couleur convertie dans l'espace gamma sRGB.
cgnumberLe canal vert de la couleur convertie dans l'espace gamma sRGB.
cbnumberLe canal bleu de la couleur convertie dans l'espace gamma sRGB.
lrnumberLe canal rouge de la couleur RVB linéaire à convertir.
lgnumberLe canal vert de la couleur RVB linéaire à convertir.
lbnumberLe canal bleu de la couleur RVB linéaire à convertir.

cr, cg, cb = love.math.linearToGamma( color )

crnumberLe canal rouge de la couleur convertie dans l'espace gamma sRGB.
cgnumberLe canal vert de la couleur convertie dans l'espace gamma sRGB.
cbnumberLe canal bleu de la couleur convertie dans l'espace gamma sRGB.
colortableUn tableau avec les canaux rouge, vert et bleu de la couleur RVB linéaire à convertir.

c = love.math.linearToGamma( lc )

cnumberLa valeur du canal de couleur dans l'espace gamma sRGB.
lcnumberLa valeur d'un canal de couleur dans l'espace RVB linéaire à convertir.

love.math.newBezierCurve

Crée un nouvel objet BezierCurve.

Le nombre de sommets dans le polygone de contrôle détermine le degré de la courbe, par ex. trois sommets définissent une courbe quadricale (degré 2) de Béryier, quatre sommets définissent une courbe cubique (degré 3) de Béryier, etc.

curve = love.math.newBezierCurve( vertices )

curveBezierCurveUn objet de courbe de Béryier.
verticestableLes sommets du polygone de contrôle comme tableau sous la forme de {x1, y1, x2, y2, x3, y3, ...}.

curve = love.math.newBezierCurve( x1, y1, x2, y2, x3, y3, ... )

curveBezierCurveUn objet de courbe de Béryier.
x1numberLa position du premier sommet du polygone de contrôle sur l'axe des abscisses.
y1numberLa position du premier sommet du polygone de contrôle sur l'axe des y.
x2numberLa position du second sommet du polygone de contrôle sur l'axe des x.
y2numberLa position du second sommet du polygone de contrôle sur l'axe des y.
x3numberLa position du troisième sommet du polygone de contrôle sur l'axe des x.
y3numberLa position du troisième sommet du polygone de contrôle sur l'axe des y.
...numberSommets supplémentaires.

love.math.newRandomGenerator

Crée un nouvel objet RandomGenerator complètement indépendant des autres objets RandomGenerator et des fonctions aléatoires.

rng = love.math.newRandomGenerator()

rngRandomGeneratorLe nouvel objet du générateur de nombres aléatoires.

rng = love.math.newRandomGenerator( seed )

rngRandomGeneratorLe nouvel objet du générateur de nombres aléatoires.
seednumberLe numéro de graine initial à utiliser pour cet objet.

rng = love.math.newRandomGenerator( low, high )

rngRandomGeneratorLe nouvel objet du générateur de nombres aléatoires.
lownumberLes 32 bits inférieurs du numéro d'état à utiliser pour cette instance de l'objet.
highnumberLes 32 bits supérieurs du numéro d'état à utiliser pour cette instance de l'objet.

love.math.noise

Génère une valeur de bruit Simplex ou Perlin en 1 à 4 dimensions. La valeur de retour sera toujours la même, compte tenu des mêmes arguments.

Le bruit simplifié est étroitement lié au bruit de Perlin. Il est largement utilisé pour la génération de contenu procédural.

Il existe de nombreuses pages Web qui discutent en détail de Perlin et Simplex.

value = love.math.noise( x )

Generates Simplex noise from 1 dimension.

valuenumberLa valeur du bruit dans la plage de {0, 1}.
xnumberLe nombre utilisé pour générer la valeur du bruit.

value = love.math.noise( x, y )

Generates Simplex noise from 2 dimensions.

valuenumberLa valeur du bruit dans la plage de {0, 1}.
xnumberLa première valeur du vecteur bidimensionnel utilisé pour générer la valeur du bruit.
ynumberLa deuxième valeur du vecteur bidimensionnel utilisé pour générer la valeur du bruit.

value = love.math.noise( x, y, z )

Generates Perlin noise (Simplex noise in version 0.9.2 and older) from 3 dimensions.

valuenumberLa valeur du bruit dans la plage de {0, 1}.
xnumberLa première valeur du vecteur tridimensionnel utilisé pour générer la valeur du bruit.
ynumberLa deuxième valeur du vecteur tridimensionnel utilisé pour générer la valeur du bruit.
znumberLa troisième valeur du vecteur tridimensionnel utilisé pour générer la valeur du bruit.

value = love.math.noise( x, y, z, w )

Generates Perlin noise (Simplex noise in version 0.9.2 and older) from 4 dimensions.

valuenumberLa valeur du bruit dans la plage de {0, 1}.
xnumberLa première valeur du vecteur 4-dimensionnel utilisé pour générer la valeur du bruit.
ynumberLa deuxième valeur du vecteur à 4 dimensions utilisé pour générer la valeur du bruit.
znumberLa troisième valeur du vecteur à 4 dimensions utilisé pour générer la valeur du bruit.
wnumberLa quatrième valeur du vecteur à 4 dimensions utilisé pour générer la valeur du bruit.

love.math.random

Génère un nombre pseudo-aléatoire d'une manière indépendante de la plate-forme.

number = love.math.random()

Get uniformly distributed pseudo-random real number within [0, 1].

numbernumberLe nombre pseudo-aléatoire.

number = love.math.random( max )

Get a uniformly distributed pseudo-random integer within [1, max].

numbernumberLe nombre entier pseudo-aléatoire.
maxnumberLa valeur maximale possible qu'il doit retourner.

number = love.math.random( min, max )

Get uniformly distributed pseudo-random integer within [min, max].

numbernumberLe nombre entier pseudo-aléatoire.
minnumberLa valeur minimale possible qu'il devrait retourner.
maxnumberLa valeur maximale possible qu'il doit retourner.

love.math.randomNormal

Obtenez un nombre pseudo-aléatoire normalement distribué.

number = love.math.randomNormal( stddev, mean )

numbernumberNuméro aléatoire normalement distribué avec variance (stddev) ² et la moyenne spécifiée.
stddev (1)numberÉcart-type de la distribution.
mean (0)numberLe moyen de la distribution.

love.math.setRandomSeed

Définit la graine du générateur de nombres aléatoires en utilisant le nombre entier spécifié.

love.math.setRandomSeed( seed )

seednumberLe nombre entier avec lequel vous voulez semer la randomisation. Doit être dans la plage de {1, 2 ^ 53}.

love.math.setRandomSeed( low, high )

lownumberLes 32 bits inférieurs de la valeur d'état. Doit être dans la plage de {0, 2 ^ 32 - 1}.
highnumberLes 32 bits supérieurs de la valeur d'état. Doit être dans la plage de {0, 2 ^ 32 - 1}.

love.math.setRandomState

Obtient l'état actuel du générateur de nombres aléatoires. Cela renvoie une chaîne opaque dépendant de la mise en œuvre qui n'est utile que pour une utilisation ultérieure avec RandomGenerator: setState.

Ceci est différent de RandomGenerator: getSeed dans que getState reçoit l'état actuel de RandomGenerator, alors que getSeed obtient le nombre de graines précédemment défini.

La valeur de la chaîne d'état ne dépend pas du système d'exploitation actuel.

love.math.setRandomState( state )

statestringL'état actuel de l'objet RandomGenerator, représenté en chaîne.

love.math.triangulate

Trianguler un polygone simple.

triangles = love.math.triangulate( polygon )

trianglestableListe des triangles dont le polygone est composé, sous la forme de {{x1, y1, x2, y2, x3, y3}, {x1, y1, x2, y2, x3, y3}, ...}.
polygontablePolygone à trianguler. Ne doit pas se croiser.

triangles = love.math.triangulate( x1, y1, x2, y2, x3, y3, ... )

trianglestableListe des triangles dont le polygone est composé, sous la forme de {{x1, y1, x2, y2, x3, y3}, {x1, y1, x2, y2, x3, y3}, ...}.
x1numberLa position du premier sommet du polygone sur l'axe des abscisses.
y1numberLa position du premier sommet du polygone sur l'axe des y.
x2numberLa position du second sommet du polygone sur l'axe des abscisses.
y2numberLa position du second sommet du polygone sur l'axe des y.
x3numberLa position du troisième sommet du polygone sur l'axe des abscisses.
y3numberLa position du troisième sommet du polygone sur l'axe des y.
...numberSommets supplémentaires.

CompressedDataFormat

lz4

Le format de compression LZ4. Compresse et décompresse très rapidement, mais le taux de compression n'est pas le meilleur. LZ4-HC est utilisé lorsque le niveau de compression 9 est spécifié.

zlib

Le format zlib est constitué de données compressées DEFLATE avec un petit nombre de données d'en-tête. Compresse relativement lentement et décompresse modérément rapidement et a un taux de compression décent.

gzip

Le format gzip est constitué de données compressées DEFLATE avec un en-tête légèrement plus grand que zlib. Comme il utilise DEFLATE, il possède les mêmes caractéristiques de compression que le format zlib.

BezierCurve

Un objet de courbe de Béryier qui peut évaluer et rendre les courbes de Béryier de degré arbitraire.

Constructors

Functions

Supertypes

BezierCurve:evaluate

Évaluez la courbe de Bésier au paramètre t. Le paramètre doit être compris entre 0 et 1 (inclus).

Cette fonction peut être utilisée pour déplacer des objets le long des chemins ou des paramètres interpolés. Cependant, il ne doit pas être utilisé pour rendre la courbe, voir BezierCurve: render à cet effet.

x, y = BezierCurve:evaluate( t )

xnumberx coordonnée de la courbe au paramètre t.
ynumbery coordonnée de la courbe au paramètre t.
tnumberOù évaluer la courbe.

BezierCurve:getControlPoint

Obtenez les coordonnées du i-ième point de contrôle. Les indices commencent par 1.

x, y = BezierCurve:getControlPoint( i )

xnumberPosition du point de contrôle le long de l'axe des x.
ynumberPosition du point de contrôle le long de l'axe y.
inumberIndex du point de contrôle.

BezierCurve:getControlPointCount

Obtenez le nombre de points de contrôle dans la courbe de Béryier.

count = BezierCurve:getControlPointCount()

countnumberLe nombre de points de contrôle.

BezierCurve:getDegree

Obtenez le degré de la courbe de Béryier. Le degré est égal au nombre de points de contrôle - 1.

degree = BezierCurve:getDegree()

degreenumberDegré de courbe de Béryier.

BezierCurve:getDerivative

Obtenez la dérivée de la courbe de Béryier.

Cette fonction peut être utilisée pour faire pivoter les sprites se déplaçant le long d'une courbe dans la direction du mouvement et calculer la direction perpendiculaire à la courbe à un paramètre t.

derivative = BezierCurve:getDerivative()

derivativeBezierCurveLa courbe dérivée.

BezierCurve:getSegment

Obtient un BezierCurve qui correspond au segment spécifié de ce BezierCurve.

curve = BezierCurve:getSegment( startpoint, endpoint )

curveBezierCurveUn BezierCurve qui correspond au segment spécifié.
startpointnumberLe point de départ le long de la courbe. Doit être compris entre 0 et 1.
endpointnumberLa fin du segment. Doit être compris entre 0 et 1.

BezierCurve:insertControlPoint

Insérez le point de contrôle comme nouveau i-ième point de contrôle. Les points de contrôle existants à partir de i sont repoussés par 1. Les indices commencent par 1. Les indices négatifs s'emballe: -1 est le dernier point de contrôle, -2 le dernier avant le dernier, etc.

BezierCurve:insertControlPoint( x, y, i )

xnumberPosition du point de contrôle le long de l'axe des x.
ynumberPosition du point de contrôle le long de l'axe y.
i (-1)numberIndex du point de contrôle.

BezierCurve:removeControlPoint

Supprime le point de contrôle spécifié.

BezierCurve:removeControlPoint( index )

indexnumberL'index du point de contrôle à éliminer.

BezierCurve:render

Obtenez une liste de coordonnées à utiliser avec love.graphics.line.

Cette fonction échantillonne la courbe de Béryier en utilisant une subdivision récursive. Vous pouvez contrôler la profondeur de récurrence en utilisant le paramètre de profondeur.

Si vous êtes intéressé de connaître le positionnement de la courbe en prenant un paramètre, utilisez BezierCurve: evaluez.

coordinates = BezierCurve:render( depth )

coordinatestableListe des paires de points x, y-coordonnées de la courbe.
depth (5)numberNombre d'étapes de subdivision récursives.

BezierCurve:renderSegment

Obtenez une liste de coordonnées sur une partie spécifique de la courbe, à utiliser avec love.graphics.line.

Cette fonction échantillonne la courbe de Béryier en utilisant une subdivision récursive. Vous pouvez contrôler la profondeur de récurrence en utilisant le paramètre de profondeur.

Si vous avez juste besoin de connaître la position sur la courbe donnée, utilisez BezierCurve: évaluez.

coordinates = BezierCurve:renderSegment( startpoint, endpoint, depth )

coordinatestableListe des paires de points x, y-coordonnées de la courbe.
startpointnumberLe point de départ le long de la courbe. Doit être compris entre 0 et 1.
endpointnumberLa fin du segment à rendre. Doit être compris entre 0 et 1.
depth (5)numberNombre d'étapes de subdivision récursives.

BezierCurve:rotate

Faites pivoter la courbe de Béryier par un angle.

BezierCurve:rotate( angle, ox, oy )

anglenumberAngle de rotation en radians.
ox (0)numberCoordonnée X du centre de rotation.
oy (0)numberCoordonnée Y du centre de rotation.

BezierCurve:scale

Écartez la courbe de Béryier par un facteur.

BezierCurve:scale( s, ox, oy )

snumberFacteur d'échelle.
ox (0)numberCoordonnée X du centre de mise à l'échelle.
oy (0)numberCoordonnée Y du centre de mise à l'échelle.

BezierCurve:setControlPoint

Définir les coordonnées du i-ième point de contrôle. Les indices commencent par 1.

BezierCurve:setControlPoint( i, ox, oy )

inumberIndex du point de contrôle.
oxnumberPosition du point de contrôle le long de l'axe des x.
oynumberPosition du point de contrôle le long de l'axe y.

BezierCurve:translate

Déplacez la courbe de Béryier par un décalage.

BezierCurve:translate( dx, dy )

dxnumberDécoupe le long de l'axe des x.
dynumberDécalage le long de l'axe des y.

CompressedData

Représente les données d'octets compressées à l'aide d'un algorithme spécifique.

love.math.decompress peut être utilisé pour décompacter les données.

Constructors

Functions

Supertypes

CompressedData:getFormat

Obtient le format de compression de CompressedData.

format = CompressedData:getFormat()

formatCompressedDataFormatLe format de la CompressedData.

RandomGenerator

Un objet de génération de nombre aléatoire qui a son propre état aléatoire.

Constructors

Functions

Supertypes

RandomGenerator:getSeed

Obtient l'état du générateur de nombres aléatoires.

L'état est divisé en deux nombres en raison de l'utilisation de doubles de Lua pour toutes les valeurs numériques. Les doubles ne peuvent pas représenter avec précision des valeurs entières supérieures à 2 ^ 53.

low, high = RandomGenerator:getSeed()

lownumberNuméro entier représentant les 32 bits inférieurs de la valeur d'état de 64 bits du générateur de nombres aléatoires.
highnumberNuméro entier représentant les 32 bits supérieurs de la valeur d'état de 64 bits du générateur de nombres aléatoires.

RandomGenerator:getState

Obtient l'état actuel du générateur de nombres aléatoires. Cela renvoie une chaîne opaque dépendant de la mise en œuvre qui n'est utile que pour une utilisation ultérieure avec RandomGenerator: setState.

Ceci est différent de RandomGenerator: getSeed dans que getState reçoit l'état actuel de RandomGenerator, alors que getSeed obtient le nombre de graines précédemment défini.

La valeur de la chaîne d'état ne dépend pas du système d'exploitation actuel.

state = RandomGenerator:getState()

statestringL'état actuel de l'objet RandomGenerator, représenté en chaîne.

RandomGenerator:random

Génère un nombre pseudo-aléatoire d'une manière indépendante de la plate-forme.

number = RandomGenerator:random()

Get uniformly distributed pseudo-random number within [0, 1].

numbernumberLe nombre pseudo-aléatoire.

number = RandomGenerator:random( max )

Get uniformly distributed pseudo-random integer number within [1, max].

numbernumberLe nombre entier pseudo-aléatoire.
maxnumberLa valeur maximale possible qu'il doit retourner.

number = RandomGenerator:random( min, max )

Get uniformly distributed pseudo-random integer number within [min, max].

numbernumberLe nombre entier pseudo-aléatoire.
minnumberLa valeur minimale possible qu'il devrait retourner.
maxnumberLa valeur maximale possible qu'il doit retourner.

RandomGenerator:randomNormal

Obtenez un nombre pseudo-aléatoire normalement distribué.

number = RandomGenerator:randomNormal( stddev, mean )

numbernumberNuméro aléatoire normalement distribué avec variance (stddev) ² et la moyenne spécifiée.
stddev (1)numberÉcart-type de la distribution.
mean (0)numberLe moyen de la distribution.

RandomGenerator:setSeed

Définit la graine du générateur de nombres aléatoires en utilisant le nombre entier spécifié.

RandomGenerator:setSeed( seed )

seednumberLe nombre entier avec lequel vous voulez semer la randomisation. Doit être dans la plage de {1, 2 ^ 53}.

RandomGenerator:setSeed( low, high )

lownumberLes 32 bits inférieurs de la valeur d'état. Doit être dans la plage de {0, 2 ^ 32 - 1}.
high (0)numberLes 32 bits supérieurs de la valeur d'état. Doit être dans la plage de {0, 2 ^ 32 - 1}.

RandomGenerator:setState

Définit l'état actuel du générateur de nombres aléatoires. La valeur utilisée comme argument pour cette fonction est une chaîne opaque dépendant de la mise en œuvre et ne doit provenir que d'un appel précédent à RandomGenerator: getState.

Ceci est différent de RandomGenerator: setSeed dans que setState définit directement l'état actuel de l'implémentation de RandomGenerator, alors que setSeed lui donne une nouvelle valeur de départ.

L'effet de la chaîne d'état ne dépend pas du système d'exploitation actuel.

RandomGenerator:setState( state )

statestringLe nouvel état de l'objet RandomGenerator, représenté sous forme de chaîne. Cela devrait provenir d'un appel précédent à RandomGenerator: getState.

love.mouse

Types

Functions

Enums

love.mouse.getCursor

Obtient le Cursor actuel.

cursor = love.mouse.getCursor()

cursorCursorLe curseur actuel, ou nul si aucun curseur n'est défini.

love.mouse.getPosition

Obtient la position actuelle de la souris.

x, y = love.mouse.getPosition()

xnumberLa position de la souris le long de l'axe des abscisses.
ynumberLa position de la souris le long de l'axe des y.

love.mouse.getRelativeMode

Détermine si le mode relatif est activé pour la souris.

Si le mode relatif est activé, le curseur est caché et ne se déplace pas lorsque la souris est activée, mais les événements de mouvement relatifs de la souris sont toujours générés via love.mousemoved. Cela permet à la souris de se déplacer dans n'importe quelle direction indéfiniment sans que le curseur ne soit coincé sur les bords de l'écran.

La position signalée de la souris n'est pas mise à jour alors que le mode relatif est activé, même lorsque des événements de mouvement relatifs de la souris sont générés.

enabled = love.mouse.getRelativeMode()

enabledbooleanVrai si le mode relatif est activé, false s'il est désactivé.

love.mouse.getSystemCursor

Obtient un objet Cursor représentant un curseur matériel natif du système.

 Les curseurs de matériel sont indépendants et fonctionnent de la même manière que les curseurs du système d'exploitation normal. Contrairement à dessiner une image aux coordonnées actuelles de la souris, les curseurs de matériel n'ont jamais de décalage visible entre les déplacements de la souris et la mise à jour de la position du curseur, même à faible taux.

cursor = love.mouse.getSystemCursor( ctype )

cursorCursorL'objet Cursor représentant le type de curseur du système.
ctypeCursorTypeLe type de curseur système à obtenir.

love.mouse.getX

Obtient la position x en cours de la souris.

x = love.mouse.getX()

xnumberLa position de la souris le long de l'axe des abscisses.

love.mouse.getY

Obtient la position actuelle de la souris.

y = love.mouse.getY()

ynumberLa position de la souris le long de l'axe des y.

love.mouse.hasCursor

Obtient si la fonctionnalité du curseur est prise en charge.

Si elle n'est pas prise en charge, appeler love.mouse.newCursor et love.mouse.getSystemCursor provoqueront une erreur. Les périphériques mobiles ne prennent pas en charge les curseurs.

hascursor = love.mouse.hasCursor()

hascursorbooleanQue le système ait une fonctionnalité de curseur.

love.mouse.isDown

Vérifie si un certain bouton de la souris est en panne. Cette fonction ne détecte pas le défilement du roulette de la souris; vous devez utiliser le rappel d'amour.wheelmoved (ou love.mousepressed version 0.9.2 et plus ancien) pour cela.

down = love.mouse.isDown( button, ... )

downbooleanVrai si le bouton spécifié est en panne.
buttonnumberL'index d'un bouton à vérifier. 1 est le bouton principal de la souris, 2 est le bouton secondaire de la souris, etc.
...numberNuméros de bouton supplémentaires à vérifier.

love.mouse.isGrabbed

Vérifie si la souris est saisie.

grabbed = love.mouse.isGrabbed()

grabbedbooleanVrai si le curseur est saisi, faux si ce n'est pas le cas.

love.mouse.isVisible

Vérifie si le curseur est visible.

visible = love.mouse.isVisible()

visiblebooleanVrai si le curseur est visible, faux si le curseur est caché.

love.mouse.newCursor

Crée un nouvel objet Cursor matériel à partir d'un fichier image ou ImageData.

Les curseurs de matériel sont indépendants et fonctionnent de la même manière que les curseurs du système d'exploitation normal. Contrairement à dessiner une image aux coordonnées actuelles de la souris, les curseurs de matériel n'ont jamais de décalage visible entre les déplacements de la souris et la mise à jour de la position du curseur, même à faible taux.

Le point chaud est le point utilisé par le système d'exploitation pour déterminer ce qui a été cliqué et à quelle position se trouve le curseur de la souris. Par exemple, le pointeur de la flèche normale a normalement son point chaud en haut à gauche de l'image, mais un curseur peut l'avoir au milieu.

cursor = love.mouse.newCursor( imageData, hotx, hoty )

cursorCursorLe nouvel objet Cursor.
imageDataImageDataImageData à utiliser pour le nouveau Cursor.
hotx (0)numberLa coordonnée x dans ImageData du point chaud du curseur.
hoty (0)numberLa coordonnée y dans ImageData du point chaud du curseur.

cursor = love.mouse.newCursor( filepath, hotx, hoty )

cursorCursorLe nouvel objet Cursor.
filepathstringChemin d'accès à l'image à utiliser pour le nouveau Cursor.
hotx (0)numberLa coordonnée x dans ImageData du point chaud du curseur.
hoty (0)numberLa coordonnée y dans ImageData du point chaud du curseur.

cursor = love.mouse.newCursor( fileData, hotx, hoty )

cursorCursorLe nouvel objet Cursor.
fileDataFileDataDonnées représentant l'image à utiliser pour le nouveau Cursor.
hotx (0)numberLa coordonnée x dans ImageData du point chaud du curseur.
hoty (0)numberLa coordonnée y dans ImageData du point chaud du curseur.

love.mouse.setCursor

Définit le curseur actuel de la souris.

Réinitialise le curseur actuel de la souris par défaut lors de l'appel sans arguments.

love.mouse.setCursor()

love.mouse.setCursor( cursor )

cursorCursorL'objet Cursor à utiliser comme curseur de la souris en cours.

love.mouse.setGrabbed

Prend la souris et la confine à la fenêtre.

love.mouse.setGrabbed( grab )

grabbooleanFidèle à confiner la souris, fausse pour la laisser sortir de la fenêtre.

love.mouse.setPosition

Définit la position actuelle de la souris. Les valeurs non entières sont en panne.

love.mouse.setPosition( x, y )

xnumberLa nouvelle position de la souris le long de l'axe des abscisses.
ynumberLa nouvelle position de la souris le long de l'axe des y.

love.mouse.setRelativeMode

Définit si le mode relatif est activé pour la souris.

Lorsque le mode relatif est activé, le curseur est caché et ne bouge pas lorsque la souris est activée, mais les événements relatifs du mouvement de la souris sont encore générés via love.mousemoved. Cela permet à la souris de se déplacer dans n'importe quelle direction indéfiniment sans que le curseur ne soit coincé sur les bords de l'écran.

La position signalée de la souris n'est pas mise à jour alors que le mode relatif est activé, même lorsque des événements de mouvement relatifs de la souris sont générés.

love.mouse.setRelativeMode( enable )

enablebooleanFacile à activer le mode relatif, faux de le désactiver.

love.mouse.setVisible

Définit la visibilité du curseur.

love.mouse.setVisible( visible )

visiblebooleanFixe de placer le curseur sur visible, faux pour cacher le curseur.

love.mouse.setX

Définit la position X actuelle de la souris. Les valeurs non entières sont en panne.

love.mouse.setX( x )

xnumberLa nouvelle position de la souris le long de l'axe des abscisses.

love.mouse.setY

Définit la position Y actuelle de la souris. Les valeurs non entières sont en panne.

love.mouse.setY( y )

ynumberLa nouvelle position de la souris le long de l'axe des y.

CursorType

image

Le curseur utilise une image personnalisée.

arrow

Un pointeur de flèche.

ibeam

Un faisceau I, normalement utilisé lors de la mousing sur un texte éditable ou sélectionnable.

wait

Attendez le graphique.

waitarrow

Petit curseur d'attente avec un pointeur de flèche.

crosshair

Symbole de la croix.

sizenwse

Double flèche pointant vers le haut en bas et en bas à droite.

sizenesw

Double flèche pointant vers le haut en bas et en bas à gauche.

sizewe

Double flèche orientée vers la gauche et vers la droite.

sizens

Double flèche pointant vers le haut et vers le bas.

sizeall

Flèche pointue vers le haut, le bas, la gauche et la droite.

no

Cercle coupé ou os croisés.

hand

Symbole de la main.

Cursor

Représente un curseur matériel.

Constructors

Functions

Supertypes

Cursor:getType

Obtient le type de curseur.

cursortype = Cursor:getType()

cursortypeCursorTypeLe type de curseur.

love.physics

Types

Functions

Enums

love.physics.getDistance

Obtient les deux points les plus proches entre deux luminaires et leur distance.

distance, x1, y1, x2, y2 = love.physics.getDistance( fixture1, fixture2 )

distancenumberLa distance des deux points.
x1numberLa coordonnée x du premier point.
y1numberLa coordonnée y du premier point.
x2numberLa coordonnée x du deuxième point.
y2numberLa coordonnée y du deuxième point.
fixture1FixtureLe premier montage.
fixture2FixtureLe deuxième match.

love.physics.getMeter

Obtenez l'échelle du monde.

L'échelle mondiale est le nombre de pixels par mètre. Essayez de garder votre taille de forme inférieure à 10 fois cette échelle.

Ceci est important car la physique de Box2D est réglée pour fonctionner correctement pour des objets de taille de 0,1 m à 10 m. Toutes les coordonnées physiques sont divisées par ce nombre pour les calculs physiques.

scale = love.physics.getMeter()

scalenumberLa taille de 1 mètre en pixels.

love.physics.newBody

Crée un nouveau corps.

Il existe trois types de corps. Les corps statiques ne se déplacent pas, ont une masse infinie et peuvent être utilisés pour les limites de niveau. Les corps dynamiques sont les acteurs principaux de la simulation, ils entrent en collision avec tout. Les corps cinématiques ne réagissent pas aux forces et ne font que faire face à des corps dynamiques.

La masse du corps est calculée lorsqu'un Fixture est attaché ou enlevé, mais peut être changé à tout moment avec Body: setMass ou Body: resetMassData.

body = love.physics.newBody( world, x, y, type )

bodyBodyUn nouveau corps.
worldWorldLe monde pour créer le corps en.
x (0)numberLa position x du corps.
y (0)numberLa position y du corps.
type ("static")BodyTypeLe type de corps.

love.physics.newChainShape

Crée une nouvelle chaîne de caractères.

shape = love.physics.newChainShape( loop, x1, y1, x2, y2, ... )

shapeChainShapeLa nouvelle forme.
loopbooleanSi la chaîne devrait retourner au premier point.
x1numberLa position x du premier point.
y1numberLa position y du premier point.
x2numberLa position x du deuxième point.
y2numberLa position y du deuxième point.
...numberPositions de points supplémentaires.

shape = love.physics.newChainShape( loop, points )

shapeChainShapeLa nouvelle forme.
loopbooleanSi la chaîne devrait retourner au premier point.
pointstableUne liste de points pour construire ChainShape, sous la forme de {x1, y1, x2, y2, ...}.

love.physics.newCircleShape

Crée une nouvelle forme CircleShape.

shape = love.physics.newCircleShape( radius )

shapeCircleShapeLa nouvelle forme.
radiusnumberLe rayon du cercle.

shape = love.physics.newCircleShape( x, y, radius )

shapeCircleShapeLa nouvelle forme.
xnumberLe décalage x du cercle.
ynumberLe décalage y du cercle.
radiusnumberLe rayon du cercle.

love.physics.newDistanceJoint

Créez une distance entre deux corps.

Cette articulation contraint la distance entre deux points sur deux corps d'être constante. Ces deux points sont spécifiés dans les coordonnées mondiales et les deux corps sont supposés être en place lorsque cette articulation est créée. Le premier point d'ancrage est relié au premier corps et le second au deuxième corps, et les points définissent la longueur de l'articulation à distance.

joint = love.physics.newDistanceJoint( body1, body2, x1, y1, x2, y2, collideConnected )

jointDistanceJointLe nouveau joint à distance.
body1BodyLe premier corps à attacher à l'articulation.
body2BodyLe deuxième corps à attacher à l'articulation.
x1numberLa position x du premier point d'ancrage (espace mondial).
y1numberLa position y du premier point d'ancrage (espace mondial).
x2numberLa position x du deuxième point d'ancrage (espace mondial).
y2numberLa position y du deuxième point d'ancrage (espace mondial).
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newEdgeShape

Crée une forme de bordure.

shape = love.physics.newEdgeShape( x1, y1, x2, y2 )

shapeEdgeShapeLa nouvelle forme.
x1numberLa position x du premier point.
y1numberLa position y du premier point.
x2numberLa position x du deuxième point.
y2numberLa position y du deuxième point.

love.physics.newFixture

Crée et attache un accessoire à un corps.

fixture = love.physics.newFixture( body, shape, density )

fixtureFixtureLe nouvel élément.
bodyBodyLe corps qui obtient le dispositif attaché.
shapeShapeLa forme de l'appareil.
density (1)numberLa densité de l'appareil.

love.physics.newFrictionJoint

Créez un joint de frottement entre deux corps. Un membre de Friction applique une friction à un corps.

joint = love.physics.newFrictionJoint( body1, body2, x, y, collideConnected )

jointFrictionJointLe nouveau membre Friction.
body1BodyLe premier corps à attacher à l'articulation.
body2BodyLe deuxième corps à attacher à l'articulation.
xnumberLa position x du point d'ancrage.
ynumberLa position y du point d'ancrage.
collideConnected (false)booleanIndique si les deux corps devraient entrer en collision les uns avec les autres.

love.physics.newGearJoint

Créez un joint d'engrenage reliant deux joints.

Le joint d'engrenage relie deux joints qui doivent être des joints prismatiques ou révolutionnaires. L'utilisation de cette articulation exige que les joints qu'elle utilise relient leurs corps respectifs au sol et que le sol soit le premier corps. Lorsque vous détruisez les corps et les joints, vous devez vous assurer de détruire l'articulation avant les autres joints.

L'articulation de l'engrenage a un rapport détermine comment les valeurs angulaires ou de distance des articulations connectées se rapportent l'une à l'autre. La formule coordonnée1 + ratio * coordonnée2 a toujours une valeur constante qui est définie lorsque l'articulation de l'engrenage est créée.

joint = love.physics.newGearJoint( joint1, joint2, ratio, collideConnected )

jointGearJointLe nouvel ensemble d'engrenages.
joint1JointLe premier joint à connecter avec un joint d'engrenage.
joint2JointLa deuxième articulation pour la connexion avec un joint d'engrenage.
ratio (1)numberLe rapport d'engrenage.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newMotorJoint

Crée un joint entre deux corps qui contrôle le mouvement relatif entre eux.

Les décalages de position et de rotation peuvent être spécifiés une fois que MotorJoint a été créé, ainsi que la force et le couple maximaux du moteur qui seront appliqués pour atteindre les décalages de la cible.

joint = love.physics.newMotorJoint( body1, body2, correctionFactor, collideConnected )

jointMotorJointLe nouveau MotorJoint.
body1BodyLe premier corps à attacher à l'articulation.
body2BodyLe deuxième corps à attacher à l'articulation.
correctionFactor (0.3)numberLe facteur de correction de position initiale de l'articulation, dans la plage de {0, 1}.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newMouseJoint

Créez une articulation entre un corps et la souris.

Cette articulation relie effectivement le corps à un point fixe dans le monde. Pour le faire suivre la souris, le point fixe doit être mis à jour chaque timestep (exemple ci-dessous).

L'avantage d'utiliser un MouseJoint au lieu de simplement changer une position du corps directement est que les collisions et les réactions à d'autres articulations sont traitées par le moteur de la physique.

joint = love.physics.newMouseJoint( body, x, y )

jointMouseJointLe nouveau joint de souris.
bodyBodyLe corps à attacher à la souris.
xnumberLa position x du point de connexion.
ynumberLa position y du point de connexion.

love.physics.newPolygonShape

Crée une nouvelle forme de polygone.

Cette forme peut avoir au maximum 8 sommets et doit former une forme convexe.

shape = love.physics.newPolygonShape( x1, y1, x2, y2, ... )

shapePolygonShapeUne nouvelle forme de polygone.
x1numberLa position du premier point sur l'axe des abscisses.
y1numberLa position du premier point sur l'axe des y.
x2numberLa position du deuxième point sur l'axe des abscisses.
y2numberLa position du deuxième point sur l'axe des y.
...numberVous pouvez continuer à passer plus de points pour créer la PolygonShape.

shape = love.physics.newPolygonShape( vertices )

shapePolygonShapeUne nouvelle forme de polygone.
verticestableUne liste de sommets pour construire le polygone, sous la forme de {x1, y1, x2, y2, x3, y3, ...}.

love.physics.newPrismaticJoint

Créez des joints prismatiques entre deux corps.

Un joint prismatique contraint deux corps à se déplacer l'un par rapport à l'autre sur un axe spécifié. Cela ne permet pas une rotation relative. Sa définition et son fonctionnement sont semblables à une articulation révolutionnaire, mais avec translation et force substituée par l'angle et le couple.

joint = love.physics.newPrismaticJoint( body1, body2, x1, y1, x2, y2, ax, ay, collideConnected, referenceAngle )

jointPrismaticJointLe nouveau joint prismatique.
body1BodyLe premier corps à se connecter avec un joint prismatique.
body2BodyLe deuxième corps à se connecter à un joint prismatique.
x1numberLa coordonnée x du premier point d'ancrage.
y1numberLa coordonnée y du premier point d'ancrage.
x2numberLa coordonnée x du deuxième point d'ancrage.
y2numberLa coordonnée y du deuxième point d'ancrage.
axnumberLa coordonnée x du vecteur unité d'axe.
aynumberLa coordonnée y du vecteur unité d'axe.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.
referenceAngle (0)numberL'angle de référence entre le corps 1 et le corps2, en radians.

love.physics.newPulleyJoint

Créez une poulie pour joindre deux corps l'un à l'autre et le sol.

L'articulation de la poulie simule une poulie avec un bloc optionnel et s'attaque. Si le paramètre de rapport a une valeur différente d'une seule, la corde simulée s'étend plus vite d'un côté que l'autre. Dans une articulation de poulie, la longueur totale de la corde simulée est la longueur constante1 + ratio * longueur2, qui est définie lorsque l'articulation de la poulie est créée.

Les articulations de la poulie peuvent se comporter de manière imprévisible si un côté est complètement étendu. Il est recommandé que la méthode setMaxLengths soit utilisée pour contraindre les longueurs maximales que chaque côté peut atteindre.

joint = love.physics.newPulleyJoint( body1, body2, gx1, gy1, gx2, gy2, x1, y1, x2, y2, ratio, collideConnected )

jointPulleyJointLa nouvelle articulation de poulie.
body1BodyLe premier corps à se connecter à une poulie.
body2BodyLe deuxième corps à se connecter avec une poulie.
gx1numberLa coordonnée x de l'ancrage au sol du premier corps.
gy1numberLa coordonnée y de l'ancre de base du premier corps.
gx2numberLa coordonnée x de l'ancrage au sol du second corps.
gy2numberLa coordonnée y de l'ancrage au sol du second corps.
x1numberLa coordonnée x de l'articulation de la poulie dans le premier corps.
y1numberLa coordonnée y de l'ancre articulaire de la poulie dans le premier corps.
x2numberLa coordonnée x de l'articulation de la poulie dans le deuxième corps.
y2numberLa coordonnée y de l'ancre articulaire de la poulie dans le deuxième corps.
ratio (1)numberLe ratio de joint.
collideConnected (true)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newRectangleShape

Sténatrie pour la création de PolygonShapes rectangulaires.

Par défaut, l'origine locale est située au centre du rectangle par opposition à la partie supérieure gauche pour les graphiques.

shape = love.physics.newRectangleShape( width, height )

shapePolygonShapeUne nouvelle forme de polygone.
widthnumberLa largeur du rectangle.
heightnumberLa hauteur du rectangle.

shape = love.physics.newRectangleShape( x, y, width, height, angle )

shapePolygonShapeUne nouvelle forme de polygone.
xnumberLe décalage le long de l'axe des abscisses.
ynumberLe décalage le long de l'axe des y.
widthnumberLa largeur du rectangle.
heightnumberLa hauteur du rectangle.
angle (0)numberL'angle initial du rectangle.

love.physics.newRevoluteJoint

Crée un joint pivot entre deux corps.

Cette articulation relie deux corps à un point autour duquel ils peuvent pivoter.

joint = love.physics.newRevoluteJoint( body1, body2, x, y, collideConnected )

jointRevoluteJointLe nouveau joint révolutionnaire.
body1BodyLe premier corps.
body2BodyLe deuxième corps.
xnumberLa position x du point de connexion.
ynumberLa position y du point de connexion.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

joint = love.physics.newRevoluteJoint( body1, body2, x1, y1, x2, y2, collideConnected, referenceAngle )

jointRevoluteJointLe nouveau joint révolutionnaire.
body1BodyLe premier corps.
body2BodyLe deuxième corps.
x1numberLa position x du premier point de connexion.
y1numberLa position y du premier point de connexion.
x2numberLa position x du deuxième point de connexion.
y2numberLa position y du deuxième point de connexion.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.
referenceAngle (0)numberSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newRopeJoint

Créer un joint entre deux corps. Sa seule fonction est d'imposer une distance maximale entre ces corps.

joint = love.physics.newRopeJoint( body1, body2, x1, y1, x2, y2, maxLength, collideConnected )

jointRopeJointLe nouveau RopeJoint.
body1BodyLe premier corps à attacher à l'articulation.
body2BodyLe deuxième corps à attacher à l'articulation.
x1numberLa position x du premier point d'ancrage.
y1numberLa position y du premier point d'ancrage.
x2numberLa position x du deuxième point d'ancrage.
y2numberLa position y du deuxième point d'ancrage.
maxLengthnumberLa distance maximale pour les corps.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newWeldJoint

Crée un joint contraignant entre deux corps. Un WeldJoint colle essentiellement deux corps ensemble. La contrainte est un peu douce, cependant, en raison du dissolvant itératif de Box2D.

joint = love.physics.newWeldJoint( body1, body2, x1, y1, x2, y2, collideConnected, referenceAngle )

jointWeldJointLe nouveau WeldJoint.
body1BodyLe premier corps à attacher à l'articulation.
body2BodyLe deuxième corps à attacher à l'articulation.
x1numberLa position x du premier point d'ancrage (espace mondial).
y1numberLa position y du premier point d'ancrage (espace mondial).
x2numberLa position x du deuxième point d'ancrage (espace mondial).
y2numberLa position y du deuxième point d'ancrage (espace mondial).
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.
referenceAngle (0)numberL'angle de référence entre le corps 1 et le corps2, en radians.

love.physics.newWheelJoint

Crée un joint de roue.

joint = love.physics.newWheelJoint( body1, body2, x, y, ax, ay, collideConnected )

jointWheelJointLe nouveau WheelJoint.
body1BodyLe premier corps.
body2BodyLe deuxième corps.
xnumberLa position x du point d'ancrage.
ynumberLa position y du point d'ancrage.
axnumberLa position x du vecteur unité d'axe.
aynumberLa position y du vecteur unité d'axe.
collideConnected (false)booleanSpécifie si les deux corps doivent entrer en collision les uns avec les autres.

love.physics.newWorld

Crée un nouveau monde.

world = love.physics.newWorld( xg, yg, sleep )

worldWorldUn nouveau monde courageux.
xg (0)numberLa composante x de la gravité.
yg (0)numberLe composant y de la gravité.
sleep (true)booleanQue les corps de ce monde soient autorisés à dormir.

love.physics.setMeter

Définit le facteur d'échelle des pixels pour compiler.

Toutes les coordonnées du module de physique sont divisées par ce nombre et converties en mètres, ce qui crée un moyen pratique de dessiner les objets directement sur l'écran sans avoir besoin de transformations graphiques.

Il est recommandé de créer des formes ne dépassant pas 10 fois l'échelle. Ceci est important car Box2D est syntonisé pour fonctionner bien avec des tailles de forme allant de 0,1 à 10 mètres. L'échelle de compteur par défaut est 30.

love.physics.setMeter ne s'applique pas rétroactivement aux objets créés. Les objets créés conservent leurs coordonnées du compteur, mais le facteur d'échelle affectera leurs coordonnées de pixels.

love.physics.setMeter( scale )

scalenumberLe facteur d'échelle en nombre entier.

BodyType

static

Les corps statiques ne bougent pas.

dynamic

Les corps dynamiques entrent en collision avec tous les corps.

kinematic

Les corps cinématiques ne font que faire face à des corps dynamiques.

JointType

distance

A DistanceJoint.

gear

Un GearJoint.

mouse

Un MouseJoint.

prismatic

Un point de vue prismatique.

pulley

A PulleyJoint.

revolute

Un assemblage révolutionnaire.

friction

A FrictionJoint.

weld

Un WeldJoint.

rope

A RopeJoint.

ShapeType

circle

La forme est une forme CircleShape.

polygon

La forme est une forme de polygone.

edge

La forme est un EdgeShape.

chain

La forme est une chaîne de caractères.

Body

Les corps sont des objets à la vitesse et à la position.

Constructors

Functions

Supertypes

Body:applyAngularImpulse

Applique une impulsion angulaire à un corps. Cela fait une seule addition instantanée à l'élan du corps.

Un corps avec une masse plus grande réagira moins. La réaction ne dépend pas du timestep et équivaut à appliquer une force en continu pendant 1 seconde. Les impulsions sont mieux utilisées pour donner une seule poussée à un corps. Pour une poussée continue vers un corps, il est préférable d'utiliser Body: applyForce.

Body:applyAngularImpulse( impulse )

impulsenumberL'impulsion en kilogramme par mètre carré par seconde.

Body:applyForce

Appliquer la force sur un corps.

Une force pousse un corps dans une direction. Un corps avec une masse plus grande réagira moins. La réaction dépend aussi de combien de temps une force est appliquée: puisque la force agit de manière continue sur l'ensemble du timestep, une courte temporisation ne poussera que le corps pendant un court laps de temps. Ainsi, les forces sont mieux utilisées pour de nombreux timestaps pour donner une poussée continue à un corps (comme la gravité). Pour une seule poussée indépendante de timestep, il est préférable d'utiliser Body: applyLinearImpulse.

Si la position d'appliquer la force n'est pas donnée, elle agira sur le centre de la masse du corps. La partie de la force qui n'est pas dirigée vers le centre de masse fera tourner le corps (et dépend de l'inertie de rotation).

Notez que les composants et la position de la force doivent être donnés dans les coordonnées mondiales.

Body:applyForce( fx, fy )

fxnumberLa composante x de la force à appliquer au centre de masse.
fynumberLa composante y de la force à appliquer au centre de masse.

Body:applyForce( fx, fy, x, y )

fxnumberLa composante x de la force à appliquer.
fynumberLa composante y de la force à appliquer.
xnumberLa position x pour appliquer la force.
ynumberLa position y pour appliquer la force.

Body:applyLinearImpulse

Applique une impulsion à un corps. Cela fait une seule addition instantanée à l'élan du corps.

Une impulsion pousse un corps dans une direction. Un corps avec une masse plus grande réagira moins. La réaction ne dépend pas du timestep et équivaut à appliquer une force en continu pendant 1 seconde. Les impulsions sont mieux utilisées pour donner une seule poussée à un corps. Pour une poussée continue vers un corps, il est préférable d'utiliser Body: applyForce.

Si la position d'appliquer l'impulsion n'est pas donnée, elle agira sur le centre de la masse du corps. La partie de l'impulsion qui n'est pas dirigée vers le centre de la masse fera tourner le corps (et dépend de l'inertie de rotation).

Notez que les composants et la position de l'impulsion doivent être donnés dans les coordonnées mondiales.

Body:applyLinearImpulse( ix, iy )

ixnumberLa composante x de l'impulsion appliquée au centre de masse.
iynumberLa composante y de l'impulsion appliquée au centre de masse.

Body:applyLinearImpulse( ix, iy, x, y )

ixnumberLa composante x de l'impulsion.
iynumberLa composante y de l'impulsion.
xnumberLa position x pour appliquer l'impulsion.
ynumberLa position y pour appliquer l'impulsion.

Body:applyTorque

Appliquer le couple sur un corps.

Le couple est comme une force qui changera la vitesse angulaire (spin) d'un corps. L'effet dépend de l'inertie de rotation d'un corps.

Body:applyTorque( torque )

torquenumberLe couple à appliquer.

Body:destroy

Détruit explicitement le corps. Lorsque vous n'avez pas le temps d'attendre la collecte des ordures, cette fonction peut être utilisée pour libérer l'objet immédiatement, mais notez qu'une erreur se produira si vous essayez d'utiliser l'objet après avoir appelé cette fonction.

Body:destroy()

Body:getAngle

Obtenez l'angle du corps.

L'angle est mesuré en radians. Si vous devez le transformer en degrés, utilisez math.deg.

Une valeur de 0 radians signifie "regarder vers la droite". Bien que les radians augmentent dans le sens inverse des aiguilles d'une montre, l'axe des Y pointe vers le bas, de sorte qu'il devient dans le sens des aiguilles d'une montre de notre point de vue.

angle = Body:getAngle()

anglenumberL'angle en radians.

Body:getAngularDamping

Obtient l'amortissement angulaire du corps

L'amortissement angulaire est le taux de diminution de la vitesse angulaire dans le temps: un corps tournant sans amortissement et sans forces externes continuera à tourner indéfiniment. Un corps tournant avec amortissement arrêtera progressivement le filage.

L'amortissement n'est pas le même que le frottement - ils peuvent être modélisés ensemble. Cependant, seul l'amortissement est fourni par Box2D (et LÖVE).

Les paramètres d'amortissement doivent être compris entre 0 et l'infini, avec 0 ce qui signifie pas d'amortissement, et l'infini signifie amortissement complet. Normalement, vous utiliserez une valeur d'amortissement entre 0 et 0,1.

damping = Body:getAngularDamping()

dampingnumberLa valeur de l'amortissement angulaire.

Body:getAngularVelocity

Obtenez la vitesse angulaire du corps.

La vitesse angulaire est le taux de changement d'angle par rapport au temps.

Il est changé dans World: mise à jour en appliquant des couples, des forces / impulsions hors centre et un amortissement angulaire. Il peut être réglé directement avec Body: setAngularVelocity.

Si vous avez besoin du taux de changement de position au fil du temps, utilisez Body: getLinearVelocity.

w = Body:getAngularVelocity()

wnumberLa vitesse angulaire en radians / seconde.

Body:getContactList

Obtient une liste de tous les contacts attachés au corps.

contacts = Body:getContactList()

contactstableUne liste avec tous les contacts associés au corps.

Body:getFixtureList

Obtient une table avec tous les luminaires.

fixtures = Body:getFixtureList()

fixturestableUne séquence avec tous les accessoires.

Body:getGravityScale

Obtient le facteur d'échelle de gravité.

scale = Body:getGravityScale()

scalenumberLe facteur d'échelle de gravité.

Body:getInertia

Obtient l'inertie de rotation du corps.

L'inertie de rotation est à quel point il est difficile de faire tourner le corps.

inertia = Body:getInertia()

inertianumberL'inertie de rotation du corps.

Body:getJointList

Obtient une table contenant les joints attachés à ce corps.

joints = Body:getJointList()

jointstableUne séquence avec les joints attachés au corps.

Body:getLinearDamping

Obtient l'amortissement linéaire du corps.

L'amortissement linéaire est le taux de diminution de la vitesse linéaire dans le temps. Un corps mobile sans amortissement et aucune force extérieure continuera à se déplacer indéfiniment, comme c'est le cas dans l'espace. Un corps mobile avec amortissement cessera progressivement de bouger.

L'amortissement n'est pas le même que le frottement - ils peuvent être modélisés ensemble. Cependant, seul l'amortissement est fourni par Box2D (et LÖVE).

damping = Body:getLinearDamping()

dampingnumberLa valeur de l'amortissement linéaire.

Body:getLinearVelocity

Obtient la vitesse linéaire du corps à partir de son centre de masse.

La vitesse linéaire est le taux de changement de position au fil du temps.

Si vous avez besoin du taux de changement d'angle au fil du temps, utilisez Body: getAngularVelocity. Si vous devez obtenir la vitesse linéaire d'un point différent du centre de masse:

Corps: getLinearVelocityFromLocalPoint vous permet de spécifier le point dans les coordonnées locales.

Corps: getLinearVelocityFromWorldPoint vous permet de spécifier le point dans les coordonnées mondiales.

x, y = Body:getLinearVelocity()

xnumberLe composant x du vecteur vitesse.
ynumberLa composante y du vecteur vitesse.

Body:getLinearVelocityFromLocalPoint

Obtenez la vitesse linéaire d'un point sur le corps.

La vitesse linéaire pour un point sur le corps est la vitesse du centre de masse du corps plus la vitesse à ce point du filage du corps.

Le point sur le corps doit être donné en coordonnées locales. Utilisez Body: getLinearVelocityFromWorldPoint pour spécifier cela avec des coordonnées mondiales.

vx, vy = Body:getLinearVelocityFromLocalPoint( x, y )

vxnumberLa composante x de la vitesse au point (x, y).
vynumberLa composante y de la vitesse au point (x, y).
xnumberLa position x pour mesurer la vitesse.
ynumberLa position y pour mesurer la vitesse.

Body:getLinearVelocityFromWorldPoint

Obtenez la vitesse linéaire d'un point sur le corps.

La vitesse linéaire pour un point sur le corps est la vitesse du centre de masse du corps plus la vitesse à ce point du filage du corps.

Le point sur le corps doit être donné en coordonnées mondiales. Utilisez Body: getLinearVelocityFromLocalPoint pour spécifier cela avec des coordonnées locales.

vx, vy = Body:getLinearVelocityFromWorldPoint( x, y )

vxnumberLa composante x de la vitesse au point (x, y).
vynumberLa composante y de la vitesse au point (x, y).
xnumberLa position x pour mesurer la vitesse.
ynumberLa position y pour mesurer la vitesse.

Body:getLocalCenter

Obtenez le centre de position de masse dans les coordonnées locales.

Utilisez Body: getWorldCenter pour obtenir le centre de masse dans les coordonnées mondiales.

x, y = Body:getLocalCenter()

xnumberLa coordonnée x du centre de masse.
ynumberLa coordonnée y du centre de masse.

Body:getLocalPoint

Transformez un point des coordonnées du monde en coordonnées locales.

localX, localY = Body:getLocalPoint( worldX, worldY )

localXnumberLa position x dans les coordonnées locales.
localYnumberLa position y dans les coordonnées locales.
worldXnumberLa position x dans les coordonnées mondiales.
worldYnumberLa position y dans les coordonnées mondiales.

Body:getLocalVector

Transformez un vecteur des coordonnées du monde en coordonnées locales.

localX, localY = Body:getLocalVector( worldX, worldY )

localXnumberLe vecteur x composant dans les coordonnées locales.
localYnumberLe composant vecteur y dans les coordonnées locales.
worldXnumberLe vecteur x composant dans les coordonnées mondiales.
worldYnumberLe vecteur y composant dans les coordonnées mondiales.

Body:getMass

Obtenez la masse du corps.

mass = Body:getMass()

massnumberLa masse du corps (en kilogrammes).

Body:getMassData

Obtient la masse, son centre et l'inertie de rotation.

x, y, mass, inertia = Body:getMassData()

xnumberLa position x du centre de masse.
ynumberLa position y du centre de masse.
massnumberLa masse du corps.
inertianumberL'inertie de rotation.

Body:getPosition

Obtenez la position du corps.

Notez que ce n'est peut-être pas le centre de la masse du corps.

x, y = Body:getPosition()

xnumberLa position x.
ynumberLa position y.

Body:getType

Obtient le type de corps.

type = Body:getType()

typeBodyTypeLe type de corps.

Body:getUserData

Obtient la valeur Lua associée à ce corps.

value = Body:getUserData()

valueanyLa valeur Lua associée au corps.

Body:getWorld

Obtient le monde dans lequel le corps vit.

world = Body:getWorld()

worldWorldLe monde dans lequel vit le corps.

Body:getWorldCenter

Obtenez le centre de la position de masse dans les coordonnées mondiales.

Utilisez Body: getLocalCenter pour obtenir le centre de masse dans les coordonnées locales.

x, y = Body:getWorldCenter()

xnumberLa coordonnée x du centre de masse.
ynumberLa coordonnée y du centre de masse.

Body:getWorldPoint

Transformez un point de coordonnées locales en coordonnées mondiales.

worldX, worldY = Body:getWorldPoint( localX, localY )

worldXnumberLa position x dans les coordonnées mondiales.
worldYnumberLa position y dans les coordonnées mondiales.
localXnumberLa position x dans les coordonnées locales.
localYnumberLa position y dans les coordonnées locales.

Body:getWorldPoints

Transforme les points multiples des coordonnées locales en coordonnées mondiales.

x1, y1, x2, y2, ... = Body:getWorldPoints( x1, y1, x2, y2, ... )

x1numberLa position X transformée du premier point.
y1numberLa position Y transformée du premier point.
x2numberLa position X transformée du deuxième point.
y2numberLa position Y transformée du deuxième point.
...numberLes positions X et Y transformées de points supplémentaires.
x1numberLa position x du premier point.
y1numberLa position y du premier point.
x2numberLa position x du deuxième point.
y2numberLa position y du deuxième point.
...numberPlus de points x et y.

Body:getWorldVector

Transformez un vecteur des coordonnées locales en coordonnées mondiales.

worldX, worldY = Body:getWorldVector( localX, localY )

worldXnumberLe vecteur x composant dans les coordonnées mondiales.
worldYnumberLe vecteur y composant dans les coordonnées mondiales.
localXnumberLe vecteur x composant dans les coordonnées locales.
localYnumberLe composant vecteur y dans les coordonnées locales.

Body:getX

Obtenez la position x du corps dans les coordonnées mondiales.

x = Body:getX()

xnumberLa position x dans les coordonnées mondiales.

Body:getY

Obtenez la position y du corps dans les coordonnées mondiales.

y = Body:getY()

ynumberLa position y dans les coordonnées mondiales.

Body:isActive

Obtient si le corps est activement utilisé dans la simulation.

status = Body:isActive()

statusbooleanVrai si le corps est actif ou est faux sinon.

Body:isAwake

Obtient le statut de sommeil du corps.

status = Body:isAwake()

statusbooleanVrai si le corps est éveillé ou faux sinon.

Body:isBullet

Obtenez le statut de balle d'un corps.

Il existe deux méthodes pour vérifier les collisions corporelles:

à leur emplacement lorsque le monde est mis à jour (par défaut)

en utilisant la détection de collision continue (CCD)

La méthode par défaut est efficace, mais un corps qui se déplace très rapidement peut parfois sauter sur un autre corps sans provoquer de collision. Un corps qui est défini comme une balle utilisera le CCD. Ceci est moins efficace, mais il est garanti de ne pas sauter lorsque vous déménagez rapidement.

Notez que les corps statiques (avec zéro masse) utilisent toujours le CCD, de sorte que vos murs ne laisseront pas passer un corps en mouvement rapide, même s'il ne s'agit pas d'une balle.

status = Body:isBullet()

statusbooleanL'état de la balle du corps.

Body:isDestroyed

Obtient si le corps est détruit. Les corps détruits ne peuvent pas être utilisés.

destroyed = Body:isDestroyed()

destroyedbooleanQue le corps soit détruit.

Body:isFixedRotation

Obtient si la rotation du corps est verrouillée.

fixed = Body:isFixedRotation()

fixedbooleanVrai si la rotation du corps est verrouillée ou est fausse sinon.

Body:isSleepingAllowed

Obtient le comportement de sommeil du corps.

status = Body:isSleepingAllowed()

statusbooleanVrai si le corps est autorisé à dormir ou est faux sinon.

Body:resetMassData

Réinitialise la masse du corps en le recalculant à partir des propriétés de masse des appareils.

Body:resetMassData()

Body:setActive

Définit si le corps est actif dans le monde.

Un corps inactif ne participe pas à la simulation. Cela ne bougera pas ou n'entraînera aucune collision.

Body:setActive( active )

activebooleanSi le corps est actif ou non.

Body:setAngle

Réglez l'angle du corps.

L'angle est mesuré en radians. Si vous devez le transformer en degrés, utilisez math.rad.

Une valeur de 0 radians signifie "regarder vers la droite". Bien que les radians augmentent dans le sens inverse des aiguilles d'une montre, l'axe des Y pointe vers le bas, de sorte qu'il devient dans le sens des aiguilles d'une montre de notre point de vue.

Il est possible de provoquer une collision avec un autre corps en modifiant son angle.

Body:setAngle( angle )

anglenumberL'angle en radians.

Body:setAngularDamping

Définit l'amortissement angulaire d'un corps.

Voir Body: getAngularDamping pour une définition de l'amortissement angulaire.

L'amortissement angulaire peut prendre n'importe quelle valeur de 0 à l'infini. Il est toutefois recommandé de rester entre 0 et 0.1. D'autres valeurs apparaîtront irréalistes.

Body:setAngularDamping( damping )

dampingnumberLe nouvel amortissement angulaire.

Body:setAngularVelocity

Définit la vitesse angulaire d'un corps.

La vitesse angulaire est le taux de changement d'angle par rapport au temps.

Cette fonction n'accumule rien; les impulsions précédemment appliquées depuis le dernier appel vers le monde: la mise à jour sera perdue.

Body:setAngularVelocity( w )

wnumberLa nouvelle vitesse angulaire, en radians par seconde

Body:setAwake

Éteint le corps ou le met à dormir.

Body:setAwake( awake )

awakebooleanL'état du sommeil du corps.

Body:setBullet

Définissez le statut de balle d'un corps.

Il existe deux méthodes pour vérifier les collisions corporelles:

à leur emplacement lorsque le monde est mis à jour (par défaut)

en utilisant la détection de collision continue (CCD)

La méthode par défaut est efficace, mais un corps qui se déplace très rapidement peut parfois sauter sur un autre corps sans provoquer de collision. Un corps qui est défini comme une balle utilisera le CCD. Ceci est moins efficace, mais il est garanti de ne pas sauter lorsque vous déménagez rapidement.

Notez que les corps statiques (avec zéro masse) utilisent toujours le CCD, de sorte que vos murs ne laisseront pas passer un corps en mouvement rapide, même s'il ne s'agit pas d'une balle.

Body:setBullet( status )

statusbooleanL'état de la balle du corps.

Body:setFixedRotation

Indiquez si un corps a une rotation fixe.

Les corps à rotation fixe ne modifient pas la vitesse à laquelle ils tournent.

Body:setFixedRotation( fixed )

fixedbooleanQue le corps ait une rotation fixe.

Body:setGravityScale

Définit un nouveau facteur d'échelle de gravité pour le corps.

Body:setGravityScale( scale )

scalenumberLe nouveau facteur d'échelle de gravité.

Body:setInertia

Réglez l'inertie d'un corps.

Body:setInertia( inertia )

inertianumberLe nouveau moment d'inertie, en kilogrammes par mètre au carré.

Body:setLinearDamping

Définit l'amortissement linéaire d'un corps

Voir Body: getLinearDamping pour une définition de l'amortissement linéaire.

L'amortissement linéaire peut prendre n'importe quelle valeur de 0 à l'infini. Il est toutefois recommandé de rester entre 0 et 0.1. D'autres valeurs rendront les objets "flottants".

Body:setLinearDamping( ld )

ldnumberLe nouvel amortissement linéaire.

Body:setLinearVelocity

Définit une nouvelle vitesse linéaire pour le corps.

Cette fonction n'accumule rien; les impulsions précédemment appliquées depuis le dernier appel vers le monde: la mise à jour sera perdue.

Body:setLinearVelocity( x, y )

xnumberLe composant x du vecteur vitesse.
ynumberLa composante y du vecteur vitesse.

Body:setMass

Définit la masse en kilogrammes.

Body:setMass( mass )

massnumberLa masse, en kilogrammes.

Body:setMassData

Remplace les données de masse calculées.

Body:setMassData( x, y, mass, inertia )

xnumberLa composante x du centre de masse dans les coordonnées locales.
ynumberLa composante y du centre de masse dans les coordonnées locales.
massnumberLa masse, en kilogrammes.
inertianumberL'inertie de rotation, en kilogrammes par mètre carré.

Body:setPosition

Réglez la position du corps.

Notez que ce n'est peut-être pas le centre de la masse du corps.

Body:setPosition( x, y )

xnumberLa position x.
ynumberLa position y.

Body:setSleepingAllowed

Définit le comportement de sommeil du corps.

Body:setSleepingAllowed( allowed )

allowedbooleanVrai si le corps est autorisé à dormir ou est faux sinon.

Body:setType

Définit un nouveau type de corps.

Body:setType( type )

typeBodyTypeLe nouveau type.

Body:setUserData

Associe une valeur Lua au corps.

Pour supprimer la référence, passez explicitement nil.

Body:setUserData( value )

valueanyLa valeur Lua à associer au corps.

Body:setX

Réglez la position x du corps.

Body:setX( x )

xnumberLa position x.

Body:setY

Réglez la position y du corps.

Body:setY( y )

ynumberLa position y.

ChainShape

Un ChainShape se compose de plusieurs segments de ligne. Il peut être utilisé pour créer les limites de votre terrain. La forme n'a pas de volume et peut seulement entrer en collision avec PolygonShape et CircleShape.

Contrairement à PolygonShape, ChainShape n'a pas de limite de sommet ou doit former une forme convexe, mais les intersections automatiques ne sont pas prises en charge.

Constructors

Functions

Supertypes

ChainShape:getChildEdge

Obtient un enfant de la forme en tant que EdgeShape.

EdgeShape = ChainShape:getChildEdge( index )

EdgeShapenumberL'enfant comme EdgeShape.
indexnumberL'indice de l'enfant.

ChainShape:getNextVertex

Obtient le sommet qui établit une connexion à la forme suivante.

Le réglage des sommets ChainShape suivants et suivants peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

ChainShape:getNextVertex( x, y )

x (nil)numberLa composante x du sommet, ou néant si ChainShape: setNextVertex n'a pas été appelé.
y (nil)numberLe composant y du sommet, ou néant si ChainShape: setNextVertex n'a pas été appelé.

ChainShape:getPoint

Obtient un point de la forme.

x, y = ChainShape:getPoint( index )

xnumberLa coordonnée x du point.
ynumberLa coordonnée y du point.
indexnumberL'indice du point à retourner.

ChainShape:getPoints

Obtient tous les points de la forme.

x1, y1, x2, y2, ... = ChainShape:getPoints()

x1numberLa coordonnée x du premier point.
y1numberLa coordonnée y du premier point.
x2numberLa coordonnée x du deuxième point.
y2numberLa coordonnée y du deuxième point.
...numberValeurs supplémentaires x et y.

ChainShape:getPreviousVertex

Obtient le sommet qui établit une connexion à la forme précédente.

Le réglage des sommets ChainShape suivants et suivants peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

x, y = ChainShape:getPreviousVertex()

x (nil)numberLa composante x du sommet, ou néant si ChainShape: setNextVertex n'a pas été appelé.
y (nil)numberLe composant y du sommet, ou néant si ChainShape: setNextVertex n'a pas été appelé.

ChainShape:getVertexCount

Obtient le nombre de sommets dont la forme a eu.

count = ChainShape:getVertexCount()

countnumberLe nombre de sommets.

ChainShape:setNextVertex

Définit un sommet qui établit une connexion à la forme suivante.

Cela peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

ChainShape:setNextVertex( x, y )

xnumberLe composant x du sommet.
ynumberLa composante y du sommet.

ChainShape:setPreviousVertex

Définit un sommet qui établit une connexion à la forme précédente.

Cela peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

ChainShape:setPreviousVertex( x, y )

xnumberLe composant x du sommet.
ynumberLa composante y du sommet.

CircleShape

Le cercle prolonge la forme et ajoute un rayon et une position locale.

Constructors

Functions

Supertypes

CircleShape:getPoint

Obtient le point central de la forme du cercle.

x, y = CircleShape:getPoint()

xnumberLa composante x du point central du cercle.
ynumberLe composant y du point central du cercle.

CircleShape:getRadius

Obtient le rayon de la forme du cercle.

radius = CircleShape:getRadius()

radiusnumberLe rayon du cercle.

CircleShape:setPoint

Définit l'emplacement du centre de la forme du cercle.

CircleShape:setPoint( x, y )

xnumberLe composant x du nouveau point central du cercle.
ynumberLe composant y du nouveau point central du cercle.

CircleShape:setRadius

Définit le rayon du cercle.

CircleShape:setRadius( radius )

radiusnumberLe rayon du cercle.

Contact

Les contacts sont des objets créés pour gérer les collisions dans les mondes.

Functions

Supertypes

Contact:getFixtures

Obtient les deux accessoires qui contiennent les formes qui sont en contact.

fixtureA, fixtureB = Contact:getFixtures()

fixtureAFixtureLe premier appareil.
fixtureBFixtureLe deuxième appareil.

Contact:getFriction

Obtenez le frottement entre deux formes qui sont en contact.

friction = Contact:getFriction()

frictionnumberLe frottement du contact.

Contact:getNormal

Obtenez le vecteur normal entre deux formes qui sont en contact.

Cette fonction renvoie les coordonnées d'un vecteur unitaire qui pointe de la première forme à la seconde.

nx, ny = Contact:getNormal()

nxnumberLe composant x du vecteur normal.
nynumberLa composante y du vecteur normal.

Contact:getPositions

Obtient les points de contact des deux collisions. Il peut y avoir un ou deux points.

x1, y1, x2, y2 = Contact:getPositions()

x1numberLa coordonnée x du premier point de contact.
y1numberLa coordonnée y du premier point de contact.
x2numberLa coordonnée x du deuxième point de contact.
y2numberLa coordonnée y du deuxième point de contact.

Contact:getRestitution

Obtenez la restitution entre deux formes qui sont en contact.

restitution = Contact:getRestitution()

restitutionnumberLa restitution entre les deux formes.

Contact:isEnabled

Obtient si le contact est activé. La collision sera ignorée si un contact est désactivé dans le rappel de preSolve.

enabled = Contact:isEnabled()

enabledbooleanVrai si activé, false sinon.

Contact:isTouching

Comprend si les deux accessoires en collision se touchent.

touching = Contact:isTouching()

touchingbooleanVrai s'ils touchent ou faux, sinon.

Contact:resetFriction

Réinitialise la friction de contact à la valeur de mélange des deux appareils.

Contact:resetFriction()

Contact:resetRestitution

Réinitialise la restitution de contact à la valeur de mélange des deux appareils.

Contact:resetRestitution()

Contact:setEnabled

Active ou désactive le contact.

Contact:setEnabled( enabled )

enabledbooleanFacile à activer ou à fausser pour désactiver.

Contact:setFriction

Définit la friction de contact.

Contact:setFriction( friction )

frictionnumberLa friction de contact.

Contact:setRestitution

Définit la restitution des contacts.

Contact:setRestitution( restitution )

restitutionnumberLa restitution des contacts.

EdgeShape

Un EdgeShape est un segment de ligne. Ils peuvent être utilisés pour créer les limites de votre terrain. La forme n'a pas de volume et peut seulement entrer en collision avec PolygonShape et CircleShape.

Constructors

Functions

Supertypes

EdgeShape:getPoints

Obtient les coordonnées locales des points de bord.

x1, y1, x2, y2 = EdgeShape:getPoints()

x1numberLe composant x du premier sommet.
y1numberLa composante y du premier sommet.
x2numberLe composant x du second sommet.
y2numberLa composante y du deuxième sommet.

EdgeShape:getNextVertex

Obtient le sommet qui établit une connexion à la forme suivante.

Le réglage des sommets EdgeShape suivants et antérieurs peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

x, y = EdgeShape:getNextVertex()

xnumberLe composant x du sommet, ou néant si EdgeShape: setNextVertex n'a pas été appelé.
ynumberLe composant y du sommet, ou néant si EdgeShape: setNextVertex n'a pas été appelé.

EdgeShape:getPreviousVertex

Obtient le sommet qui établit une connexion à la forme précédente.

Le réglage des sommets EdgeShape suivants et antérieurs peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

x, y = EdgeShape:getPreviousVertex()

xnumberLe composant x du sommet, ou néant si EdgeShape: setPreviousVertex n'a pas été appelé.
ynumberLe composant y du sommet, ou néant si EdgeShape: setPreviousVertex n'a pas été appelé.

EdgeShape:setNextVertex

Définit un sommet qui établit une connexion à la forme suivante.

Cela peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

EdgeShape:setNextVertex( x, y )

xnumberLe composant x du sommet.
ynumberLe composant y du sommet.

EdgeShape:setPreviousVertex

Définit un sommet qui établit une connexion à la forme précédente.

Cela peut aider à éviter les collisions indésirables lorsqu'une forme plate glisse le long du bord et se déplace vers la nouvelle forme.

EdgeShape:setPreviousVertex( x, y )

xnumberLe composant x du sommet.
ynumberLe composant y du sommet.

DistanceJoint

Maintient deux corps à la même distance.

Constructors

Functions

Supertypes

DistanceJoint:getDampingRatio

Obtient le taux d'amortissement.

ratio = DistanceJoint:getDampingRatio()

rationumberLe rapport d'amortissement.

DistanceJoint:getFrequency

Obtient la vitesse de réponse.

Hz = DistanceJoint:getFrequency()

HznumberLa vitesse de réponse.

DistanceJoint:getLength

Obtient la distance d'équilibre entre les deux corps.

l = DistanceJoint:getLength()

lnumberLa longueur entre les deux corps.

DistanceJoint:setDampingRatio

Définit le taux d'amortissement.

DistanceJoint:setDampingRatio( ratio )

rationumberLe rapport d'amortissement.

DistanceJoint:setFrequency

Définit la vitesse de réponse.

DistanceJoint:setFrequency( Hz )

HznumberLa vitesse de réponse.

DistanceJoint:setLength

Définit la distance d'équilibre entre les deux corps.

DistanceJoint:setLength( l )

lnumberLa longueur entre les deux corps.

Fixture

Les luminaires attachent des formes aux corps.

Constructors

Functions

Supertypes

Fixture:destroy

Détruit le montage

Fixture:destroy()

Fixture:getBody

Obtient le corps auquel l'accessoire est attaché.

body = Fixture:getBody()

bodyBodyLe corps parent.

Fixture:getBoundingBox

Obtient les points de la boîte de fixation. Dans le cas où l'appareil comporte plusieurs enfants, un index basé sur 1 peut être spécifié. Par exemple, un accessoire aura plusieurs enfants avec une forme de chaîne.

topLeftX, topLeftY, bottomRightX, bottomRightY = Fixture:getBoundingBox( index )

topLeftXnumberLa position x du point supérieur gauche.
topLeftYnumberLa position y du point supérieur gauche.
bottomRightXnumberLa position x du point inférieur droit.
bottomRightYnumberLa position y du point inférieur droit.
index (1)numberUne boîte délimitée de l'appareil.

Fixture:getCategory

Obtient les catégories auxquelles appartient l'accessoire.

category1, category2, ... = Fixture:getCategory()

category1numberLa première catégorie.
category2numberLa deuxième catégorie.
...numberAutres catégories.

Fixture:getDensity

Obtient la densité de l'appareil.

density = Fixture:getDensity()

densitynumberLa densité de l'appareil en kilogrammes par mètre carré.

Fixture:getFilterData

Obtient les données du filtre de l'appareil. Les catégories et les masques sont codés en bits d'un nombre entier de 16 bits.

categories, mask, group = Fixture:getFilterData()

categoriesnumberLes catégories en nombre entier de 0 à 65535.
masknumberLe masque est un nombre entier de 0 à 65535.
groupnumberLe groupe en entier de -32768 à 32767.

Fixture:getFriction

Obtient le frottement de l'appareil.

friction = Fixture:getFriction()

frictionnumberLe frottement de l'appareil.

Fixture:getGroupIndex

Obtient le groupe auquel appartient l'accessoire. Les luminaires avec le même groupe se heurteront toujours si le groupe est positif ou ne se heurte jamais s'il est négatif. Le groupe zéro signifie aucun groupe.

Les groupes varient de -32768 à 32767.

group = Fixture:getGroupIndex()

groupnumberLe groupe de l'appareil.

Fixture:getMask

Obtient le masque de catégorie de l'appareil.

mask1, mask2, ... = Fixture:getMask()

mask1numberLa première catégorie sélectionnée par le masque.
mask2numberLa deuxième catégorie sélectionnée par le masque.
...numberAutres catégories sélectionnées par le masque.

Fixture:getMassData

Obtient la masse, son centre et l'inertie de rotation.

x, y, mass, inertia = Fixture:getMassData()

xnumberLa position x du centre de masse.
ynumberLa position y du centre de masse.
massnumberLa masse de l'assiette.
inertianumberL'inertie de rotation.

Fixture:getRestitution

Obtient la restitution de l'appareil.

restitution = Fixture:getRestitution()

restitutionnumberLa restitution des appareils.

Fixture:getShape

Obtient la forme de l'appareil. Cette forme est une référence aux données réelles utilisées dans la simulation. Il est possible de modifier ses valeurs entre timestaps.

N'appelez aucune fonction sur cette forme après la destruction de l'appareil parent. Cette forme indiquera une adresse de mémoire invalide et risque de causer des pannes si vous interagissez avec elle.

shape = Fixture:getShape()

shapeShapeLa forme de l'appareil.

Fixture:getUserData

Obtient la valeur Lua associée à cet appareil.

Utilisez cette fonction uniquement dans un seul fil.

value = Fixture:getUserData()

valueanyLa valeur Lua associée à l'appareil.

Fixture:isDestroyed

Obtient si le Fixture est détruit. Les appareils détruits ne peuvent pas être utilisés.

destroyed = Fixture:isDestroyed()

destroyedbooleanQue le Fixture soit détruit.

Fixture:isSensor

Obtient si l'appareil est un capteur.

sensor = Fixture:isSensor()

sensorbooleanSi l'appareil est un capteur.

Fixture:rayCast

Casse un rayon contre la forme de l'appareil et renvoie le vecteur normal de surface et la position de ligne où le rayon atteint. Si le rayon manquait la forme, nul ne sera renvoyé.

Le rayon commence sur le premier point de la ligne d'entrée et se dirige vers le deuxième point de la ligne. Le quatrième argument est la distance maximale que le rayon voyagera en tant que facteur d'échelle de la longueur de ligne d'entrée.

Le paramètre childIndex est utilisé pour spécifier quel enfant d'une forme parentale, comme un ChainShape, sera rayé. Pour ChainShapes, l'indice de 1 est le premier bord de la chaîne. Ray mettant la forme d'un parent ne fera que tester l'enfant spécifié, donc, si vous souhaitez tester toutes les formes du parent, vous devez passer à travers tous ses enfants.

La position mondiale de l'impact peut être calculée en multipliant le vecteur de ligne par la troisième valeur de retour et en l'ajoutant au point de départ de la ligne.

hitx, hity = x1 + (x2 - x1) * fraction, y1 + (y2 - y1) * fraction

x, y, fraction = Fixture:rayCast( x1, y1, x2, y1, maxFraction, childIndex )

xnumberLa position x où le rayon croise la forme.
ynumberLa position y où le rayon croise la forme.
fractionnumberLa position sur le vecteur d'entrée où l'intersection s'est produite en tant que nombre de 0 à 1.
x1numberLa position x du point de départ du rayon.
y1numberLa position y du point de départ du rayon.
x2numberLa position x du point final du rayon.
y1numberLa position y du point final du rayon.
maxFractionnumberLa distance maximale du rayon va se déplacer en un nombre de 0 à 1.
childIndex (1)numberL'indice de l'enfant sur lequel le rayon est rejeté.

Fixture:setCategory

Définit les catégories auxquelles appartient l'accessoire. Il peut y avoir jusqu'à 16 catégories représentées comme un nombre de 1 à 16.

Fixture:setCategory( category1, category2, ... )

category1numberLa première catégorie.
category2numberLa deuxième catégorie.
...numberAutres catégories.

Fixture:setDensity

Définit la densité de l'appareil. Corps de l'appel: resetMassData si cela doit prendre effet immédiatement.

Fixture:setDensity( density )

densitynumberLa densité de l'appareil en kilogrammes par mètre carré.

Fixture:setFilterData

Définit les données du filtre de l'appareil.

Les groupes, les catégories et le masque peuvent être utilisés pour définir le comportement de collision de l'appareil.

Si deux appareils sont dans le même groupe, ils se heurtent toujours si le groupe est positif ou ne se heurtent que s'il est négatif. Si le groupe est nul ou ne correspondent pas, le filtre de contact vérifie si les appareils sélectionnent une catégorie de l'autre appareil avec leurs masques. Les luminaires n'interviennent pas si ce n'est pas le cas. Si elles ont les catégories choisies, la valeur de retour du filtre de contact personnalisé sera utilisée. Ils entrent en collision si aucun n'a été réglé.

Il peut y avoir jusqu'à 16 catégories. Les catégories et les masques sont codés en bits d'un nombre entier de 16 bits.

Fixture:setFilterData( categories, mask, group )

categoriesnumberLes catégories en nombre entier de 0 à 65535.
masknumberLe masque est un nombre entier de 0 à 65535.
groupnumberLe groupe en entier de -32768 à 32767.

Fixture:setFriction

Définit le frottement de l'appareil.

Fixture:setFriction( friction )

frictionnumberLe frottement de l'appareil.

Fixture:setGroupIndex

Définit le groupe auquel appartient l'accessoire. Les luminaires avec le même groupe se heurteront toujours si le groupe est positif ou ne se heurte jamais s'il est négatif. Le groupe zéro signifie aucun groupe.

Les groupes varient de -32768 à 32767.

Fixture:setGroupIndex( group )

groupnumberLe groupe en entier de -32768 à 32767.

Fixture:setMask

Définit le masque de catégorie de l'appareil. Il peut y avoir jusqu'à 16 catégories représentées comme un nombre de 1 à 16.

Cet appareil collabore avec les appareils qui se trouvent dans les catégories sélectionnées si l'autre appareil a également sélectionné une catégorie de ce kit.

Fixture:setMask( mask1, mask2, ... )

mask1numberLa première catégorie.
mask2numberLa deuxième catégorie.
...numberAutres catégories.

Fixture:setRestitution

Définit la restitution de l'appareil.

Fixture:setRestitution( restitution )

restitutionnumberLa restitution des appareils.

Fixture:setSensor

Définit si l'appareil doit agir comme un capteur.

Le capteur ne produit pas de réponses de collision, mais les rappels de début et de fin seront toujours appelés pour cet appareil.

Fixture:setSensor( sensor )

sensorbooleanL'état du capteur.

Fixture:setUserData

Associe une valeur Lua à l'appareil.

Utilisez cette fonction uniquement dans un seul fil.

Fixture:setUserData( value )

valueanyLa valeur Lua associée à l'appareil.

Fixture:testPoint

Vérifie si un point se trouve dans la forme de l'appareil.

isInside = Fixture:testPoint( x, y )

isInsidebooleanVrai si le point est à l'intérieur ou est faux s'il se trouve à l'extérieur.
xnumberLa position x du point.
ynumberLa position y du point.

FrictionJoint

Un membre de Friction applique une friction à un corps.

Constructors

Functions

Supertypes

FrictionJoint:getMaxForce

Obtient la force de frottement maximale dans Newtons.

force = FrictionJoint:getMaxForce()

forcenumberForce maximale dans Newtons.

FrictionJoint:getMaxTorque

Obtient le couple de friction maximum dans Newton-mètres.

torque = FrictionJoint:getMaxTorque()

torquenumberCouple maximal en Newton-mètres.

FrictionJoint:setMaxForce

Définit la force de frottement maximale dans Newtons.

FrictionJoint:setMaxForce( maxForce )

maxForcenumberForce maximale dans Newtons.

FrictionJoint:setMaxTorque

Définit le couple de friction maximum dans Newton-mètres.

FrictionJoint:setMaxTorque( torque )

torquenumberCouple maximal en Newton-mètres.

GearJoint

Maintient les corps ensemble de telle manière qu'ils agissent comme des engrenages.

Constructors

Functions

Supertypes

GearJoint:getJoints

Obtenez les joints connectés par ce GearJoint.

joint1, joint2 = GearJoint:getJoints()

joint1JointLa première articulation connectée.
joint2JointLa deuxième articulation connectée.

GearJoint:getRatio

Obtenez le rapport d'un joint d'engrenage.

ratio = GearJoint:getRatio()

rationumberLe rapport de l'articulation.

GearJoint:setRatio

Réglez le rapport d'un joint d'engrenage.

GearJoint:setRatio( ratio )

rationumberLe nouveau ratio de l'articulation.

Joint

Joignez plusieurs corps ensemble pour interagir de manière unique.

Functions

Supertypes

Subtypes

Joint:destroy

Détruis explicitement le Joint. Lorsque vous n'avez pas le temps d'attendre la collecte des ordures, cette fonction peut être utilisée pour libérer l'objet immédiatement, mais notez qu'une erreur se produira si vous essayez d'utiliser l'objet après avoir appelé cette fonction.

Joint:destroy()

Joint:getAnchors

Obtenez les points d'ancrage de l'articulation.

x1, y1, x2, y2 = Joint:getAnchors()

x1numberLe composant x de l'ancre sur le corps 1.
y1numberLe composant y de l'ancre sur le corps 1.
x2numberLe composant x de l'ancre sur le corps 2.
y2numberLe composant y de l'ancre sur le corps 2.

Joint:getBodies

Obtient les corps auxquels le joint est joint.

bodyA, bodyB = Joint:getBodies()

bodyABodyLe premier Corps.
bodyBBodyLe deuxième corps.

Joint:getCollideConnected

Obtient si les corps connectés entrent en collision.

c = Joint:getCollideConnected()

cbooleanVrai s'ils entrent en collision, faux sinon.

Joint:getReactionForce

Obtient la force de réaction sur le corps 2 à l'ancre d'articulation.

x, y = Joint:getReactionForce()

xnumberLa composante x de la force.
ynumberLa composante y de la force.

Joint:getReactionTorque

Obtient le couple de réaction sur le deuxième corps.

torque = Joint:getReactionTorque( invdt )

torquenumberLe couple de réaction sur le deuxième corps.
invdtnumberCombien de temps dure la force. Habituellement, le temps inverse ou 1 / dt.

Joint:getType

Obtient une chaîne représentant le type.

type = Joint:getType()

typeJointTypeUne chaîne avec le nom du type Joint.

Joint:getUserData

Obtient la valeur Lua associée à cette Joint.

value = Joint:getUserData()

valueanyLa valeur de Lua associée au Joint.

Joint:isDestroyed

Obtient si le Joint est détruit. Les joints détruits ne peuvent pas être utilisés.

destroyed = Joint:isDestroyed()

destroyedbooleanQue le joint soit détruit.

Joint:setUserData

Associe une valeur Lua avec le Joint.

Pour supprimer la référence, passez explicitement nil.

Joint:setUserData( value )

valueanyLa valeur Lua à associer à la Joint.

MotorJoint

Contrôle le mouvement relatif entre deux corps. Les décalages de position et de rotation peuvent être spécifiés, ainsi que la force et le couple maximaux du moteur qui seront appliqués pour atteindre les décalages de la cible.

Constructors

Functions

Supertypes

MotorJoint:getAngularOffset

Obtient le décalage angulaire cible entre les deux corps auxquels l'articulation est attachée.

angularoffset = MotorJoint:getAngularOffset()

angularoffsetnumberLe décalage angulaire cible en radians: l'angle du second corps moins l'angle du premier corps.

MotorJoint:getLinearOffset

Obtient le décalage linéaire cible entre les deux corps auxquels l'articulation est attachée.

x, y = MotorJoint:getLinearOffset()

xnumberLe composant x du décalage linéaire cible par rapport au premier corps.
ynumberLe composant y du décalage linéaire cible par rapport au premier corps.

MotorJoint:setAngularOffset

Définit le décalage anglal cible entre les deux corps auxquels l'articulation est attachée.

MotorJoint:setAngularOffset( angularoffset )

angularoffsetnumberLe décalage angulaire cible en radians: l'angle du second corps moins l'angle du premier corps.

MotorJoint:setLinearOffset

Définit le décalage linéaire cible entre les deux corps auxquels l'articulation est attachée.

MotorJoint:setLinearOffset( x, y )

xnumberLe composant x du décalage linéaire cible par rapport au premier corps.
ynumberLe composant y du décalage linéaire cible par rapport au premier corps.

MouseJoint

Pour contrôler les objets avec la souris.

Constructors

Functions

Supertypes

MouseJoint:getDampingRatio

Obtient le taux d'amortissement.

ratio = MouseJoint:getDampingRatio()

rationumberLe nouveau rapport d'amortissement.

MouseJoint:getFrequency

Obtient la fréquence.

freq = MouseJoint:getFrequency()

freqnumberLa fréquence en hertz.

MouseJoint:getMaxForce

Obtient la plus grande force autorisée.

f = MouseJoint:getMaxForce()

fnumberLa force maximale autorisée.

MouseJoint:getTarget

Obtient le point cible.

x, y = MouseJoint:getTarget()

xnumberLe composant x de la cible.
ynumberLe composant x de la cible.

MouseJoint:setDampingRatio

Définit un nouveau taux d'amortissement.

MouseJoint:setDampingRatio( ratio )

rationumberLe nouveau rapport d'amortissement.

MouseJoint:setFrequency

Définit une nouvelle fréquence.

MouseJoint:setFrequency( freq )

freqnumberLa nouvelle fréquence en hertz.

MouseJoint:setMaxForce

Définit la plus grande force autorisée.

MouseJoint:setMaxForce( f )

fnumberLa force maximale autorisée.

MouseJoint:setTarget

Définit le point cible.

MouseJoint:setTarget( x, y )

xnumberLe composant x de la cible.
ynumberLa composante y de la cible.

PolygonShape

Le polygone est un polygone convexe avec jusqu'à 8 côtés.

Constructors

Functions

Supertypes

PolygonShape:getPoints

Obtenez les coordonnées locales des sommets du polygone.

Cette fonction a un nombre variable de valeurs de retour. Il peut être utilisé de manière imbriquée avec love.graphics.polygon.

Cette fonction peut avoir jusqu'à 16 valeurs de retour, puisqu'il renvoie deux valeurs pour chaque sommet dans le polygone. En d'autres termes, il peut renvoyer les coordonnées jusqu'à 8 points.

x1, y1, x2, y2, ... = PolygonShape:getPoints()

x1numberLe composant x du premier sommet.
y1numberLa composante y du premier sommet.
x2numberLe composant x du second sommet.
y2numberLa composante y du deuxième sommet.
...numberValeurs supplémentaires x et y.

PrismaticJoint

Limite le mouvement relatif entre les corps à un axe partagé.

Constructors

Functions

Supertypes

PrismaticJoint:getAxis

Obtient le vecteur de l'axe de l'articulation prismatique dans le monde entier.

x, y = PrismaticJoint:getAxis()

xnumberLa coordonnée des axes x du vecteur de l'axe de l'espace mondial.
ynumberLa coordonnée des axes y du vecteur de l'axe espace-monde.

PrismaticJoint:getJointSpeed

Obtenez la vitesse d'angle articulaire actuelle.

s = PrismaticJoint:getJointSpeed()

snumberVitesse angulaire en mètres / seconde.

PrismaticJoint:getJointTranslation

Obtenez la traduction conjointe actuelle.

t = PrismaticJoint:getJointTranslation()

tnumberTraduction conjointe, habituellement en mètres.

PrismaticJoint:getLimits

Obtient les limites communes.

lower, upper = PrismaticJoint:getLimits()

lowernumberLa limite inférieure, habituellement en mètres.
uppernumberLa limite supérieure, habituellement en mètres.

PrismaticJoint:getLowerLimit

Obtient la limite inférieure.

lower = PrismaticJoint:getLowerLimit()

lowernumberLa limite inférieure, habituellement en mètres.

PrismaticJoint:getMaxMotorForce

Obtient la force motrice maximale.

f = PrismaticJoint:getMaxMotorForce()

fnumberLa force motrice maximale, généralement en N.

PrismaticJoint:getMotorForce

Obtenez la force motrice actuelle.

f = PrismaticJoint:getMotorForce()

fnumberLa force motrice actuelle, habituellement en N.

PrismaticJoint:getMotorSpeed

Obtient la vitesse du moteur.

s = PrismaticJoint:getMotorSpeed()

snumberLa vitesse du moteur, généralement en mètres par seconde.

PrismaticJoint:getUpperLimit

Obtient la limite supérieure.

upper = PrismaticJoint:getUpperLimit()

uppernumberLa limite supérieure, habituellement en mètres.

PrismaticJoint:hasLimitsEnabled

Vérifie si les limites sont activées.

enabled = PrismaticJoint:hasLimitsEnabled()

enabledbooleanVrai si activé, false sinon.

PrismaticJoint:isMotorEnabled

Vérifie si le moteur est activé.

enabled = PrismaticJoint:isMotorEnabled()

enabledbooleanVert si activé, faux s'il est désactivé.

PrismaticJoint:setLimits

Définit les limites.

PrismaticJoint:setLimits( lower, upper )

lowernumberLa limite inférieure, habituellement en mètres.
uppernumberLa limite supérieure, habituellement en mètres.

PrismaticJoint:setLimitsEnabled

Active ou désactive les limites de l'articulation.

PrismaticJoint:setLimitsEnabled( enable )

enablebooleanFacile à activer, faux à désactiver.

PrismaticJoint:setLowerLimit

Définit la limite inférieure.

PrismaticJoint:setLowerLimit( lower )

lowernumberLa limite inférieure, habituellement en mètres.

PrismaticJoint:setMaxMotorForce

Réglez la force motrice maximale.

PrismaticJoint:setMaxMotorForce( f )

fnumberLa force motrice maximale, généralement en N.

PrismaticJoint:setMotorEnabled

Démarre ou arrête le moteur de l'articulation.

PrismaticJoint:setMotorEnabled( enable )

enablebooleanFacile à activer, faux à désactiver.

PrismaticJoint:setMotorSpeed

Définit la vitesse du moteur.

PrismaticJoint:setMotorSpeed( s )

snumberLa vitesse du moteur, généralement en mètres par seconde.

PrismaticJoint:setUpperLimit

Définit la limite supérieure.

PrismaticJoint:setUpperLimit( upper )

uppernumberLa limite supérieure, habituellement en mètres.

PulleyJoint

Permet de simuler des corps connectés par des poulies.

Constructors

Functions

Supertypes

PulleyJoint:getConstant

Obtenez la longueur totale de la corde.

length = PulleyJoint:getConstant()

lengthnumberLa longueur de la corde dans l'articulation.

PulleyJoint:getGroundAnchors

Obtenez les positions d'ancrage au sol dans les coordonnées mondiales.

a1x, a1y, a2x, a2y = PulleyJoint:getGroundAnchors()

a1xnumberLa coordonnée x de la première ancre.
a1ynumberLa coordonnée y de la première ancre.
a2xnumberLa coordonnée x de la deuxième ancre.
a2ynumberLa coordonnée y de la deuxième ancre.

PulleyJoint:getLengthA

Obtenez la longueur actuelle du segment de corde attachée au premier corps.

length = PulleyJoint:getLengthA()

lengthnumberLongueur du segment de la corde.

PulleyJoint:getLengthB

Obtenez la longueur actuelle du segment de corde attachée au deuxième corps.

length = PulleyJoint:getLengthB()

lengthnumberLongueur du segment de la corde.

PulleyJoint:getMaxLengths

Obtenez les longueurs maximales des segments de corde.

len1, len2 = PulleyJoint:getMaxLengths()

len1numberLa longueur maximale du premier segment de corde.
len2numberLa longueur maximale du second segment de corde.

PulleyJoint:getRatio

Obtenez le taux de poulie.

ratio = PulleyJoint:getRatio()

rationumberLe rapport de la poulie de l'articulation.

PulleyJoint:setConstant

Réglez la longueur totale de la corde.

Une nouvelle longueur pour la corde met à jour les valeurs de longueur maximale de l'articulation.

PulleyJoint:setConstant( length )

lengthnumberLa nouvelle longueur de la corde dans l'articulation.

PulleyJoint:setMaxLengths

Réglez les longueurs maximales des segments de corde.

Le module de physique impose également des valeurs maximales pour les segments de corde. Si les paramètres dépassent ces valeurs, les valeurs maximales sont définies au lieu des valeurs demandées.

PulleyJoint:setMaxLengths( max1, max2 )

max1numberLa nouvelle longueur maximale du premier segment.
max2numberLa nouvelle longueur maximale du deuxième segment.

PulleyJoint:setRatio

Réglez le rapport de la poulie.

PulleyJoint:setRatio( ratio )

rationumberLe nouveau rapport de poulie de l'articulation.

RevoluteJoint

Autoriser deux corps à tourner autour d'un point partagé.

Constructors

Functions

Supertypes

RevoluteJoint:setLimitsEnabled

Active ou désactive les limites d'assemblage.

RevoluteJoint:setLimitsEnabled( enable )

enablebooleanFacile à activer, faux à désactiver.

RevoluteJoint:setMotorEnabled

Démarre ou arrête le moteur de l'articulation.

RevoluteJoint:setMotorEnabled( enable )

enablebooleanFacile à activer, faux à désactiver.

RevoluteJoint:getJointAngle

Obtenez l'angle d'articulation actuel.

angle = RevoluteJoint:getJointAngle()

anglenumberL'angle de l'articulation en radians.

RevoluteJoint:getJointSpeed

Obtenez la vitesse d'angle articulaire actuelle.

s = RevoluteJoint:getJointSpeed()

snumberVitesse d'angle de l'articulation en radians / seconde.

RevoluteJoint:getLimits

Obtient les limites communes.

lower, upper = RevoluteJoint:getLimits()

lowernumberLa limite inférieure, en radians.
uppernumberLa limite supérieure, en radians.

RevoluteJoint:getLowerLimit

Obtient la limite inférieure.

lower = RevoluteJoint:getLowerLimit()

lowernumberLa limite inférieure, en radians.

RevoluteJoint:getMaxMotorTorque

Obtient la force motrice maximale.

f = RevoluteJoint:getMaxMotorTorque()

fnumberLa force motrice maximale, en Nm.

RevoluteJoint:getMotorSpeed

Obtient la vitesse du moteur.

s = RevoluteJoint:getMotorSpeed()

snumberLa vitesse du moteur, les radians par seconde.

RevoluteJoint:getMotorTorque

Obtenez la force motrice actuelle.

f = RevoluteJoint:getMotorTorque()

fnumberLa force motrice actuelle, en Nm.

RevoluteJoint:getUpperLimit

Obtient la limite supérieure.

upper = RevoluteJoint:getUpperLimit()

uppernumberLa limite supérieure, en radians.

RevoluteJoint:hasLimitsEnabled

Vérifie si les limites sont activées.

enabled = RevoluteJoint:hasLimitsEnabled()

enabledbooleanVrai si activé, false sinon.

RevoluteJoint:isMotorEnabled

Vérifie si le moteur est activé.

enabled = RevoluteJoint:isMotorEnabled()

enabledbooleanVert si activé, faux s'il est désactivé.

RevoluteJoint:setLimits

Définit les limites.

RevoluteJoint:setLimits( lower, upper )

<