Lista de Funções

Aqui está a lista (ainda não finalizada) de funções incluídas na OSL

oslib.h

void oslInit(int useOwnCallbacks);

Inicializa a biblioteca. Esta função deve ser chamada no começo de cada programa. Se for passado TRUE como parâmetro para useOwnCallbacks, você pode controlar os callbacks (chamadas) padrões. (update_thread, Exit Callback e Power Callback, devem ser chamados, que devem chamar a osl_powerCallback se esta não for nula(NULL!))

void oslQuit();

Fecha o aplicativo, voltando para o XMB

void oslInitGfx(int pixelFormat, int bDoubleBuffer);

Inicializa a parte gráfica.Você deve especificar o pixelFormat, qual é o tamanho de pixel que você quer desenhar na tela ou se você deseja utilizar double buffering

void oslShowNeoflashLogo();

Mostra o logo da competição Neoflash. Deve ser chamada após iniciar a biblioteca e a parte gráfica, passe a definição que você quiser (mas de preferência o double buffering).

void oslStartDrawing();

Você precisa chamar esta função antes de desenhar qualquer coisa. O número de operações que a GPU pode fazer é limitado, sendo assim a reinicialização permite desenhar outra vez do começo.

void oslSyncDrawing();

Espera até que todas as operações de desenho estejam terminadas.Esta operação pode ser muito lenta, pois a GPU trabalha paralelamente com nosso programa. Esta função aguarda a GPU terminar tudo, antes de continuar.É útil se você quiser mostrar uma imagem que será modificada mais tarde. (a GPU não desenha imediatamente quando você solicita, e sim quando há um tempo, passando novamente pelo while a mesma será desenhada na tela)

void oslEndDrawing();

Finaliza a função de desenho.Certifique-se de ter deletados todas as imagens alocadas, para sincronizar a tela e os double buffering.

void oslWaitVSync();

Aguarda o VSync (60 Hz).

void oslSwapBuffers();

Em double buffering, troca o visivel e desenha o que está em buffer.

void oslEndGfx();

Finaliza a parte gráfica da biblioteca. Então você pode reiniciá-lo com outros parâmetros.

void oslFlushDataCache();

Nivela o data cache. Não use.

int oslSyncFrame();

Sincroniza a tela. é utilizada quando se é preciso redesenhar todos os desenhos na tela. Esta função fará a troca de buffers e aguardará o VSync

int oslSyncFrameEx();

Indica os parâmetros suplementares para a sincronização.

Frameskip:
	0: sem frameskip (normal)
	1: normal frameskip
	>1: depende do vsync, salta 1 frame de X
	
Max frameskip:
	>=1: Máximo frameskip autorizado
VSync:
	0: sem VSync
	1: VSync habilitado
	+4: se você adicionar 4, fixa o minimo de frameskip (ex. com 2,o jogo roda a 60 fps, mas em  30 imagens por segundo)
	+0: senão, com frameskip > 1, sincroniza o framerate, ex. 2 -> 30 fps
Exemplos:
	//30 fps (sem frameskip)
	oslSyncFrameEx(2,0,0);
	//30 fps, jogo 60, o máximo de frameskip é 2, que significa não mais que 1 frameskip
	oslSyncFrameEx(2,2,4);
	//sincroniza a 60 fps
	oslSyncFrameEx(0,0,0);

void void oslSetTransparentColor(OSL_COLOR color);

Define a cor transparente. Se um pixel da imagem que você quer desenhar for desta cor, ele não será desenhado. Util para qualquer coisa (textos, rectangulos, etc.),isto porque o mesmo não é desenhado. Durante o carregamento da imagem, os pixels que tiverem esta cor, terão seu canal alpha como 0, indicando que são transparentes. Você só pode ativar a cor transparente no carregamento da imagem, e desativá-lo quando terminar.

void oslDisableTransparentColor();

