Écran#

Introduction #

La classe screen est dérivée de la classe de base brain. Elle contrôle la façon dont le cerveau IQ (1ère génération) affiche le texte et les valeurs sur son écran intégré.

L’écran cérébral IQ (1ère génération) prend en charge jusqu’à 5 lignes et 21 colonnes de texte.

Le cerveau VEX IQ (1re génération) avec une grille numérotée superposée (colonnes 1 à 21 et lignes 1 à 5). Les lignes rouges superposées mettent en évidence la structure de la grille, avec des flèches indiquant la colonne 1, la colonne 21, la ligne 1, la ligne 2 et la ligne 5. La première ligne affiche les nombres de 1 à 21 en haut.

Accéder #

La classe screen est accessible par :

Brain.Screen

Notes #

L’objet de l’écran screen est fourni par le cerveau. Il n’est pas construit directement.
Les projets utilisent un seul objet global Brain , donc les fonctions d’écran sont appelées en utilisant Brain.Screen.

Exemple #

/* This constructor is required when using VS Code.
A Brain is generated automatically at the start of
VEXcode projects. */

// Create the Brain
brain Brain = brain();

// Print text to the Brain screen
Brain.Screen.print("Hello!");

Fonctions des membres #

La classe screen comprend les fonctions membres suivantes :

print — Affiche du texte formaté, des nombres ou des valeurs booléennes sur l’écran du cerveau.
setCursor — Déplace le curseur de texte vers une ligne et une colonne spécifiées.
newLine — Efface le reste de la ligne actuelle et déplace le curseur vers la ligne suivante.
clearLine — Efface le reste de la ligne actuelle ou efface une ligne spécifiée.
row — Renvoie la ligne où le texte sera imprimé.
column — Renvoie la colonne dans laquelle le texte sera imprimé.
getStringHeight — Renvoie la hauteur d’une chaîne en pixels en utilisant la police actuelle.
getStringWidth — Renvoie la largeur d’une chaîne en pixels en utilisant la police actuelle.
printAt — Imprime du texte formaté à un emplacement de pixel x, y (éventuellement opaque).
clearScreen — Efface l’écran entier (éventuellement à une couleur spécifiée).
setFont — Définit la police utilisée pour l’impression à l’écran.
setPenWidth — Définit l’épaisseur des lignes dessinées et des contours des formes.
setPenColor — Définit la couleur du texte, des pixels, des lignes et des contours des formes.
setFillColor — Définit la couleur de remplissage des formes dessinées et des arrière-plans de texte imprimés.
setOrigin — Définit l’origine utilisée pour les coordonnées de l’écran.
setClipRegion — Limite la sortie écran à une région rectangulaire.
drawPixel — Dessine un pixel à une coordonnée.
drawLine — Trace une ligne entre deux points.
drawRectangle — Dessine un rectangle à un emplacement x, y avec une taille spécifiée.
drawCircle — Dessine un cercle à un emplacement x, y avec un rayon spécifié.
render — Active le double tampon ou affiche le tampon arrière à l’écran.

Before calling any screen member functions, a brain instance must be created, as shown below:

// Create the Brain
brain Brain = brain();

print #

Affiche du texte, des nombres ou des valeurs booléennes sur l’écran cérébral IQ (1ère génération).

Available Functions

1 — Imprime du texte formaté à l’aide de chaînes littérales ou de chaînes de style C en lecture seule.
void print(
    const char* format,
    ... );

2 — Imprime du texte formaté à l’aide de tableaux de caractères modifiables.
void print(
    char* format,
    ... );

Parameters

Paramètre	Taper	Description
`format`	`const char*`	Une chaîne de format fournie sous forme de chaîne littérale ou de chaîne de style C en lecture seule (par exemple, `“Score: %d”`).
`format`	`char*`	Une chaîne de format fournie sous forme de tableau de caractères modifiable.
`…`		Une ou plusieurs valeurs supplémentaires insérées dans la chaîne de format, séparées par des virgules.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’affichage commence à la position actuelle du curseur sur l’écran.
Le texte imprimé utilise la police d’écran actuelle .
Le texte imprimé utilise la couleur de stylo actuelle .
Le texte imprimé avec print est toujours imprimé avec un fond, et la couleur de fond est déterminée par la couleur de remplissage actuelle.
Lors de l’utilisation d’une chaîne de format, le nombre et les types de valeurs transmises doivent correspondre aux spécificateurs de format dans la chaîne.

