---

r_font.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/18 09:31:53 $
// By           :       $Author: kolrabi $
// $Id: r_font.cpp,v 1.3 2002/12/18 09:31:53 kolrabi Exp $ 

/*

  $Log: r_font.cpp,v $
  Revision 1.3  2002/12/18 09:31:53  kolrabi
  added string rendering flag SF_RIGHT

  Revision 1.2  2002/12/13 12:29:26  kolrabi
  fixed some bugs

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


*/

#include            "omicron/internal.h"
#include            "omicron/render.h"
#include            "omicron/image.h"
#include            "omicron/texture.h"
 
/**************************************************************************** 
 **************************************************************************** 
 * VARIABLES **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
/**************************************************************************** 
 **************************************************************************** 
 * FONT ROUTINES ************************************************************ 
 **************************************************************************** 
 ****************************************************************************/ 

font_t *renderer_c::font_createfromimage_fixed(image_c *img, uchar width)
{
    AssertThisV;
    AssertReturnValue2(img, width, NULL);

    font_t *fnt = new font_t;

    ushort w, h;
    ushort cw, ch;

    w = img->get_width();
    h = img->get_height();

    fnt->width  = cw = (sshort)(w / 16);
    fnt->height = ch = (sshort)(h / 16);

    fnt->texture = gv.texman->create(w, h, "*font");
    fnt->shader  = shader_create_simple(BT_BLEND, fnt->texture);
    fnt->shader->passes[0].magfilter =
    fnt->shader->passes[0].minfilter = TF_LINEAR;
    gv.texman->set_image(fnt->texture, img);

    for (ulong i=0; i<256; i++)
    {
        fnt->images[i] = new image_c;
        fnt->images[i]->copy(img);
        fnt->images[i]->crop((ushort)((i%16)*cw), (ushort)(i/16)*ch, (ushort)cw, (ushort)ch);
        fnt->widths[i] = width;
    }

    return fnt;
}

void renderer_c::font_free(font_t *fnt)
{
    AssertThis;

    AssertReturn1(fnt);

    for (ulong i=0; i<256; i++)
        SafeDelete(fnt->images[i]);

    SafeDelete(fnt);
}
 
/**************************************************************************** 
 * _reset_charmode                               setting charmode to normal * 
 ****************************************************************************/ 
void renderer_c::reset_charmode() 
{ 
    AssertThis;

    state.font_bold    = 0; 
    state.font_italic  = 0; 
    state.font_color   = get_color(); 
} 
 
 
 
/**************************************************************************** 
 * _r_draw_char                                                draws a char * 
 ****************************************************************************/ 
float renderer_c::draw_char 
( 
    float       x,                  // left and 
    float       y,                  // bottom coordinates 
    float       size,               // height of character 
    char        c,                  // character to draw 
    const font_t *fnt
) 
{ 
    AssertThisV;

    if (c==32)
        return size;

    if (c<32) 
    { 
        if (c<16) 
        { 
            switch(c) 
            { 
                case    1:  state.font_bold    = !state.font_bold; break; 
                case    2:  state.font_italic  = !state.font_italic; break; 
            } 
        } 
        else 
        { 
            ulong  intensity  = c&7;
            char col        = intensity?0xFF:0xC0;

            state.font_color = get_color()&0xFF000000; 

            for (ulong i=0; i<3; i++)
                state.font_color |= ((c&(1<<i))?col:0)<<(8*i);
        } 
 
        return 0; 
    } 
 
    float w   = state.font_bold  ? 3.0f:0.0f; 
//    float it  = state.font_italic?-3.0f:0.0f; 

    set_color(state.font_color);
    draw_pic_shader(x, y, x+w+size, y+size, (c%16)/16.0f, (c/16)/16.0f, (c%16+1)/16.0f, (c/16+1)/16.0f, fnt->shader);

    return size; 
} // _r_draw_char 
 
 
float renderer_c::get_stringwidth(const char *c, const font_t *fnt)
{
    AssertThisV;

    AssertReturnValue2(c,fnt,0);

    ushort ww = 0;

    for (ulong i=0; i<strlen(c); i++)
        ww += fnt->widths[c[i]];

    return (float)ww/(float)fnt->width;;
}

ushort renderer_c::get_string_pixelwidth(const char *c, const font_t *fnt)
{
    AssertThisV;

    AssertReturnValue2(c,fnt,0);

    ushort ww = 0;

    for (ulong i=0; i<strlen(c); i++)
        ww += fnt->widths[c[i]];

    return ww;
}
 
/**************************************************************************** 
 * _r_draw_string                                            draws a string * 
 ****************************************************************************/ 
void renderer_c::draw_string 
( 
    float       x,                  // left and 
    float       y,                  // bottom coordinates 
    float       size,               // height of character 
    const char   *c,                // string 
    const font_t *fnt,
    ulong       flags               // flags 
)
{
    AssertThis;

    AssertReturn2(c,fnt);

    float       cx = x; 
 
    if (flags & SF_CENTERED) 
        cx = x-get_stringwidth(c,fnt)*0.5f*size; 
    else if (flags & SF_RIGHT) 
        cx = x-get_stringwidth(c,fnt)*size; 
 
    reset_charmode(); 

    // save currentcolor
    color_t col = get_color(); 

    // draw! 

    while (*c)
    { 
        draw_char(cx, y, size, *c, fnt); 
        cx += (float)fnt->widths[*c]/(float)fnt->width*size;
        c++; 
    }
 
    // restore current color
    set_color(col); 
} // _r_draw_string 
 
 
 

---