Desativa a cor transparente (todos os pixels serão desenhados, exceto aqueles cujo o alfa é nulo(0)).

float oslSin(int angle, int dist);

Computa o seno do Ângulo especificado, multiplicando-o pelo raio.

float oslCos(int angle, int dist);

O mesmo para o cosseno

int oslGetNextPower2(int val);

Retorna o power de 2 para o número passado.

OSL_IMAGE *oslCreateImage(int larg, int haut, short location, short pixelFormat);

Cria uma nova imagem com os parâmetros fornecidos. Em location pode ser OSL_IN_RAM (na RAM, 20MB, lentos) ou OSL_IN_VRAM (em VRAM, em 2MB, rápidos). O VRAM é muito limitado, sendo assim use-o somente para as imagens frequentemente usadas.

void oslDeleteImage(OSL_IMAGE *img);

Deleta a imagem especificada. Como não há nenhum gerenciador, é necessário apagar conforme o empilhamento na memoria.Exemplo: imagem1 carregada, imagem2 carrega, só posso apagar a imagem1, após apagar a imagem2

OSL_IMAGE *oslLoadImageFile(char *filename, int location, int pixelFormat);

Carrega um arquivo de imagem(Até o presente momento, apenas o formato PNG é suportado). Você pode escolher onde colocar e também o pixelformat.

OSL_IMAGE *oslCreateImageTile(OSL_IMAGE *img, int offsetX0, int offsetY0, int offsetX1, int offsetY1);

Cria uma imagem com referência em uma parte de outra.Você precisa indicar a área de offsetX0,offsetY0 e offsetX1,offsetY1 na imagem.Os índices da imagem não são copiados, somente referênciados, sendo assim você precisa executar o oslDeleteImage de qualquer forma antes de deletar a imagem

OSL_IMAGE *oslCreateImageTileSize(OSL_IMAGE *img, int offsetX0, int offsetY0, int width, int height);

O mesmo, exceto que você precisa apenas especificar as posições esquerda acima, largura e altura da área.

void oslCopyImage(OSL_IMAGE *imgDst, OSL_IMAGE *imgSrc);

Copia uma imagem para outra. Ambas precisam ter o mesmo formato.

void oslSwizzleImage(OSL_IMAGE *imgDst, OSL_IMAGE *imgSrc);

Cria uma cópia otimizada da imgSrc para imgDst.imgSrc deve ser diferente da imgDst, a versão otimizada é mais rápida para a GPU, porém você não pode modificá-la.

void oslClearImage(OSL_IMAGE *img, int color);

Apaga a cor especificada da imagem que a utiliza. Nota: Se a imagem estiver na RAM, a operação será feita pelo CPU, é mais lento e o cálculo de cor não é o mesmo da GPU. Além disso no modo de 4 ou 8 bits, a cor especifica o indice da paleta a ser indexado no buffer, e não a cor real a ser procurada na paleta

void oslUncacheImage(OSL_IMAGE *img);

Sincroniza a imagem especificada no cache da CPU. Você precisa chamar esta função antes de indicar uma imagem que teve seu dados modificados.

OSL_IMAGE *oslCreateImageCopy(OSL_IMAGE *src, int newLocation);

Cria uma cópia da imagem especificada.

OSL_IMAGE *oslCreateSwizzledImage(OSL_IMAGE *src, int newLocation);

O mesmo, porém a cópia é otimizada

OSL_PALETTE *oslCreatePalette(int size, short pixelFormat);

Cria uma nova paleta com o size(tamanho) de cores do tipo do pixelFormat.

OSL_PALETTE *oslLoadPalette(void *data, int size, short pixelFormat);

Cria uma nova paleta de um array definido em seu codigo.

void oslDrawImage(OSL_IMAGE *img);

Desenha a imagem especificada, usando os parâmetros contidos na mesma.

void oslDrawImageSimple(OSL_IMAGE *img);

Desenha a imagem especificada. É uma versão mais rápida, porém não suporta rotação.

