Voici la liste (pas terminée) des fonctions incluses dans OSL.
void oslInit(int useOwnCallbacks);
Initialise la librairie. Cette fonction devrait être appelée au début de chaque programme. Si vous mettez useOwnCallbacks à TRUE, vous pourrez gérer vous-même les callbacks standard (update_thread et Exit Callback).
void oslQuit();
Quitte le jeu complètement. Vous reviendrez au menu de la PSP.
void oslInitGfx(int pixelFormat, int bDoubleBuffer);
Initialise la partie graphique. Vous devez spécifier le pixelFormat, qui est en fait la taille d'un pixel à l'écran, ainsi que si vous souhaitez utiliser le double buffering ou non.
void oslShowNeoflashLogo();
Affiche le logo de la compétition neoflash. Appelez-la après avoir initialisé la librairie ainsi que la partie graphique à n'importe quelle résolution (mais activez de préférence le double buffering).
void oslStartDrawing();
Vous devez appeler cette fonction avant de dessiner quoi que ce soit. Le nombre d'opérations réalisables à la fois par le GPU est limité, et le fait de redémarrer le dessin permet de recommencer à zéro.
void oslSyncDrawing();
Effectue immédiatement toutes les opérations de dessin en attente. Cette opération peut s'avérer très lente, car en temps normal le GPU travaille en parallèle de votre programme, et effectue ses tâches à son rythme. Cette fonction attend qu'il ait tout terminé avant de continuer. Utile si vous voulez afficher une image qui va changer par la suite (le GPU ne la dessine pas tout de suite lorsque vous le lui ordonnez, mais uniquement après avoir terminé le reste, et donc entre temps, l'image pourrait avoir changé et l'affichage sera erroné).
void oslEndDrawing();
Fin de l'affichage. S'assure également que tout a été dessiné correctement. A appeler avant de synchroniser l'écran ou de basculer les buffers.
void oslWaitVSync();
Attend la VSync.
void oslSwapBuffers();
En mode double buffer, échange le buffer visible et le buffer de dessin.
void oslEndGfx();
Termine la partie graphique de la librairie. Vous pouvez ensuite la réinitialiser avec d'autres paramètres.
void oslFlushDataCache();
Vide le cache de données. Ne pas utiliser.
int oslSyncFrame();
Synchronise l'écran, à utiliser après avoir terminé l'affichage. Cette fonction s'occupera elle-même de basculer les buffers, attendre la VSync, etc.
int oslSyncFrameEx();
Permet d'indiquer les paramètres supplémentaires à la synchronisation.
Frameskip: 0: pas de frameskip (normal) 1: frameskip normal >1: dépend de vsync, saute 1 frame sur X Max frameskip: >=1: Frameskip maximum autorisé VSync: 0: pas de VSync 1: VSync activée +4: si on rajoute 4, fixe le frameskip minimum (ex. avec 2, le jeu tournera à 60 fps, 30 images par seconde) +0: sinon, avec un frameskip >1, synchronise au framerate souhaité, par ex. 2 -> 30 fps Exemples: //30 fps (pas de frameskip) oslSyncFrameEx(2,0,0); //30 fps, jeu à 60, frameskip max de 2, c'est-à-dire pas plus d'une frame skippée pour une affichée oslSyncFrameEx(2,2,4); //synchronise à 60 fps oslSyncFrameEx(0,0,0);
void void oslSetTransparentColor(OSL_COLOR color);
Définit la couleur considérée comme transparente. Si un pixel de l'image à dessiner est de cette couleur, il ne sera pas dessiné. Cela s'étend à tout (texte, rectangles, etc.), c'est pourquoi désactivez-le de préférence une fois que votre image est dessinée. Lors du chargement d'une image, les pixels de cette couleur prendront la valeur alpha 0, indiquant qu'ils sont transparents, vous pouvez donc activer la couleur transparente uniquement pour le chargement des images et la désactiver une fois terminé, c'est ce qui est le plus simple.
void oslDisableTransparentColor();
Désactive la couleur transparente (tous les pixels seront dessinés, sauf ceux dont l'alpha est nul, bien entendu).
float oslSin(int angle, int dist);
Calcule le sinus de l'anlge passé, et le multiplie par le rayon fourni.
float oslCos(int angle, int dist);
Idem pour le cosinus
int oslGetNextPower2(int val);
Donne la prochaine puissance de deux du nombre passé.
OSL_IMAGE *oslCreateImage(int larg, int haut, short location, short pixelFormat);
Crée une nouvelle image avec les paramètres fournis. Location peut être OSL_IN_RAM (en RAM, 20 Mo, lente) ou OSL_IN_VRAM (en VRAM, 2 Mo, rapide). La VRAM est très limitée, ne l'utilisez que pour les images très souvent utilisées.
void oslDeleteImage(OSL_IMAGE *img);
Efface l'image spécifiée. Il n'y a pas encore de gestionnaire de VRAM, donc si l'image est en VRAM, vous devez obligatoirement détruire la dernière créée, puis l'avant-dernière, etc. dans l'ordre.
OSL_IMAGE *oslLoadImageFile(char *filename, int location, int pixelFormat);
Charge un fichier image (seul le PNG est supporté pour le moment). Vous pouvez choisir où la mettre ainsi que son pixelformat.
OSL_IMAGE *oslCreateImageTile(OSL_IMAGE *img, int offsetX0, int offsetY0, int offsetX1, int offsetY1);
Crée une image représentant une partie d'une autre. Vous pouvez l'utiliser pour désigner la zone de img entre offsetX0,offsetY0 et offsetX1,offsetY1. Le contenu de l'image n'est pas copié, mais vous devez quand même faire appel à oslDeleteImage une fois que vous avez terminé.
OSL_IMAGE *oslCreateImageTileSize(OSL_IMAGE *img, int offsetX0, int offsetY0, int width, int height);
Idem, sauf que vous spécifiez les positions de départ et la largeur/hauteur de la zone.
void oslCopyImage(OSL_IMAGE *imgDst, OSL_IMAGE *imgSrc);
Copie une image vers une deuxième. Le format des deux doit être identique.
void oslSwizzleImage(OSL_IMAGE *imgDst, OSL_IMAGE *imgSrc);
Crée une copie optimisée de imgSrc vers imgDst. imgSrc et imgDst ne doivent pas designer la même image. La version optimisée est plus rapide à afficher pour le GPU, mais elle n'est plus modifiable après.
void oslClearImage(OSL_IMAGE *img, int color);
Efface entièrement l'image avec la couleur spécifiée.
Note: Si l'image est en RAM, l'opération est effectuée par le processeur principal. C'est donc plus lent, et le
calcul des couleurs n'est pas pareil qu'avec le GPU. De plus, en mode 8 ou 4 bits, la couleur spécifie le n° de couleur
de palette à remplir, et non la couleur réelle à rechercher dans la palette.
void oslUncacheImage(OSL_IMAGE *img);
Vide l'image spécifiée du cache CPU. Vous devez appeler cette fonction avant d'afficher une image dont vous avez modifié les données vous même.
OSL_IMAGE *oslCreateImageCopy(OSL_IMAGE *src, int newLocation);
Crée une copie de l'image spécifiée.
OSL_IMAGE *oslCreateSwizzledImage(OSL_IMAGE *src, int newLocation);
Idem, mais "swizzle" (optimise) l'image.
OSL_PALETTE *oslCreatePalette(int size, short pixelFormat);
Crée une nouvelle palette contenant size couleurs de type pixelFormat.
OSL_PALETTE *oslLoadPalette(void *data, int size, short pixelFormat);
Crée une nouvelle palette à partir d'un tableau défini dans le code.
void oslDrawImage(OSL_IMAGE *img);
Dessine l'image spécifiée, en utilisant les paramètres qui lui sont propres.
void oslDrawImageSimple(OSL_IMAGE *img);
Dessine l'image spécifiée. C'est une version plus rapide, mais qui ne supporte pas la rotation.
void oslDrawLine(int x0, int y0, int x1, int y1, OSL_COLOR color);
Dessine une ligne de couleur spécifiée entre x0,y0 et x1,y1.
void oslDrawRect(int x0, int y0, int x1, int y1, OSL_COLOR color);
Dessine un cadre (rectangle vide).
void oslDrawFillRect(int x0, int y0, int x1, int y1, OSL_COLOR color);
Dessine un rectangle plein.
void oslDrawGradientRect(int x0, int y0, int x1, int y1, OSL_COLOR c1, OSL_COLOR c2, OSL_COLOR c3, OSL_COLOR c4);
Dessine un dégradé à quatre coins (c1: haut-gauche, c2: haut-droite, c3: bas-gauche, c4: bas-droite).
OSL_MAP *oslCreateMap(OSL_IMAGE *img, void *map_data, int tileX, int tileY, int mapSizeX, int mapSizeY, int map_format);
Crée une nouvelle map. map_format doit être OSL_MF_U16 (chaque élément de la map est un unsigned short). Img est le tileset (la largeur doit être une puissance de deux), tileX et tileY la taille d'une tile, mapSizeX et mapSizeY la taille totale de la map.
void oslDrawMap(OSL_MAP *m);
Dessine la map spécifiée.
void oslDrawMapSimple(OSL_MAP *m);
Version plus rapide, tileX, tileY et la largeur du tileset doivent être des puissances de deux.
void oslClearScreen(int backColor);
Efface l'écran avec la couleur spécifiée.
void oslSetScreenClipping(int x0, int y0, int x1, int y1);
Règle la région de l'écran sur laquelle vous pouvez dessiner. Tout ce qui est en dehors de ce rectangle ne sera pas dessiné. Utile pour du fenêtrage par exemple.
void oslSetDrawBuffer(OSL_IMAGE *img);
Définit l'image sur laquelle vous allez dessiner. Passer OSL_DEFAULT_BUFFER pour réinitialiser et OSL_SECONDARY_BUFFER pour le buffer en cours d'affichage en mode double-buffering.
void oslSetAlpha(int effect, int coeff);
Définit les paramètres alpha (transparence). Le type d'alpha peut être un des suivants:
OSL_FX_NONE: aucun effet, vaut zéro. Formule: dst = src (l'alpha est aussi copié à la destination, et non pas calculé) OSL_FX_FLAT: Identique à OSL_FX_NONE, sauf que si l'alpha est nul, alors le pixel ne sera pas dessiné. Formule: dst = (src & 0xff000000) ? src : dst; OSL_FX_RGBA: Tient compte du canal alpha pour les couleurs. En appelant cela, vous pouvez par exemple dessiner une boîte bleue transparente ainsi: oslDrawFillRect(0,0,100,100,RGBA(0,0,255,128)); Pour le canal alpha, zéro signifie transparent, et 255 opaque. Ces valeurs peuvent également être prises pour chacun des pixels ou des couleurs de la palette, permettant de rendre des parties de votre image transparentes simplement. C'est le mode par défaut. Formule: dst = src * asrc + dst * (1 - asrc) OSL_FX_ALPHA: Alpha blend (transparence normale). Le coefficient est multiplié par la couleur source pour définir si le plan est plus ou moins transparent. Formule: dst = src * coeff + dst * (1 - coeff) OSL_FX_ADD: Additionne la source et la destination, utile pour rendre des plans "fantômes". Vous pouvez également spécifier le coefficient, qui est multiplié par la valeur source à l'addition. Formule: dst = src * coeff + dst OSL_FX_SUB: Soustrait la source et la destination. Utile pour les plans "masque". Formule: dst = src * coeff - dst OSL_FX_COLOR: Rajoutez (avec un OR) aux autres effets pour pouvoir définir la transparence de chacune des composantes RGBA. Par exemple, si vous voulez teindre une image en rouge, vous pouvez faire: oslSetAlpha(OSL_FX_ALPHA|OSL_FX_COLOR, RGBA(0xff,0,0,0xff));
void oslSystemMessage(const char *message);
Affiche le message système de Sony. Bizarrement, cela ne fonctionne pas très bien.
unsigned int oslMessageBox(const char *text, const char *title, unsigned int flags);
Affiche une petite boîte de dialogue. Cliquez ici pour plus d'infos.
int oslBenchmarkTestEx(int startend, int slot);
Effectue une opération sur l'emplacement (slot) de benchmark spécifié. Pour les valeurs de startend, voyez ici.
OSL_CONTROLLER *oslReadKeys();
Lit l'état actuel du clavier et le stocke dans la variable globale osl_keys. Elle renvoie également un pointeur vers ces données.
int oslWaitKey();
Attend qu'une touche soit appuyée et renvoie son code.
int oslKbhit();
Renvoie le code de la dernière touche appuyée, si ce code n'est pas nul, vous pouvez appeler oslWaitKey pour récupérer la touche appuyée.
void oslFlushKey();
Vide le buffer des touches appuyées.
int oslInitAudio();
Initialise la partie audio de la librairie. Cette fonction doit obligatoirement être appelée si vous voulez jouer du son dans votre programme.
void oslDeinitAudio();
Détruit la partie audio de la librairie. Après avoir appelé cette option, il ne sera plus possible de jouer un son. Appelez-la pour libérer les ressources et s'assurer que tout son est stoppé.
void oslPlaySound(OSL_SOUND *s, int voice);
Joue un son sur le canal audio spécifié. Le n° de canal peut être entre 0 et 7, et si vous jouez le son sur un canal déjà utilisé, le nouveau son remplacera celui qui est en train d'y être joué.
int oslGetSoundChannel(OSL_SOUND *s);
Permet de savoir sur quel canal audio hardware un son est joué. Le résultat est -1 si le son n'est pas joué en ce moment.
void oslStopSound(OSL_SOUND *s);
Arrête un son en train d'être joué. Ne fait rien dans le cas contraire. Pour reprendre le son, appelez oslPlaySound, le son sera joué depuis le début.
void oslPauseSound(OSL_SOUND *s, int pause);
Met un son en pause. Si l'argument pause vaut 1, le son est mis en pause, s'il vaut 0 le son est repris (là où il était resté), s'il vaut -1 l'état est inversé (play/pause).
void oslAudioVSync();
A appeler dans votre boucle principale. Pourquoi? La mise en veille de la PSP provoque la fermeture de tous les fichiers ouverts! Alors forcément le système audio plantait. Maintenant je gère ça, mais il faut réouvrir les fichiers par après, et ce n'est pas possible directement à la sortie de la veille car la MS n'est pas encore initialisée. Cette fonction va vérifier que la MS est prête et charger les fichiers et continuer là où ils étaient restés si c'est le cas. Si vous ne faites pas appel à cette fonction, tout son joué en streaming sera stoppé à la reprise de la veille. Il sera toutefois rechargé automatiquement (mais recommencé au début) lorsque vous appelez oslPlaySound. Idem pour les sons qui étaient ouverts en streaming mais pas joués.
OSL_SOUND *oslLoadSoundFile(const char *filename, int stream);
Charge un fichier .wav ou .bgm. Indiquez simplement le nom du fichier ainsi que si vous souhaitez le streamer sur la Memory Stick. Si vous streamez un son, il n'est pas chargé en mémoire, ce qui vous fait gagner du temps mais surtout beaucoup de RAM, car la PSP n'en a que 20 Mo, alors imaginez que si vous chargez des effets sonores de 1 Mo chacun, elle sera vite saturée. Toutefois le streaming affecte pas mal les performances de la restitution sonore, surtout si le taux d'échantillonnage est important. Pour des performances optimales, je vous conseille d'utiliser de petits fichiers .wav chargés pour les effets sonores, et des .bgm streamés pour les musiques. Vous pouvez également streamer les effets sonores, mais uniquement ceux qui ne sont presque jamais joués en temps normal.
int oslDeleteSound();
Supprime un son.
void oslSetSoundLoop(OSL_SOUND *s, int loop);
Met en place le looping pour un son. Si la boucle est activée pour un son (loop = TRUE), le son va être répété une fois qu'il sera terminé.