Manual do programador
 última modificação: 23/03/2010

NOTAS IMPORTANTES:

  1. Se você está lendo este documento através do site oficial da GameSpaceLib, assume-se que você esteja utilizando a última versão da GameSpaceLib disponível à partir da data de modificação acima.

  2. Alguns parâmetros const foram omitidos na exibição dos escopos dos métodos e funções para facilitar a visualização.

  3. Alguns métodos não verificam se os ponteiros passados são válidos ou não (ex.: NULL), portanto tenha cuidado ao omitir um ponteiro.

  4. Fique atento aos parâmetros com valor default nas funções e métodos. Estes poderão ser omitidos.

  5. Fique atento às funções e métodos sobrecarregados. Suas variações podem oferecer parâmetros adicionais úteis ou simplificações.

  6. Todas as funções booleanas retornam true caso tenham sido executadas com sucesso. Caso retornem false, a função gsShowLastError pode ser usada para obter mais informações sobre o erro.

  7. As funções em métodos com sufixo F realizam a mesma operação que suas versões sem F porém trabalhando com float.

  8. Importante: os métodos SetupProc, BeginSpriteScene e EndSpriteScene são considerados obsoletos à partir da versão 1.4.0. Esta alteração se deu em virtude da possibilidade de tornar a programação ainda mais fácil. O método GAMESPACE_VIDEO_HANDLER::ManageLoop deve ser usado no lugar dos métodos obsoletos.
    Este método foi escrito para ser chamado uma vez a cada execução do laço principal do programa para executar todas as operações de back/front buffer e tratamento de mensagens.
    À partir da versão 1.4.0 recomenda-se o uso desse método ao invés de aplicar SetupProc, BeginSpriteScene e EndSpriteScene manualmente.

ÍNDICE

ÍNDICE DE FUNCIONALIDADES

class GAMESPACE_VIDEO_HANDLER
{

};

 

class GAMESPACE_INPUT_HANDLER
{

}

 

class GS_SPRITE
{

};

 

class GAMESPACE_AUDIO_HANDLER
{

};

 

class GS_AUDIO_SAMPLE
{

  • LoadSample: carrega uma faixa de áudio de um arquivo

  • LoadSample: carrega uma faixa de áudio de um arquivo armazenado na memória virtual (sobrecarga)

  • Destroy: apaga a faixa de áudio

  • GetStatus: retorna o estado de reprodução da faixa

  • GetType: retorna o tipo da faixa

  • Play: reproduz a faixa

  • IsPlaying: informa se a faixa está sendo tocada

  • SetLoop: configura o modo de repetição da faixa

  • GetLoop: informa se a faixa está em modo de repetição

  • Pause: pausa a reprodução da faixa

  • Stop: pára a reprodução da faixa

  • SetVolume: altera o volume da faixa

  • GetVolume: retorna o valor de volume da faixa

  • SetSpeed: altera a velocidade/freqüência da faixa

  • GetSpeed: informa a velocidade/freqüência da faixa

  • SetPan: ajusta a posição da faixa

  • GetPan: informa a posição da faixa

};

 

class GAMESPACE_MEDIA_PLAYER
{

};

 

 