void oslDrawLine(int x0, int y0, int x1, int y1, OSL_COLOR color);

Desenha uma linha com a cor especifica dos pontos(x0,y0) e (x1,y1).

void oslDrawRect(int x0, int y0, int x1, int y1, OSL_COLOR color);

Desenha um frame (retangulo vazio)

void oslDrawFillRect(int x0, int y0, int x1, int y1, OSL_COLOR color);

Desenha um retangulo preenchido

void oslDrawGradientRect(int x0, int y0, int x1, int y1, OSL_COLOR c1, OSL_COLOR c2, OSL_COLOR c3, OSL_COLOR c4);

Desenha um gradiente de 4 pontos (c1: esquerda acima, c2: direita acima, c3: esquerda abaixo, c4: direita abaixo).

OSL_MAP *oslCreateMap(OSL_IMAGE *img, void *map_data, int tileX, int tileY, int mapSizeX, int mapSizeY, int map_format);

Cria um novo mapa. map_format deve ser OSL_MF_U16 (cada elemento do mapa é um unsigned short). img é o tileset(a largura tem que ser maior que 2), tileX e tileY é o tamanho de cada tile, mapSizeX e mapSizeY é o tamanho total do mapa.

void oslDrawMap(OSL_MAP *m);

Desenha o mapa especificado

void oslDrawMapSimple(OSL_MAP *m);

Versão rápida, tileX, tileY e o tileset devem ter os tamanhos maiores que 2.

void oslClearScreen(int backColor);

Limpa a tela com a cor especificada.

void oslSetScreenClipping(int x0, int y0, int x1, int y1);

Ajusta a região da tela a ser desenhada. O que estiver fora deste retângulo não será desenhado. Útil para janelas.

void oslSetDrawBuffer(OSL_IMAGE *img);

Define a imagem atual em buffer, passe OSL_DEFAULT_BUFFER para reiniciar a tela default, ou OSL_SECONDARY_BUFFER para desenhar o que estiver em double buffering.

void oslSetAlpha(int effect, int coeff);

Define os parâmetros do alfa (transparência). O tipo do alfa pode ser um dos seguintes:

OSL_FX_NONE: sem efeito
             Formula: dst = src (O alpha é copiado para o destino, não computado)
OSL_FX_FLAT: Identico ao OSL_FX_NONE, exceto que o alpha e nulo (null), o pixel não será desenhado
             Formula: dst = (src & 0xff000000) ? src : dst;
OSL_FX_RGBA: Examina o canal alpha da paleta durante a computaçao.Use-a caso utilize transparência
             por exemplo um retangulo com alpha: oslDrawFillRect(0,0,100,100,RGBA(0,0,255,128)); Para o canal alpha 0 (zero) significa
						 transparente e 255 opaco. Estes valores podem ser utilizados também para cada pixel de uma imagem, 
						 ou cada cor de uma paleta, permitindo renderizar mais facilmente suas imagens transparentes. É o modo DEFAULT.
             Formula: dst = src * asrc + dst * (1 - asrc)
OSL_FX_ALPHA: Alpha blend (transparencia normal). O coeficiente é multiplicado pela cor da fonteque define se o plano
             é mais ou menos transparente
             Formula: dst = src * coeff + dst * (1 - coeff)
OSL_FX_ADD:  Adiciona a fonte e destino, Útil para "ghosts". Você pode especificar o coeficiente, que é multiplicado
pelo valor da fonte. Se você quiser uma adição simples, passa o coeficiente 0xff.
             Formula: dst = src * coeff + dst
OSL_FX_SUB:  Extrai o imagem fonte e destino. Útil para "máscaras".
             Formula: dst = src * coeff - dst
OSL_FX_COLOR: Adiciona outros efeitos, de forma que você possa definir a transparência para cada componente de RGBA
Por exemplo se você quiser matizar uma imagem vermelha utilize:
			 oslSetAlpha(OSL_FX_ALPHA|OSL_FX_COLOR, RGBA(0xff,0,0,0xff));

