---

x_image.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/08 20:08:15 $
// By           :       $Author: kolrabi $
// $Id: x_image.cpp,v 1.2 2002/12/08 20:08:15 kolrabi Exp $ 

/*

  $Log: x_image.cpp,v $
  Revision 1.2  2002/12/08 20:08:15  kolrabi
  Now really runs under X11

  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/

#include            "omicron/internal.h"
#include            "omicron/file.h"
#include            "omicron/render.h"
#include            "omicron/texture.h"
#include            "omicron/image.h"
// #include            "omicron/string.h"
#include            <string>

/**************************************************************************** 
 **************************************************************************** 
 * BITMAP ROUTINES ********************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

image_c::image_c()
{
    buf             = NULL;
    buflen          = 0;
    width = height  = 0;
    bpp             = 0;
    hasalpha        = false;
    tex             = INVALID_INDEX;
    dirty           = true;
}

image_c::~image_c()
{
    AssertThis;

    SafeArrayDelete(buf); 
}

void
image_c::create
(
        ushort                  x,                                      
        ushort                  y                                       
)
{
    AssertThis;

    SafeArrayDelete(buf); 

    buflen              = x*y*4;
    buf                 = new char[buflen*2]; // FIXME: *2 ??
    width               = x;
    height              = y;
    hasalpha    = 0;
    bpp                 = 32;
    tex         = INVALID_INDEX;
    dirty           = true;
}

bool
image_c::load
(
        const char *    filename                        
)
{ 
    AssertThisV;

    std::string szFilename = filename;

    szFilename = szFilename + ".tga";

    if (load_tga(szFilename.c_str()))
        return true;

    dirty           = true;
    return false;
} 
 
 
/**************************************************************************** 
 * _image_mirror_v                               mirror an image vertically * 
 ****************************************************************************/ 
void
image_c::mirror_vertical
()
{ 
    AssertThis;

    char        *b = NULL; 
 
    // allocate memory for one line 
    b = new char[ 4 * width ]; 
    AssertReturn1(b);
 
    // for every line 
    for (sshort i=0; i<height/2; i++) 
    { 
        sshort h2 = height - i - 1; 
 
        // save line i to buffer 
        memcpy( b, buf+width * 4 * i, 4*width ); 
 
        // move line h2 to line i 
        memcpy( buf+width * 4 * i, 
                buf+4*width * h2, 4*width ); 
 
        // move saved line to line h2 
        memcpy( buf + 4*width * h2, b, 4 * width ); 
    } 
 
    SafeArrayDelete(b); 
    dirty           = true;
} // _image_mirror_v 
 
 
 
/**************************************************************************** 
 * _image_stamp                             alphablits an image into another* 
 ****************************************************************************/ 
void
image_c::stamp
( 
    image_c *           src,                            
    sshort                      x,                  
    sshort                      y                                       
) 
{ 
    AssertThis;

    blt_blend(src, 0, 0, x-src->width/2, y-src->height/2, src->width, src->height, BT_BLEND);
    dirty           = true;
} 

bool
image_c::prepare_blt
(
    image_c *           src,                            
    sshort &            sx,                                     
    sshort &            sy,                                     
    sshort &            x,                                      
    sshort &            y,                                      
    sshort &            w,                                      
    sshort &            h                                       
)
{
    if (sx<0 || sy<0 || w<=0 || h<=0)
        return false;

    if (w>=src->get_width()) w = src->get_width();
    if (h>=src->get_height()) h = src->get_height();

    if (x>width)    return false;
    if (y>height)   return false;

    if (x<0) 
    { 
        sx  -= x; 
        w   += x; 
        x    = 0;
    }
    if (y<0) 
    { 
        sy  -= y; 
        h   += y; 
        y    = 0;
    }

    if (x+w>=width)     { w -= x+w-width;   }
    if (y+h>=height)    { h -= y+h-height;  }

    if (sx<0 || sy<0 || w<=0 || h<=0)
        return false;

    return true;
}

void
image_c::blt
(
        image_c *               src,                            
    sshort                      sx,                                     
    sshort                      sy,                                     
    sshort                      x,                                      
    sshort                      y,                                      
    sshort                      w,                                      
    sshort                      h                                       
)
{
    AssertThis;

    AssertReturn3(src, buf, src->get_pixels());
    if (!prepare_blt(src, sy, sy, x, y, w, h))
        return;
 
    ulong   sp, dp; 
    ushort  v; 
 
    const char *srcbuf = src->get_pixels();
 
    v = sy;
    for (ushort yy=y; yy<y+h; yy++) 
    { 
        sp = sx+v*src->width; 
        dp = x +yy*width; 

        if (dp*4+3>buflen || sp*4+3>src->get_buffer_len())
            break;

        memcpy(buf+dp*4, srcbuf+sp*4, 4*w);
        v++; 
    } 
    dirty           = true;
}