class GAMESPACE_VIDEO_HANDLER

  • GS_VIDEO_MODE GAMESPACE_VIDEO_HANDLER::GetVideoMode(int nMode)
    Este método disponibiliza ao usuário a lista com todos os modos de vídeo suportados pela placa de vídeo primária e o monitor (ex.: 640x480x16, 800x600x16, 1024x768x16, ...). nMode é o valor do modo de vídeo dentro do índice interno e pode estar entre 0 e GAMESPACE_VIDEO_HANDLER::GetVideoModeCount()-1.
    O valor de retorno é uma estrutura GS_VIDEO_MODE correspondente ao modo escolhido com nMode.
    Para obter uma lista com todos os modos de vídeo suportados, siga o seguinte exemplo:

       const int total_de_modos = gsVideo.GetVideoModeCount();
      for (int t=0; t<total_de_modos; t++)
      {
          GS_VIDEO_MODE mode = gsVideo.GetVideoMode(t);
          fazer_algo(mode);
      }
    Consulte a pasta de exemplos do SDK para um exemplo de uso deste método.

    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o recurso de enumeração de modos de vídeo está disponível somente para a versão Windows da GameSpaceLib.

  • int GAMESPACE_VIDEO_HANDLER::GetVideoModeCount()
    Retorna a quantidade de modos de vídeo suportados pela placa de vídeo e o monitor.

     Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o recurso de enumeração de modos de vídeo está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::StartApplication
    (
      int x,
      int y,
      char *szWinTitle,
      bool bWindowed,
      bool bSync,
      GS_PIXEL_FORMAT pfBB = GSPF_UNKNOWN,
      bool bMaximizable = false
    )
    Abre uma nova janela e a prepara para os gráficos.
        const int x
                Largura em pixels da janela
        const int y
                Altura em pixels da janela
        char *szWinTitle
                String terminada em NULL que define o título da janela
        const bool bWindowed
                true para modo janela e false para modo fullscreen
        const bool bSync
                true para habilitar o trancamento da taxa de quadros por segundo em 60 e false para desenhar cada quadro imediatamente
        const GS_PIXEL_FORMAT pfBB
                Constante que especifica a quantidade de bits para cor do back buffer. Ver GS_PIXEL_FORMAT.
         const bool bMaximizable
          true para habilitar o botão "Maximize" da janela e false para desabilitar.
    Caso seja escolhido o modo fullscreen, tenha certeza de que seu monitor e a placa de vídeo suportem a dimensão de janela definida em x e y.
    Só é permitida uma janela por aplicação. Para abrir uma nova janela é necessário que a antiga seja encerrada com GAMESPACE_VIDEO_HANDLER::Destroy.

  • void GAMESPACE_VIDEO_HANDLER::QuitApplication()
    Envia um sinal interno requisitando o fechamento do programa. Esse método força GAMESPACE_VIDEO_HANDLER::SetupProc a retornar GSPROC_QUIT e GAMESPACE_VIDEO_HANDLER::ManageLoop a retornar false.

  • bool GAMESPACE_VIDEO_HANDLER::ManageLoop()
    Trata automaticamente dos eventos do sistema, exibe o que está no back buffer (se houver algo) e prepara o back buffer para o desenho direto de sprites.
    Retorna true caso tenha obtido sucesso ou false caso o usuário do programa tenha requisitado seu encerramento.

    Este método foi implementado à partir da versão 1.4.0 da GSlib e foi escrito para ser chamado uma vez a cada execução do laço principal do programa para executar todas as operações de back/front buffer e tratamento de mensagens.
    À partir da versão 1.4.0 recomenda-se o uso desse método ao invés de aplicar SetupProc, BeginSpriteScene e EndSpriteScene manualmente.
    Os laços principais nas versões anteriores seguiam a seguinte lógica:

       for (;;)
          {
              // forma obsoleta de laço principal da GSlib:
              const GS_PROC_STATUS status = gsVideo.SetupProc();
              if (status == GSPROC_QUIT)
                  break;
              else
                  if (status == GSPROC_SKIP)
                      continue;
              gsVideo.BeginSpriteScene(GS_ARGB(255,0,64,128));
                  // Desenha tudo...
              gsVideo.EndSpriteScene();
              gsInput.UpdateInputData();
          }

    Agora, com a implementação do método ManageLoop, o laço principal fica simplesmente assim:

       while (gsVideo.ManageLoop())
          {
              gsInput.UpdateInputData();
              // Desenha tudo...
          }

    Apesar de recomendado, o uso do método ManageLoop é opcional, e programas que utilizam a forma antiga de laço ainda funcionarão normalmente.

  • bool GAMESPACE_VIDEO_HANDLER::ResetVideoMode(GS_VIDEO_MODE mode, bool bToogleFullscreen)
    Redefine a resolução da tela ou janela para a configuração especificada em mode. Veja GS_VIDEO_MODE.
    Este método pode ser usado para permitir que o usuário escolha a resolução da tela ou da janela, em tempo do execução, sem alterar em nada o andamento do programa.
    Se bToogleFullscreen for true, então o modo de janela será trocado: se estiver em janela irá para fullscreen e se estiver em fullscreen irá para janela.
    Este método deve ser chamado somente se a janela ou tela fullscreen já foi criada e não pode ser chamado entre os métodos GAMESPACE_VIDEO_HANDLER::BeginSpriteScene e EndSpriteScene.
    Consulte a pasta de exemplos do SDK para um exemplo de uso deste método.

  • bool GAMESPACE_VIDEO_HANDLER::ResetVideoMode(int x, int y, GS_PIXEL_FORMAT pfBB, bool bToogleFullscreen)
    Redefine a resolução da tela ou janela. Define a largura para x, a altura para y e o modo de cor para pfBB. Veja GS_PIXEL_FORMAT.
    Se bToogleFullscreen for true, então o modo de janela será trocado: se estiver em janela irá para fullscreen e se estiver em fullscreen irá para janela.
    Este método pode ser usado para permitir que o usuário escolha a resolução da tela ou da janela, em tempo do execução, sem alterar em nada o andamento do programa.
    Este método deve ser chamado somente se a janela ou tela fullscreen já foi criada e não pode ser chamado entre os métodos GAMESPACE_VIDEO_HANDLER::BeginSpriteScene e EndSpriteScene.
    Consulte a pasta de exemplos do SDK para um exemplo de uso deste método.

  • bool GAMESPACE_VIDEO_HANDLER::SetWindowTitle(char *szTitle)
    Redefine o título da janela. String terminada em '\0' (NULL) pode possuir até 512 caracteres.

  • bool GAMESPACE_VIDEO_HANDLER::GetWindowTitle(char *szOutTitle)
    Coloca em szOutTitle o atual título da janela. É de responsabilidade do programador não permitir que a dimensão da string passada como parâmetro seja menor que a quantidade de caracteres no título mais um (para o caractere '\0' (NULL)).

  • bool GAMESPACE_VIDEO_HANDLER::WindowVisible()
    Somente útil no modo de janela (windowed). Retorna false se a janela estiver minimizada e true se estiver maximizada.

  • bool GAMESPACE_VIDEO_HANDLER::WindowInFocus()
    Somente útil no modo de janela (windowed). Retorna true se a janela estiver com o foco no sistema e false se não estiver com o foco.

  • GS_VECTOR2i GAMESPACE_VIDEO_HANDLER::GetScreenDim()
    Retorna a largura e altura da janela.

  • GS_VECTOR2 GAMESPACE_VIDEO_HANDLER::GetScreenDimF()
    Retorna a largura e altura da janela.

  • GS_PROC_STATUS GAMESPACE_VIDEO_HANDLER::SetupProc()
    Este método é obsoleto: MAIS INFORMAÇÕES
    Retorna uma instrução do sistema operacional para o programa. Deve ser verificado antes de executar qualquer outra operação dentro do laço central da aplicação. As possibilidades de retorno são as seguintes:
       GSPROC_OK: informa que o quadro pode ser executado e desenhado normalmente. 
       GSPROC_QUIT: informa que o usuário executou um comando para fechar a janela.
       GSPROC_SKIP: informa que a execução do quadro atual assim como seu desenho devem ser pulados. Este valor é retornado quando a janela está minimizada ou fora do foco do sistema.
     É fundamental que SetupProc esteja presente logo no início de cada laço e que seja utilizado corretamente (conforme os exemplos) pois é esta função a responsável por realizar as operações de recuperação de modo de vídeo.

  • void GAMESPACE_VIDEO_HANDLER::Destroy()
    Apaga todos os dados que foram alocados pelo objeto e fecha a janela.

  • unsigned long GAMESPACE_VIDEO_HANDLER::GetElapsedTime(GS_TIME_UNITY unity = GSTU_MILLISECONDS)
    Retorna o tempo que se passou desde que a janela foi iniciada (do exato momento em que GAMESPACE_VIDEO_HANDLER::StartApplication foi concluída). O parâmetro unity informa se a função deve retornar este tempo em milisegundos, segundos, minutos ou horas. Veja GS_TIME_UNITY.
    O valor de retorno dessa função será do tipo inteiro, sendo que 1.9 será arredondado para 1. Para obter mais precisão de timer, utilize GAMESPACE_VIDEO_HANDLER::GetElapsedTimeF.

  • float GAMESPACE_VIDEO_HANDLER::GetElapsedTimeF(GS_TIME_UNITY unity = GSTU_MILLISECONDS)
    Retorna o tempo que se passou desde que a janela foi iniciada (do exato momento em que GAMESPACE_VIDEO_HANDLER::StartApplication foi concluída). O parâmetro unity informa se a função deve retornar este tempo em milisegundos, segundos, minutos ou horas. Veja GS_TIME_UNITY.
    O valor de retorno dessa função possuirá ponto flutuante, sendo 1.5f de hora equivalente a uma hora e meia.

  • void GAMESPACE_VIDEO_HANDLER::SetWindowPosition(GS_VECTOR2i v2)
    Define uma nova posição para a janela com relação à tela do computador.
    Este método pode ser chamado antes de GAMESPACE_VIDEO_HANDLER::StartApplication, dessa forma a janela já será exibida na posição pré-definida inicialmente.
    Caso o modo tela-cheia (fullscreen) esteja sendo utilizado, este método será ignorado.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_VECTOR2i GAMESPACE_VIDEO_HANDLER::GetWindowPosition()
    Retorna a posição, em pixels, da janela com relação a tela do computador.

  • GS_VECTOR2i GAMESPACE_VIDEO_HANDLER::GetSystemScreenDim()
    Este método retorna a resolução (largura x e altura y), em pixels, da tela do sistema. Quando a aplicação está em modo fullscreen, esse valor passa a ser igual à a resolução do back-buffer. Já em modo windowed, a resolução do sistema é mantida independentemente da resolução do back-buffer.
    Com este método é possível centralizar a janela da aplicação de acordo com a tela do sistema operacional.

    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • void GAMESPACE_VIDEO_HANDLER::Message
    (
      char *szText,
      GS_MESSAGE_TYPE type
    )
    Exibe uma mensagem em caixa de texto para o usuário. A execução do programa será interrompida até que o botão OK seja pressionado. szText corresponde ao texto a ser exibido na mensagem. type corresponde ao tipo da mensagem, veja GS_MESSAGE_TYPE.

  • bool GAMESPACE_VIDEO_HANDLER::PrintText
    (
      GS_VECTOR2 v2Pos,
      char *szText,
      char *szFont,
      float fSize,
      GS_COLOR dwColor
    )
    Desenha uma string na tela.
        GS_VECTOR2 v2Pos
                Pontos X e Y onde começará a string
        const char *szText
                String terminada em NULL a ser desenhada na tela
        const char *szFont
                String terminada em NULL que informa o nome da fonte. As fones disponíveis são as mesmas do sistema (pasta $WINDOWS\Fonts). Para utilizar bitmap fonts ao invés de fontes true-type basta especificar o nome do bitmap (ex.: "Space_font.png"). A fonte em bitmap precisa possuir todos os 256 elementos da tabela ASCII ordenados em ordem crescente e estarem organizados na forma de grade de 16x16 caracteres.
        const float fSize
                Escala da fonte. Se szFont estiver especificando uma fonte de bitmap, este valor pode ser definido como 0.0f para manter o tamanho original da fonte no bitmap.
        GS_COLOR dwColor
                Cor da fonte no formato hexadecimal 32-bit (alpha/r/g/b - 0xAARRGGBB)
     Ver GS_COLOR.
    Dica de portabilidade: caso você não esteja utilizando a versão Windows da GameSpaceLib, certifique-se de que o arquivo TTF (TrueType) da fonte especificada seja definido com o caminho relativo ao executável do projeto (exemplo: fontes_do_jogo\Verdana.ttf).

  • bool GAMESPACE_VIDEO_HANDLER::SetTextRect(GS_VECTOR2i rect)
    Define o tamanho x (largura) e y (altura), em pixels, do retângulo de recorte do texto. Após a chamada desse método, todo o texto desenhado com GAMESPACE_VIDEO_HANDLER::PrintText que exceder a altura e largura do retângulo, será cortado (os pixels não serão desenhados). Utilize o método GAMESPACE_VIDEO_HANDLER::UnsetTextRect para desfazer o que foi criado por este método e permitir que todo o texto seja desenhado sempre.

  • GS_VECTOR2i GAMESPACE_VIDEO_HANDLER::GetTextRect()
    Retorna a altura (y) e largura (x) do retângulo de recorte de texto definido em GAMESPACE_VIDEO_HANDLER::SetTextRect.

  • void GAMESPACE_VIDEO_HANDLER::UnsetTextRect()
    Desfaz as operações feitas por GAMESPACE_VIDEO_HANDLER::SetTextRect e permite que todo o texto seja desenhado por completo na tela.

  • bool GAMESPACE_VIDEO_HANDLER::SetScissor(GS_2DRECT rect)
    Define o retângulo de recorte geral da tela. Se este método for utilizado, os pixels dos próximos sprites a serem desenhados só serão desenhados se estiverem dentro do retângulo aqui definido.     Utilize o método GAMESPACE_VIDEO_HANDLER::UnsetScissor para desfazer o que foi criado por este método e permitir que todos os sprites sejam desenhados em todo o back buffer.

  • GS_2DRECT GAMESPACE_VIDEO_HANDLER::GetScissor()
    Retorna do retângulo de recorte atual, definido pela função GAMESPACE_VIDEO_HANDLER::SetScissor.
     

  • void GAMESPACE_VIDEO_HANDLER::UnsetScissor()
    Desfaz a operação feita por GAMESPACE_VIDEO_HANDLER::SetScissor. Todos os sprites serão desenhados em todo o back buffer. O valor interno do retângulo será zerado, dessa forma, o método GAMESPACE_VIDEO_HANDLER::GetScissor retornará um retângulo zerado.

  • void GAMESPACE_VIDEO_HANDLER::SetBGColor(GS_COLOR dwBGColor)
    Define a cor padrão no formato hexadecimal (alpha/r/g/b - 0xAARRGGBB) que será utilizada para limpar o back buffer caso o argumento de GAMESPACE_VIDEO_HANDLER::BeginSpriteScene seja omitido. Ver GS_COLOR.

  • GS_COLOR GAMESPACE_VIDEO_HANDLER::GetBGColor()
    Retorna a cor padrão do fundo da tela. Este valor é definido para todos pixels do back buffer toda vez que os métodos GAMESPACE_VIDEO_HANDLER::EndScene ou GAMESPACE_VIDEO_HANDLER::EndSpriteScene são chamados. Ver GS_COLOR.

  • bool GAMESPACE_VIDEO_HANDLER::BeginSpriteScene(GS_COLOR dwBGColor = GS_COLOR(0,0,0,0))
     Este método é obsoleto: MAIS INFORMAÇÕES
    Inicia o processo de desenho gráfico. Deve ser chamado toda a vez que o processo de desenho for iniciado em cada quadro no laço principal. dwBGColor define a cor no formato hexadecimal (alpha/r/g/b - 0xAARRGGBB) que será utilizada para limpar o back buffer. Ver GS_COLOR.

  • bool GAMESPACE_VIDEO_HANDLER::EndSpriteScene()
    Este método é obsoleto: MAIS INFORMAÇÕES
    Finaliza o processo iniciado por GAMESPACE_VIDEO_HANDLER::BeginSpriteScene e encerra o processo de desenho.

  • bool GAMESPACE_VIDEO_HANDLER::DrawLine
    (
      GS_VECTOR2 p1,
      GS_VECTOR2 p2,
      GS_COLOR dwColor1,
      GS_COLOR dwColor2
    )
    Desenha uma reta na tela.
        GS_VECTOR2 p1
                Posição, em pixels, do ponto A da reta.
        GS_VECTOR2 p2
                Posição, em pixels, do ponto B da reta.
        GS_COLOR dwColor1
                Cor, em ARGB, do ponto A da reta.
        GS_COLOR dwColor2
                Cor, em ARGB, do ponto B da reta.
    As cores do ponto A e B da reta serão interpolados de uma ponta a outra. Ver GS_COLOR.

  • void GAMESPACE_VIDEO_HANDLER::SetLineWidth(const float fWidth)
    Define a largura, em pixels, da linha a ser desenhada com GAMESPACE_VIDEO_HANDLER::DrawLine. O valor padrão é 1.0f.

  • float GAMESPACE_VIDEO_HANDLER::GetLineWidth()
    Retorna a largura atual da linha. Valor definido por GAMESPACE_VIDEO_HANDLER::SetLineWidth.

  • bool GAMESPACE_VIDEO_HANDLER::DrawRectangle
    (
      GS_VECTOR2 v2Pos,
      GS_VECTOR2 v2Size,
          GS_COLOR dwColor0,
          GS_COLOR dwColor1,
          GS_COLOR dwColor2,
          GS_COLOR dwColor3,
      float fAngle = 0.0f,
      GS_SPRITE_ORIGIN origin = GSSO_DEFAULT
    )
    Desenha um retângulo na tela.
        GS_VECTOR2 v2Pos
                Posição, em pixels, da origem do retângulo. A origem do retângulo dependerá do que for passado em origin.
        GS_VECTOR2 v2Size
                Tamanho, em pixels, do retângulo.
        GS_COLOR dwColor0
                Cor, em ARGB, do vértice superior esquerdo do retângulo.
        GS_COLOR dwColor1
                Cor, em ARGB, do vértice superior direito do retângulo.
        GS_COLOR dwColor2
                Cor, em ARGB, do vértice inferior esquerdo do retângulo.
        GS_COLOR dwColor3
                Cor, em ARGB, do vértice inferior direito do retângulo.
        const float fAngle
                Ângulo, em graus, de rotação para o retângulo.
        GS_SPRITE_ORIGIN origin
                Ponto de origem, em pixels, para a orientação e rotação do retângulo. Ver GS_SPRITE_ORIGIN.
    Caso sejam enviadas cores diferentes como parâmetro, elas serão interpoladas suavemente entre os vértices do quadrado. O valor alpha de transparência dos vértices também será interpolado.     Ver GS_COLOR.

  • bool GAMESPACE_VIDEO_HANDLER::DrawRectangle(GS_VECTOR2 v2Pos, GS_VECTOR2 v2Size, GS_COLOR dwColor, float fAngle = 0.0f, GS_SPRITE_ORIGIN origin = GSSO_DEFAULT)
    Desenha um retângulo na tela.
       GS_VECTOR2 v2Pos
                Posição, em pixels, da origem do retângulo. A origem do retângulo dependerá do que for passado em origin.
        GS_VECTOR2 v2Size
                Tamanho, em pixels, do retângulo.
        GS_COLOR dwColor
                Cor, em ARGB, do retângulo.
        const float fAngle
                Ângulo, em graus, de rotação para o retângulo.
        GS_SPRITE_ORIGIN origin
                Ponto de origem, em pixels, para a orientação e rotação do retângulo. Ver GS_SPRITE_ORIGIN.
     Ver GS_COLOR.

  • bool GAMESPACE_VIDEO_HANDLER::DrawTriangleFan
    (
      int nVertexCount,
      GS_2DVERTEX *pVertex,
      GS_VECTOR2 v2Pos,
      float fAngle = 0.0f
    )
    Desenha um ou mais triângulos em formato de triangle fan.
        int nVertexCount
                Total de vértices contidos em pVertex.
         GS_2DVERTEX *pVertex
                Ponteiro para a array de vértices (no mínimo três).
       GS_VECTOR2 v2Pos
                Posição, em pixels, da origem dos triângulos.
        const float fAngle
                Ângulo, em graus, de rotação para os vértices.
    Veja GS_2DVERTEX.

  • bool GAMESPACE_VIDEO_HANDLER::SetAlphaMode(GS_ALPHA_MODE mode)
    Altera o modo de calcular a transparência dos sprites. Toda a vez que o método GAMESPACE_VIDEO_HANDLER::BeginSpriteScene for chamada, o valor é definido para GSAM_PIXEL. Ver GS_ALPHA_MODE.

  • GS_ALPHA_MODE GAMESPACE_VIDEO_HANDLER::GetAlphaMode()
    Retorna o modo de transparência atual. Este valor pode ser alterado com GAMESPACE_VIDEO_HANDLER::SetAlphaMode. Ver GS_ALPHA_MODE.

  • bool GAMESPACE_VIDEO_HANDLER::SetFilterMode(const GS_TEXTUREFILTER_MODE tfm)
    Define o critério para aplicação de filtro nas texturas (superfície de pixels dos sprites). Filtros são o que suavizam e tiram o aspecto "pixelado" das imagens quando são rotacionadas ou escaladas. O valor padrão (inicial) é GSTM_IFNEEDED. Veja GS_TEXTUREFILTER_MODE.

  • GS_TEXTUREFILTER_MODE GAMESPACE_VIDEO_HANDLER::GetFilterMode()
    Retorna o critério atualmente usado pela biblioteca para aplicação de filtro nas texturas (superfície de pixels dos sprites). Veja GS_TEXTUREFILTER_MODE.

  • bool GAMESPACE_VIDEO_HANDLER::HideCursor(bool bHide)
    true para esconde o cursor do mouse quando estiver sobre a janela e false para exibir.

  • bool GAMESPACE_VIDEO_HANDLER::IsCursorHidden()
    Retorna true se o cursor do mouse estiver escondido e false caso contrário.

  • bool GAMESPACE_VIDEO_HANDLER::Rendering(bool bHide)
    Retorna true se a aplicação estiver no processo de desenho de sprites (BeginSpriteScene foi chamada e EndSpriteScene ainda não). Caso contrário retorna false.

  • float GAMESPACE_VIDEO_HANDLER::GetFPSRate()
    Retorna o valor aproximado da atual taxa de quadros por segundo.

  • bool GAMESPACE_VIDEO_HANDLER::SaveScreenshot(const char *szName, const GS_BITMAP_FORMAT fmt = GSSF_BMP, GS_2DRECT rect = GS_2DRECT(0,0,0,0))
    Salva uma "foto" da tela e armazena no diretório e com o nome que for especificado em szName. Em fmt pode ser definido um formato de arquivo de imagem. Um retângulo em rect pode ser emitido para recortar uma área específica da tela.
     Nota importante: no momento em que esta documentação foi disponibilizada (veja a data no cabeçalho da página), somente a versão para Windows da GameSpaceLib suporta salvar screenshots em formato JPG (GSSF_JPG).

  • void GAMESPACE_VIDEO_HANDLER::EnableQuitKeys(bool bEnable)
    bEnable deve ser false para desabilitar o Alt+F4 e true para reabilitar. O valor padrão é true.
    Se esse método for utilizado para desabilitar o fechamento do programa via Alt+F4 em uma janela fullscreen, a única forma segura de fechar o programa será através do método GAMESPACE_VIDEO_HANDLER:: QuitApplication.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::QuitKeysEnabled()
    Retorna true se o Alt+F4 estiver habilitado, caso contrário retorna false.

    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetRenderTarget(GS_SURFACE_HANDLE pTarget, int nTarget = 0)
    Define o sprite que receberá os desenhos no lugar do back buffer. Este método é utilizado para aplicar desenhos em sprites do tipo render target.
    Em pTarget deve ser passado o valor retornado pelo método GS_SPRITE::GetTexture de um sprite válido do tipo render target (criado com GS_SPRITE::CreateRenderTarget).
    nTarget corresponde ao alvo onde queremos indexar o render target. O valor padrão é 0. Um valor superior a 0 para nTarget o fará somente acessível através de pixel shaders.
    Caso o sprite passado não tenha sido criado como render target (GS_SPRITE::CreateRenderTarget) este método irá falhar.
    Os métodos GAMESPACE_VIDEO_HANDLER::BeginTargetScene e GAMESPACE_VIDEO_HANDLER:: EndTargetScene devem ser utilizados para iniciar e encerrar o desenho no render target.

     Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::BeginTargetScene(GS_COLOR dwBGColor = GS_ZERO, bool bClear = true)
    Inicia o processo de desenho em um render target. Este método deve ser utilizado após GAMESPACE_VIDEO_HANDLER::SetRenderTarget, que define o sprite que receberá os desenhos no lugar do back buffer.
    Se bClear for igual a true, o alvo não terá seu conteúdo apagado.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::EndTargetScene()
    Encerra o processo de desenho em um render target. Veja GAMESPACE_VIDEO_HANDLER:: BeginTargetScene.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • int GAMESPACE_VIDEO_HANDLER::GetMaxRenderTargets()
    Retorna o máximo de render targets múltiplos suportados pelo sistema. Esses alvos são somente acessíveis através de pixel shaders. Veja GAMESPACE_VIDEO_HANDLER::SetRenderTarget.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • int GAMESPACE_VIDEO_HANDLER::GetProgramPath(char *szPath)
    Copia ao no string passado como parâmetro o caminho do diretório onde o executável que está rodando a GameSpaceLib se encontra. Ex.: "C:\Arquivos de programas\Meu jogo\Bin\".

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetCameraPos(const GS_VECTOR2 pos)
    Define a posição da câmera 2D. O ponto inicial padrão da câmera é (0,0). Ao manipular esse valor todos os sprites se deslocarão na direção contrária, simulando o efeito de scroll de câmera.
    O scroll é realizado dentro do shader padrão da GameSpaceLib e é aplicado somente às sprites (não afetando, por padrão, retângulos, linhas ou demais polígonos).

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::MoveCamera(const GS_VECTOR2 dir)
    Desloca a câmera 2D somando os valores de dir à posição interna da câmera. Provocando o scroll de todos os sprites. Ver GAMESPACE_VIDEO_HANDLER::SetCameraPos.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_VECTOR2 GAMESPACE_VIDEO_HANDLER::GetCameraPos()
    Retorna a posição interna da câmera. Ver GAMESPACE_VIDEO_HANDLER::SetCameraPos.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • int GAMESPACE_VIDEO_HANDLER::GetMaxMultitextures()
    Retorna a quantidade máxima de texturas simultâneas permitidas para os sprites.
    Multitexturas podem ser utilizadas para combinar várias imagens na superfície de um único sprite. Ideal para criar lightmaps entre outros efeitos.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetBlendMode(int nPass, GS_BLEND_MODE mode)
    Seta o tipo de cálculo que será utilizado para combinar as texturas simultâneas do sprite. nPass é o estágio de textura (à partir de 1) que será manipulado. Os valores possíveis para mode são:

    -GSBM_ADD: a cor dos pixels da textura que for enviada nesse estágio será somada à textura corrente.
    -GSBM_MODULATE: a cor dos pixels da textura que for enviada nesse estágio será multiplicada à textura corrente.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_BLEND_MODE GAMESPACE_VIDEO_HANDLER::GetBlendMode(int nPass)
    Retorna o tipo de cálculo que será utilizado para calcular a combinação da cor da textura do estágio nPass. Veja GAMESPACE_VIDEO_HANDLER::SetBlendMode.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::UnsetTexture(int nPass)
    Desliga a textura enviada no estágio nPass. Veja GAMESPACE_VIDEO_HANDLER::SetBlendMode.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetClamp(bool bSet)
    Set bSet for true, liga o texture-clamping. Caso contrário, desliga-o. Quando o texture-clamping está ligado, as coordenadas UV da textura dos sprite é trancada entre 0 e 1, isso significa que se a textura sofrer scroll ou for multiplicada, a imagem não irá se repetir sobre a superfície do sprite.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::GetClamp()
    Retorna true se o texture-clamping estiver ligado, false caso contrário. Veja GAMESPACE_VIDEO_HANDLER::SetClamp.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetSpriteDepth(float fDepth)
    Especifica um valor (de 0.0f a 1.0f) para a profundidade dos pixels do sprite. Caso o z-test e o z-write estejam ligados, os sprites com menor valor de depth (profundidade) serão desenhados na frente.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • float GAMESPACE_VIDEO_HANDLER::GetSpriteDepth()
    Retorna a profundidade atual do sprite no z-buffer. Veja GAMESPACE_VIDEO_HANDLER::SetSpriteDepth.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetZBuffer(bool bEnable)
    Liga/desliga o z-test. Caso o z-test e o z-write estejam ligados, os sprites com menor valor de depth (profundidade) serão desenhados na frente. Veja GAMESPACE_VIDEO_HANDLER::SetSpriteDepth.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::GetZBuffer()
    Retorna true se o z-test estiver ligado e false caso contrário. Veja GAMESPACE_VIDEO_HANDLER:: SetZBuffer.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::SetZWrite(bool bEnable)
    Liga/desliga o z-write. Quando o z-write está desligado e o z-test ligado, os sprites sofrem z-test porém não adicionam novos valores de profundidade ao z-buffer.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::GetZWrite()
    Retorna true se o z-write estiver ligado e false caso contrário. Veja GAMESPACE_VIDEO_HANDLER:: SetZWrite.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • void GAMESPACE_VIDEO_HANDLER::SetRectMode(GS_RECT_MODE mode)
    Altera a quantidade de primitivas que serão usadas para desenhar os sprites. Esta mudança permite diferentes efeitos de distorção com vertex shaders. Veja GS_RECT_MODE.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_RECT_MODE GAMESPACE_VIDEO_HANDLER::GetRectMode()
    Informa a quantidade de primitivas que estão sendo usadas para desenhar os sprites. Veja GS_RECT_MODE.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • void GAMESPACE_VIDEO_HANDLER::RoundUpPosition(const bool bRoundUp)
    true para que a posição final do sprite seja arredondada para um valor inteiro sempre que for desenhado, evitando desalinhamento pixel-texel. O valor padrão é false.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GAMESPACE_VIDEO_HANDLER::IsRoundingUpPosition()
    Retorna true se a posição final dos sprites está sendo arredondada.

    Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.


 

