//-----------------------------------------------------------------------------
// Purpose: Draw a line, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEnginePS3::BDrawLine( float xPos0, float yPos0, DWORD dwColor0, float xPos1, float yPos1, DWORD dwColor1 )
{
if ( !m_pPSGLContext || !m_pPSGLDevice || m_bShuttingDown )
return false;
// Check if we are out of room and need to flush the buffer
if ( m_dwLinesToFlush == LINE_BUFFER_TOTAL_SIZE )
{
BFlushLineBuffer();
}
DWORD dwOffset = m_dwLinesToFlush*6;
m_rgflLinesData[dwOffset] = xPos0;
m_rgflLinesData[dwOffset+1] = yPos0;
m_rgflLinesData[dwOffset+2] = 1.0;
m_rgflLinesData[dwOffset+3] = xPos1;
m_rgflLinesData[dwOffset+4] = yPos1;
m_rgflLinesData[dwOffset+5] = 1.0;
dwOffset = m_dwLinesToFlush*8;
m_rgflLinesColorData[dwOffset] = COLOR_RED( dwColor0 );
m_rgflLinesColorData[dwOffset+1] = COLOR_GREEN( dwColor0 );
m_rgflLinesColorData[dwOffset+2] = COLOR_BLUE( dwColor0 );
m_rgflLinesColorData[dwOffset+3] = COLOR_ALPHA( dwColor0 );
m_rgflLinesColorData[dwOffset+4] = COLOR_RED( dwColor1 );
m_rgflLinesColorData[dwOffset+5] = COLOR_GREEN( dwColor1 );
m_rgflLinesColorData[dwOffset+6] = COLOR_BLUE( dwColor1 );
m_rgflLinesColorData[dwOffset+7] = COLOR_ALPHA( dwColor1 );
++m_dwLinesToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a point, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEnginePS3::BDrawPoint( float xPos, float yPos, DWORD dwColor )
{
if ( !m_pPSGLContext || !m_pPSGLDevice || m_bShuttingDown )
return false;
// Check if we are out of room and need to flush the buffer
if ( m_dwPointsToFlush == POINT_BUFFER_TOTAL_SIZE )
{
BFlushPointBuffer();
}
DWORD dwOffset = m_dwPointsToFlush*3;
m_rgflPointsData[dwOffset] = xPos;
m_rgflPointsData[dwOffset+1] = yPos;
m_rgflPointsData[dwOffset+2] = 1.0;
dwOffset = m_dwPointsToFlush*4;
m_rgflPointsColorData[dwOffset] = COLOR_RED( dwColor );
m_rgflPointsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
m_rgflPointsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
m_rgflPointsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
++m_dwPointsToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a textured quad
//-----------------------------------------------------------------------------
bool CGameEnginePS3::BDrawTexturedQuad( float xPos0, float yPos0, float xPos1, float yPos1, float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
{
if ( m_bShuttingDown || !m_pPSGLDevice || !m_pPSGLContext )
return false;
// Find the texture
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if ( iter == m_MapTextures.end() )
{
OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
return false;
}
// Check if we are out of room and need to flush the buffer, or if our texture is changing
// then we also need to flush the buffer.
if ( m_dwQuadsToFlush == QUAD_BUFFER_TOTAL_SIZE || m_hLastTexture != hTexture )
{
BFlushQuadBuffer();
}
// Bind the new texture
glBindTexture( GL_TEXTURE_2D, iter->second.m_uTextureID );
DWORD dwOffset = m_dwQuadsToFlush*12;
m_rgflQuadsData[dwOffset] = xPos0;
m_rgflQuadsData[dwOffset+1] = yPos0;
m_rgflQuadsData[dwOffset+2] = 1.0;
m_rgflQuadsData[dwOffset+3] = xPos1;
m_rgflQuadsData[dwOffset+4] = yPos0;
m_rgflQuadsData[dwOffset+5] = 1.0;
m_rgflQuadsData[dwOffset+6] = xPos1;
m_rgflQuadsData[dwOffset+7] = yPos1;
m_rgflQuadsData[dwOffset+8] = 1.0;
m_rgflQuadsData[dwOffset+9] = xPos0;
m_rgflQuadsData[dwOffset+10] = yPos1;
m_rgflQuadsData[dwOffset+11] = 1.0;
dwOffset = m_dwQuadsToFlush*16;
m_rgflQuadsColorData[dwOffset] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+4] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+5] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+6] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+7] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+8] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+9] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+10] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+11] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+12] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+13] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+14] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+15] = COLOR_ALPHA( dwColor );
dwOffset = m_dwQuadsToFlush*8;
m_rgflQuadsTextureData[dwOffset] = u0;
m_rgflQuadsTextureData[dwOffset+1] = v0;
m_rgflQuadsTextureData[dwOffset+2] = u1;
m_rgflQuadsTextureData[dwOffset+3] = v0;
m_rgflQuadsTextureData[dwOffset+4] = u1;
m_rgflQuadsTextureData[dwOffset+5] = v1;
m_rgflQuadsTextureData[dwOffset+6] = u0;
m_rgflQuadsTextureData[dwOffset+7] = v1;
++m_dwQuadsToFlush;
return true;
}
int GImageWrite_Png(GImage *gi, FILE *fp, int progressive) {
struct _GImage *base = gi->list_len==0?gi->u.image:gi->u.images[0];
png_structp png_ptr;
png_infop info_ptr;
png_byte **rows;
int i;
int bit_depth;
int color_type;
int num_palette;
png_bytep trans_alpha = NULL;
png_color_16p trans_color = NULL;
png_colorp palette = NULL;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(void *)NULL, user_error_fn, user_warning_fn);
if (!png_ptr) {
return(false);
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return(false);
}
#if (PNG_LIBPNG_VER < 10500)
if (setjmp(png_ptr->jmpbuf))
#else
if (setjmp(*png_set_longjmp_fn(png_ptr, longjmp, sizeof (jmp_buf))))
#endif
{
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return(false);
}
png_init_io(png_ptr, fp);
bit_depth = 8;
num_palette = base->clut==NULL?2:base->clut->clut_len;
if ( base->image_type==it_index || base->image_type==it_bitmap ) {
color_type = PNG_COLOR_TYPE_PALETTE;
if ( num_palette<=2 )
bit_depth=1;
else if ( num_palette<=4 )
bit_depth=2;
else if ( num_palette<=16 )
bit_depth=4;
} else {
color_type = PNG_COLOR_TYPE_RGB;
if ( base->image_type == it_rgba )
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
}
png_set_IHDR(png_ptr, info_ptr, base->width, base->height,
bit_depth, color_type, progressive,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
if ( base->image_type==it_index || base->image_type==it_bitmap ) {
palette = (png_color *) galloc(num_palette*sizeof(png_color));
if ( base->clut==NULL ) {
palette[0].red = palette[0].green = palette[0].blue = 0;
palette[1].red = palette[1].green = palette[1].blue = 0xff;
} else {
for ( i=0; i<num_palette; ++i ) {
long col = base->clut->clut[i];
palette[i].red = COLOR_RED(col);
palette[i].green = COLOR_GREEN(col);
palette[i].blue = COLOR_BLUE(col);
}
}
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
if ( num_palette<=16 )
png_set_packing(png_ptr);
if ( base->trans!=-1 ) {
trans_alpha = (png_bytep) galloc(1);
trans_alpha[0] = base->trans;
}
} else {
if ( base->trans!=-1 ) {
trans_color = (png_color_16p) galloc(sizeof(png_color_16));
trans_color->red = COLOR_RED(base->trans);
trans_color->green = COLOR_GREEN(base->trans);
trans_color->blue = COLOR_BLUE(base->trans);
}
}
if ( base->trans!=-1 ) {
png_set_tRNS(png_ptr, info_ptr, trans_alpha, 1, trans_color);
}
png_write_info(png_ptr, info_ptr);
if (color_type == PNG_COLOR_TYPE_RGB)
png_set_filler(png_ptr, '\0', PNG_FILLER_BEFORE);
rows = (png_byte **) galloc(base->height*sizeof(png_byte *));
for ( i=0; i<base->height; ++i )
rows[i] = (png_byte *) (base->data + i*base->bytes_per_line);
png_write_image(png_ptr,rows);
png_write_end(png_ptr, info_ptr);
if ( trans_alpha!=NULL ) gfree(trans_alpha);
if ( trans_color!=NULL ) gfree(trans_color);
if ( palette!=NULL ) gfree(palette);
png_destroy_write_struct(&png_ptr, &info_ptr);
gfree(rows);
return( 1 );
}
//-----------------------------------------------------------------------------
// Purpose: Draw a textured quad
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawVRScreenQuad()
{
if ( m_bShuttingDown )
return false;
// Check if we are out of room and need to flush the buffer, or if our texture is changing
// then we also need to flush the buffer.
if ( m_dwQuadsToFlush > 0 )
{
BFlushQuadBuffer();
}
// Bind the new texture
glBindTexture( GL_TEXTURE_2D, m_pVRGLHelper->GetUITexture() );
float fHeight = m_pVRGLHelper->GetAspectRatio();
DWORD dwOffset = m_dwQuadsToFlush*12;
m_rgflQuadsData[dwOffset] = -1.f;
m_rgflQuadsData[dwOffset+1] = -fHeight;
m_rgflQuadsData[dwOffset+2] = -2.f;
m_rgflQuadsData[dwOffset+3] = 1.f;
m_rgflQuadsData[dwOffset+4] = -fHeight;
m_rgflQuadsData[dwOffset+5] = -2.f;
m_rgflQuadsData[dwOffset+6] = 1.f;
m_rgflQuadsData[dwOffset+7] = fHeight;
m_rgflQuadsData[dwOffset+8] = -2.f;
m_rgflQuadsData[dwOffset+9] = -1.f;
m_rgflQuadsData[dwOffset+10] = fHeight;
m_rgflQuadsData[dwOffset+11] = -2.f;
uint32 dwColor = 0xFFFFFFFF;
dwOffset = m_dwQuadsToFlush*16;
m_rgflQuadsColorData[dwOffset] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+4] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+5] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+6] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+7] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+8] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+9] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+10] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+11] = COLOR_ALPHA( dwColor );
m_rgflQuadsColorData[dwOffset+12] = COLOR_RED( dwColor );
m_rgflQuadsColorData[dwOffset+13] = COLOR_GREEN( dwColor );
m_rgflQuadsColorData[dwOffset+14] = COLOR_BLUE( dwColor );
m_rgflQuadsColorData[dwOffset+15] = COLOR_ALPHA( dwColor );
dwOffset = m_dwQuadsToFlush*8;
m_rgflQuadsTextureData[dwOffset] = 0;
m_rgflQuadsTextureData[dwOffset+1] = 0;
m_rgflQuadsTextureData[dwOffset+2] = 1.f;
m_rgflQuadsTextureData[dwOffset+3] = 0;
m_rgflQuadsTextureData[dwOffset+4] = 1.f;
m_rgflQuadsTextureData[dwOffset+5] = 1.f;
m_rgflQuadsTextureData[dwOffset+6] = 0;
m_rgflQuadsTextureData[dwOffset+7] = 1.f;
++m_dwQuadsToFlush;
return true;
}
