indrajith/RCBASIC4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

GFX Primitives and Image drawing functions

Browse Source
This commit is contained in:
n00b
2024-05-23 23:07:11 -05:00
parent 0ca34a769d
commit 60ecf625aa
6 changed files with 3884 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
rcbasic_build/rcbasic4_changes.ods
View File

Binary file not shown.

538
rcbasic_runtime/irr_gfx/gui_freetype_font.cpp Normal file
View File

@@ -0,0 +1,538 @@
#include "gui_freetype_font.h"
#if COMPILE_WITH_FREETYPE
#include <cassert>
using namespace irr;
using namespace gui;
#ifdef _MSC_VER
#pragma warning(disable: 4996)
#endif
// --------------------------------------------------------
CGUITTGlyph::CGUITTGlyph()
: IReferenceCounted()
,cached(false)
,size(0)
,top(0)
,left(0)
,texw(0)
,texh(0)
,imgw(0)
,imgh(0)
,tex(NULL)
,top16(0)
,left16(0)
,texw16(0)
,texh16(0)
,imgw16(0)
,imgh16(0)
,tex16(NULL)
,image(NULL)
{
}
CGUITTGlyph::~CGUITTGlyph()
{
delete[] image;
}
//void CGUITTGlyph::cache(u32 idx_, CGUITTFace& ttFace_, video::IVideoDriver* driver_, irr::core::dimension2d<irr::u32> &largestSize)
void CGUITTGlyph::cache(u32 idx_, const CGUIFreetypeFont * freetypeFont)
{
assert(freetypeFont);
FT_Face face = freetypeFont->TrueTypeFace->face;
FT_Set_Pixel_Sizes(face, 0, size);
if ( size > freetypeFont->LargestGlyph.Height )
freetypeFont->LargestGlyph.Height = size;
if ( !FT_Load_Glyph(face, idx_, FT_LOAD_NO_HINTING|FT_LOAD_NO_BITMAP) )
{
FT_GlyphSlot glyph = face->glyph;
FT_Bitmap bits;
if (glyph->format == ft_glyph_format_outline )
{
if (!FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL))
{
bits = glyph->bitmap;
u8 *pt = bits.buffer;
delete[] image;
image = new u8[bits.width * bits.rows];
memcpy(image,pt,bits.width * bits.rows);
top = glyph->bitmap_top;
left = glyph->bitmap_left;
imgw = 1;
imgh = 1;
texw = bits.width;
texh = bits.rows;
for(;;)
{
if (imgw > texw)
{
break;
}
else
{
imgw <<= 1;
}
}
for(;;)
{
if (imgh > texh)
{
break;
}
else
{
imgh <<= 1;
}
}
if (imgw > imgh)
{
imgh = imgw;
}
else
{
imgw = imgh;
}
s32 offx = left;
s32 offy = size - top;
if ( offx+texw > freetypeFont->LargestGlyph.Width )
freetypeFont->LargestGlyph.Width = offx+texw;
if ( offy+texh > freetypeFont->LargestGlyph.Height )
freetypeFont->LargestGlyph.Height = offy+texh;
u32 *texd = new u32[imgw*imgh];
memset(texd,0,imgw*imgh*sizeof(u32));
u32 *texp = texd;
bool cflag = (freetypeFont->Driver->getDriverType() == video::EDT_DIRECT3D9);
for (int i = 0;i < bits.rows;i++)
{
u32 *rowp = texp;
for (int j = 0;j < bits.width;j++)
{
if (*pt)
{
if (cflag)
{
*rowp = *pt;
*rowp *= 0x01010101;
}
else
{
*rowp = *pt << 24;
*rowp |= 0xffffff;
}
}
else
{
*rowp = 0;
}
pt++;
rowp++;
}
texp += imgw;
}
c8 name[128];
sprintf(name,"ttf%d_%d_%p",idx_, size, freetypeFont );
video::IImage *img = freetypeFont->Driver->createImageFromData(video::ECF_A8R8G8B8,core::dimension2d<u32>(imgw,imgh),texd);
setGlyphTextureFlags(freetypeFont->Driver);
tex = freetypeFont->Driver->addTexture(name,img);
img->drop();
restoreTextureFlags(freetypeFont->Driver);
delete[] texd;
cached = true;
}
}
}
if (!FT_Load_Glyph(face,idx_,FT_LOAD_NO_HINTING|FT_LOAD_RENDER|FT_LOAD_MONOCHROME))
{
FT_GlyphSlot glyph = face->glyph;
FT_Bitmap bits = glyph->bitmap;
u8 *pt = bits.buffer;
top16 = glyph->bitmap_top;
left16 = glyph->bitmap_left;
imgw16 = 1;
imgh16 = 1;
texw16 = bits.width;
texh16 = bits.rows;
for(;;)
{
if (imgw16 >= texw16)
{
break;
}
else
{
imgw16 <<= 1;
}
}
for(;;)
{
if (imgh16 >= texh16)
{
break;
}
else
{
imgh16 <<= 1;
}
}
if (imgw16 > imgh16)
{
imgh16 = imgw16;
}
else
{
imgw16 = imgh16;
}
s32 offx = left;
s32 offy = size - top;
if ( offx+texw > freetypeFont->LargestGlyph.Width )
freetypeFont->LargestGlyph.Width = offx+texw;
if ( offy+texh > freetypeFont->LargestGlyph.Height )
freetypeFont->LargestGlyph.Height = offy+texh;
u16 *texd16 = new u16[imgw16*imgh16];
memset(texd16,0,imgw16*imgh16*sizeof(u16));
u16 *texp16 = texd16;
for (int y = 0;y < bits.rows;y++)
{
u16 *rowp = texp16;
for (int x = 0;x < bits.width;x++)
{
if (pt[y * bits.pitch + (x / 8)] & (0x80 >> (x % 8)))
{
*rowp = 0xffff;
}
rowp++;
}
texp16 += imgw16;
}
c8 name[128];
sprintf(name,"ttf%d_%d_%p_16",idx_, size, freetypeFont );
video::IImage *img = freetypeFont->Driver->createImageFromData(video::ECF_A1R5G5B5,core::dimension2d<u32>(imgw16,imgh16),texd16);
setGlyphTextureFlags(freetypeFont->Driver);
tex16 = freetypeFont->Driver->addTexture(name,img);
img->drop();
restoreTextureFlags(freetypeFont->Driver);
// freetypeFont->Driver->makeColorKeyTexture(tex16,video::SColor(0,0,0,0));
delete[] texd16;
}
}
bool CGUITTGlyph::mTexFlag16 = false;
bool CGUITTGlyph::mTexFlag32 = true;
bool CGUITTGlyph::mTexFlagMip = false;
void CGUITTGlyph::setGlyphTextureFlags(video::IVideoDriver* driver_)
{
mTexFlag16 = driver_->getTextureCreationFlag(video::ETCF_ALWAYS_16_BIT);
mTexFlag32 = driver_->getTextureCreationFlag(video::ETCF_ALWAYS_32_BIT);
mTexFlagMip = driver_->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
driver_->setTextureCreationFlag(video::ETCF_ALWAYS_16_BIT,false);
driver_->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT,true);
driver_->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
}
void CGUITTGlyph::restoreTextureFlags(video::IVideoDriver* driver_)
{
driver_->setTextureCreationFlag(video::ETCF_ALWAYS_16_BIT, mTexFlag16);
driver_->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, mTexFlag32);
driver_->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, mTexFlagMip);
}
// --------------------------------------------------------
FT_Library CGUITTFace::library = 0;
int CGUITTFace::countClassObjects = 0;
CGUITTFace::CGUITTFace()
: face(0)
{
++countClassObjects;
}
CGUITTFace::~CGUITTFace()
{
if ( face )
FT_Done_Face( face );
--countClassObjects;
assert(countClassObjects >= 0 );
if ( !countClassObjects && library )
{
FT_Done_FreeType( library );
library = 0;
}
}
//! loads a font file
bool CGUITTFace::load(const irr::io::path& filename)
{
if ( !library )
{
if (FT_Init_FreeType( &library ))
{
return false;
}
}
core::stringc ansiFilename(filename); // path can be anything but freetype can only work with ansi-filenames
if (FT_New_Face( library,ansiFilename.c_str(),0,&face ))
{
return false;
}
return true;
}
// --------------------------------------------------------
//! constructor
CGUIFreetypeFont::CGUIFreetypeFont(video::IVideoDriver* driver)
: Driver(driver)
, TrueTypeFace(0)
{
#ifdef _DEBUG
setDebugName("CGUIFreetypeFont");
#endif
if (Driver)
Driver->grab();
AntiAlias = false;
Transparency = false;
}
//! destructor
CGUIFreetypeFont::~CGUIFreetypeFont()
{
if ( TrueTypeFace )
TrueTypeFace->drop();
if (Driver)
Driver->drop();
clearGlyphs();
}
bool CGUIFreetypeFont::attach(CGUITTFace *Face,u32 size)
{
if (!Driver || !Face)
return false;
Face->grab();
if ( TrueTypeFace )
TrueTypeFace->drop();
TrueTypeFace = Face;
if ( !TrueTypeFace )
return false;
clearGlyphs();
Glyphs.reallocate(TrueTypeFace->face->num_glyphs);
Glyphs.set_used(TrueTypeFace->face->num_glyphs);
for (int i = 0;i < TrueTypeFace->face->num_glyphs;i++)
{
CGUITTGlyph * glyph = new CGUITTGlyph();
glyph->size = size;
// glyph->cache((wchar_t)i + 1);
Glyphs[i] = glyph;
}
// TODO: this is a workaround to get a probably ok height for getDimensions. So we check a few extreme characters which usually make trouble.
getGlyphByChar(L'A');
getGlyphByChar(L'g');
getGlyphByChar(L'.');
getGlyphByChar(L'(');
return true;
}
void CGUIFreetypeFont::clearGlyphs()
{
for ( unsigned int i=0; i < Glyphs.size(); ++i )
{
if ( Glyphs[i] )
{
Glyphs[i]->drop();
}
Glyphs[i] = 0;
}
}
u32 CGUIFreetypeFont::getGlyphByChar(wchar_t c) const
{
u32 idx = FT_Get_Char_Index( TrueTypeFace->face, c );
if ( idx && !Glyphs[idx - 1]->cached )
Glyphs[idx - 1]->cache(idx, this);
return idx;
}
//! returns the dimension of a text
core::dimension2d<u32> CGUIFreetypeFont::getDimension(const wchar_t* text) const
{
core::dimension2d<u32> dim(0, Glyphs[0]->size);
for(const wchar_t* p = text; *p; ++p)
{
dim.Width += getWidthFromCharacter(*p);
}
// TODO: The correct solution might be working with TrueTypeFace->height but I can't figure out how to use units_per_EM
// even if I know which FT_Render_Mode I used. I'm sure there is some way to figure that out, but I have to give up for now.
if ( TrueTypeFace && LargestGlyph.Height > dim.Height)
dim.Height = LargestGlyph.Height;
return dim;
}
inline u32 CGUIFreetypeFont::getWidthFromCharacter(wchar_t c) const
{
u32 n = getGlyphByChar(c);
if ( n > 0)
{
int w = Glyphs[n - 1]->texw;
s32 left = Glyphs[n - 1]->left;
if (w + left > 0)
return w + left;
}
if (c >= 0x2000)
{
return Glyphs[0]->size;
}
else
{
return Glyphs[0]->size / 2;
}
}
//! draws an text and clips it to the specified rectangle if wanted
void CGUIFreetypeFont::draw(const irr::core::stringw& textstring, const irr::core::rect<s32>& position, video::SColor color, bool hcenter, bool vcenter, const core::rect<s32>* clip)
{
if (!Driver)
return;
core::dimension2d<s32> textDimension;
core::position2d<s32> offset = position.UpperLeftCorner;
video::SColor colors[4];
for (int i = 0;i < 4;i++)
{
colors[i] = color;
}
const wchar_t * text = textstring.c_str();
if (hcenter || vcenter)
{
textDimension = getDimension(text);
if (hcenter)
offset.X = ((position.getWidth() - textDimension.Width)>>1) + offset.X;
if (vcenter)
offset.Y = ((position.getHeight() - textDimension.Height)>>1) + offset.Y;
}
u32 n;
while(*text)
{
n = getGlyphByChar(*text);
if ( n > 0)
{
if (AntiAlias)
{
// s32 imgw = Glyphs[n-1]->imgw;
// s32 imgh = Glyphs[n-1]->imgh;
s32 texw = Glyphs[n-1]->texw;
s32 texh = Glyphs[n-1]->texh;
s32 offx = Glyphs[n-1]->left;
s32 offy = Glyphs[n-1]->size - Glyphs[n-1]->top;
if (Driver->getDriverType() != video::EDT_SOFTWARE)
{
if (!Transparency)
color.color |= 0xff000000;
Driver->draw2DImage(Glyphs[n-1]->tex,core::position2d<s32>(offset.X+offx,offset.Y+offy),core::rect<s32>(0,0,texw,texh),clip,color,true);
}
else
{
s32 a = color.getAlpha();
s32 r = color.getRed();
s32 g = color.getGreen();
s32 b = color.getBlue();
u8 *pt = Glyphs[n-1]->image;
if (!Transparency) a = 255;
for (int y = 0;y < texh;y++)
{
for (int x = 0;x < texw;x++)
{
if (!clip || clip->isPointInside(core::position2d<s32>(offset.X+x+offx,offset.Y+y+offy)))
{
if (*pt)
{
Driver->draw2DRectangle(video::SColor((a * *pt)/255,r,g,b),core::rect<s32>(offset.X+x+offx,offset.Y+y+offy,offset.X+x+offx+1,offset.Y+y+offy+1));
}
pt++;
}
}
}
}
}
else
{
// s32 imgw = Glyphs[n-1]->imgw16;
// s32 imgh = Glyphs[n-1]->imgh16;
s32 texw = Glyphs[n-1]->texw16;
s32 texh = Glyphs[n-1]->texh16;
s32 offx = Glyphs[n-1]->left16;
s32 offy = Glyphs[n-1]->size - Glyphs[n-1]->top16;
if (!Transparency)
{
color.color |= 0xff000000;
}
Driver->draw2DImage(Glyphs[n-1]->tex16,
core::position2d<s32>(offset.X+offx,offset.Y+offy),
core::rect<s32>(0,0,texw,texh),
clip, color, true);
}
offset.X += getWidthFromCharacter(*text);
}
else
{
offset.X += getWidthFromCharacter(*text);
}
++text;
}
}
//! Calculates the index of the character in the text which is on a specific position.
s32 CGUIFreetypeFont::getCharacterFromPos(const wchar_t* text, s32 pixel_x) const
{
s32 x = 0;
s32 idx = 0;
while (text[idx])
{
x += getWidthFromCharacter(text[idx]);
if (x >= pixel_x)
return idx;
++idx;
}
return -1;
}
#endif // #if COMPILE_WITH_FREETYPE