class GAMESPACE_INPUT_HANDLER

  • bool GAMESPACE_INPUT_HANDLER::RegisterInputDevice(void *pData)
    Cria e prepara o objeto para receber os comandos dos dispositivos de entrada: teclado, mouse e joysticks (se houver algum conectado ao computador). pData é reservado e deve ser definido como NULL.

  • bool GAMESPACE_INPUT_HANDLER::UpdateInputData()
    Atualização interna para controle dos dispositivos de entrada. Deve ser chamada uma vez a cada quadro no laço principal.

  • void GAMESPACE_INPUT_HANDLER::Destroy()
         Apaga a memória alocada pelo objeto. Deve ser chamada antes de encerrar o programa.

  • GS_KEY_STATE GAMESPACE_INPUT_HANDLER::KeyState(GS_KEY GSKey)
    Retorna o estado da tecla definida em GSKey. Consulte GS_KEY.

  • bool GAMESPACE_INPUT_HANDLER::KeyDown(GS_KEY GSKey)
    Retorna true caso a tecla esteja sendo pressionada, caso contrário retorna false.

  • GS_VECTOR2i GAMESPACE_INPUT_HANDLER::GetMouseMove()
         Retorna um valor de x e y que corresponde à direção, em pixels em screen space, percorrida pelo mouse neste frame.

  • GS_VECTOR2 GAMESPACE_INPUT_HANDLER::GetMouseMoveF()
     Retorna o mesmo valor que GAMESPACE_INPUT_HANDLER::GetMouseMove porém convertido em float.

  • GS_KEY_STATE GAMESPACE_INPUT_HANDLER::GetLeftClickState()
     Retorna o estado do botão esquerdo do mouse. Consulte GS_KEY_STATE.

  • GS_KEY_STATE GAMESPACE_INPUT_HANDLER::GetRightClickState()
     Retorna o estado do botão direito do mouse. Consulte GS_KEY_STATE.

  • GS_KEY_STATE GAMESPACE_INPUT_HANDLER::GetMiddleClickState()
     Retorna o estado do botão do meio do mouse. Consulte GS_KEY_STATE.

  • bool GAMESPACE_INPUT_HANDLER::SetCursorTo(GS_VECTOR2i v2Pos)
    Reposiciona o cursos do mouse (do sistema operacional) em outro ponto da tela. A instrução só será executada quando GAMESPACE_INPUT_HANDLER::UpdateInputData for chamada.

  • bool GAMESPACE_INPUT_HANDLER::SetCursorToF(GS_VECTOR2 v2Pos)
    Reposiciona o cursos do mouse (do sistema operacional) em outro ponto da tela. A instrução só será executada quando GAMESPACE_INPUT_HANDLER::UpdateInputData for chamada.

  • GS_VECTOR2i GAMESPACE_INPUT_HANDLER::GetCursor(GAMESPACE_VIDEO_HANDLER *pVideo)
    Retorna a posição, em pixels, do cursor do sistema na tela. Se pVideo for igual a NULL, a posição do cursor será relativa a toda a tela do computador. Se pVideo informar um endereço válido, a função retornará a posição do cursor com relação à janela correspondente ao objeto GAMESPACE_VIDEO_HANDLER passado. Recomendado para "picking" em modo de janela (windowed).

  • GS_VECTOR2 GAMESPACE_INPUT_HANDLER::GetCursorF(GAMESPACE_VIDEO_HANDLER *pVideo)
    Retorna a posição, em pixels, do cursor do sistema na tela. Se pVideo for igual a NULL, a posição do cursor será relativa a toda a tela do computador. Se pVideo informar um endereço válido, a função retornará a posição do cursor com relação à janela correspondente ao objeto GAMESPACE_VIDEO_HANDLER passado. Recomendado para "picking" em modo de janela (windowed).

  • float GAMESPACE_INPUT_HANDLER::GetWheelState()
    Retorna o estado atual do mouse wheel (tambem conhecido por mouse scroll, ou simplesmente roda do mouse). Retorna 0.0f caso a roda esteja parada e 1.0f ou -1.0f caso esteja sendo rotacionada. O estado do mouse wheel só é atualizado quando o método GAMESPACE_VIDEO_HANDLER::SetupProc é atualizada.

  • bool GAMESPACE_INPUT_HANDLER::DetectJoysticks()
    Atualiza os dados internos do objeto com relação a possíveis joysticks que estejam conectados ao computador.
    Este método pode ser utilizado para detectar joysticks que foram conectados durante a execução do programa. Este método é chamado automaticamente quando GAMESPACE_INPUT_HANDLER::RegisterInputDevice é executado.

    Nota importante: nas versões da GameSpaceLib cuja parte de entrada de dados seja baseada na SDL (ex.: Linux), os joysticks que forem plugados DURANTE a execução do programa não serão detectados, sendo necessário reiniciar a aplicação para que estes sejam reconhecidos pelo sistema.

  • GS_JOYSTICK_STATUS GAMESPACE_INPUT_HANDLER::GetJoystickStatus(const GS_JOYSTICKID id)
    Retorna a informação do estado atual do joystick id (veja GS_JOYSTICKID). Veja em GS_JOYSTICK_STATUS os valores possíveis.

  • int GAMESPACE_INPUT_HANDLER::GetNumJoyButtons(const GS_JOYSTICKID id)
    Retorna o número inteiro equivalente à quantidade total de botões que o joystick id possui (veja GS_JOYSTICKID).

  • GS_KEY_STATE GAMESPACE_INPUT_HANDLER::JoyButtonState(const GS_JOYSTICKID id, const GS_JOYSTICK_BUTTON GSKey)
    Retorna o estado (ver GS_KEY_STATE) do botão GSKey (ver GS_JOYSTICK_BUTTON) do joystick id (ver GS_JOYSTICKID).

  • bool GAMESPACE_INPUT_HANDLER::JoyButtonDown(const GS_JOYSTICKID id, const GS_JOYSTICK_BUTTON GSKey)
    Retorna true se o botão GSKey (ver GS_JOYSTICK_BUTTON) do joystick id (ver GS_JOYSTICKID) estiver sendo pressionado.

  • GS_VECTOR2 GAMESPACE_INPUT_HANDLER::GetJoystickXY(const GS_JOYSTICKID id)
    Retorna os valores dos eixos X e Y equivalentes ao direcional do joystick (analógico ou não). O valor de cada eixo pode variar entre 0.0f e 1.0f.

  • float GAMESPACE_INPUT_HANDLER::GetJoystickZ(const GS_JOYSTICKID id)
    Retorna o valor do eixo Z equivalente à alavanca Z do joystick (analógica ou não). O valor do eixo pode variar entre 0.0f e 1.0f. Nem todos os joysticks possuem este eixo.

  • float GAMESPACE_INPUT_HANDLER::GetJoystickRudder(const GS_JOYSTICKID id)
    Retorna o valor do eixo R equivalente ao volante do joystick. O valor do eixo pode variar entre 0.0f e 1.0f. Nem todos os joysticks possuem este eixo.

  • GS_VECTOR2 GAMESPACE_INPUT_HANDLER::GetJoystickUV(const GS_JOYSTICKID id)
    Retorna os valores dos eixos U e V equivalentes ao direcional secundário do joystick (analógico ou não). O valor de cada eixo pode variar entre 0.0f e 1.0f. Nem todos os joysticks possuem este eixo.

  • GS_JOYSTICK_BUTTON GAMESPACE_INPUT_HANDLER::GetFirstButtonDown(const GS_JOYSTICKID id)
    Retorna o primeiro botão que estiver sendo pressionado. Este método é útil para criar interfaces que permitam que o usuário ajuste a própria configuração do joystick. Veja GS_JOYSTICK_BUTTON.

  • int GAMESPACE_INPUT_HANDLER::GetMaxJoysticks()
    Retorna a quantidade máxima de joysticks suportados pelo sistema.

  • char GAMESPACE_INPUT_HANDLER::GetLastCharInput()
    Retorna um caractere caso o usuário tenha digitado alguma tecla que envia caracteres como mensagens ao sistema. Caso nada tenha sido recém digitado, retorna '\0'.

 