void
image_c::blt_blend
(
        image_c *               src,                            
    sshort                      sx,                                     
    sshort                      sy,                                     
    sshort                      x,                                      
    sshort                      y,                                      
    sshort                      w,                                      
    sshort                      h,                                      
        sshort                  blendtype                       
)
{
    AssertThis;

    if (blendtype==BT_OPAQUE)
    {
        blt(src, sx, sy, x, y, w, h);
        return;
    }

    if (blendtype==BT_NONE)
        return;

    AssertReturn3(src, buf, src->get_pixels());
    if (!prepare_blt(src, sy, sy, x, y, w, h))
        return;

    const char            *srcbuf = src->get_pixels();
    uchar   r1,g1,b1,a1; 
    uchar   r2,g2,b2,a2; 

    ulong           sp, dp; 
    ulong           u,  v; 
 
    u = sx;
    for (sshort xx=x; xx<x+w; xx++) 
    { 
        v = sy;
        for (sshort yy=y; yy<y+h; yy++) 
        { 
            sp = u+v*src->width; 
            dp = xx+yy*width; 

            AssertReturn2(dp*4+3<=buflen, sp*4+3<=src->get_buffer_len());

            a1 = (uchar)buf[dp*4+3];
            a2 = (uchar)srcbuf[sp*4+3];
 
            float alpha = a2/(float)255; 

            r1 = buf[dp*4+0]; 
            g1 = buf[dp*4+1]; 
            b1 = buf[dp*4+2]; 
 
            r2 = srcbuf[sp*4+0]; 
            g2 = srcbuf[sp*4+1]; 
            b2 = srcbuf[sp*4+2]; 

            switch (blendtype)
            {
                case BT_ALPHATEST:
                    if (a2>0.5)
                    {
                        buf[dp*4+0] = (char)(r1*(1-alpha)+r2*alpha); 
                        buf[dp*4+1] = (char)(g1*(1-alpha)+g2*alpha); 
                        buf[dp*4+2] = (char)(b1*(1-alpha)+b2*alpha); 
                        buf[dp*4+3] = a2;
                    }
                    break;

                case BT_ADD:
                    buf[dp*4+0] += r2; 
                    buf[dp*4+1] += g2; 
                    buf[dp*4+2] += b2; 
                    buf[dp*4+3] += a2;
                    break;

                case BT_MODULATE:
                    buf[dp*4+0] = (char)(((float)r2/255.0f+(float)r1/255.0f)*255); 
                    buf[dp*4+1] = (char)(((float)g2/255.0f+(float)g1/255.0f)*255); 
                    buf[dp*4+2] = (char)(((float)b2/255.0f+(float)b1/255.0f)*255); 
                    buf[dp*4+3] = (char)(((float)a2/255.0f+(float)a1/255.0f)*255);
                    break;

                case BT_BLEND:
                    buf[dp*4+0] = (char)(r1*(1-alpha)+r2*alpha); 
                    buf[dp*4+1] = (char)(g1*(1-alpha)+g2*alpha); 
                    buf[dp*4+2] = (char)(b1*(1-alpha)+b2*alpha); 
                    if (a1<a2)
                        buf[dp*4+3] = a2;
                    break;

            }
 
            v++; 
        } 
 
        u++; 
    } 
    dirty           = true;
}