Examples

// Display a message at the starting cursor
Brain.Screen.print("Hello, Robot!");

setCursor #

Déplace le curseur vers une ligne et une colonne spécifiques de l’écran Cerveau IQ (1re génération). L’impression du prochain appel print à partir de cet emplacement.

Available Functions

void setCursor(
  int32_t row, 
  int32_t col );

Parameters

Paramètre	Taper	Description
`row`	`int32_t`	La ligne sur laquelle déplacer le curseur.
`col`	`int32_t`	La colonne vers laquelle déplacer le curseur.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Affecte l’endroit où commence la sortie de texte suivante lors de l’utilisation de print.
Les lignes et les colonnes sont basées sur la police d’écran actuellement définie.
L’appel à setCursor affecte uniquement la position du texte qui s’affichera ensuite.

Examples

// Print at row 3 column 7
Brain.Screen.setCursor(3, 7);
Brain.Screen.print("VEXcode!");

L'écran du cerveau IQ (1re génération) affiche le texte centré « VEXcode ! ».

newLine #

Déplace le curseur au début de la ligne suivante sur l’écran Cerveau.

Available Functions

void newLine();

Parameters

Cette fonction n’accepte aucun paramètre.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Si le curseur se trouve au milieu d’une phrase, newLine effacera le reste de la ligne après le curseur avant de passer à la ligne suivante.
Après l’appel à newLine, le curseur est positionné sur la première colonne de la ligne suivante.
La position du curseur et la numérotation des lignes sont définies à l’aide de setCursor.

Examples

// Display two lines of text
Brain.Screen.print("First message");
Brain.Screen.newLine();
Brain.Screen.print("Second message");

L'écran du cerveau IQ (1re génération) affiche « Premier message » et « Deuxième message », affichés sur des lignes séparées.

clearLine #

Efface le texte d’une ligne sur l’écran cérébral IQ (1ère génération).

Available Functions

1 — Efface le reste de la ligne actuelle à partir de la position du curseur.
void clearLine();

2 — Efface la ligne spécifiée en utilisant la couleur de remplissage actuellement configurée.
void clearLine(
    int number );

3 — Efface la ligne spécifiée à l’aide d’un objet de couleur prédéfinie ou couleur personnalisée.
void clearLine(
    int          number,
    const color& color );

4 — Efface la ligne spécifiée en utilisant une valeur de couleur hexadécimale.
void clearLine(
    int         number,
    const char* color );

5 — Efface la ligne spécifiée à l’aide d’une valeur de teinte.
void clearLine(
    int number,
    int hue );

Parameters

Paramètre	Taper	Description
`number`	`int`	Numéro de la ligne à effacer. La numérotation des lignes commence à `1`.
`color`	`const color&`	Efface la ligne en utilisant un objet de couleur `color` Les couleurs prédéfinies incluent : `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent` Ceci peut également utiliser un objet de couleur personnalisé.
`color`	`const char*`	Efface la ligne en utilisant une valeur de couleur hexadécimale (par exemple, `“#000000”`).
`hue`	`int`	Efface la ligne en utilisant une valeur de teinte entière dans la plage `0`–`359`, représentant des degrés autour d’une roue chromatique.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Effacer une ligne ne modifie pas la position actuelle du curseur.
La position du curseur et la numérotation des lignes sont définies à l’aide de setCursor.
L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.

Examples

// Display text on two rows
Brain.Screen.print("This text stays");
Brain.Screen.newLine();
Brain.Screen.print("This disappears");

// Wait 3 seconds before clearing row 2
wait(3, seconds);
Brain.Screen.clearLine(2);

row #

Renvoie la position actuelle du curseur sur l’écran cérébral IQ (1ère génération).

Available Functions

int32_t row();

Parameters

Cette fonction n’accepte aucun paramètre.

Return Values

Renvoie un int32_t int32_t représentant la ligne dans laquelle le texte sera imprimé.

La numérotation des lignes commence à 1.

Notes

La position du curseur est basée sur la police d’écran actuelle .
La valeur renvoyée indique où apparaîtra le prochain texte imprimé.
La valeur de la ligne change lorsque du texte est imprimé ou lorsque setCursor est appelé.

Examples

// Display the cursor's current row
Brain.Screen.setCursor(3, 12);
Brain.Screen.print("row: ", Brain.Screen.row());

