// bitmap01.cpp
// Esse programa testa funções de bitmap
#include "DarkGDK.h"
void initsys(); // inicializa o sisema
void tst_bitmap01(); // testa funções de bitmap
void virar_bmp(void); // Vira a imagem bitmap
void espelhar_bmp(void); // Espelha a imagem bitmap
void menu(void); // Apresenta um menu de opções
void info_bmp(void); // Mostra informações sobre o bitmap
void carregar_mostrar_bmp(void); // Carrega e mostra o bitmap
int igual(char *stecla, char *txt); // Compara duas strins
// Copia parte de um bitmap para uma área de destino
void tst_copiar_bmp(int nEsquerda, int nTopo, int nDireita, int nFundo);
// Cores
const int nPreto = 0;
const int nBranco = 0xFFFFFF;
// ----------------------------------------------------------------------------
void DarkGDK ( void ) {
// Começo da aplicação DarkGdk
initsys();
carregar_mostrar_bmp();
while ( LoopGDK ( ) ) {
menu();
tst_bitmap01();
info_bmp();
if (dbEscapeKey()==1) {
MessageBox (0,"Saindo do programa", "bitmap01.cpp", MB_OK);
dbDeleteBitmap(1);
return;
} // fim do if
dbSync ( );
} // fim do while
return;
} // fim da função: DarkGDK
// ----------------------------------------------------------------------------
void initsys() {
// Esta função inicializa o sistema
dbSyncOn( ); dbSyncRate (60);
dbDisableEscapeKey();
dbCLS(nBranco);
dbInk(nPreto, nBranco);
// Configurando a janela
dbSetWindowTitle("bitmap01.cpp");
dbSetTextOpaque();
} // fim da função: initsys()
// ----------------------------------------------------------------------------
void tst_bitmap01 () {
char *stecla;
stecla = dbInKey();
if (igual(stecla,"l")) {
carregar_mostrar_bmp();
} // fim do if
if (igual(stecla,"f")) {
virar_bmp();
} // fim do if
if (igual(stecla,"m")) {
espelhar_bmp();
} // fim do if
if (igual(stecla,"c")) {
tst_copiar_bmp(0,0,127,127);
} // fim do if
if (igual(stecla,"b")) {
dbBlurBitmap(1,5);
dbCopyBitmap(1,0);
} // fim do if
if (igual(stecla,"d")) {
dbFadeBitmap(1,80);
dbCopyBitmap(1,0);
} // fim do if
} // fim tst_bitmap01()
// ----------------------------------------------------------------------------
void menu(void) {
dbSetCurrentBitmap(0);
dbText( 10, 300, "l- dbLoadBitmap()"); dbText( 210, 300, "d- dbFadeBitmap()");
dbText( 10, 320, "m- dbMirrorBitmap()"); dbText( 210, 320, "b- dbBlurBitmap()");
dbText( 10, 340, "f- dbFlipBitmap()"); dbText( 210, 340, "c- dbCopyBitmap()");
} // fim menu()
// ----------------------------------------------------------------------------
int igual(char *stecla, char *txt) {
int res=0;
res = strcmp(stecla, txt);
return !res;
} // fim igual()
// ----------------------------------------------------------------------------
void carregar_mostrar_bmp(void) {
dbLoadBitmap("c://gameprog//gdkmedia//bitmap//textura.bmp",1);
dbCopyBitmap(1,0);
} // fim loadbmp()
// ----------------------------------------------------------------------------
void tst_copiar_bmp(int nEsquerda, int nTopo, int nDireita, int nFundo) {
const int bmpFonte = 1;
const int bmpDestino = 0;
int esquerdaAlvo = 300;
int topoAlvo = 0;
int direitaAlvo = 428;
int fundoAlvo = 120;
dbCopyBitmap(bmpFonte,
nEsquerda, nTopo, nDireita,nFundo,
bmpDestino,
esquerdaAlvo, topoAlvo, direitaAlvo, fundoAlvo);
} // fim tst_copiar_bmp
// ----------------------------------------------------------------------------
void virar_bmp() {
dbFlipBitmap(1);
dbCopyBitmap(1,0);
} // fim virar_bmp()
// ----------------------------------------------------------------------------
void espelhar_bmp() {
dbMirrorBitmap(1);
dbCopyBitmap(1,0);
} // fim espelhar_bmp()
// ----------------------------------------------------------------------------
void info_bmp() {
char txt[255];
int nlargura, nAltura, nprofundidade;
int nvirado, nEspelhado;
// Obtendo os dados do bitmap 1
nlargura = dbBitmapWidth(1);
nAltura = dbBitmapHeight(1);
nprofundidade = dbBitmapDepth(1);
nvirado = dbBitmapFlipped(1);
nEspelhado = dbBitmapMirrored(1);
// Mostrando os dados
dbSetCurrentBitmap(0);
sprintf(txt, "Largura: %d Altura:%d Profundidade: %d",
nlargura, nAltura, nprofundidade);
dbText (10,260, txt);
sprintf(txt, "Virado: %d Espelhado: %d", nvirado, nEspelhado);
dbText (10,280, txt);
} // fim info_bmp()
Carregando o bitmap
dbLoadBitmap ( sArquivo )
void dbLoadBitmap ( char* szFilename )
dbLoadBitmap("c://gameprog//gdkmedia//bitmap//textura.bmp");
Nesta primeira versão, esta função carrega e mostra o arquivo bitmap
especificado.
dbLoadBitmap ( sArquivo, nbmp)
void dbLoadBitmap ( char* szFilename, int iBitmap )
dbLoadBitmap("c://gameprog//gdkmedia//bitmap//textura.bmp",1);
Nesta segunda versão, esta função carrega o arquivo bitmap especificado
assinalando ao mesmo o número de handle nbmp. Repare que para mostrar
esse bitmap você deve copiá-lo para o bitmap zero com dbCopyBitmap(nbmp,0).
Deletando o bitmap
dbDeleteBitmap ( nbmp )
void dbDeleteBitmap ( int iBitmap )
dbDisableEscapeKey();
if (dbEscapeKey()==1) {
MessageBox (0,"Saindo do programa", "bitmap01.cpp", MB_OK);
dbDeleteBitmap(1);
return;
} // fim do if
Quando não for mais utilizar o bitmap delete-o com dbDeleteBitmap(). Isso
libera mais memória para seu programa. Em nosso programa tivemos o cuidado
de mudar o fechamento do programa para garantir a deleção do bitmap
utilizado.
Aplicando efeitos sobre o bitmap
Na Darkgdk você pode virar e/ou espelhar o bitmap, pode aplicar o efeito de
esmaecimento (fade) ou pode aplicar o efeito de borrar (blur). Veja abaixo
as funções que aplicam esses efeitos:
dbFlipBitmap (nbmp)
void dbFlipBitmap ( int iBitmap )
dbFlipBitmap(1);
Inverte verticalmente o bitmap nbmp especificado.
---------------------------------------------------------------------------
dbMirrorBitmap (nbmp)
void dbMirrorBitmap ( int iBitmap )
dbMirrorBitmap(1);
Inverte horizontalmente o bitmap nbmp especificado.
---------------------------------------------------------------------------
dbFadeBitmap (nbmp, nfade)
void dbFadeBitmap ( int iBitmap, int iFade )
dbBlurBitmap(1,5);
Aplica uma taxa (nfade) de esmaecimento no bitmap (nbmp) especificado.
---------------------------------------------------------------------------
dbBlurBitmap (nbmp, nblur)
void dbBlurBitmap ( int iBitmap, int iBlur )
dbFadeBitmap(1,80);
Aplica uma taxa (nblur) do efeito borrar no bitmap (nbmp) especificado.
---------------------------------------------------------------------------
Obtendo os dados do bitmap
nlargura = dbBitmapWidth(1); // Retorna a largura do bitmap
nAltura = dbBitmapHeight(1); // Retorna a altura do bitmap
nprofundidade = dbBitmapDepth(1); // Profundidade de cor do bitmap
nvirado = dbBitmapFlipped(1); // Retorna 1 se bitmap está virado
nEspelhado = dbBitmapMirrored(1); // Retorna 1 se bitmap está espelhado
As funções acima obtém informações importantes do bitmap como largura, altura,
profundidade de cor, se o bitmap está virado e/ou espelhado. Você precisa
passar um bitmap como referência e definir uma variável inteira para receber
o resultado.
Copiando bitmaps - primeira sintaxe
dbCopyBitmap ( nbmp_fonte, nbmp_destino)
void dbCopyBitmap ( int iFrom, int iTo )
dbCopyBitmap(1,0);
Nesta sintaxe mais simples essa função copia um bitmap fonte (nbmp_fonte)
para dentro de um bitmap destino (nbmp_destino).
Copiando bitmaps - segunda sintaxe
Agora na sintaxe abaixo, você consegue copiar um quadro parcial do bitmap
fonte para um quadro parcial do bitmap de destino. E isso dá origem a uma
função muito complexa com 10 argumentos:
dbCopyBitmap(bmpFonte, nEsquerda, nTopo, nDireita,nFundo,
bmpDestino, esquerdaAlvo, topoAlvo, direitaAlvo, fundoAlvo);
Observe atentamente o desenho abaixo que ilustra os argumentos dessa função:
void tst_copiar_bmp(int nEsquerda, int nTopo, int nDireita, int nFundo) {
const int bmpFonte = 1;
const int bmpDestino = 0;
int esquerdaAlvo = 300;
int topoAlvo = 0;
int direitaAlvo = 428;
int fundoAlvo = 120;
dbCopyBitmap(nbmpFonte,
nEsquerda, nTopo, nDireita,nFundo,
nbmpDestino,
esquerdaAlvo, topoAlvo, direitaAlvo, fundoAlvo);
} // fim tst_copiar_bmp
Descrição dos argumentos:
nbmpFonte - Bitmap fonte
nbmpDestino - Bitmap de destino
nEsquerda, nTop - Canto superior esquerdo do bitmap fonte
nDireita, nFundo - Canto inferior direito do bitmap fonte
esquerdaAlvo, topoAlvo - Canto superior esquerdo do bitmap destino
direitaAlvo, fundoAlvo - Canto inferior direito do bitmap de destino
(*) Com apenas dois pontos diagonais qualquer função consegue mapear
um quadrado completo, fazendo um jogo de somas e subtrações com esses
dois pontos para localizar os pontos restantes. Algumas funções da
Darkgdk e muitas funções da biblioteca do Windows utilizam esse esquema
para tratar regiões quadradas.
Estabelecendo o bitmap corrente para as operações gráficas
dbSetCurrentBitmap(nbmp)
Esta função configura o bitmap nbmp para receber as operações gráficas.
Todas as funções gráficas vão operar sobre esse bitmap selecionado.
É interessante que você pode desenhar sobre um bitmap nos bastidores do
programa e depois mostrar o resultado.
nbmp = dbCurrentBitmap()
Esta função retorna o bitmap corrente o qual está sofrendo as operações
gráficas.