void
image_c::color_blend
(
        image_c *               src,                            
    sshort                      sx,                                     
    sshort                      sy,                                     
    sshort                      x,                                      
    sshort                      y,                                      
    sshort                      w,                                      
    sshort                      h,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn3(src, buf, src->get_pixels());
    if (!prepare_blt(src, sy, sy, x, y, w, h))
        return;

    const char            *srcbuf = src->get_pixels();

    // colors
    uchar           r1,g1,b1,a1; 
    uchar           r2,g2,b2,a2; 
 
    ulong           sp, dp; 
    sshort          u,v; 
 
    u = sx;
    for (sshort xx=0; xx<w; xx++) 
    { 
        AssertReturn2(u<src->get_width(), xx+x<width);

        v = sy;
        for (sshort yy=0; yy<h; yy++) 
        { 
            AssertReturn2(v<src->get_height(), yy+y<height);

            sp = u+v*src->width;
            dp = (xx+x)+(y+yy)*width; 

            AssertReturn2(dp*4+3<=buflen, sp*4+3<=src->get_buffer_len());

            a1 = (uchar)buf[dp*4+3];
            a2 = (uchar)srcbuf[sp*4+3];
 
            float alpha = a2/(float)255; 

            r1          = buf[dp*4+0]; 
            g1          = buf[dp*4+1]; 
            b1          = buf[dp*4+2]; 
 
            r2          = (uchar)(color&0xFF);
            g2          = (uchar)((color>>8)&0xFF);
            b2          = (uchar)((color>>16)&0xFF);

            buf[dp*4+0] = (uchar)(r1*(1-alpha)+r2*alpha); 
            buf[dp*4+1] = (uchar)(g1*(1-alpha)+g2*alpha); 
            buf[dp*4+2] = (uchar)(b1*(1-alpha)+b2*alpha); 

            sshort na = a1+a2;

            if (na>255) na = 255;

            buf[dp*4+3] = (uchar)na;

            v++; 
        } 
 
        u++; 
    } 
    dirty           = true;
}

void
image_c::copy
(
        image_c *               src                                     
)
{
    AssertThis;

    AssertReturn2(src, src->get_pixels());

    SafeDelete(buf);

    buf = new char[src->get_buffer_len()];

    AssertReturn1(buf);

    const char *srcbuf = src->get_pixels();

    memcpy(buf, srcbuf, src->get_buffer_len());
    buflen      = src->buflen;
    bpp         = src->bpp;
    width       = src->width;
    height      = src->height;
    hasalpha    = src->hasalpha;
    dirty           = true;
}

void
image_c::crop
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  w,                                      
        sshort                  h                                       
)
{
    AssertThis;

    AssertReturn2(w>0, h>0);

    x = x % width;
    y = y % height;

    char *buf2 = new char[w*h*4*2];

    AssertReturn1(buf2);

    for (sshort xx=0; xx<w; xx++)
    {
        for (sshort yy=0; yy<h; yy++)
        {
            sshort srcx = xx+x;
            sshort srcy = yy+y;

            srcx %= width;
            srcy %= height;

            memcpy(&buf2[(xx+yy*w)*4], &buf[(srcx+srcy*width)*4], 4);
        }
    }

    SafeArrayDelete(buf);
    buf     = buf2;
    buflen  = w*h*4;
    width   = w;
    height  = h;
    dirty           = true;
}

void image_c::draw
(
    ushort                      x,                                      
        ushort                  y                                       
)
{
    AssertThis;

    if (dirty)
        update_tex();

    if (tex==INVALID_INDEX)
    {
        const char *srcbuf = get_pixels();
        AssertReturn1(srcbuf);

        glRasterPos2s(x,gv.init.vres-y-1);

        glViewport(x,gv.init.vres-y,width,height);

        gv.renderer->set_blending(BT_BLEND);

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
        glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, srcbuf);

        glViewport(0,0,gv.init.hres, gv.init.vres);
    }
    else
    {
        gv.renderer->set_texture_params(TF_NEAREST, TF_NEAREST, TW_CLAMP, TW_CLAMP);
        gv.renderer->draw_pic(x,gv.init.vres-y-height, x+width, gv.init.vres-y, 0,0,1,1,tex,BT_BLEND);
    }
}

void
image_c::vline
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  h,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn1(buf);

    if (x<0 || x>=width)    { return; };

    if (h+y>=height)        h = height-y-1;
    if (y<0)                { h+=y; y=0; };

    char *startpos = buf+(x+y*width)*4;
    char col[4] = { 
        (char)((color>>0)&0xFF), 
        (char)((color>>8)&0xFF), 
        (char)((color>>16)&0xFF), 
        (char)((color>>24)&0xFF) };

    for (sshort i=0; i<h; i++)
        memcpy(startpos+i*4*width, col, 4);
    dirty = true;
}

void
image_c::hline
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  w,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn1(buf);

    if (w+x>=width)         w = width-x;
    if (x<0)                { w+=x; x=0; };
    if (y<0||y>=height)     { return; };

    char *startpos = buf+(x+y*width)*4;
    char col[4] = { 
        (char)((color>>0)&0xFF), 
        (char)((color>>8)&0xFF), 
        (char)((color>>16)&0xFF), 
        (char)((color>>24)&0xFF) };

    for (sshort i=0; i<w; i++)
        memcpy(startpos+i*4, col, 4);
    dirty = true;
}

