Text.cpp

Go to the documentation of this file.

#include "Text.h"
#include <iostream>
#include <string>
#include "Game.h"
#include "fns.h"
#include <GL/gl.h>
#include <stdexcept>
#include <map>
#include <fstream>
#include <yaml-cpp/yaml.h>
using namespace std;

Text::Text(string filename, string sectionName, FontType t, int s, Color c, int w, int h, Point2D pos)
        : WorldObject(filename),
        mFont(Game::game()->getFont(t, s)),
        color(c),
        width(w),
        height(h),
        lines(vector<string>()),
        startline(0)
{
        mPos = pos;
        filename="ArtAssets/Story/"+filename+".yaml";
        ifstream fin(filename.c_str());

        if(!fin)
        {
                printf("Error opening %s\n\n",filename.c_str());
        }

        YAML::Parser parser(fin);

        YAML::Node doc;

        while(parser.GetNextDocument(doc)) {
                try{
                        const YAML::Node& section = doc[sectionName];
                        string lang = "en";
                        switch(t)
                        {
                        case English:
                                {
                                        lang="en";
                                        break;
                                }
                        case Japanese:
                                {
                                        lang="jp";
                                        break;
                                }
                        case JapaneseWithRuby:
                                {
                                        lang="jprub";
                                        break;
                                }
                        }
                        
                        const YAML::Node& items = section[lang];
                        string tmp;
                        foritr(it,items)
                        {
                                *it>>tmp;
                                lines.push_back( tmp.size() > 0 && tmp[tmp.size()-1]==10 ? tmp.substr(0,tmp.size()-1):tmp);
                        }
                }
                catch (exception e){
                        cout<<e.what()<<endl;
                }
        }
        wrap();
}

Text::Text(string name, string t, int s, Color c, int w, int h, Point2D pos)
        : WorldObject(name),
        mFont(Game::game()->getFont(Game::game()->Language, s)),
        color(c),
        width(w),
        height(h),
        lines(vector<string>()),
        startline(0)
{
        mPos = pos;
        //here we see if the thing wil fit on one line if not we resize it
        lines.push_back(t);
        wrap();
}

Text::~Text()
{
        Game::game()->removeFont(mFont);
}

void Text::draw()
{
        int size = lines.size();
        if(size>0){
                int i= startline;
                while(mFont->size > 0 && i < size && i*mFont->size < height){
                                /*vector<string> ss = splitString(tmp);
                                for(size_t i=0;i<ss.size();++i){
                                        lines.push_back(ss[i]);
                                }*/
                        if(mFont->font){
                                SDL_Surface *initial;
                                SDL_Surface *intermediary;
                                int w,h;
                                Texture texture;

                                /* Use SDL_TTF to render our txt */
                                if (!(initial = TTF_RenderUTF8_Blended(mFont->font, lines[i].c_str(), color.toSDLColor())))
                                {
                                        fprintf(stderr, "TTF_RenderUTF8_Blended: %s\n", TTF_GetError());
                                        return;
                                }

                                /* Convert the rendered txt to a known format */
                                w = nextPow2(initial->w);
                                h = nextPow2(initial->h);

                                intermediary = SDL_CreateRGBSurface(0, w, h, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
                                SDL_BlitSurface(initial, 0, intermediary, 0);

                                glBlendFunc(GL_ONE, GL_ONE);

                                /* Tell GL about our new texture */
                                glGenTextures(1, &texture.image);
                                glBindTexture(GL_TEXTURE_2D, texture.image);
                                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, intermediary->pixels );

                                /* GL_NEAREST looks horrible, if scaled... */
                                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);       

                                /* prepare to render our texture */
                                glBindTexture(GL_TEXTURE_2D, texture.image);
                                //this is always corrrect... the color is taken care of higher up for render
                                glColor3f(1.0f, 1.0f, 1.0f);

                                /* Draw a quad at location */
                                glBegin(GL_QUADS);
                                        glTexCoord2d(0.0f, 0.0f); 
                                        glVertex2d(mPos.x , mPos.y + i*mFont->size);
                                        glTexCoord2d(1.0f, 0.0f); 
                                        glVertex2d(mPos.x + w, mPos.y + i*mFont->size);
                                        glTexCoord2d(1.0f, 1.0f); 
                                        glVertex2d(mPos.x + w, mPos.y + h + i*mFont->size);
                                        glTexCoord2d(0.0f, 1.0f); 
                                        glVertex2d(mPos.x , mPos.y + h + i*mFont->size);
                                glEnd();
                                glLoadIdentity();

                                /* Bad things happen if we delete the texture before it finishes */
                                glFinish();

                                /* Clean up */
                                SDL_FreeSurface(initial);
                                SDL_FreeSurface(intermediary);
                                glDeleteTextures(1, &texture.image);
                        }
                        lastline = i++;
                }
        }
}

void Text::update()
{
        if(mUnused) return;
        WorldObject::update();
}

void Text::setStartLine(unsigned int line){
        if(line < lines.size())
                startline=line;
}

int Text::getLastLine(){
        return lastline;
}

void Text::wrap(){
        //vector<string> text();
        //foritr(line, lines){
        //      string txt = *line;
        //      int w,h;
        //      TTF_SizeUTF8(mFont->font,txt.c_str(), &w, &h);
        //      while(w>width){

        //      }
        //      int a=0;
        //}
}