void oslSystemMessage(const char *message);

Mostra a mensagem de sistema da Sony. É estranha e também não trabalha bem.

unsigned int oslMessageBox(const char *text, const char *title, unsigned int flags);

Mostra uma caixa de diálogo pequena. Click Aqui para mais informações.

int oslBenchmarkTestEx(int startend, int slot);

Faz uma operação de marca de nível. Para valores de startend , por favor veja Aqui.

OSL_CONTROLLER *oslReadKeys();

Lê o estado atual do joypad e o armazena nas osl_keys (variaveis globais), e retorna também um ponteiro com estes dados.

int oslWaitKey();

Aguarda até que um botão seja pressionado, para assim retomar ao codigo.

int oslKbhit();

Retorna o ultimo botão pressionado, se este código não for nulo (NULL), você pode chamar a função oslWaitKey para iniciá-lo (nenhum dos botões pressionados serão armazenados até que você chame a oslWaitKey).

void oslFlushKey();

Esvazia o buffer dos botões pressionados. De modo que as seguintes sejam armazenadas.

audio.h

int oslInitAudio();

Inicializa a parte de audio da biblioteca. Essa função é necessária para quando você quiser carregar ou tocar um som.

void oslDeinitAudio();

Finaliza parte de audio da biblioteca. Após chamar esta função não é possivel, tocar som algum. Chame-a para terminar os recursos de audio e certificar-se de que todo o som está parado.

void oslPlaySound(OSL_SOUND *s, int voice);

Toca o som em um canal especificado, podendo este ser de 0 a 7, se o som for jogado no mesmo canal o mesmo substitui o anterior

int oslGetSoundChannel(OSL_SOUND *s);

Retorna qual canal o audio está sendo tocado. O resultado -1 é retornado caso o mesmo não esteja sendo tocado.

void oslStopSound(OSL_SOUND *s);

Para o som que está sendo tocado. Para começar novamente, chame a função oslPlaySound, o som será tocado desde o início.

void oslPauseSound(OSL_SOUND *s, int pause);

Pausa o som atual. Se o status do som for 1, o som está pausado, se for 0 o som está tocando, se for -1 o som está invertido (play/pause)

void oslAudioVSync();

Chame a em seu laço (while) principal, caso você chame vários sons. Por quê? Quando você coloca o PSP em Standy-by o kernel fecha todos os arquivos abertos. Então, obviamente o sistema audio deixa de funcionar. Mas OSLib controla isto, porém é necessário reabrir os arquivos para continuar, e não é possível logo quando o PSP inicia porque o MS não está inicializado ainda. Esta Função irá verificar se o MS está pronto, irá reabir o arquivo e continuará de onde parou. Se você não chamar esta função, todo o som carregado atualmente estará parado quando o PSP inciar. Entretanto será carregado automaticamente (porém desde o início) quando for chamado a função oslPlaySound. O mesmo para os sons que foram abertos mas não estão sendo tocados.

OSL_SOUND *oslLoadSoundFile(const char *filename, int stream);

Carrega um arquivo wav ou bgm.É necessário identificar nome do arquivo e seu caminho no Memory Stick. Se você estiver tocando um som, este não será carregado em memória, assim poupando o sobrecarregamento da memória. Porque o PSP atem apenas 20 MB, imagine carregar vários sons com tamanho de 1 MB cada, a memória estaria cheia, (A memória é compartilhada para imagens, seu código, musica, etc). Entretando, tocar afeta a performance, especialmente se a taxa de amostragem for elevada. Para um melhor desempenho é recomendado utilizar arquivo Wav para efeitos, e bgm para músicas de fundo.

int oslDeleteSound();

Delete um som.

void oslSetSoundLoop(OSL_SOUND *s, int loop);

Seta se o som deve ser tocado em loop (seguidamente) após seu término.