124
rcbasic_runtime/irr_gfx/gui_freetype_font.h Normal file
View File

@@ -0,0 +1,124 @@
#ifndef _GUI_FREETYPE_FONT_H
#define _GUI_FREETYPE_FONT_H
//! freetype support enabled with 1 and disabled with 0
#define COMPILE_WITH_FREETYPE 1
#if COMPILE_WITH_FREETYPE
#include <freetype2/ft2build.h>
#include <freetype/freetype.h>
#include <irrlicht.h>
class CGUITTFace : public irr::IReferenceCounted
{
public:
CGUITTFace();
virtual ~CGUITTFace();
bool load(const irr::io::path& filename);
FT_Face face; // handle to face
private:
static int countClassObjects;
static FT_Library library; // handle to library
};
class CGUIFreetypeFont;
class CGUITTGlyph : public irr::IReferenceCounted
{
public:
CGUITTGlyph();
virtual ~CGUITTGlyph();
bool cached;
void cache(irr::u32 idx_, const CGUIFreetypeFont * freetypeFont);
irr::u32 size;
irr::u32 top;
irr::u32 left;
irr::u32 texw;
irr::u32 texh;
irr::u32 imgw;
irr::u32 imgh;
irr::video::ITexture *tex;
irr::u32 top16;
irr::u32 left16;
irr::u32 texw16;
irr::u32 texh16;
irr::u32 imgw16;
irr::u32 imgh16;
irr::video::ITexture *tex16;
irr::u8 *image;
private:
void setGlyphTextureFlags(irr::video::IVideoDriver* driver_);
void restoreTextureFlags(irr::video::IVideoDriver* driver_);
static bool mTexFlag16;
static bool mTexFlag32;
static bool mTexFlagMip;
};
class CGUIFreetypeFont : public irr::gui::IGUIFont
{
friend class CGUITTGlyph;
public:
//! constructor
CGUIFreetypeFont(irr::video::IVideoDriver* Driver);
//! destructor
virtual ~CGUIFreetypeFont();
//! loads a truetype font file
bool attach(CGUITTFace *Face,irr::u32 size);
//! draws an text and clips it to the specified rectangle if wanted
virtual void draw(const irr::core::stringw& text, const irr::core::rect<irr::s32>& position, irr::video::SColor color, bool hcenter=false, bool vcenter=false, const irr::core::rect<irr::s32>* clip=0);
//! returns the dimension of a text
virtual irr::core::dimension2d<irr::u32> getDimension(const wchar_t* text) const;
//! Calculates the index of the character in the text which is on a specific position.
virtual irr::s32 getCharacterFromPos(const wchar_t* text, irr::s32 pixel_x) const;
//! Not yet supported
virtual void setKerningWidth (irr::s32 kerning) {}
//! Not yet supported
virtual void setKerningHeight (irr::s32 kerning) {}
//! Not yet supported
virtual irr::s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const { return 0; }
//! Not yet supported
virtual irr::s32 getKerningHeight() const { return 0; }
//! Not yet supported
virtual void setInvisibleCharacters( const wchar_t *s ) {}
bool AntiAlias;
bool Transparency;
protected:
void clearGlyphs();
private:
irr::u32 getWidthFromCharacter(wchar_t c) const;
irr::u32 getGlyphByChar(wchar_t c) const;
irr::video::IVideoDriver* Driver;
irr::core::array< CGUITTGlyph* > Glyphs;
CGUITTFace * TrueTypeFace;
mutable irr::core::dimension2d<irr::u32> LargestGlyph;
};
#endif // #if COMPILE_WITH_FREETYPE
#endif // _GUI_FREETYPE_FONT_H

