C++博客-Cpper-随笔分类-设计模式

使用Opengl显示富文本

ccsdu2009 — Mon, 22 Feb 2016 09:46:00 GMT

给BGE加上了富文本显示功能
相关代码如下:

void GLTextRenderer::render(const Color& color,const String& string,const FloatRect& area,bool isMultiLine,
        Horizontal hAlignment,Vertical vAlignment,bool rich)
{
    if(typeFace_ != 0 && !rich)
    {
        typeFace_->setColor(color);
        if(isMultiLine)
        {
            renderMultiline(color,string,area,hAlignment);
        }
        else
        {
            Vector2f position(typeFace_->penX(string,area,hAlignment),baseLineY(area,vAlignment));
            typeFace_->render(string,position);
        }
    }
    else if(typeFace_)
    {
        if(!isMultiLine)
        {
            auto cmdlist = parseString(string);
            Vector2f position(typeFace_->penX(string,area,hAlignment),baseLineY(area,vAlignment));
            typeFace_->render(String(),position,cmdlist);
        }
        else
        {
            auto cmdlist = parseString(string);
            renderMultiline(color,cmdlist,area,hAlignment);
        }
    }
}

这里的parseString用于解析类似html的问题
函数实现如下:

std::list<textRenderCmdUnit> TextRenderer::parseString(const String& content)
{
    String text(content);
    std::list<textRenderCmdUnit> cmdList;

    String current;
    auto list = text.split('<');
    for(int i=0;i<list.size();i++)
    {
        current = list[i];
        if(current.startWith(L"/>"))
        {
            textRenderCmdUnit unit;
            unit.undo = true;
            cmdList.push_back(unit);

            String remain = current.substr(2);
            if(!remain.empty())
            {
                unit.text = remain;
                unit.undo = false;
                cmdList.push_back(unit);
            }
        }
        else if(current.find('>') != String::InvalidPos)
        {
            textRenderCmdUnit unit;
            unit.tag = current.substr(0,current.find('>'));
            unit.undo = false;
            cmdList.push_back(unit);

            int32_t find = current.find('>');
            if(find < current.size()-1)
            {
                unit.tag.clear();
                unit.text = current.substr(find+1);
                cmdList.push_back(unit);
            }
        }
        else
        {
            textRenderCmdUnit unit;
            unit.text = current;
            unit.undo = false;
            cmdList.push_back(unit);
        }
    }

    return cmdList;
}

以下用于渲染富文本

void TypeFace::render(const FloatRect& area,const std::list<textRenderCmdUnit>& queue,Horizontal hAlignment,float vpos)
{
    const float availableWidth = area.width_ - 2.0f;

    textRenderCmdUnit unit;

    String line,lineRemain;

    String tag;
    std::queue<String> cmdStack;

    float y = vpos;
    float x = penX(String(),area,hAlignment);

    auto itr = queue.begin();
    while(itr != queue.end())
    {
        unit = *itr;
        if(unit.undo)
        {
            if(!cmdStack.empty())
            {
                tag = cmdStack.front();
                cmdStack.pop();

                if(tag == "bold")
                    bold_ = false;
                else if(tag == "italic")
                    italic_ = false;
                else if(tag == "underline")
                    underline_ = false;
                else
                    applyColor(tag);
            }
        }
        else if(!unit.tag.empty())
        {
            tag = unit.tag;
            cmdStack.push(tag);

            if(tag == "bold")
                bold_ = true;
            else if(tag == "italic")
                italic_ = true;
            else if(tag == "underline")
                underline_ = true;
            else
                applyColor(tag);
        }
        else
        {
            line += unit.text;

            while(true)
            {
                size_t pos = hitCharacterIndex(line,availableWidth-x);
                if(pos == 0)
                {
                    x = penX(String(),area,hAlignment);
                    y += lineHeight();
                    continue;
                }

                if(pos == String::InvalidPos)
                    pos = line.size();

                String current = line.substr(0,pos);
                lineRemain = line.substr(pos);
                line = current;

                auto linefeed = line.get().find_first_of('\n');
                if(linefeed != std::basic_string<uint32_t>::npos)
                {
                    line = line.substr(0,linefeed);
                    lineRemain = line.substr(linefeed+1) + lineRemain;
                }

                render(line,Vector2f(x,y),std::list<textRenderCmdUnit>());
                x += width(line);

                if(linefeed != String::InvalidPos)
                {
                    x = penX(String(),area,hAlignment);
                    y += lineHeight();
                }
                line = lineRemain;

                if(lineRemain.empty())
                    break;
            }
        }
        itr ++;
    }
}

以下渲染单色文本

