openvg
1.0.0
Voici l'équivalent graphique de "Hello, World"
// first OpenVG program
// Anthony Starks ([email protected])
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "VG/openvg.h"
#include "VG/vgu.h"
#include "fontinfo.h"
#include "shapes.h"
int main() {
int width, height;
char s[3];
init(&width, &height); // Graphics initialization
Start(width, height); // Start the picture
Background(0, 0, 0); // Black background
Fill(44, 77, 232, 1); // Big blue marble
Circle(width / 2, 0, width); // The "world"
Fill(255, 255, 255, 1); // White text
TextMid(width / 2, height / 2, "hello, world", SerifTypeface, width / 10); // Greetings
End(); // End the picture
fgets(s, 2, stdin); // look at the pic, end with [RETURN]
finish(); // Graphics cleanup
exit(0);
}
Les coordonnées sont des valeurs de vgfloat, avec l'origine en bas à gauche, X augmentant vers la droite, et y augmentant. OpenVG spécifie les couleurs comme un tableau VGFLOAT contenant des valeurs alpha rouges, vert, bleu alpha allant de 0,0 à 1,0, mais généralement les couleurs sont spécifiées en RGBA (0-255 pour RGB, A de 0,0 à 1,0)
void WindowClear()
WindowClear efface la fenêtre pour définir précédemment la couleur d'arrière-plan
void AreaClear(unsigned int x, unsigned int y, unsigned int w, unsigned int h)
AreaClear efface un rectangle donné dans les coordonnées de la fenêtre
void WindowOpacity(unsigned int a)
WindowOpacity définit l'opacité de la fenêtre
void WindowPosition(int x, int y)
WindowPosition déplace la fenêtre en position donnée
void init(int *w, int *h)
Initialiser les graphiques: la largeur et la hauteur de la toile sont retournées. Cela devrait commencer chaque programme.
void initWindowSize(int x, int y, unsigned int w, unsigned int h)
Initialiser avec des dimensions spécifiques
void finish()
Arrêtez les graphiques. Cela devrait mettre fin à chaque programme.
void Start(int width, int height)
Commencez l'image, effacez l'écran avec un blanc par défaut, définissez la course et remplissez sur noir.
void End()
Terminez l'image, en rendant à l'écran.
void SaveEnd(char *filename)
Terminez l'image, en rendant à l'écran, enregistrez le raster dans le fichier nommé en mots RGBA de 4 octets, avec une foulée de largeur * 4 octets. Le programme Raw2png convertit le raster "brut" en PNG.
void saveterm(), restoreterm(), rawterm()
Paramètres du terminal, enregistrer les paramètres actuels, restaurer les paramètres, mettre le terminal en mode brut.
void setfill(float color[4])
Réglez la couleur de remplissage
void Background(unsigned int r, unsigned int g, unsigned int b)
Remplissez l'écran avec la couleur d'arrière-plan définie à partir des valeurs RVB.
void BackgroundRGB(unsigned int r, unsigned int g, unsigned int b, VGfloat a)
Efface l'écran à une couleur d'arrière-plan avec alpha
void StrokeWidth(float width)
Réglez la largeur de course.
void RGBA(unsigned int r, unsigned int g, unsigned int b, VGfloat a, VGfloat color[4])
Remplissez un vecteur de couleur à partir des valeurs RGBA.
void RGB(unsigned int r, unsigned int g, unsigned int b, VGfloat color[4])
Remplissez un vecteur de couleur à partir des valeurs RVB.
void Stroke(unsigned int r, unsigned int g, unsigned int b, VGfloat a)
Réglez la couleur de trait à l'aide des valeurs RGBA.
void Fill(unsigned int r, unsigned int g, unsigned int b, VGfloat a)
Définissez la couleur de remplissage à l'aide des valeurs RGBA.
void FillLinearGradient(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2, VGfloat *stops, int n)
Réglez le remplissage sur un gradient linéaire délimité par (x1, y1) et (x2, y2). Utilisation des décalages et des couleurs spécifiés en n nombre d'arrêts
void FillRadialGradient(VGfloat cx, VGfloat cy, VGfloat fx VGfloat fy, VGfloat r, VGfloat *stops, int n)
Réglez le remplissage sur un gradient radial centré sur (CX, CY) avec RADIUS R, et le point focal à (FX, RY), en utilisant des décalages et des couleurs spécifiés dans n nombre d'arrêts
void Line(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2)
Tracer une ligne entre (x1, y1) et (x2, y2).
void Rect(VGfloat x, VGfloat y, VGfloat w, VGfloat h)
Dessinez un rectangle avec son origine (en bas à gauche) en (x, y), et la taille est (largeur, hauteur).
void RectOutline(VGfloat x, VGfloat y, VGfloat w, VGfloat h)
Version décrite
void Roundrect(VGfloat x, VGfloat y, VGfloat w, VGfloat h, VGfloat rw, VGfloat rh)
Dessinez un rectangle arrondi avec son origine (en bas à gauche) en (x, y), et la taille est (largeur, hauteur).
La largeur et la hauteur des coins sont spécifiées avec (RW, RH).
void RoundrectOutline(VGfloat x, VGfloat y, VGfloat w, VGfloat h, VGfloat rw, VGfloat rh)
Version décrite
void Polygon(VGfloat *x, VGfloat *y, VGint n)
Dessinez un polygone en utilisant les coordonnées dans les tableaux pointés par x et y. Le nombre de coordonnées est n.
void Polyline(VGfloat *x, VGfloat *y, VGint n)
Dessinez une polyligne en utilisant les coordonnées dans les tableaux pointés par x et y. Le nombre de coordonnées est n.
void Circle(VGfloat x, VGfloat y, VGfloat d)
Dessinez un cercle centré à (x, y) de diamètre d.
void CircleOutline(VGfloat x, VGfloat y, VGfloat r)
Version décrite
void Ellipse(VGfloat x, VGfloat y, VGfloat w, VGfloat h)
Dessinez une ellipse centrée à (x, y) avec des rayons (w, h).
void EllipseOutline(VGfloat x, VGfloat y, VGfloat w, VGfloat h)
Version décrite
void Qbezier(VGfloat sx, VGfloat sy, VGfloat cx, VGfloat cy, VGfloat ex, VGfloat ey)
Dessinez une courbe de Bezier quadratique commençant à (SX, SY), en utilisant des points de contrôle à (CX, Cy), se terminant à (Ex, ey).
void QbezierOutline(VGfloat sx, VGfloat sy, VGfloat cx, VGfloat cy, VGfloat ex, VGfloat ey)
Version décrite
void Cbezier(VGfloat sx, VGfloat sy, VGfloat cx, VGfloat cy, VGfloat px, VGfloat py, VGfloat ex, VGfloat ey)
Dessinez une courbe de Bezier cubique commençant à (SX, SY), en utilisant des points de contrôle à (CX, Cy) et (Px, Py), se terminant à (Ex, EY).
void CbezierOutline(VGfloat sx, VGfloat sy, VGfloat cx, VGfloat cy, VGfloat px, VGfloat py, VGfloat ex, VGfloat ey)
Version décrite
void Arc(VGfloat x, VGfloat y, VGfloat w, VGfloat h, VGfloat sa, VGfloat aext)
Dessinez un arc elliptique centré à (x, y), avec une largeur et une hauteur à (w, h). L'angle de démarrage (degrés) est SA, l'étendue de l'angle est AEXT.
void ArcOutline(VGfloat x, VGfloat y, VGfloat w, VGfloat h, VGfloat sa, VGfloat aext)
Version décrite
void Text(VGfloat x, VGfloat y, char* s, Fontinfo f, int pointsize)
Dessinez un texte Srtring (s) à l'emplacement (x, y), en utilisant des points de pointage.
void TextMid(VGfloat x, VGfloat y, char* s, Fontinfo f, int pointsize)
Dessinez un texte Srtring (s) au centre à l'emplacement (x, y), en utilisant des points de point.
void TextEnd(VGfloat x, VGfloat y, char* s, Fontinfo f, int pointsize)
Dessinez un texte Srtring (s) avec son prêt aligné sur l'emplacement (x, y), en utilisant des points de point
VGfloat TextWidth(char *s, Fontinfo f, int pointsize)
Retourner la largeur du texte
VGfloat TextHeight(Fontinfo f, int pointsize)
Retournez la hauteur d'une police
TextDepth(Fontinfo f, int pointsize)
Retournez la distance d'une police au-delà de la ligne de base.
void Image(VGfloat x, VGfloat y, int w, int h, char * filename)
Placer une image JPEG avec des dimensions (W, H) à (x, y).
void Translate(VGfloat x, VGfloat y)
Traduire le système de coordonnées en (x, y).
void Rotate(VGfloat r)
Faites pivoter le système de coordonnées autour de l'angle R (degrés).
void Scale(VGfloat x, VGfloat y)
Échelle par x, y.
void Shear(VGfloat x, VGfloat y)
Cisaillement par les angles x, y.
void ClipRect(VGint x, VGint y, VGint w, VGint h)
Limitez le dessin de la zone de dessin sur le rectangle spécifié, terminez avec clipend ()
void ClipEnd()
Ends Discusing Zone
Le programme FONT2OpenVG est également inclus, qui transforme les informations de police en source C que vous pouvez intégrer dans votre programme. Le makefile fabrique du code de police à partir de fichiers trouvés dans / usr / share / fontts / trueetype / ttf-dejavu /. Si vous souhaitez utiliser d'autres polices, ajustez le makefile en conséquence ou générez le code de police par vous-même une fois le programme Font2Openvg.
Font2Openvg prend trois arguments: le fichier de police TrueType, le fichier de sortie à inclure et le préfixe pour les identifiants. Par exemple pour utiliser la police dejavu sans:
./font2openvg /usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf DejaVuSans.inc DejaVuSans
et inclure le code généré dans votre programme:
#include "DejaVuSans.inc"
Fontinfo DejaFont
La fonction LoadFont crée des chemins OpenVG à partir des données de police:
loadfont(DejaVuSans_glyphPoints,
DejaVuSans_glyphPointIndices,
DejaVuSans_glyphInstructions,
DejaVuSans_glyphInstructionIndices,
DejaVuSans_glyphInstructionCounts,
DejaVuSans_glyphAdvances,
DejaVuSans_characterMap,
DejaVuSans_glyphCount);
La fonction UNDOLDFONT libère les informations du chemin:
unloadfont(DejaFont.Glyphs, DejaFont.Count);
Notez que l'emplacement des fichiers de police peut différer. (L'emplacement actuel pour Jessie est / usr / share / fonts / trueetype / ttf-dejavu) Utilisez la variable de makefile de Fontlib pour ajuster cet emplacement.
Notez que vous aurez besoin d'au moins 64 mytes de RAM GPU : . Vous aurez également besoin des polices Dejavu et des bibliothèques JPEG et Freetype. L'outil d'emploi est également utile pour le formatage du code. Installez-les via:
pi@raspberrypi ~ $ sudo apt-get install libjpeg8-dev indent libfreetype6-dev ttf-dejavu-core
Ensuite, créez la bibliothèque et testez:
pi@raspberrypi ~ $ git clone git://github.com/ajstarks/openvg
pi@raspberrypi ~ $ cd openvg
pi@raspberrypi ~/openvg $ make
g++ -I/usr/include/freetype2 fontutil/font2openvg.cpp -o font2openvg -lfreetype
./font2openvg /usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf DejaVuSans.inc DejaVuSans
224 glyphs written
./font2openvg /usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf DejaVuSansMono.inc DejaVuSansMono
224 glyphs written
./font2openvg /usr/share/fonts/truetype/ttf-dejavu/DejaVuSerif.ttf DejaVuSerif.inc DejaVuSerif
224 glyphs written
gcc -O2 -Wall -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads -c libshapes.c
gcc -O2 -Wall -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads -c oglinit.c
pi@raspberrypi ~/openvg/client $ cd client
pi@raspberrypi ~/openvg/client $ make test
cc -Wall -I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads -o shapedemo shapedemo.c ../libshapes.o ../oglinit.o -L/opt/vc/lib -lGLESv2 -ljpeg
./shapedemo demo 5
Le programme "ShapeDemo" exerce une API de haut niveau construite sur OpenVG trouvée dans libshapes.c.
./shapedemo # show a reference card
./shapedemo raspi # show a self-portrait
./shapedemo image # show four test images
./shapedemo astro # the sun and the earth, to scale
./shapedemo text # show blocks of text in serif, sans, and mono fonts
./shapedemo rand 10 # show 10 random shapes
./shapedemo rotate 10 a # rotated and faded "a"
./shapedemo test "hello, world" # show a test pattern, with "hello, world" at mid-display in sans, serif, and mono.
./shapedemo fontsize # show a range of font sizes (per <https://speakerdeck.com/u/idangazit/p/better-products-through-typography>)
./shapedemo demo 10 # run through the demo, pausing 10 seconds between each one; contemplate the awesome.
Pour installer la bibliothèque de formes en tant que bibliothèque partagée à l'échelle du système
pi@raspberrypi ~/openvg $ make library
pi@raspberrypi ~/openvg $ sudo make install
La bibliothèque OpenVG Shapes peut désormais être utilisée dans le code C en incluant des formes.h et Fontinfo.h et en liant avec des libshapes.so:
#include <shapes.h>
#include <fontinfo.h>
pi@raspberrypi ~ $ gcc -I/opt/vc/include -I/opt/vc/include/interface/vmcs_host/linux -I/opt/vc/include/interface/vcos/pthreads anysource.c -o anysource -lshapes
pi@raspberrypi ~ $ ./anysource
Un emballage de langage de programmation Go pour la bibliothèque se trouve dans openvg.go. Les échantillons de clients sont dans le go-client de répertoire. L'API suit de près l'API C; Voici le programme "Hello, World" en Go:
L'API GO
package main
import (
"bufio"
"github.com/ajstarks/openvg"
"os"
)
func main() {
width, height := openvg.Init() // OpenGL, etc initialization
w2 := openvg.VGfloat(width / 2)
h2 := openvg.VGfloat(height / 2)
w := openvg.VGfloat(width)
openvg.Start(width, height) // Start the picture
openvg.BackgroundColor("black") // Black background
openvg.FillRGB(44, 77, 232, 1) // Big blue marble
openvg.Circle(w2, 0, w) // The "world"
openvg.FillColor("white") // White text
openvg.TextMid(w2, h2, "hello, world", "serif", width/10) // Greetings
openvg.End() // End the picture
bufio.NewReader(os.Stdin).ReadBytes('n') // Pause until [RETURN]
openvg.Finish() // Graphics cleanup
}
Pour construire l'emballage: (Assurez-vous que Gopath est réglé)
pi@raspberrypi ~/openvg $ go install .
pi@raspberrypi ~/openvg $ cd go-client/hellovg
pi@raspberrypi ~/openvg/go-client/hellovg $ go build .
pi@raspberrypi ~/openvg/go-client/hellovg $ ./hellovg