column #

Renvoie la colonne dans laquelle le texte sera imprimé sur l’écran cérébral IQ (1ère génération).

Available Functions

int32_t column();

Parameters

Cette fonction n’accepte aucun paramètre.

Return Values

Renvoie un entier int32_t représentant la colonne dans laquelle le texte sera imprimé.

La numérotation des colonnes commence à 1.

Notes

La position du curseur est basée sur la police d’écran actuelle .
La valeur renvoyée indique où apparaîtra le prochain texte imprimé.
La valeur de la colonne change lorsque du texte est imprimé ou lorsque setCursor est appelé.

Examples

// Display the cursor's current column
Brain.Screen.print("column: ", Brain.Screen.column());

getStringHeight #

Renvoie la hauteur, en pixels, d’une chaîne de caractères lorsqu’elle est affichée sur l’écran IQ (1ère génération) Brain.

Available Functions

int32_t getStringHeight( 
    const char* cstr );

Parameters

Paramètre	Taper	Description
`cstr`	`const char*`	Le texte à mesurer, fourni sous forme de chaîne de caractères de style C (par exemple, `“Hello”`).

Return Values

Renvoie un int32_t int32_t représentant la hauteur de la chaîne en pixels lorsqu’elle est affichée sur l’écran Brain.

Notes

La hauteur renvoyée dépend de la d’écran actuellement.
Cette fonction mesure la chaîne de caractères sans l’afficher à l’écran.
La hauteur renvoyée correspond à l’apparence de la chaîne une fois imprimée.

getStringWidth #

Renvoie la largeur, en pixels, d’une chaîne de caractères lorsqu’elle est affichée sur l’écran IQ (1ère génération) Brain.

Available Functions

int32_t getStringWidth( 
    const char* cstr );

Parameters

Paramètre	Taper	Description
`cstr`	`const char*`	Le texte à mesurer, fourni sous forme de chaîne de caractères de style C (par exemple, `“Hello”`).

Return Values

Renvoie un int32_t int32_t représentant la largeur de la chaîne en pixels lorsqu’elle est affichée sur l’écran Brain.

Notes

La largeur renvoyée dépend de la écran actuellement sélectionnée.
Cette fonction mesure la chaîne de caractères sans l’afficher à l’écran.
La largeur renvoyée correspond à l’apparence de la chaîne une fois imprimée.

printAt #

Imprime du texte, des nombres ou des valeurs booléennes à une coordonnée spécifique sur l’écran cérébral IQ (1ère génération).

Available Functions

1 — Imprime la sortie formatée à l’emplacement de pixel spécifié.
void printAt(
    int32_t    x,
    int32_t    y,
    const char* format,
    ... );

2 — Imprime la sortie formatée à l’emplacement de pixel spécifié et définit si l’arrière-plan du texte est opaque ou transparent.
void printAt(
    int32_t    x,
    int32_t    y,
    bool       bOpaque,
    const char* format,
    ... );

Parameters

Paramètre	Taper	Description
`x`	`int32_t`	Position x d’impression, par rapport à l’origine de l’écran.
`y`	`int32_t`	Position y d’impression, par rapport à l’origine de l’écran.
`bOpaque`	`bool`	Contrôle l’opacité ou la transparence du texte imprimé : `true` — Le fond du texte imprimé est rempli avec la couleur de remplissage actuelle. `false` — Le texte est transparent et le fond n’est pas rempli.
`format`	`const char*`	Une chaîne de format qui contrôle ce qui est imprimé à l’écran (par exemple, `“Score: %d”`).
`…`		Une ou plusieurs valeurs supplémentaires insérées dans la chaîne de format, séparées par des virgules.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être modifiée à l’aide de setOrigin.
Le texte imprimé utilise la police d’écran actuelle .
Le texte imprimé utilise la couleur de stylo actuelle .
Lors de l’utilisation d’une chaîne de format, le nombre et les types de valeurs transmises doivent correspondre aux spécificateurs de format dans la chaîne.

Examples

// Print the number 1 at pixel (100, 40)
Brain.Screen.printAt(100, 40, 1);

clearScreen #

Efface tous les dessins et textes de l’écran du Cerveau.

Available Functions

1 — Efface l’écran en noir.
void clearScreen();

2 — Efface l’écran à l’aide d’un objet de couleur prédéfinie ou personnalisée.
void clearScreen(
    const color& color );