6
rcbasic_runtime/irr_gfx/rc_font.h Normal file
View File

@@ -0,0 +1,6 @@
#ifndef RC_FONT_H_INCLUDED
#define RC_FONT_H_INCLUDED
#endif // RC_FONT_H_INCLUDED

3171
rcbasic_runtime/irr_gfx/rc_gfx.h Normal file
View File

File diff suppressed because it is too large Load Diff

45
rcbasic_runtime/irr_gfx/rc_utf8.h Normal file
View File

@@ -0,0 +1,45 @@
#ifndef RC_UTF8_H_INCLUDED
#define RC_UTF8_H_INCLUDED
#include <string>
#include <algorithm>
std::string rc_utf8_substr(const std::string& str, unsigned int start, unsigned int leng)
{
if (leng==0) { return ""; }
unsigned int c, i, ix, q, min=std::string::npos, max=std::string::npos;
for (q=0, i=0, ix=str.length(); i < ix; i++, q++)
{
if (q==start){ min=i; }
if (q<=start+leng || leng==std::string::npos){ max=i; }
c = (unsigned char) str[i];
if (
//c>=0 &&
c<=127) i+=0;
else if ((c & 0xE0) == 0xC0) i+=1;
else if ((c & 0xF0) == 0xE0) i+=2;
else if ((c & 0xF8) == 0xF0) i+=3;
//else if (($c & 0xFC) == 0xF8) i+=4; // 111110bb //byte 5, unnecessary in 4 byte UTF-8
//else if (($c & 0xFE) == 0xFC) i+=5; // 1111110b //byte 6, unnecessary in 4 byte UTF-8
else return "";//invalid utf8
}
if (q<=start+leng || leng==std::string::npos){ max=i; }
if (min==std::string::npos || max==std::string::npos) { return ""; }
return str.substr(min,max-min);
}
std::size_t rc_utf8_length(std::string const &s)
{
return std::count_if(s.begin(), s.end(),
[](char c) { return (static_cast<unsigned char>(c) & 0xC0) != 0x80; } );
}
// convert UTF-8 string to wstring
std::wstring utf8_to_wstring (const std::string& str)
{
std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
return myconv.from_bytes(str);
}
#endif // RC_UTF8_H_INCLUDED