class GS_SPRITE

  • bool GS_SPRITE::LoadSprite
    (
      GAMESPACE_VIDEO_HANDLER *pVideo,
      char *szFileName,
      GS_COLOR dwMask = GS_COLOR(0,0,0,0),
      int nWidth = 0,
      int nHeight = 0
    )
    Esta função carrega um bitmap em formato BMP, JPEG, PNG ou TGA e prepara-o para ser utilizado como sprite.
        GAMESPACE_VIDEO_HANDLER *pVideo
                Ponteiro para um objeto GAMESPACE_VIDEO_HANDLER válido
          Após criado, o sprite só poderá ser desenhado na janela correspondente ao objeto aqui definido
            const char *szFileName
                String terminada em NULL que corresponde ao nome completo do arquivo a ser carregado
            GS_COLOR dwMask
                Cor de fundo do sprite. Todos os pixels que tiverem cor exatamente igual ao aqui definido serão
          cortados do processo de desenho. Utilize 0x00000000 caso não hajam pixels a ser recortados ou
          caso a imagem já possua seu próprio canal alpha
            const int nWidth
                Nova largura, em pixels, para o bitmap. Defina 0 para manter a largura original do arquivo
    Ver GS_COLOR.

    Dica de portabilidade: evite utilizar sprites cujo bitmap ultrapasse a dimensão de 512x512 pixels.

  • bool GS_SPRITE::LoadSprite
    (
      GAMESPACE_VIDEO_HANDLER *pVideo,
      char *szFileName,
      GS_COLOR dwMask,
      int nWidth,
      int nHeight,
      void *pBuffer, // utilizado para carregar sprite de um buffer ao invés de arquivo
      int nDataSize // utilizado para carregar sprite de um buffer ao invés de arquivo
    )
    Esta função carrega um bitmap em formato BMP, JPEG, PNG ou TGA que esteja armazenado na memória virtual e prepara-o para ser utilizado como sprite.
        GAMESPACE_VIDEO_HANDLER *pVideo
                Ponteiro para um objeto GAMESPACE_VIDEO_HANDLER válido
          Após criado, o sprite só poderá ser desenhado na janela correspondente ao objeto aqui definido
            const char *szFileName
                String terminada em NULL que corresponde ao nome completo do arquivo a ser carregado
            GS_COLOR dwMask
                Cor de fundo do sprite. Todos os pixels que tiverem cor exatamente igual ao aqui definido serão
          cortados do processo de desenho. Utilize 0x00000000 caso não hajam pixels a ser recortados ou
          caso a imagem já possua seu próprio canal alpha
            const int nWidth
                Nova largura, em pixels, para o bitmap. Defina 0 para manter a largura original do arquivo
        void *pBuffer
                Ponteiro para o primeiro byte do buffer onde se encontra o arquivo de imagem
          Se este ponteiro for omitido (pBuffer == 0), o sprite será carregado de um arquivo em disco
            const int nDataSize
                Total de bytes contidos no buffer passado em pBuffer.
          Se o ponteiro pBuffer for omitido (pBuffer == 0), o sprite será carregado de um arquivo em disco
     Ver GS_COLOR.

    Os dois últimos parâmetros desse método podem ser utilizados para gerar sprites de arquivos armazenados na memória virtual. Útil para carregar sprites de pacotes compactados que são descompactados virtualmente.

    Dica de portabilidade: evite utilizar sprites cujo bitmap ultrapasse a dimensão de 512x512 pixels.

  • void GS_SPRITE::Destroy()
         Apaga toda a memória alocada pelo objeto.

  • bool GS_SPRITE::SetupSpriteRects(int collums, int rows)
    Esta função é utilizada caso o bitmap do atual sprite possuir mais de um sprite em sua composição. Para isso, os sprites precisam possuir a mesma altura e mesma largura, como mostra a imagem à seguir.

    Aqui temos um sprite 4x4 com 16 frames de igual dimensão. A função SetupSpriteRects cria estas divisões para serem posteriormente usadas para animação. Em collums deve ser especificada a quantidade de colunas de sprites e em rows a quantidade de linhas. A própria função se encarregará de dividi-la igualmente. Para selecionar os quadros específicos, utilize GS_SPRITE::SetRect(int collum, int row).

     

  • bool GS_SPRITE::DrawSprite
    (
      GS_VECTOR2 v2Pos,
      GS_COLOR dwColor = GS_COLOR(255,255,255,255),
      float fAngle = 0.0f,
      GS_VECTOR2 v2Scale = GS_VECTOR2(1.0f,1.0f)
    )
    Desenha o sprite na tela. Caso o método GS_SPRITE::SetRect tenha sido utilizado, esta função desenhará somente o quadro especificado. Esta função deve ser chamada entre GAMESPACE_VIDEO_HANDLER::BeginSpriteScene e GAMESPACE_VIDEO_HANDLER::EndSpriteScene.
        GS_VECTOR2 v2Pos
                Ponto em screen space onde será posicionado o ponto de origem do sprite.
            GS_COLOR dwColor
                Cor em ARGB hexadecimal 32-bit do sprite. Este valor será multiplicado por cada pixel do sprite.
          Pode ser utilizado para clarear, escurecer, anular canais e alterar a tonalidade de cor.
          Este valor também admite um valor de 0 a 255 para o canal alpha.
            float fAngle
          Ângulo de rotação, em graus, do sprite. 0.0f configura seu ângulo reto (padrão)
          O sprite será rotacionado em torno de seu ponto de origem.
            GS_VECTOR2 v2Scale
                Vetor bidimensional que define a escala artificial do sprite
    Um sprite pode ser desenhado mais de uma vez a cada quadro. Ver GS_COLOR.

  • bool GS_SPRITE::DrawShapedSprite
    (
      GS_VECTOR2 v2Pos,
      GS_VECTOR2 v2Size,
      GS_COLOR dwColor0,
      GS_COLOR dwColor1,
      GS_COLOR dwColor2,
      GS_COLOR dwColor3,
      float fAngle
    )
    Desenha o sprite independentemente de seu tamanho original.
        GS_VECTOR2 v2Pos
                Ponto em screen space onde será posicionado o ponto de origem do sprite.
            GS_VECTOR2 v2Size
            Tamanho, em pixels, do sprite.
            GS_COLOR dwColor0
                Cor em ARGB hexadecimal 32-bit do vértice superior esquerdo do sprite. Este valor será multiplicado por cada pixel do sprite.
          Pode ser utilizado para clarear, escurecer, anular canais e alterar a tonalidade de cor.
          Este valor também admite um valor de 0 a 255 para o canal alpha.
        GS_COLOR     dwColor1
                Cor em ARGB hexadecimal 32-bit do vértice superior direito do sprite. Este valor será multiplicado por cada pixel do sprite.
          Pode ser utilizado para clarear, escurecer, anular canais e alterar a tonalidade de cor.
          Este valor também admite um valor de 0 a 255 para o canal alpha.
        GS_COLOR     dwColor2
                Cor em ARGB hexadecimal 32-bit do vértice inferior esquerdo do sprite. Este valor será multiplicado por cada pixel do sprite.
          Pode ser utilizado para clarear, escurecer, anular canais e alterar a tonalidade de cor.
          Este valor também admite um valor de 0 a 255 para o canal alpha.
        GS_COLOR     dwColor3
                Cor em ARGB hexadecimal 32-bit do vértice inferior direito. Este valor será multiplicado por cada pixel do sprite.
          Pode ser utilizado para clarear, escurecer, anular canais e alterar a tonalidade de cor.
          Este valor também admite um valor de 0 a 255 para o canal alpha.
            float fAngle
          Ângulo de rotação, em graus, do sprite. 0.0f configura seu ângulo reto (padrão)
          O sprite será rotacionado em torno de seu ponto de origem.
    Sempre que este método for utilizado, o sprite será desenhado com filtragem anisotrópica máxima (ou linear caso a placa de vídeo não suporte), mesmo que o modo de filtragem seja GSTM_IFNEEDED e o sprite não precise de filtragem. Caso o filtro seja GSTM_NEVER ele não será aplicado. Ver GS_COLOR.

  • bool GS_SPRITE::StretchSprite
    (
      GS_VECTOR2 v2A,
      GS_VECTOR2 v2B,
      float fWidth,
      GS_COLOR dwColor0,
      GS_COLOR dwColor1
    )
    Estica e desenha um sprite do ponto v2A ao ponto v2B. Como mostra a figura à seguir:

    A imagem será esticada verticalmente e seu tamanho, em pixels, deve ser definido em fWidth. Caso fWidth seja igual a -1.0f, a largura original do bitmap ou do retângulo será usada. dwColor0 e dwColor1 correspondem às cores, em ARGB 32-bit, do ponto A e B respectivamente. Caso dwColor0 e dwColor1 sejam diferentes, a cor será interpolada de uma extremidade à outra. Ver GS_COLOR.

  • void GS_SPRITE::SetSpriteOrigin(GS_SPRITE_ORIGIN origin)
     Redefine o eixo de rotação e translação do sprite. Veja GS_SPRITE_ORIGIN.

  • void GS_SPRITE::SetSpriteOrigin(GS_VECTOR2 v2Custom)
    Define o eixo para rotação e translação do sprite baseado em coordenadas UV. O ponto (0,0) equivale ao canto superior esquerdo do sprite e o ponto (1,1) equivale ao canto inferior direito do sprite. Os valores x e y de v2Custom podem ser intercalados entre 0.0f e 1.0f para especificar qualquer eixo para o sprite. Valores fora desse intervalo corresponderão a pontos fora da área retangular do sprite.

  • void GS_SPRITE::SetRect(GS_2DRECT rect)
    Define um retângulo imaginário que recortará apenas uma parcela da imagem. O valor deve ser definido em pixels e considerar que a origem do retângulo (sua posição) está em seu canto superior esquerdo. Veja GS_2DRECT.

  • bool GS_SPRITE::SetRect(int collum, int row)
    Deve ser utilizada se GS_SPRITE::SetupSpriteRects(const int collums, const int rows) foi chamada anteriormente. collum e row correspondem à posição, começando com 0, do retângulo a ser recortado do bitmap.

  • bool GS_SPRITE::SetRect(int rect)
    Deve ser utilizada se GS_SPRITE::SetupSpriteRects(const int collums, const int rows) foi chamada anteriormente. rect corresponde à posição linear (de     0 a X sendo X=collums*rows) do retângulo a ser recortado do bitmap.

  • GS_2DRECT GS_SPRITE::GetRect()
    Retorna o retângulo de recorte do sprite. Veja GS_2DRECT.

  • int GS_SPRITE::GetNumRects()
    Retorna o valor relativo à quantidade de quadros de animação atualmente existentes do sprite (total de linhas * total de colunas).

  • void GS_SPRITE::UnsetRect()
    Especifica que todo o bitmap do sprite deve ser desenhado. Utilize esta função para cancelar as alterações feitas por GS_SPRITE::SetRect.

  • void GS_SPRITE::FlipX(bool flip)
    Liga ou desliga o espelhamento horizontal do sprite. Defina true para habilitar o espelhamento ou false para desabilita-lo.

  • void GS_SPRITE::FlipY(bool flip)
    Liga ou desliga o espelhamento vertical do sprite. Defina true para habilitar o espelhamento ou false para desabilita-lo.

  • void GS_SPRITE::FlipX()
    Inverte o estado do espelhamento horizontal. Liga o espelhamento horizontal caso ele esteja desligado ou desliga caso ele esteja ligado.

  • void GS_SPRITE::FlipY()
    Inverte o estado do espelhamento vertical. Liga o espelhamento vertical caso ele esteja desligado ou desliga caso ele esteja ligado.

  • void GS_SPRITE::GetFlipX()
    Retorna o estado do espelhamento horizontal.

  • void GS_SPRITE::GetFlipY()
    Retorna o estado do espelhamento vertical.

  • GS_TEX_PROFILE GS_SPRITE::GetProfile()
    Obtém informações avançadas sobre o bitmap do sprite. Veja GS_TEX_PROFILE.

  • GS_VECTOR2i GS_SPRITE::GetBitmapSize()
    Retorna um vetor de valores inteiros com a largura (x) e altura (y), em pixels, do bitmap do sprite.

  • GS_VECTOR2 GS_SPRITE::GetBitmapSizeF()
    Retorna um vetor de valores float com a largura (x) e altura (y), em pixels, do bitmap do sprite.

  • GS_SURFACE_HANDLE GS_SPRITE::GetTexture()
    Retorna um ponteiro para o objeto que corresponde ao bitmap do sprite. Esta região na memória não corresponde necessariamente ao buffer de pixels.

  • void GS_SPRITE::SetScroll(GS_VECTOR2 v2Scroll)
    Esta função faz a rolagem do birmap em cima da superfície do sprite. v2Scroll determina o quanto, em pixels, que será girado nos eixos X e Y. Esta técnica não funcionará corretamente se o sprite estiver utilizando retângulos de recorte.

  • GS_VECTOR2 GS_SPRITE::GetScroll()
    Retorna o valor atual de rolagem do sprite. Ver GS_SPRITE::SetScroll.

  • void GS_SPRITE::SetMultiply(GS_VECTOR2 v2Multiply)
    Multiplica a superfície do bitmap ao longo da superfície do sprite. Esta técnica não funcionará corretamente se o sprite estiver utilizando retângulos de recorte.

  • GS_VECTOR2 GS_SPRITE::GetMultiply()
    Retorna o valor atual de multiplicação da textura. Ver GS_SPRITE::SetMultiply.

  • bool GS_SPRITE::CreateRenderTarget(GAMESPACE_VIDEO_HANDLER *pVideo, int nWidth, int nHeight, GS_TARGET_FORMAT format = GSTF_DEFAULT)
    Cria um sprite do tipo "render target" (também conhecido como Framebuffer object - veja o artigo no wikipedia). Este tipo de sprite não tem seu conteúdo carregado de um bitmap, mas sim recebe este através de outros desenhos em sua própria superfície.
    Quando esse método for usado para criar um render target, o sprite não mais poderá ser carregado de um bitmap. Em outras palavras, os métodos GS_SPRITE::LoadSprite e GS_SPRITE::CreateRenderTarget. não podem ser usados com um mesmo objeto GS_SPRITE.
        GAMESPACE_VIDEO_HANDLER *pVideo
                Ponteiro para o gerenciador da vídeo responsável pela aplicação.
        int nWidth
            Largura, em pixels, do render target. A largura do render target nunca poderá ser maior que a largura do backbuffer.
         int nHeight
            Altura, em pixels, do render target. A altura do render target nunca poderá ser maior que a altura do backbuffer.
        GS_TARGET_FORMAT format
            Formato de cor do render target.
            GSTF_DEFAULT utilizará o mesmo formato de pixel do backbuffer e
            GSTF_ARGB forçará o uso de canal alpha.
    Após criado o render target, o método GAMESPACE_VIDEO_HANDLER::SetRenderTarget define o render target a ser utilizado e os métodos GAMESPACE_VIDEO_HANDLER::BeginTargetScene e GAMESPACE_VIDEO_HANDLER::EndTargetScene iniciam e encerram o desenho no render target.

     Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • void GS_SPRITE::GenerateBackup()
    Este método pode ser usado em render targets estáticos (aqueles que não são atualizados a cada quadro da aplicação) para salvar a imagem atual na memória do sistema. Se o render target for salvo através do uso desse método, a própria biblioteca irá recuperar seu conteúdo caso haja necessidade de reiniciar o dispositivo. Isso evita que seu conteúdo tenha de ser desenhado novamente, uma vez que tudo que está armazenado na memória de vídeo é perdido quando está é reiniciada.

     Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_SPRITE_TYPE GS_SPRITE::GetType()
    Retorna o tipo de sprite. Os valores de retorno possíveis são:
    GSST_BITMAP: o sprite atual foi carregado de um bitmap em arquivo.
    GSST_TARGET: o sprite atual é um render target, e seu conteúdo é ou será composto por desenhos de outros sprites ou entidades.
    GSST_NOT_LOADED: o sprite atual ainda não foi carregado/criado.

     Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • bool GS_SPRITE::SetAsTexture(int nPass)
    Define a superfície do sprite como textura para multitexturização. nPass equivale ao estágio de textura. As coordenadas de textura para esse estágio precisam ser passadas como parâmetro de saída no vertex shader (TEXCOORD1-n).
    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib.

  • GS_VECTOR2 GS_SPRITE::GetCurrentOrigin()
    Retorna a posição da origem do sprite. Veja GS_SPRITE_ORIGIN.

    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib    .

  • bool GS_SPRITE::SaveBitmap(char *szName, const GS_BITMAP_FORMAT fmt, GS_2DRECT *pRect = 0)
    Salva     este sprite ou render target em um arquivo com nome szName e no formato fmt (veja GS_BITMAP_FORMAT). É possível especificar um retângulo para salvar com pRect. Para salvar toda a imagem, utilize NULL para este parâmetro.

    Nota importante:     no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o método acima apresentado está disponível somente para a versão Windows da GameSpaceLib    .

 