3 — Efface l’écran en utilisant une valeur de couleur hexadécimale.
void clearScreen(
    const char* color );

4 — Efface l’écran en utilisant une valeur de teinte.
void clearScreen(
    int hue );

Parameters

Paramètre	Taper	Description
`color`	`const color&`	Clears the screen using a `color` object. Predefined colors include: `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent` This can also use a custom color object.
`color`	`const char*`	Efface l’écran en utilisant une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, `“#000000”`).
`hue`	`int`	Efface l’écran en utilisant une valeur de teinte entière dans la plage `0`–`359`, représentant des degrés autour d’une roue chromatique.

Paramètre

Taper

Description

color

const color&

Clears the screen using a color object. Predefined colors include:

black
white
red
green
blue
yellow
orange
purple
cyan
transparent

This can also use a custom color object.

color

const char*

Efface l’écran en utilisant une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, “#000000”).

hue

int

Efface l’écran en utilisant une valeur de teinte entière dans la plage 0–359, représentant des degrés autour d’une roue chromatique.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.

Examples

// Clear screen after 2 seconds
Brain.Screen.print("VEXcode");
wait(2, seconds);
Brain.Screen.clearScreen();

// Clear screen to blue after 2 seconds
Brain.Screen.print("VEXcode");
wait(2, seconds);
Brain.Screen.clearScreen(red);

setFont #

Définit la police utilisée pour le texte affiché sur l’écran cérébral IQ (1ère génération).

Cela contrôle la police appliquée à la sortie de texte ultérieure lors de l’utilisation de fonctions de texte à l’écran telles que print.

Available Functions

void setFont(
  fontType font );

Parameters

Paramètre	Taper	Description
`font`	`fontType`	Sets the font to one of the following: `mono12` `mono15` `mono20` `mono30` `mono40` `mono60` `prop20` `prop30` `prop40` `prop60` These options are shown below.

Paramètre

Taper

Description

font

fontType

Sets the font to one of the following:

mono12
mono15
mono20
mono30
mono40
mono60
prop20
prop30
prop40
prop60

These options are shown below.

Return Values

Cette fonction ne renvoie aucune valeur.

Examples

// Display two different fonts on
// two separate lines
Brain.Screen.setFont(mono20);
Brain.Screen.print("Mono Medium");
Brain.Screen.newLine();
Brain.Screen.setFont(prop20);
Brain.Screen.print("Prop Medium");

setPenWidth #

Définit l’épaisseur des lignes tracées et des contours des formes.

Available Functions

void setPenWidth(
  uint32_t width );

Parameters

Paramètre	Taper	Description
`width`	`uint32_t`	La largeur du stylo, en pixels, de 0 à 32.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

La largeur du stylo s’applique aux fonctions de dessin telles que drawLine, drawRectangle et drawCircle.

Examples

// Draw a circle with a pen width of 5
Brain.Screen.drawCircle(40, 70, 20);
Brain.Screen.setPenWidth(5);
Brain.Screen.drawCircle(100, 70, 20);

setPenColor #

Définit la couleur du texte, des pixels, des lignes et des contours des formes.

Available Functions

1 — Définit la couleur du stylo à l’aide d’un objet prédéfini ou couleur personnalisée.
void setPenColor(
    const color& color );

2 — Définit la couleur du stylo à l’aide d’une valeur de couleur hexadécimale.
void setPenColor(
    const char* color );

3 — Définit la couleur du stylo à l’aide d’une valeur de teinte.
void setPenColor(
    int hue );

Parameters

Paramètre	Taper	Description
`color`	`const color&`	Définit la couleur du stylo à l’aide d’un objet couleur `color` Les couleurs prédéfinies incluent : `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent`
`color`	`const char*`	Définit la couleur du stylo à l’aide d’une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, `“#FF0000”`).
`hue`	`int`	Définit la couleur du stylo à l’aide d’une valeur de teinte entière dans la plage `0`–`359`, représentant des degrés autour d’une roue chromatique (par exemple, `0` est rouge, `120` est vert et `240` est bleu).

Paramètre

Taper

Description

color

const color&

Définit la couleur du stylo à l’aide d’un objet couleur color Les couleurs prédéfinies incluent :

black
white
red
green
blue
yellow
orange
purple
cyan
transparent

color

const char*

Définit la couleur du stylo à l’aide d’une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, “#FF0000”).

hue

int