void TypeFace::renderGlyphs(const std::list<textRenderCmdUnit>& cmd)
{
    Vector2f position(0.0f,0.0f);
    size_t leftChar = 0;

    textRenderCmdUnit unit;

    String tag;
    std::queue<String> cmdStack;

    std::list<textRenderCmdUnit>::const_iterator itr = cmd.begin();
    while(itr != cmd.end())
    {
        unit = *itr;
        if(unit.tag.empty() && !unit.undo)
        {
            position = renderGlyphs(unit.text,position);
        }
        else if(!unit.tag.empty())
        {
            tag = unit.tag;
            cmdStack.push(tag);

            if(tag == "bold")
                bold_ = true;
            else if(tag == "italic")
                italic_ = true;
            else if(tag == "underline")
                underline_ = true;
            else
                applyColor(tag);
        }
        else if(unit.undo)
        {
            if(!cmdStack.empty())
            {
                tag = cmdStack.front();
                cmdStack.pop();

                if(tag == "bold")
                    bold_ = false;
                else if(tag == "italic")
                    italic_ = false;
                else if(tag == "underline")
                    underline_ = false;
                else
                    applyColor(tag);
            }
        }

        itr ++;
    }
}

可以看出支持的文本格式为Text
一个例子是:

<Blue>这段代码主要测试BGE的富文本显示功能\nBlue><Red>需要指出的是当前只要能支持多行显示和多颜色显示功能即可(不考虑下划线斜体以及加粗显示)。Red><White>这句话将被显示为白色<Blue>这句话应该被蓝色字体Blue><Green>绿色字体<Cyan>Cyan色";

最终显示如下:

ccsdu2009 2016-02-22 17:46 发表评论

发布一个基于OPENGL的GUI库

ccsdu2009 — Fri, 22 Jan 2016 07:41:00 GMT

算是基本完成了，先上一个截图

可以说GUI所需要的当前基本都是实现了

再上一个使用例子:

#include

using namespace bge;

int main(int argc, char* argv[])
{
    FileSystem::instance().initial(argv[0]);
    FileSystem::instance().setResourcePackage("data.zip");
    WindowManager::instance().initialize("simkai.ttf",true);

    Device* device = Device::create();
    device->initial();
    device->createWindow(640,480,bge::String("BGE Window"));

    WindowManager::instance().propertyScheme()->load(":skin1.xml");

    Window* window = WindowManager::instance().createWindow(":grid-layout-window.xml");
    WindowManager::instance().addWindow(window);

    while(device->isRunning())
    {
        device->preRender();
        WindowManager::instance().update();
        device->swapBuffers();
        device->pollEvents();
    }

    WindowManager::instance().terminate();
    device->closeWindow();
    device->terminate();
    device->deleteLater();
    return 0;
}

个人感觉写的还是比较清晰，没什么需要特别说明的
使用的开源库有libpng,glfw,freetype,sigslot,physfs
不过代码有点大，有兴趣的可以留个邮箱

ccsdu2009 2016-01-22 15:41 发表评论

设计模式-门面模式

ccsdu2009 — Sun, 08 May 2011 03:53:00 GMT

啥是门面模式？
按照我的理解就是:给一系列子对象或者系统提高一个统一的接口
在使用过程中该接口把客户端发送来的要求传递到各个可能的子系统中去。
一句话:门面模式是为了简化客户端操作而产生的
一个简单的例子是:
之前我要看电视，只需要打开电视机即可
但是现在有了机顶盒这个东西，要看电视需要2个步骤:打开电视机，打开机顶盒，反而繁琐了。
做个梦，如果一天我想看电视我只要说一句-我要看电视，然后自动打开电视机和机顶盒。那该多好。

可以看出，在实际开发过程中，对于那些没有学过设计模式滴淫，他们也可能使用过该模式，只不过不知道名字罢了

门面模式的一个例子:
很简单滴:

class A;
class B;
class C;
class Op
{
   A* a;
   B* b;
   C* c;
   void Call()
   {
      a->Call();
      b->Call();
      c->Call();
   }
}

注意这里A,B,C不具有共同基类

不管什么模式，都是为了应用服务的，如果但是将复杂化，高深化，那是不可取的。想想当时买了设计模式一书，看的稀里糊涂的。

PS：门面模式=简化客户端操作(统一包装)

ccsdu2009 2011-05-08 11:53 发表评论

GUI库分块

ccsdu2009 — Fri, 06 May 2011 14:44:00 GMT

嗯 GUI库应该分为几个大的模块呢? :)我想

这次的GUI库我会采用类似GUICHAN的方式，具体的GUI并不依赖于特定的图形接口，而是采取插件的方式动态加载，这样有助于提高其使用的广度
应该包含一个GUIRender

另外GUI库涉及面比较广，需要有大量附加的数据结构比如XML，图形处理，向量，插件，基本对象，日志等。我们应该再加一个辅助库
于是有一个叫做Util的东西

其次我们主要的GUI库类
这个是核心
我暂时给他起个名字叫coregui吧
这个是这个GUi的核心
其功能除了一般的GUI控件对象之后还应该有控件工厂，控件池(管理器)，控件数据串行化，控件布局，控件编辑，控件动态加载，脚本处理等功能（想想功能还比较多-不过总比之前做的游戏引擎量要小很多）