void
image_c::line
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  w,                                      
        sshort                  h,                                      
        color_t                 color                           
)
{
    AssertThis;

    sshort   Ax = x, Ay = y, Bx = x+w, By = y+h;
    //------------------------------------------------------------------------
    // INITIALIZE THE COMPONENTS OF THE ALGORITHM THAT ARE NOT AFFECTED BY THE
    // SLOPE OR DIRECTION OF THE LINE
    //------------------------------------------------------------------------
    sshort dX = abs(Bx-Ax);// store the change in X and Y of the line endpoints
    sshort dY = abs(By-Ay);

    //------------------------------------------------------------------------
    // DETERMINE "DIRECTIONS" TO INCREMENT X AND Y (REGARDLESS OF DECISION)
    //------------------------------------------------------------------------
    sshort Xincr, Yincr;
    if (Ax > Bx) { Xincr=-1; } else { Xincr=1; }// which direction in X?
    if (Ay > By) { Yincr=-1; } else { Yincr=1; }// which direction in Y?

    //------------------------------------------------------------------------
    // DETERMINE INDEPENDENT VARIABLE (ONE THAT ALWAYS INCREMENTS BY 1 (OR -1) )
    // AND INITIATE APPROPRIATE LINE DRAWING ROUTINE (BASED ON FIRST OCTANT
    // ALWAYS). THE X AND Y'S MAY BE FLIPPED IF Y IS THE INDEPENDENT VARIABLE.
    //------------------------------------------------------------------------
    if (dX >= dY)// if X is the independent variable
    {          
        sshort dPr  = dY<<1;           // amount to increment decision if right is chosen (always)
        sshort dPru = dPr - (dX<<1);   // amount to increment decision if up is chosen
        sshort P    = dPr - dX;        // decision variable start value

        for (; dX>=0; dX--)         // process each point in the line one at a time (just use dX)
        {
            set_pixel(Ax, Ay, color); // plot the pixel
            if (P > 0)               // is the pixel going right AND up?
            {
                Ax+=Xincr;       // increment independent variable
                Ay+=Yincr;         // increment dependent variable
                P+=dPru;           // increment decision (for up)
            }
            else                     // is the pixel just going right?
            {
                Ax+=Xincr;         // increment independent variable
                P+=dPr;            // increment decision (for right)
            }
        }
    }
    else              // if Y is the independent variable
    {
        sshort dPr = dX<<1;           // amount to increment decision if right is chosen (always)
        sshort dPru = dPr - (dY<<1);   // amount to increment decision if up is chosen
        sshort P = dPr - dY;  // decision variable start value

        for (; dY>=0; dY--)            // process each point in the line one at a time (just use dY)
        {
            set_pixel(Ax, Ay, color); // plot the pixel
            if (P > 0)               // is the pixel going up AND right?
            {
                Ax+=Xincr;         // increment dependent variable
                Ay+=Yincr;         // increment independent variable
                P+=dPru;           // increment decision (for up)
            }
            else                     // is the pixel just going up?
            {
                Ay+=Yincr;         // increment independent variable
                P+=dPr;            // increment decision (for right)
            }
        }
    }
    dirty = true;
}

void
image_c::rectangle
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  w,                                      
        sshort                  h,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn1(buf);

    hline(x,        y,      w,color);
    hline(x,        y+h-1,  w,color);
    vline(x,        y,      h,color);
    vline(x+w-1,    y,      h,color);
    dirty = true;
}

void
image_c::filled_rectangle
(
        sshort                  x,                                      
        sshort                  y,                                      
        sshort                  w,                                      
        sshort                  h,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn1(buf);

    for (sshort i=0; i<h; i++)
        hline(x,y+i,w, color);
    dirty = true;
}

sshort
image_c::draw_char
(
        sshort                  x,                                      
        sshort                  y,                                      
        uchar                   c,                                      
        struct font_s * fnt,                            
        color_t                 color                           
)
{
    AssertThisV;

    AssertReturnValue1(fnt, 0);

    sshort w = fnt->widths[c];

    color_blend(fnt->images[c], 0, 0, x, y, fnt->width, fnt->height, color);

    dirty = true;
    return w;
}

sshort
image_c::draw_string
(
        sshort                  x,                                      
        sshort                  y,                                      
        const char *    c,                                      
        struct font_s * fnt,                            
        color_t                 color                           
)
{
    AssertThisV;

    AssertReturnValue2(c,fnt,0);

    sshort w = 0;

    for (ulong i=0; i<strlen(c); i++)
        w+=draw_char(x+w,y,c[i],fnt, color);

    dirty = true;
    return w;
}