Définit la couleur du stylo à l’aide d’une valeur de teinte entière dans la plage 0–359, représentant des degrés autour d’une roue chromatique (par exemple, 0 est rouge, 120 est vert et 240 est bleu).

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.

Examples

Brain.Screen.drawRectangle(100, 50, 10, 20);
Brain.Screen.setPenColor(blue);
Brain.Screen.drawRectangle(50, 50, 10, 20);

setFillColor #

Définit la couleur de remplissage utilisée lors du dessin des formes.

Available Functions

1 — Définit la couleur de remplissage à l’aide d’un objet prédéfini ou couleur personnalisée.
void setFillColor(
    const color& color );

2 — Définit la couleur de remplissage à l’aide d’une valeur de couleur hexadécimale.
void setFillColor(
    const char* color );

3 — Définit la couleur de remplissage à l’aide d’une valeur de teinte.
void setFillColor(
    int hue );

Parameters

Paramètre	Taper	Description
`color`	`const color&`	Définit la couleur de remplissage à l’aide d’un objet couleur `color` Les couleurs prédéfinies incluent : `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent`
`color`	`const char*`	Définit la couleur de remplissage à l’aide d’une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, `“#00FF00”`).
`hue`	`int`	Définit la couleur de remplissage à l’aide d’une valeur de teinte entière dans la plage `0`–`359`, représentant des degrés autour d’une roue chromatique (par exemple, `0` est rouge, `120` est vert et `240` est bleu).

Paramètre

Taper

Description

color

const color&

Définit la couleur de remplissage à l’aide d’un objet couleur color Les couleurs prédéfinies incluent :

black
white
red
green
blue
yellow
orange
purple
cyan
transparent

color

const char*