class GAMESPACE_AUDIO_HANDLER

  • bool GAMESPACE_AUDIO_HANDLER::RegisterAudioDevice(void *pData)
    Prepara o dispositivo de som para carregar e tocar efeitos sonoros. pData deve ser NULL.
     

  • void GAMESPACE_AUDIO_HANDLER::Destroy()
    Apaga toda a memória alocada pelo objeto.
     

 

class GS_AUDIO_SAMPLE

  • bool GS_AUDIO_SAMPLE::LoadSample
    (
      GAMESPACE_AUDIO_HANDLER *pAudio,
      char *szName,
      const GS_SAMPLE_TYPE type = GSST_UNKNOWN
    )
    Carrega uma faixa de áudio de um arquivo OGG, MP3, FLAC, WAV, AIFF, MOD, S3M, XM ou IT. pAudio deve apontar para um objeto GAMESPACE_AUDIO_HANDLER válido e szName corresponde à string terminada em NULL que indica o nome e diretório do arquivo.
    GS_SAMPLE_TYPE type pode ser usado para indicar o tipo de uso que será feito pela faixa de áudio. Com isso, o objeto pode otimizar o processo para melhorar a performance conforme o tipo. Veja GS_SAMPLE_TYPE.

    Note que alguns formatos de áudio são proprietários (MP3 por exemplo), ou seja, seu uso em aplicações comerciais estará sujeito à sua licença.
     

  • bool GS_AUDIO_SAMPLE::LoadSample
    (
      GAMESPACE_AUDIO_HANDLER *pAudio,
      char *szName,
      const GS_SAMPLE_TYPE type,
      void *pBuffer, // utilizado para carregar sprite de um buffer ao invés de arquivo
      int nDataSize // utilizado para carregar sprite de um buffer ao invés de arquivo
    )
    Carrega uma faixa de áudio de um arquivo OGG, MP3, FLAC, WAV, AIFF, MOD, S3M, XM ou IT que esteja armazenado na memória virtual. pAudio deve apontar para um objeto GAMESPACE_AUDIO_HANDLER válido e szName corresponde à string terminada em NULL que indica o nome e diretório do arquivo.
    GS_SAMPLE_TYPE type pode ser usado para indicar o tipo de uso que será feito pela faixa de áudio. Com isso, o objeto pode otimizar o processo para melhorar a performance conforme o tipo. Veja GS_SAMPLE_TYPE.

    pBuffer corresponde a um ponteiro para o primeiro byte do buffer onde se encontra o arquivo de áudio na memória virtual. Se este ponteiro for omitido (pBuffer == 0), o recurso será carregado de um arquivo armazenado em disco. nDataSize representa o total de bytes contidos no buffer passado em pBuffer (caso este seja diferente de 0).

    Os dois últimos parâmetros desse método podem ser utilizados para gerar faixas de áudio de arquivos armazenados na memória virtual. Útil para carregar recursos de pacotes compactados que são descompactados virtualmente.

    Note que alguns formatos de áudio são proprietários (MP3 por exemplo), ou seja, seu uso em aplicações comerciais estará sujeito à sua licença.
     

  • void GS_AUDIO_SAMPLE::Destroy()
    Apaga toda a memória alocada pelo objeto.
     

  • GS_SAMPLE_STATUS GS_AUDIO_SAMPLE::GetStatus()
    Retorna um valor de GS_SAMPLE_STATUS relativo ao atual estado de reprodução da faixa de áudio carregada.
     

  • GS_SAMPLE_TYPE GS_AUDIO_SAMPLE::GetType()
    Retorna o tipo de uso da faixa de áudio. Este valor pode ser definido durante a chamada do método GS_AUDIO_SAMPLE::LoadSample. Veja GS_SAMPLE_TYPE.
     

  • bool GS_AUDIO_SAMPLE::Play()
    Reproduz a faixa carregada. Se a faixa ainda estiver sendo tocada, ela será reiniciada.
     

  • bool GS_AUDIO_SAMPLE::IsPlaying()
    Retorna true caso a faixa esteja sendo tocada neste exato momento. Caso contrário retorna false.
     

  • bool GS_AUDIO_SAMPLE::SetLoop(const bool bEnable)
    Se bEnable for igual a true, a repetição de reprodução será ativada, caso contrário, será desativada. Se estiver ativada, sempre que a reprodução da faixa chegar ao fim, ela voltará automaticamente ao seu início e será reproduzida novamente.
     

  • bool GS_AUDIO_SAMPLE::GetLoop()
    Retorna true caso a repetição contínua de faixa esteja ativada e false caso esteja desativada.
     

  • bool GS_AUDIO_SAMPLE::Pause()
    Pausa a reprodução da faixa.
     

  • bool GS_AUDIO_SAMPLE::Stop()
    Interrompe toda a execução da faixa.
     

  • bool GS_AUDIO_SAMPLE::SetVolume(float fVolume)
    Ajusta o volume de reprodução da faixa. O valor de 0.0f equivale ao silêncio total e 1.0f ao volume padrão da faixa.
     

  • float GS_AUDIO_SAMPLE::GetVolume()
    Retorna o valor de volume atual da faixa de áudio.

  • bool GS_AUDIO_SAMPLE::SetSpeed(const float fSpeed)
    Define uma velocidade para a reprodução da faixa de áudio aumentando ou diminuindo a freqüencia das ondas sonoras e em conseqüencia disso diminuindo ou aumentando o tempo de reprodução total da faixa. 1.0f equivale à velocidade padrão. Este valor pode variar de 0.5f a 2.0f.

  • float GS_AUDIO_SAMPLE::GetSpeed()
    Retorna a velocidade atual (freqüencia das ondas sonoras) da faixa de áudio. Veja GS_AUDIO_SAMPLE::SetSpeed.

  • bool GS_AUDIO_SAMPLE::SetPan(const float fPan)
    Rearranja a posição da faixa de áudio entre os canais direito e esquerdo do dispositivo de som. -1.0f envia o som todo para o alto-falante esquerdo e 1.0f para o direito. Esta função aceita valores entre -1.0f e 1.0f para balancear analogicamente a posição da faixa.

 

