int GetStringLen(int _sx, char *string, int size)
{
unsigned int i = 0;
int stringlen = 0;
//reset kerning
prev_glyphindex = 0;
//calc len
if(size)
{
desc.width = desc.height = size;
}
while(*string != '\0')
{
if(*string != '~')
{
stringlen += RenderChar(*string, -1, -1, -1, -1);
}
else
{
string++;
if(*string=='t')
{
stringlen=desc.width+TABULATOR*((int)(stringlen/TABULATOR)+1);
}
else
{
if(*string=='T')
{
if(sscanf(string+1,"%4d",&i)==1)
{
string+=4;
stringlen=i-_sx;
}
}
else
{
int found=0;
for(i=0; i<sizeof(sc)/sizeof(sc[0]) && !found; i++)
{
if(*string==sc[i])
{
stringlen += RenderChar(tc[i], -1, -1, -1, -1);
found=1;
}
}
}
}
}
string++;
}
return stringlen;
}
void CTools::Loop(double timestep) {
switch (tool_mode) {
case 0: RenderChar (timestep); break;
case 1: RenderSingleFrame (timestep); break;
case 2: RenderSequence (timestep); break;
}
}
/* Render a string at a specific location of an rgb buffer */
void et_RenderText(char *text, simple_font_t *font, color_t col, rgb_buffer_t *buf, int x, int y) {
while(*text) {
RenderChar(*text, font, col, buf, x, y);
x += SC(*text).width + font->between_width;
text++;
}
}
void Font::WalkString(char *buffPtr, int xpos, int ypos, int *vPort, int dir)
{
int x;
int y = ypos;
int tabs = 0;
int xMax = vPort[0] + vPort[2];
int ret;
tabs = GetCharHits(buffPtr, '\t');
if (!tabs) tabs = 1;
else tabs *= fontTabSpace;
if (dir > 0) x = xpos;
else x = xpos - ysize * tabs * GetTrueLen(buffPtr);
for ( ; *buffPtr; ++buffPtr)
{
if (x > xMax) break;
switch (*buffPtr)
{
case '\n':
y -= ysize;
x = xpos;
continue;
break;
case '\t':
x += (ysize * fontTabSpace);
continue;
break;
case TEXT_STYLE_KEYWORD:
ret = SlashParser(buffPtr, &x, &y);
buffPtr += ret;
if (*buffPtr == '\n' || *buffPtr == '\t')
{
--buffPtr;
continue;
}
if (ret) continue;
break;
case '^':
ret = HutParser(buffPtr, &x, &y);
buffPtr += ret;
if (ret) continue;
break;
default:
RenderChar((unsigned char) *buffPtr, x, y, ysize);
break;
}
x += (int)((float)width[(int)(*buffPtr)]*ratio*scale);
}
}
void RenderString(int ovwidth,Pixel *dest,const char *string, int sx, int sy, int maxwidth, int layout, int color, int bgcolor)
{
if (strlen(string) == 0) return;
int stringlen, ex, charwidth,i,j;
#if ((defined(FREETYPE_MAJOR)) && (((FREETYPE_MAJOR == 2) && (((FREETYPE_MINOR == 1) && (FREETYPE_PATCH >= 9)) || (FREETYPE_MINOR > 1))) || (FREETYPE_MAJOR > 2)))
desc.width = desc.height = ROW_HEIGHT;
#else
desc.font.pix_width = desc.font.pix_height = ROW_HEIGHT;
#endif
//set alignment
stringlen = GetStringLen(string);
if(layout != LEFT)
{
switch(layout)
{
case CENTER: if(stringlen < maxwidth) sx += (maxwidth - stringlen)/2;
break;
case RIGHT: if(stringlen < maxwidth) sx += maxwidth - stringlen;
}
}
//render string
ex = sx + maxwidth;
// fill background
for(i = 1; i < ROW_HEIGHT-2; i++)
{
int in = 0;
switch (i)
{
case 1 : in = 2;break;
case 2 : in = 1;break;
case ROW_HEIGHT-4: in = 1;break;
case ROW_HEIGHT-3: in = 2;break;
}
for(j = in; j < stringlen-in; j++)
dest[sx + j + ovwidth*(sy + i- ROW_HEIGHT)] = bgcolor;
}
while(*string != '\0' && *string != '\n')
{
if((charwidth = RenderChar(dest,*string, sx+1, sy, ex, color,ovwidth)) == -1) return; // string > maxwidth
sx += charwidth;
string++;
}
}
GLint text_t::SlashParser(char *buffPtr, GLint *x, GLint *y)
{
GLint ret = 0;
buffPtr++;
if (!*buffPtr)
return ret;
switch (*buffPtr)
{
case 'a':
case 'c':
{
/*x -= size;
return SetColorFromToken(buffPtr);*/
int ret = SetColorFromToken(buffPtr);
if (ret != -1)
*x -= size;
return ret == -1 ? 0 : ret;
}
break;
case 'i':
{
/**x -= size;
return ItalicsMode(buffPtr);*/
int ret = ItalicsMode(buffPtr);
if (ret != -1)
*x -= size;
return ret == -1 ? 0 : ret;
}
break;
case 'b':
{
/**x -= size;
return BoldMode(buffPtr);*/
int ret = BoldMode(buffPtr);
if (ret != -1)
*x -= size;
return ret == -1 ? 0 : ret;
}
break;
default:
buffPtr--;
RenderChar(*buffPtr, *x, *y, size);
return ret;
break;
}
}
int GetStringLen(const char *string)
{
int stringlen = 0;
//calc len
while(*string != '\0')
{
stringlen += RenderChar(NULL,*string, -1, -1, -1, -1,0);
string++;
}
return stringlen;
}
int Font::SlashParser(char *buffPtr, int *x, int *y)
{
if (!(*(++buffPtr))) return 0;
switch (*buffPtr)
{
case 'a':
case 'c':
return SetColorFromToken(buffPtr);
break;
case 'i':
return ItalicsMode(buffPtr);
break;
case 'b':
return BoldMode(buffPtr);
break;
default:
RenderChar(*(--buffPtr), *x, *y, ysize);
return 0;
break;
}
}
void text_t::WalkString(char *buffPtr, GLint xpos, GLint ypos, GLint *vPort)
{
GLint x = xpos;
GLint y = ypos;
GLint carrage = 0;
GLint tabs = 0;
GLint len = strlen(buffPtr);
GLint xMax;
xMax = vPort[0] + vPort[2];
carrage = GetCharHits(buffPtr, '\n');
tabs = GetCharHits(buffPtr, '\t');
if (!tabs)
tabs = 1;
else tabs *= fontTabSpace;
if (region)
{
ScissorTextRegion();
x = regionX;
y = (regionY + regionH) - size;
} else ScissorNormal(xpos, ypos, tabs, carrage, size, len);
/* lets draw! */
for ( ; *buffPtr; buffPtr++, x += size)
{
if (x > xMax)
break;
if (region)
{
if (x + size > (regionX + regionW))
{
y -= size;
x = regionX;
}
if (y < regionY)
break;
}
switch (*buffPtr)
{
case '\n':
y -= size;
if(region)
x = regionX - size;
else
x = xpos - size;
continue;
break;
case '\t':
x += (size * fontTabSpace);
continue;
break;
case '\\':
{
int ret = SlashParser(buffPtr, &x, &y);
buffPtr += ret;
if (*buffPtr == '\n' || *buffPtr == '\t')
{
buffPtr -= 1;
continue;
}
if (!ret)
RenderChar(*buffPtr, x, y, size);
}
break;
default:
RenderChar(*buffPtr, x, y, size);
break;
}
}
}
/******************************************************************************
* RenderString
******************************************************************************/
int RenderString(char *string, int _sx, int _sy, int maxwidth, int layout, int size, int color)
{
int stringlen = 0, _ex = 0, charwidth = 0,found = 0;
unsigned int i = 0;
char rstr[BUFSIZE]={0}, *rptr=rstr, rc=' ';
int varcolor=color;
//set size
snprintf(rstr,sizeof(rstr),"%s",string);
desc.width = desc.height = size;
TABULATOR=3*size;
//set alignment
stringlen = GetStringLen(_sx, rstr, size);
if(layout != LEFT)
{
switch(layout)
{
case CENTER: if(stringlen < maxwidth) _sx += (maxwidth - stringlen)/2;
break;
case RIGHT: if(stringlen < maxwidth) _sx += maxwidth - stringlen;
}
}
//reset kerning
prev_glyphindex = 0;
//render string
_ex = _sx + maxwidth;
while(*rptr != '\0')
{
if(*rptr=='~')
{
++rptr;
rc=*rptr;
found=0;
for(i=0; i< sizeof(sc)/sizeof(sc[0]) && !found; i++)
{
if(rc==sc[i])
{
rc=tc[i];
found=1;
}
}
if(found)
{
if((charwidth = RenderChar(rc, _sx, _sy, _ex, varcolor)) == -1) return _sx; /* string > maxwidth */
_sx += charwidth;
}
else
{
switch(*rptr)
{
case 'R': varcolor=RED; break;
case 'G': varcolor=GREEN; break;
case 'Y': varcolor=YELLOW; break;
case 'B': varcolor=BLUE1; break;
case 'S': varcolor=color; break;
case 't':
_sx=TABULATOR*((int)(_sx/TABULATOR)+1);
break;
case 'T':
if(sscanf(rptr+1,"%4d",&i)==1)
{
rptr+=4;
_sx=i;
}
break;
}
}
}
else
{
int uml = 0;
switch(*rptr) /* skip Umlauts */
{
case '\xc4':
case '\xd6':
case '\xdc':
case '\xe4':
case '\xf6':
case '\xfc':
case '\xdf': uml=1; break;
}
if (uml == 0)
{
// UTF8_to_Latin1 encoding
if (((*rptr) & 0xf0) == 0xf0) /* skip (can't be encoded in Latin1) */
{
rptr++;
if ((*rptr) == 0)
*rptr='\x3f'; // ? question mark
rptr++;
if ((*rptr) == 0)
*rptr='\x3f';
rptr++;
if ((*rptr) == 0)
*rptr='\x3f';
}
else if (((*rptr) & 0xe0) == 0xe0) /* skip (can't be encoded in Latin1) */
{
rptr++;
if ((*rptr) == 0)
*rptr='\x3f';
rptr++;
if ((*rptr) == 0)
*rptr='\x3f';
}
else if (((*rptr) & 0xc0) == 0xc0)
{
char c = (((*rptr) & 3) << 6);
rptr++;
if ((*rptr) == 0)
*rptr='\x3f';
*rptr = (c | ((*rptr) & 0x3f));
}
}
if((charwidth = RenderChar(*rptr, _sx, _sy, _ex, varcolor)) == -1) return _sx; /* string > maxwidth */
_sx += charwidth;
}
rptr++;
}
return stringlen;
}
/// Renders text ^^
void TextFont::RenderText(Text & text, GraphicsState & graphicsState)
{
// Set starting variables.
NewText(text);
/// One color for all text?
this->SetColor(text.color);
/// Save old shader!
Shader * oldShader = ActiveShader();
// Load shader, set default uniform values, etc.
if (!PrepareForRender())
return;
/// Sort the carets in order to render selected text properly.
int min, max;
if (text.caretPosition < text.previousCaretPosition)
{
min = text.caretPosition;
max = text.previousCaretPosition;
}
else
{
max = text.caretPosition;
min = text.previousCaretPosition;
}
bool shouldRenderCaret = Timer::GetCurrentTimeMs() % 1000 > 500;
if (text.Length() == 0 && shouldRenderCaret)
RenderChar('|');
for (i = 0; i < text.Length(); ++i)
{
if (text.caretPosition == i && shouldRenderCaret)
{
RenderChar('|');
}
currentCharIndex = i;
currentChar = text.c_str()[i];
if (currentChar == 0)
break;
nextChar = text.c_str()[i + 1];
if (EvaluateSpecialChar())
continue;
StartChar(); // Move in.
RenderChar(currentChar); // Render
/// If we are between the 2 active carets, render the region the char covers over with a white quad ?
if (text.previousCaretPosition != -1 && i >= min && i < max)
{
RenderSelection(currentChar);
}
EndChar(); // Move out.
lastChar = currentChar;
}
// Caret at the end?
if (text.caretPosition >= text.Length() && shouldRenderCaret)
{
RenderChar('|');
}
OnEndRender(graphicsState);
/// Revert to old shader!
ShadeMan.SetActiveShader(oldShader);
}