Définit la couleur de remplissage à l’aide d’une valeur de couleur hexadécimale représentée sous forme de chaîne (par exemple, “#00FF00”).

hue

int

Définit la couleur de remplissage à l’aide d’une valeur de teinte entière dans la plage 0–359, représentant des degrés autour d’une roue chromatique (par exemple, 0 est rouge, 120 est vert et 240 est bleu).

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.

Examples

// Draw a circle filled with yellow
Brain.Screen.setFillColor(yellow);
Brain.Screen.drawCircle(50, 50, 20);

setOrigin #

Définit l’origine utilisée pour le dessin des graphismes sur l’écran du Cerveau.

Available Functions

void setOrigin(
  int32_t x,
  int32_t y );

Parameters

Paramètre	Taper	Description
`x`	`int32_t`	Position x de l’origine par rapport au coin supérieur gauche de l’écran du Cerveau, de 0 à 159.
`y`	`int32_t`	Position y de l’origine par rapport au coin supérieur gauche de l’écran du Cerveau, de 0 à 107.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’origine par défaut est le coin supérieur gauche de l’écran aux coordonnées (0, 0).
L’origine s’applique aux fonctions de coordonnées telles que drawLine, drawRectangle, drawCircle, et printAt.
L’origine reste effective jusqu’à ce qu’elle soit modifiée à nouveau ou que le projet soit réinitialisé.

setClipRegion #

Définit une zone rectangulaire à l’écran où seront contenus tous les dessins et textes. Tout contenu situé en dehors de cette zone ne sera pas affiché.

Available Functions

void setClipRegion(
  int x,
  int y,
  int width,
  int height );

Parameters

Paramètre	Taper	Description
`x`	`int`	La coordonnée x du coin supérieur gauche de la zone de découpage, donnée sous forme d’entier compris entre 0 et 159.
`y`	`int`	La coordonnée y du coin supérieur gauche de la zone de découpage, donnée sous forme d’entier compris entre 0 et 107.
`width`	`int`	La largeur de la zone de découpage en pixels, donnée sous forme d’entier compris entre 0 et 159.
`height`	`int`	La hauteur de la zone de découpage en pixels, donnée sous forme d’entier compris entre 0 et 107.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Les fonctions de dessin sont toujours exécutées même si elles se trouvent en dehors de la zone de découpage, mais seule la portion située à l’intérieur de cette zone est visible.
Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être modifiée à l’aide de setOrigin.
La zone de découpage s’applique uniquement au thread actuel.
La définition d’une nouvelle zone de découpage remplace toute zone de découpage précédemment définie pour le thread actuel.

Examples

// Restrict text and drawings to a specific region
Brain.Screen.setClipRegion(0, 0, 120, 120);
Brain.Screen.drawRectangle(60, 60, 100, 100, red);
Brain.Screen.printAt(60, 60, "Cut off!");

drawPixel #

Dessine un seul pixel sur l’écran cérébral IQ (1ère génération) à l’emplacement de pixel x et y spécifié.

Available Functions

void drawPixel(
  int x,
  int y );

Parameters

Paramètre	Taper	Description
`x`	`int`	La coordonnée x où le pixel sera dessiné, donnée sous forme d’entier compris entre 0 et 159.
`y`	`int`	La coordonnée y où le pixel sera dessiné, donnée sous forme d’entier compris entre 0 et 107.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.
Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être définie à l’aide de setOrigin.
Si l’emplacement du pixel spécifié se trouve en dehors des limites de l’écran, le pixel n’est pas dessiné.

Examples

// Draw one pixel at the center 
// of the screen
Brain.Screen.drawPixel(80, 50);

drawLine #

Trace une ligne droite reliant deux points sur l’écran cérébral IQ (1ère génération).

Available Functions

void drawLine(
  int x1,
  int y1,
  int x2,
  int y2 );

Parameters

Paramètre	Taper	Description
`x1`	`int`	La coordonnée x de départ de la ligne, donnée sous forme d’entier compris entre 0 et 159.
`y1`	`int`	La coordonnée y de départ de la ligne, donnée sous forme d’entier compris entre 0 et 107.
`x2`	`int`	La coordonnée x finale de la ligne, donnée sous forme d’un entier compris entre 0 et 159.
`y2`	`int`	La coordonnée y finale de la ligne, donnée sous forme d’un entier compris entre 0 et 107.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.
La largeur de la ligne est déterminée par la largeur du stylo actuelle définie avec setPenWidth.
Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être définie à l’aide de setOrigin.
Si une partie quelconque de la ligne se trouve en dehors des limites de l’écran, seule la partie visible est dessinée.

Examples

// Draw a line from the top left to 
// bottom right of the screen
Brain.Screen.drawLine(0, 0, 159, 107);

drawRectangle #

Dessine un rectangle sur l’écran cérébral IQ (1ère génération) à la position et à la taille spécifiées.

Available Functions

1 — Draws and fills a rectangle using the currently configured fill color.
void drawRectangle(
    int x,
    int y,
    int width,
    int height );

2 — Dessine et remplit un rectangle à l’aide d’un objet de couleur prédéfinie ou couleur personnalisée.
void drawRectangle(
    int           x,
    int           y,
    int           width,
    int           height,
    const color&  color );

3 — Dessine et remplit un rectangle en utilisant une valeur de couleur hexadécimale.
void drawRectangle(
    int           x,
    int           y,
    int           width,
    int           height,
    const char*   color );

4 — Dessine et remplit un rectangle en utilisant une valeur de teinte.
void drawRectangle(
    int x,
    int y,
    int width,
    int height,
    int hue );

Parameters

Paramètre	Taper	Description
`x`	`int`	La coordonnée x du coin supérieur gauche du rectangle, donnée sous forme d’entier compris entre 0 et 159.
`y`	`int`	La coordonnée y du coin supérieur gauche du rectangle, donnée sous forme d’entier compris entre 0 et 107.
`width`	`int`	La largeur du rectangle, donnée sous forme d’un entier compris entre 0 et 159.
`height`	`int`	La hauteur du rectangle, donnée sous forme d’un entier compris entre 0 et 107.
`color`	`const color&`	Fills the rectangle using a `color` object. Predefined colors include: `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent` This can also use a custom color object.
`color`	`const char*`	Remplit le rectangle en utilisant une valeur de couleur hexadécimale (par exemple, `“#FF0000”`).
`hue`	`int`	Remplit le rectangle en utilisant une valeur de teinte dans la plage `0`–`359`.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.
L’épaisseur du contour est déterminée par la largeur du stylo actuelle définie avec setPenWidth.
Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être modifiée à l’aide de setOrigin.
Si une partie quelconque du rectangle se trouve en dehors des limites de l’écran, seule la partie visible est dessinée.

Examples

// Draw a red rectangle on the screen
Brain.Screen.drawRectangle(25, 25, 100, 50, red);

drawCircle #

Dessine un cercle sur l’écran cérébral IQ (1ère génération) à la position et au rayon spécifiés.

Available Functions

1 — Draws and fills a circle using the currently configured fill color.
void drawCircle(
    int x,
    int y,
    int radius );

2 — Dessine et remplit un cercle en utilisant un objet de couleur prédéfinie ou couleur personnalisée.
void drawCircle(
    int           x,
    int           y,
    int           radius,
    const color&  color );

3 — Dessine et remplit un cercle en utilisant une valeur de couleur hexadécimale.
void drawCircle(
    int           x,
    int           y,
    int           radius,
    const char*   color );

4 — Dessine et remplit un cercle en utilisant une valeur de teinte.
void drawCircle(
    int x,
    int y,
    int radius,
    int hue );

Parameters

Paramètre	Taper	Description
`x`	`int`	L’abscisse du centre du cercle, donnée sous forme d’un entier compris entre 0 et 159.
`y`	`int`	La coordonnée y du centre du cercle, donnée sous forme d’un entier compris entre 0 et 107.
`radius`	`int`	Le rayon du cercle, exprimé sous forme d’un entier compris entre 0 et 107 pixels.
`color`	`const color&`	Remplit le cercle à l’aide d’un objet de couleur `color` Les couleurs prédéfinies incluent : `black` `white` `red` `green` `blue` `yellow` `orange` `purple` `cyan` `transparent` Ceci peut également utiliser un objet de couleur personnalisé.
`color`	`const char*`	Remplit le cercle en utilisant une valeur de couleur hexadécimale (par exemple, `“#FF0000”`).
`hue`	`int`	Remplit le cercle en utilisant une valeur de teinte dans la plage `0`–`359`.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

L’écran du test IQ (1ère génération) Brain est monochrome, donc les couleurs spécifiées n’apparaîtront pas à l’écran.
L’épaisseur du contour est déterminée par la largeur du stylo actuelle définie avec setPenWidth.
Les coordonnées x et y sont relatives à l’origine de l’écran actuel, qui peut être modifiée à l’aide de setOrigin.

Examples

// Draw a green circle on the screen
Brain.Screen.drawCircle(80, 50, 20, green);

render #

Active le double tampon pour l’écran du Cerveau. Une fois cette fonction appelée, les fonctions de dessin (texte, formes, etc.) ne s’afficheront plus immédiatement pour le reste du projet. Les mises à jour ne seront visibles que lorsque la fonction render sera de nouveau utilisée. Cela permet des mises à jour d’écran plus fluides et mieux contrôlées, mais rien ne sera visible tant que la fonction render n’aura pas été utilisée.

Available Functions

1 — Active le double tampon ou affiche le tampon arrière à l’écran.
bool render();

2 — Affiche le tampon arrière à l’écran avec contrôle du comportement de synchronisation verticale et exécution optionnelle du planificateur.
bool render(
    bool bVsyncWait,
    bool bRunScheduler = true );

Parameters

Paramètre	Taper	Description
`bVsyncWait`	`bool`	`true` — Attendre le rafraîchissement vertical de l’écran avant le rendu pour réduire les déchirures d’image. `false` — Ne pas attendre le rafraîchissement vertical de l’écran avant le rendu.
`bRunScheduler`	`bool`	Facultatif. `true` (par défaut) — Autoriser l’exécution des tâches en arrière-plan pendant le rendu. `false` — Interdire l’exécution des tâches en arrière-plan pendant le rendu.

Paramètre

Taper

Description

bVsyncWait

bool

true — Attendre le rafraîchissement vertical de l’écran avant le rendu pour réduire les déchirures d’image.
false — Ne pas attendre le rafraîchissement vertical de l’écran avant le rendu.

bRunScheduler

bool

Facultatif.

true (par défaut) — Autoriser l’exécution des tâches en arrière-plan pendant le rendu.
false — Interdire l’exécution des tâches en arrière-plan pendant le rendu.

Return Values

Renvoie une valeur booléenne indiquant si les dessins enregistrés dans la mémoire tampon ont été correctement affichés à l’écran :

true — Les dessins ont été correctement affichés à l’écran.
false — Les dessins n’ont pas pu être affichés à l’écran.

Notes

L’appel à render nécessitera l’utilisation de render pour le reste du projet.

Examples

Brain.Screen.render();

// Draw text to the back buffer
Brain.Screen.print("Render later...");

// Wait for a screen press to render drawings
while (!Brain.Screen.pressing()) {
  wait(20, msec);
}
Brain.Screen.render();