//-----------------------------------------------------------------------------
// 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;
}
void Character::SendTell(Character *target, char *arg)
{
target->send(COLOR_RED(target, CL_NORMAL));
sprintf(buf, "$n tells you, '%s'", (char*)this->ScrambleSpeech(arg, target).c_str());
Act(buf, FALSE, this, 0, target, TO_VICT | TO_SLEEP);
target->send(COLOR_NORMAL(target, CL_NORMAL));
if(!IS_NPC(target) && NEWB_FLAGGED(target, NEW_TELL) && !IS_NPC(this))
{
REMOVE_BIT_AR(NEWB_FLAGS(target), NEW_TELL);
target->NewbieTip("You can reply to %s by typing 'reply' followed by the message you wish to send.\r\n",
GET_NAME(this), GET_NAME(this));
}
if (!IS_NPC(this) && PRF_FLAGGED(this, PRF_NOREPEAT))
this->send(OK);
else
{
CommManager::GetManager().SaveComm(std::string("tell"), arg, this, this->in_room->getVnum(), target);
sprintf(buf, "You tell $N, '%s'", arg);
Act(buf, FALSE, this, 0, target, TO_CHAR);
if(IS_NPC(target) && !IS_NPC(this))
MudLog(CMP, MAX(GET_LEVEL(this), LVL_GOD), TRUE, "%s tells %s '%s' in room %d.",
GET_NAME(this), GET_NAME(target), arg, this->in_room->getVnum());
if(this->IsIgnoring(target->player.name))
this->RemoveIgnore(target->player.name);
}
if (!IS_NPC(target) && !IS_NPC(this))
target->last_tell = this->player.idnum;
js_tell_triggers(this, target, arg);
}
//-----------------------------------------------------------------------------
// 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;
}
static void bga_drawimg( img_t *img, uint16_t x, uint16_t y, uint16_t ox,
uint16_t oy, uint16_t w, uint16_t h )
{
uint8_t sk = 4;
uint8_t usealpha = 1;
uint8_t idx = 0;
if ( (img->depth == IMG_DP_16COL) || (img->depth == IMG_DP_256COL) )
{
idx = 1;
sk = 1;
usealpha = 0;
}
else if ( img->depth == IMG_DP_RGB8 )
{
idx = 0;
sk = 3;
usealpha = 0;
}
else if ( img->depth != IMG_DP_RGBA8 )
{
/* not supported */
bga_drawrect(x,y,w,h,COLOR_RED(255));
return;
}
uint16_t px, py;
uint16_t lx, ly;
uint16_t iw, ih;
iw = img->w*sk;
ih = img->h;
px = x;
py = y;
lx = x+w;
ly = y+h;
uint16_t ix, iy;
ix = (ox*sk);
iy = oy;
color_t imgc;
while ( (px < lx) && (py < ly) )
{
if ( idx )
{
imgc.r = bga_fbpal[img->data[ix+iy*iw]&15].r;
imgc.g = bga_fbpal[img->data[ix+iy*iw]&15].g;
imgc.b = bga_fbpal[img->data[ix+iy*iw]&15].b;
imgc.a = bga_fbpal[img->data[ix+iy*iw]&15].a;
if ( img->data[ix+iy*iw] == 0xFF )
imgc = bga_getpixel(px,py);
}
else
{
imgc.r = img->data[ix+iy*iw];
imgc.g = img->data[ix+iy*iw+1];
imgc.b = img->data[ix+iy*iw+2];
imgc.a = (usealpha)?img->data[ix+iy*iw+3]:0xFF;
}
bga_putpixel(px,py,imgc);
ix+=sk;
if ( ix >= (iw*sk) )
ix = (ox*sk);
if ( (++px) < lx )
continue;
ix = (ox*sk);
px = x;
py++;
if ( (++iy) < ih )
continue;
iy = oy;
}
}
//-----------------------------------------------------------------------------
// 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;
}