class GAMESPACE_MEDIA_PLAYER

Nota importante: no momento em que esta documentação é disponibilizada (veja a data no cabeçalho da página), o objeto GAMESPACE_MEDIA_PLAYER só está disponível na versão Windows da GameSpaceLib.

  • bool GAMESPACE_MEDIA_PLAYER::LoadVideo(GAMESPACE_VIDEO_HANDLER *pVideo, const char *szFile)
    Carrega uma faixa de vídeo do formato MPEG, AVI, WMV e outros compatíveis com DirectShow. Este método decodificará o vídeo e exibirá na janela um retângulo onde será exibida a faixa.
    Para que este método tenha sucesso, ele precisa ser chamado depois que a janela já estiver aberta (GAMESPACE_VIDEO_HANDLER::StartApplication) e não pode ser chamado durante o desenho no laço principal (entre BeginSpriteScene e EndSpriteScene). pVideo precisa apontar a um objeto válido e szFile precisa conter uma string terminada em NULL que corresponde ao caminho e o nome do arquivo (Ex.: "meu_video.avi" ou "C:\Videos\Video_qualquer.mpg").
     

  • void GAMESPACE_MEDIA_PLAYER::UpdateVideo()
    Este método atualiza o vídeo. Precisa ser chamado uma vez a cada quadro de um laço principal que utilize o método GAMESPACE_VIDEO_HANDLER::SetupProc para atualizar as mensagens do sistema.
     

  • void GAMESPACE_MEDIA_PLAYER::Destroy()
    Apaga o vídeo da memória e todos os dados alocados pelo objeto. Para que este método tenha sucesso, ele precisa ser chamado depois que a janela já estiver aberta (GAMESPACE_VIDEO_HANDLER::StartApplication) e não pode ser chamado durante o desenho no laço principal (entre BeginSpriteScene e EndSpriteScene).
     

  • bool GAMESPACE_MEDIA_PLAYER::Play()
    Reproduz o vídeo e sua faixa de áudio. Caso o vídeo esteja pausado e o método GAMESPACE_MEDIA_PLAYER::Play seja chamado, sua execução será retomada de onde havia parado. Caso o vídeo já esteja sendo executado e este método seja chamado novamente, a execução retornará ao seu ponto inicial.
     

  • bool GAMESPACE_MEDIA_PLAYER::Rewind()
    Retorna ao ponto inicial do vídeo.
     

  • bool GAMESPACE_MEDIA_PLAYER::Stop()
    Interrompe a execução do vídeo e retorna ao início.
     

  • bool GAMESPACE_MEDIA_PLAYER::Pause()
    Pausa a execução do vídeo. Caso o vídeo esteja pausado e o método GAMESPACE_MEDIA_PLAYER::Play seja chamado, sua execução será retomada de onde havia parado.
     

  • bool GAMESPACE_MEDIA_PLAYER::SetVideoPos(GS_VECTOR2i v2Pos)
    Posiciona o vídeo no ponto determinado por v2Pos. Sendo (0,0) o ponto de origem do back buffer.
     

  • bool GAMESPACE_MEDIA_PLAYER::SetVideoSize(GS_VECTOR2i v2Size)
    Define a dimensão, em pixels, do vídeo.
     

  • GS_VECTOR2i GAMESPACE_MEDIA_PLAYER::GetVideoPos()
    Retorna a posição atual, em pixels, do vídeo.
     

  • GS_VECTOR2i GAMESPACE_MEDIA_PLAYER::GetVideoSize()
    Retorna o tamanho atual, em pixels, do vídeo.
     

  • bool GAMESPACE_MEDIA_PLAYER::SetFullscreen()
    Faz com que o vídeo ocupe a tela toda (todo o back buffer).
     

  • void GAMESPACE_MEDIA_PLAYER::ShowVideo(const bool bShow)
    Exibe ou esconde o vídeo. false para esconder e true para exibi-lo. Caso a faixa de vídeo esteja no meio de sua execução, este método não a afetará em nada e o áudio continuará sendo tocado mesmo que o retângulo do vídeo esteja escondido.
     

  • bool GAMESPACE_MEDIA_PLAYER::VideoVisible()
    Retorna true caso o vídeo esteja visível e false caso esteja escondido.
     

  • bool GAMESPACE_MEDIA_PLAYER::SetAudioVolume(const float fVolume)
    Ajusta o volume do áudio do vídeo. O valor de 0.0f equivale ao silêncio total e 1.0f ao volume padrão da faixa.
     

  • bool GAMESPACE_MEDIA_PLAYER::Finished()
    Retorna true caso a reprodução do vídeo tenha sido encerrada "naturalmente" (tenha chegado ao fim sem nenhuma interrupção do usuário). Caso contrário retorna false.
     

  • GS_SAMPLE_STATUS GAMESPACE_MEDIA_PLAYER::GetStatus()
    Retorna o estado atual da reprodução do vídeo. Veja GS_SAMPLE_STATUS.
     