animation_c::animation_c()
{
    img = new image_c;
    frame = 0;
    fps = 0;
    framecount = 0;
}

animation_c::~animation_c()
{
    AssertThis;

    SafeDelete(img);
}

bool
animation_c::load
(
        char *                  filename                        
)
{
    AssertThisV;

    AssertReturnValue1(filename, false);

    img->load(filename);
    set_framecount(1);
    set_frame(0);
    set_fps(0);

    return true;
}

void
animation_c::set_framecount
(
        ushort                  f                                       
)
{
    AssertThis;

    AssertReturn3(f, img, f<img->get_width());

    image_c::create(img->get_width()/f,img->get_height());

    framecount = f;
}

void
animation_c::set_fps
(
        ushort                  f                                       
) 
{
    AssertThis;

    fps = f;
}

image_c *
animation_c::set_frame
(
        ushort                  f                                       
)
{
    AssertThisV;

    frame = f;
    blt(img, (img->get_width()*f/framecount), 0, 0, 0, width, height);
    return this;
}

void
animation_c::play
(
        sshort                  type                            
)
{
    AssertThis;

    playtype = type;

    set_frame(0);
    playdir = 1;

    if (fps)
        nextframetime = _time_get()+1000/fps;
}

const char *
animation_c::get_pixels
()
{
    AssertThisV;

    if (_time_get()>=nextframetime)
    {
        frame+=playdir;

        if (frame>=framecount)
        {
            if (playtype == ANIM_PINGPONG)
            {
                playdir = -1;
                frame = framecount-1;
            }
            else if (playtype == ANIM_LOOP)
            {
                frame = 0;
            }
            else
            {
                playtype = 0;
                playdir = 0;
                frame = 0;
            }
        } else
        {
            if (frame<0)
            {
                if (playtype == ANIM_PINGPONG)
                {
                    playdir = 0;
                    frame   = 0;
                }
            }
        }

        if (playdir)
            nextframetime = _time_get()+1000/fps;
    }

    set_frame(frame);
    dirty = true;

    return image_c::get_pixels();
}

void
image_c::rgb2yuv
()
{
    AssertThis;

    AssertReturn1(buf);

    for (ulong x=0; x<width; x++)
        for (ulong y=0; y<height; y++)
        {
            float r,g,b, yy,u,v;

            r = buf[(x+y*width)*4+0];
            g = buf[(x+y*width)*4+1];
            b = buf[(x+y*width)*4+2];

            yy = 0.299f*r + 0.587f*g + 0.114f*b;
            u = (b-yy)*0.565f;
            v = (r-yy)*0.713f;

            buf[(x+y*width)*4+0]=(char)y;
            buf[(x+y*width)*4+1]=(char)u;
            buf[(x+y*width)*4+2]=(char)v;
        }

    dirty = true;
}

void
image_c::yuv2rgb
()
{
    AssertThis;

    AssertReturn1(buf);

    for (ulong x=0; x<width; x++)
        for (ulong y=0; y<height; y++)
        {
            float r,g,b, yy,u,v;

            yy = buf[(x+y*width)*4+0];
            u = buf[(x+y*width)*4+1];
            v = buf[(x+y*width)*4+2];

            r = yy + 1.403f;
            g = yy - 0.344f*u - 0.714f*v;
            b = yy + 1.770f*u;

            buf[(x+y*width)*4+0]=(char)r;
            buf[(x+y*width)*4+1]=(char)g;
            buf[(x+y*width)*4+2]=(char)b;
        }
    dirty = true;
}



void
image_c::set_pixel
(
        sshort                  x,                                      
        sshort                  y,                                      
        color_t                 color                           
)
{
    AssertThis;

    AssertReturn1(buf);
    AssertReturn4(x>=0, x<width, y>=0, y<height);

    char col[4] = { 
        (char)((color>>0)&0xFF), 
        (char)((color>>8)&0xFF), 
        (char)((color>>16)&0xFF), 
        (char)((color>>24)&0xFF) };

    memcpy(buf+(x+y*width)*4, col, 4);

    dirty = true;
}


void image_c::update_tex()
{
    if (!dirty)
        return;

    if (tex == INVALID_INDEX)
        tex = gv.texman->create(width, height, "*pic");

    gv.texman->set_image(tex, this, true, true);
    dirty = false;
}

---