---

image.h

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/07 19:02:17 $
// By           :       $Author: kolrabi $
// $Id: image.h,v 1.1.1.1 2002/12/07 19:02:17 kolrabi Exp $ 

/*

  $Log: image.h,v $
  Revision 1.1.1.1  2002/12/07 19:02:17  kolrabi
  initial release


*/

#include            "forward.h"
#include "omicron.h"    // Hinzugefügt von der Klassenansicht

/**************************************************************************** 
 **************************************************************************** 
 * DEFINES ****************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
/* IMAGE TYPES **************************************************************/ 
#define             IMAGE_TGA                   1 
// #define         IMAGE_BMP                   2 
// #define         IMAGE_JPG                   3
// #define         IMAGE_PNG                   4

#define             ANIM_ONESHOT                1
#define             ANIM_LOOP                   2
#define             ANIM_PINGPONG               3
 
/**************************************************************************** 
 **************************************************************************** 
 * TYPES ******************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
#ifndef             OMICRON_TYPES_IMAGE_DEFINED 
#define             OMICRON_TYPES_IMAGE_DEFINED

class image_c
{ 

protected:
        void update_tex();

    friend class texture_manager_c;

    ushort          width;              
    ushort          height;             
 
    char            *buf;               
    ulong           buflen;             
 
    bool            hasalpha;           

    char            bpp;                

    bool
        load_tga_rgb(struct file_s *file);

    bool
        load_tga_rgbrle(struct file_s *file);

    bool                                
        load_tga(const char *filename);

    bool
        prepare_blt(image_c *src, sshort &sx, sshort &sy, 
            sshort &x, sshort &y, sshort &w, sshort &h);
public:
        sshort tex;
        bool dirty;

                    image_c();
    virtual         ~image_c();

    virtual void
        create(ushort x, ushort y);

    virtual bool
        load(const char *filename);

    void
        copy(image_c *src);

    void
        draw(ushort x, ushort y);

    inline ushort   
        get_width() const;

    inline ushort   
        get_height() const;

    virtual inline const char *
        get_pixels() const;

    inline ulong    
        get_buffer_len() const;

    inline char     
        get_bpp() const;

    inline bool     
        get_has_alpha() const;

    // manipulations

    void
        stamp(image_c *src, sshort x, sshort y);

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

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

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

    void
        crop(sshort x, sshort y, sshort w, sshort h);

    void
        set_pixel(sshort x, sshort y, color_t color);

    color_t
        get_pixel(sshort x, sshort y);

    void
        vline(sshort x, sshort y, sshort h, color_t color);

    void
        hline(sshort x, sshort y, sshort w, color_t color);

    void
        line(sshort x, sshort y, sshort w, sshort h, color_t color);

    void
        rectangle(sshort x, sshort y, sshort w, sshort h, color_t color);

    void
        filled_rectangle(sshort x, sshort y, sshort w, sshort h, color_t color);

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

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

    void
        mirror_vertical();

    void
        rgb2yuv();

    void
        yuv2rgb();
}; 

// inlines

inline ushort image_c::get_width() const
{
    AssertThisV;    return width;
}

inline ushort image_c::get_height() const
{
    AssertThisV;    return height;
}

inline const char *image_c::get_pixels() const
{ 
    AssertThisV;    return buf;
}

inline ulong image_c::get_buffer_len() const
{
    AssertThisV;    return buflen;
}

inline char image_c::get_bpp() const
{ 
    AssertThisV;    return bpp;
}

inline bool image_c::get_has_alpha() const
{
    AssertThisV;    return hasalpha;  
}

class animation_c:public image_c
{
protected:

    ushort          framecount;         
    ushort          fps;                
    sshort          frame;              

    ulong           nextframetime;      

    image_c         *img;               

    sshort          playdir;            
    sshort          playtype;           

public:

                    animation_c();
    virtual         ~animation_c();

    void
        set_framecount(ushort f);

    image_c *
        set_frame(ushort f);

    bool
        load(char *filename);

    void
        set_fps(ushort f);

    void
        play(sshort type);

    void
        stop();

    const char *
        get_pixels();
};

#endif

---