Funções globais

void gsSystemUserMessage(
   GAMESPACE_VIDEO_HANDLER *pVideo,
  char *szText,
  GS_MESSAGE_TYPE type
)

  • Exibe uma mensagem em caixa de texto para o usuário. A execução do programa será interrompida até que o botão OK seja pressionado. pVideo corresponde ao ponteiro para um objeto GAMESPACE_VIDEO_HANDLER válido, este parâmetro pode ser NULL. szText corresponde ao texto a ser exibido na mensagem. type corresponde ao tipo da mensagem, veja GS_MESSAGE_TYPE.
    Se pVideo for igual a NULL, a mensagem não será vinculada com a janela do programa, mas o programa ficará pausado até que o botão OK seja pressionado da mesma forma.

GS_PLAYER_INFO gsPlayCutscene(
  GAMESPACE_VIDEO_HANDLER *pVideo,
  char *szFile,
  GAMESPACE_INPUT_HANDLER *pInput = 0,
  GS_KEY escapeKey = GSK_ESC
)

  • Carrega e reproduz uma faixa de vídeo que ocupa toda a região do back buffer.
    pVideo precisa ser um objeto válido e já possuir uma janela aberta com StartApplication.
    szFile     precisa conter uma string terminada em NULL que corresponde ao caminho e o nome do arquivo (Ex.: "meu_video.avi" ou "C:\Videos\Video_qualquer.mpg").
    pInput é opcional e pode conter um ponteiro para um objeto GAMESPACE_INPUT_HANDLER válido caso o programador queira permitir ao usuário a possibilidade de interromper a execução do vídeo ao pressionar alguma tecla (escapeKey, ver GS_KEY).
    Caso o usuário pressione a tecla ou botão de mouse correspondente a escapeKey durante a execução do vídeo, ela será cancelada.
    Confira a seção de exemplos do SDK para ter um exemplo de uso desta função.

void gsGetErrorMessage(char *szOutMessage)

  • Copia a última mensagem de erro ou alerta enviada pelas funções internas da GameSpaceLib para a string (de no mínimo 1024 caracteres) passada como parâmetro. Caso não hajam mensagens de erro, o valor passado será "\0".

void gsShowLastError(GAMESPACE_VIDEO_HANDLER *pVideo)

  • Exibe para usuário a última mensagem de erro enviada pelas funções internas da GameSpaceLib.

int gsRandI(const int max)

  • Retorna um número inteiro pseudo-randômico (aleatório) entre 0 e max. Isto inclui tanto 0 como max dentro da probabilidade.

int gsRandI(const int min, const int max)

  • Retorna um número inteiro pseudo-randômico (aleatório) entre min e max. Isto inclui tanto min como max dentro da probabilidade.

float gsRandF(const float max)

  • Retorna um número real pseudo-randômico (aleatório) entre 0.0f e max. Isto inclui tanto 0.0f como max dentro da probabilidade.

float gsRandF(const float min, const float max)

  • Retorna um número real pseudo-randômico (aleatório) entre min e max. Isto inclui tanto min como max dentro da probabilidade.

float gsGetDist2(GS_VECTOR2 P0, GS_VECTOR2 P1)

  • Retorna o valor da distância em linha reta, medida em pixels, entre o ponto P0 e P1.

GS_VECTOR2 gsNormalize2(const GS_VECTOR3 v0)

  • Retorna o a versão normalizada de v0.

float gsGetAngle(const GS_VECTOR2 v2)

  • Retorna o ângulo, em radianos, do vetor v2.

float gsRadianToDegree(const float fAngle)

  • Retorna o ângulo em radianos fAngle convertido para graus de 0º a 360º.

float gsDegreeToRadian(const float fAngle)

  • Retorna o valor de ângulo em graus (de 0º a 360º) convertido para radianos.

GS_COLOR GS_ARGB(const GS_BYTE na, const GS_BYTE nr, const GS_BYTE ng, const GS_BYTE nb)

  •  Converte quatro bytes de cor ARGB (1 byte para cada canal) para o formato GS_COLOR.

 
Estruturas

struct GS_COLOR - Armazena um valor de cor 32-bit com canal alpha, vermelho, verde e azul

  • GS_COLOR(GS_DWORD color)
    Construtor que pode inicializar a estrutura com o valor de cor em hexadecimal.
  • GS_COLOR(GS_BYTE na, GS_BYTE nr, GS_BYTE ng, GS_BYTE nb)
    Construtor que define valores alpha, vermelho, verde e azul em bytes que valem de 0 a 255 em decimal.
  • void SetColor(GS_BYTE na, GS_BYTE nr, GS_BYTE ng, GS_BYTE nb)
    Define valores alpha, vermelho, verde e azul em bytes que valem de 0 a 255 em decimal.
  • void SetAlpha(GS_BYTE na)
    Define um valor de 0 a 255 para o canal alpha.
  • void SetRed(GS_BYTE nr)
    Define um valor de 0 a 255 para o canal vermelho.
  • void SetGreen(GS_BYTE ng)
    Define um valor de 0 a 255 para o canal verde.
  • void SetBlue(GS_BYTE nb)
    Define um valor de 0 a 255 para o canal azul.
  • void SetColor(GS_DWORD color)
    Permite definir um valor de cor 32-bit em hexadecimal.

struct GS_VIDEO_MODE - Informações relativas ao modo de vídeo da janela

  • int width: largura, em pixels, do back buffer da aplicação.
  • int height: altura, em pixels, do back buffer da aplicação.
  • GS_PIXEL_FORMAT pf: formato dos pixels do back buffer. Ver GS_PIXEL_FORMAT.
  • GS_DWORD n: valor de uso exclusivo da GameSpaceLib, deve ser ignorado.

struct GS_VECTOR2i - Vetor bidimensional de valores inteiros

  • int x
  • int y

struct GS_VECTOR2 - Vetor bidimensional com ponto flutuante

  • float x
  • float y

struct GS_2DRECT - Retângulo bidimensional

  • GS_VECTOR2i point: posição do retângulo.
  • GS_VECTOR2i size: tamanho do retângulo.

struct GS_TEX_PROFILE - Dados de uma textura (superfície gráfica)

  • GS_COLOR dwMask: valor de cor ARGB 32-bit do pixel neutro (invisível).
  • int nWidth: largura, em pixels, do bitmap.
  • int nHeight: altura, em pixels, do birmap.
  • int nNumMipMaps: total de mipmaps da textura.

struct GS_2DVERTEX - Vértice bidimensional para desenho de polígonos

  • GS_VECTOR2 pos: posição 2D do vértice (em pixels).
  • float z, rhw: valores reservados (ignore-os).
  • GS_COLOR color: cor do vértice.
  • GS_VECTOR2 tex: valor reservado para implementações futuras.

 
Enumerações