分块就这么几个了

在开发过程中，我会一个一个GUI对象都贴上来，然后说明为什么要这样做，并附上可能对应的设计模式（要活学活用(⊙v⊙)?）

PS:其实一个比较好的办法是借助于UML，可是我现在忘了这几个字母如何写，有空学学吧

ccsdu2009 2011-05-06 22:44 发表评论

设计模式-原型方法

ccsdu2009 — Fri, 06 May 2011 14:22:00 GMT

一般来说原型方法主要使用于快速生成和已存在对象基本一致的对象。
一般典型的例子是细胞分裂和孙悟空变换出N的小猴子
不过我这里举一个在GUI设计过程的例子

假如一个面板上的同质按钮，他们仅文本不同，代表的逻辑不同，其他信息是完全一致的，比如皮肤，边框，大小等
按照一般方法可能会这样构造面板

Button* btn1 = new Button();
btn1->SetSize(..);
btn1->SetBorder(..);
btn1->SetListener(..);
btn1->SetVisible(true);
btn1->SetParent(panel);
btn1->SetColor()
Button* btn2 =..
当然还有其他按钮:)

是不是很烦?
借助原型模式
可以大大的简化!
比如:

Button *btn1 = new Button(panel);
Button *btn2= btn1->Clone();
Button *btn3= btn1->Clone();
Button *btn4= btn1->Clone();
然后只要设置各个按钮对应的文本即可

为了使用原型方法我们需要做的仅仅是
给对象增加Clone接口和其实现即可
比如:

class AbstractWidget
{
public:
virtual AbstractWidget* Clone() = 0;

};

需要说明的是原型一般使用的是浅拷贝

ccsdu2009 2011-05-06 22:22 发表评论

设计模式-工厂方法

ccsdu2009 — Thu, 05 May 2011 14:27:00 GMT

接上文:设计模式-简单工厂 http://www.cppblog.com/gaimor/archive/2011/05/02/145498.html
简单工厂是根据传入要求决定生产那类产品,其工厂只有一个
在简单工厂基础之上,如果一个工厂对应一个产品则形成了工厂方法

interface Product
{
    public void Call();
};

public class Product1 implements Product
{
    public void Call()
    {}
};

public class Product2 implements Product
{
    public void Call()
    {}
};

interface ProductFactory
{
    public Product GetProduct();
};

public class ProductFactory1 implements ProductFactory
{
    public Product GetProduct()
    {
        return new Product1();
    }
}

public class ProductFactory2 implements ProductFactory
{
    public Product GetProduct()
    {
        return new Product2();
    }
}

这样使用
ProductFactory factory1 = new ProductFactory1();

Product p1 = factory1.GetProduct();
ProductFactory factory2 = new ProductFactory2();

Product p2 = factory2.GetProduct();

可以看出工厂方法中工厂和产品总是一一对应的
一个工厂只能生产一个产品
很显然工厂方法最大的弊端就在这里.

使用的场合:一个对象希望由子对象来指定它所创建的对象时,可以使用工厂方法

PS:系统那个总结下设计模式

ccsdu2009 2011-05-05 22:27 发表评论

设计模型系列-简单工厂

ccsdu2009 — Mon, 02 May 2011 08:57:00 GMT

这段时间在学习Android，也要学点jav方面的编程知识
乘着这个机会，俺就总结下学过和使用过的设计模式，并使用java写下

先说简单工厂
简单工厂属于工厂模式的一种，不过似乎不在GOF模式之列.
一句话描述:简单工厂就是根据给定要求生成给定对象
简单的java版本代码如下:

public interface Product
{
    abstract public void Call();
};

public Pen implements Product
{
    public void Call()
    {

    }
};

public Book implements Product
{
    public void Call()
    {

    }
};

public clas Factory
{
    public Product CreateProducrt(String name)
    {
        if(name.equals("Pen"))
            return Pen.class.newInstance();
        else if(name.equals("Book"))
            return Book.class.newInstance();
        return null;
    }
};

简单工厂就是根据输入标签返回给定的对象实例

很显然，简单工厂的主要缺陷就在于:如果需要增加一个新的产品那就需要修改其产品生成函数

另外，如果把工厂和产品对象合二为一就变成了如下的形式:

public class Object
{
public static ObjectCreateObject(String name);
other function.
};

这类似于MFC中CObject

简单工厂的一个使用例子如下(之前我写的GUI):

class WidgetFactory
{
public:
Widget* CreateWidgetByName(const std::string& name);
};

在这里如果传入Spin则返回一个new Spin,传入一个Slider则返回一个new Slider对象
如果我增加一个新的Widget对象，则需要把CreateWidgetByName函数修改下(当然可以使用Object::CreateObject(name)函数,只是返回的对象需要做类型转换,原则一致)

下篇说说抽象工厂和工厂方法吧

ccsdu2009 2011-05-02 16:57 发表评论