---

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

/*

  $Log: f_out.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/

#include            "omicron/internal.h"
#include            "omicron/file.h"
#include            "omicron/list.h"
#include            "omicron/array.h"
#include            <string.h>
 
/**************************************************************************** 
 **************************************************************************** 
 * ROUTINES ***************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

slong
file_manager_c::putch
( 
    slong                       c,                                      
    file_t *            file                            
) 
{ 
    AssertReturnValue2(file, file->buf, EOF);

    char        ch = c & 0xFF;

    write(&ch, 1, 1, file);

    return c;
} // putch 
 
slong
file_manager_c::puts
( 
    const char *        string,                         
    file_t *            file                            
) 
{ 
    slong           c   =   strlen(string); 
    slong           count = 0;

    AssertReturnValue3(string, file, file->buf, EOF);
 
    do
    { 
        putch(*string, file);
        c--; string++; count ++;
    } 
    while(c);
 
    return count; 
} // puts

void
file_manager_c::putpixel 
( 
    file_t *            file,                           
    char                        r,                                      
    char                        g,                                      
    char                        b,                                      
    char                        a,                                      
    char                        bpp                 
) 
{ 
    AssertReturn1(file);

    switch(bpp) 
    { 
        case 32:                    // 32 bits are easy 
            putch( r, file ); 
            putch( g, file ); 
            putch( b, file ); 
            putch( a, file ); 
            break; 
 
        case 24:                    // 24 too 
            putch( r, file ); 
            putch( g, file ); 
            putch( b, file ); 
            break; 
 
        case 16:                    // wtf... ? ;) 
            // msb in byte 1 indicates alpha state if its set 
            // make pixel non transparent 
 
            char c1,c2; 
 
            c1 = ((a?0x80:0)) | ((r>>1)&124) | ((g>>6)&3);
            c2 = ((g<<2)&224) | ((b>>3)&31);
 
            putch( c1, file ); 
            putch( c2, file ); 
            break; 
    } 
 
}
 
ulong
file_manager_c::write
( 
    void *                      buf,                            
    ulong                       size,               
    ulong                       n,                  
    file_t *            file                            
) 
{ 
    ulong i; 

    AssertReturnValue2(buf, file, 0);
 
    if (file->pos+size*n>file->size) 
        resize(file, file->pos+size*n); 
 
    for (i=0; i<n; i++) 
    { 
        if (file->pos+size > file->size) 
            break;                  // eof :) 
 
        memcpy( file->buf+file->pos, (char*)buf+size*i, size ); 
        file->pos += size; 
    } 
 
    return i; 
} // write 

---