enum GS_PIXEL_FORMAT - Quantidade de bits por pixel

  • GSPF_16BIT: pixel com 16bit de precisão de cor.
  • GSPF_32BIT: pixel com 32bit de precisão de cor.
  • GSPF_UNKNOWN: valor de precisão de pixel desconhecida ou ignorada.
  • GSPF_DEFAULT: precisão de cor do pixel é igual à atualmente utilizada pelo sistema.

enum GS_MESSAGE_TYPE - Tipo de mensagem ao usuário

  • GSMT_INFO: a mensagem é apenas informativa.
  • GSMT_WARNING: a mensagem é de alerta ao usuário.
  • GSMT_ERROR: a mensagem é de erro.

enum GS_PROC_STATUS - Instrução de execução para o laço principal do programa

  • GSPROC_OK
  • GSPROC_QUIT
  • GSPROC_SKIP

enum GS_SPRITE_ORIGIN - Ponto de origem (centro) de um sprite

  • GSSO_DEFAULT: a origem do sprite será seu canto superior esquerdo.
  • GSSO_CENTER: a origem do sprite será o centro do bitmap.
  • GSSO_CENTER_BOTTOM: a origem do sprite será o centro de sua linha inferior.
  • GSSO_CENTER_TOP: a origem do sprite será o centro de sua linha superior.
  • GSSO_RECT_CENTER: a origem será o centro do atual retângulo. Precisa ser especificado após o comando GS:SPRITE::SetRect.
  • GSSO_RECT_CENTER_BOTTOM: a origem será o centro inferior do atual retângulo. Precisa ser especificado após o comando GS:SPRITE::SetRect.
  • GSSO_RECT_CENTER_TOP: a origem será o centro superior do atual retângulo. Precisa ser especificado após o comando GS:SPRITE::SetRect.

enum GS_SAMPLE_STATUS - Estado de reprodução de uma faixa de áudio

  • GSSS_PLAYING: a faixa de áudio ou vídeo está sendo reproduzida neste momento.
  • GSSS_PAUSED: a reprodução da faixa de áudio ou vídeo encontra-se pausada e quando voltar a ser reproduzida continuará do ponto em que foi pausada.
  • GSSS_STOPPED: a reprodução está parada e foi retornada ao início da faixa.
  • GSSS_UNKNOWN: estado de reprodução desconhecido ou ignorado pelo sistema.

enum GS_PLAYER_INFO - valor de retorno que informa o resultado da execução do vídeo

  • GSPI_FAILED: a reprodução da faixa de vídeo falhou.
  • GSPI_SKIPPED: o usuário cancelou manualmente a reprodução da faixa de vídeo.
  • GSPI_CLOSE_WINDOW: o usuário fechou a janela durante a reprodução do vídeo.
  • GSPI_FINISHED: a faixa de vídeo foi reproduzida com sucesso até o fim.

enum GS_SAMPLE_TYPE - Determina as diferentes formas de uso de um arquivo de áudio

  • GSST_SOUND_EFFECT: diz ao sistema que trata-se de um efeito sonoro curto (com alguns segundos ou décimos de segundo de duração).
  • GSST_MUSIC: diz ao sistema de trata-se de uma música.
  • GSST_SOUNDTRACK: diz ao sistema que trata-se de uma trilha sonora (com minutos de duração).
  • GSST_AMBIENT_SFX: diz ao sistema que trata-se de um efeito sonoro de fundo (com minutos de duração).
  • GSST_UNKNOWN: o tipo de uso para a faixa de áudio é desconhecida ou ignorada pelo usuário.

enum GS_KEY_STATE - Estados de teclas ou botões

  • GSKS_HIT: a tecla ou botão acabou de ser pressionado.
  • GSKS_DOWN: a tecla ou botão ESTÁ sendo pressionado.
  • GSKS_RELEASE: a tecla ou botão acaba de ser solto.
  • GSKS_UP: a tecla ou botão NÃO ESTÁ sendo pressionado.

enum GS_ALPHA_MODE - Tipos de transparência de sprites

  • GSAM_PIXEL: a cor de cada novo pixel renderizado será interpolada com a cor do pixel ao seu respectivo fundo utilizando o valor de ALPHA do pixel do bitmap como parâmetro.
  • GSAM_ADD: a cor de cada novo pixel renderizado será somada à cor do pixel ao seu respectivo fundo.
  • GSAM_MODULATE: a cor de cada novo pixel será o resultado da multiplicação da cor do pixel do sprite com a cor do pixel no fundo.
  • GSAM_NONE: desliga o alpha blending (transparência).
  • GSAM_ALPHA_TEST: desliga o alpha blending mas corta os pixels cujo valor de alpha se iguale a 0. Sprites desenhados com este método são bem mais rápidos do que aqueles desenhados com GSAM_PIXEL ou GSAM_ADD.

enum GS_TEXTUREFILTER_MODE - Critério para execução de filtro na textura (sprite)

  • GSTM_NEVER: os filtros de textura (sprite) estão totalmente desligados.
  • GSTM_IFNEEDED: antes de aplicar o filtro biblioteca vai verificar se o caso necessita de filtragem no sprite.
  • GSTM_ALWAYS: a biblioteca sempre aplicará o filtro de textura (sprite).

enum GS_TIME_UNITY - Unidade de medida de tempo

  • GSTU_MILLISECONDS: a função retornará o tempo em milisegundos.
  • GSTU_SECONDS: a função retornará o tempo em segundos.
  • GSTU_MINUTES: a função retornará o tempo em minutos, sendo que 1.5f equivale a 1:30 (1min30seg).
  • GSTU_HOURS: a função retornará o tempo em horas, sendo que 1.5f equivale a 1:30 (1h30min).

enum GS_BITMAP_FORMAT - Formato de arquivo de imagem para salvar screenshot

  • GSSF_BMP: formato bitmap do Windows sem perda de qualidade (.bmp).
  • GSSF_JPG: formato de compressão com perda de qualidade JPEG (.jpg/.jpeg).
  • GSSF_PNG: formato com compressão de dados e suporte a canal alpha (.png).
  • GSSF_TGA: formato TGA.
  • GSSF_DDS: formato de superfície do DirectX.

typedef unsigned int GS_JOYSTICKID - Constante de identificação de joysticks

  • GS_JOYSTICK1 = 0: joystick do primeiro slot.
  • GS_JOYSTICK2 = 1: joystick do segundo slot.
  • GS_JOYSTICK3 = 2: joystick do terceiro slot.
  • GS_JOYSTICK4 = 3: joystick do quarto slot.

enum GS_JOYSTICK_STATUS - Estado do joystick ou joypad

  • GSJS_DETECTED: joystick conectado e detectado
  • GSJS_NOTDETECTED: joystick não detectado ou não conectado
  • GSJS_INVALID: joystick inválido

enum GS_RECT_MODE

  • GSRM_TWO_TRIANGLES: utiliza dois triângulos para formar o retângulo.
  • GSRM_THREE_TRIANGLES: utiliza três triângulos para formar o retângulo.
  • GSRM_FOUR_TRIANGLES: utiliza quatro triângulos para formar o retângulo.

enum GS_JOYSTICK_BUTTON - Lista de botões do joystick

Cada constante equivale a um botão do joystick. A GameSpaceLib suporta joysticks com até 32 botões.
Ex.: as constantes válidas para um joystick que possui 8 botões serão GSB_01 à GSB_08.

  • GSB_01
  • GSB_02
  • GSB_03
  • GSB_04
  • GSB_05
  • GSB_06
  • GSB_07
  • GSB_08
  • GSB_09
  • GSB_10
  • GSB_11
  • GSB_12
  • GSB_13
  • GSB_14
  • GSB_15
  • GSB_16
  • GSB_17
  • GSB_18
  • GSB_19
  • GSB_20
  • GSB_21
  • GSB_22
  • GSB_23
  • GSB_24
  • GSB_25
  • GSB_26
  • GSB_27
  • GSB_28
  • GSB_29
  • GSB_30
  • GSB_31
  • GSB_32
  • GSB_UP
  • GSB_DOWN
  • GSB_LEFT
  • GSB_RIGHT

enum GS_KEY - Teclas do teclado e botões do mouse

  • GSK_UP = 0,
  • GSK_DOWN = 1,
  • GSK_LEFT = 2,
  • GSK_RIGHT,
  • GSK_CTRL,
  • GSK_ALT,
  • GSK_SHIFT,
  • GSK_PAGEDOWN,
  • GSK_PAGEUP,
  • GSK_SPACE,
  • GSK_ENTER,
  • GSK_DELETE,
  • GSK_HOME,
  • GSK_END,
  • GSK_INSERT,
  • GSK_PAUSE,
  • GSK_ESC,
  • GSK_BACKSPACE,
  • GSK_TAB,
  • GSK_PRINTSCREEN,
  • GSK_SUBTRACT,
  • GSK_ADD,
  • GSK_F1,
  • GSK_F2,
  • GSK_F3,
  • GSK_F4,
  • GSK_F5,
  • GSK_F6,
  • GSK_F7,
  • GSK_F8,
  • GSK_F9,
  • GSK_F10,
  • GSK_F11,
  • GSK_F12,
  • GSK_F13,
  • GSK_F14,
  • GSK_F15,
  • GSK_F16,
  • GSK_F17,
  • GSK_F18,
  • GSK_F19,
  • GSK_F20,
  • GSK_F21,
  • GSK_F22,
  • GSK_F23,
  • GSK_F24,
  • GSK_A,
  • GSK_B,
  • GSK_C,
  • GSK_D,
  • GSK_E,
  • GSK_F,
  • GSK_G,
  • GSK_H,
  • GSK_I,
  • GSK_J,
  • GSK_K,
  • GSK_L,
  • GSK_M,
  • GSK_N,
  • GSK_O,
  • GSK_P,
  • GSK_Q,
  • GSK_R,
  • GSK_S,
  • GSK_T,
  • GSK_U,
  • GSK_V,
  • GSK_W,
  • GSK_X,
  • GSK_Y,
  • GSK_Z,
  • GSK_0,
  • GSK_1,
  • GSK_2,
  • GSK_3,
  • GSK_4,
  • GSK_5,
  • GSK_6,
  • GSK_7,
  • GSK_8,
  • GSK_9,
  • GSK_NUMPAD0
  • GSK_NUMPAD1
  • GSK_NUMPAD2
  • GSK_NUMPAD3
  • GSK_NUMPAD4
  • GSK_NUMPAD5
  • GSK_NUMPAD6
  • GSK_NUMPAD7
  • GSK_NUMPAD8
  • GSK_NUMPAD9
  • GSK_RMOUSE,
  • GSK_LMOUSE,
  • GSK_MMOUSE,
  • GSK_MINUS,
  • GSK_PLUS,
  • GSK_COMMA,
  • GSK_DOT,
  • GSK_NO_KEY (nenhuma tecla, valor inválido para GAMESPACE_INPUT_HANDLER)

 


GameSpaceLib - Copyright © 2008-2009 André Santee