9

私のアプリケーションでは、アプリケーション ウィンドウ内にコンソールを埋め込む必要があります。例としては、コンソールがウィンドウの下部にあり、コマンドを待機しているautoCADのようなプログラムがあります。

ここに画像の説明を入力

変数やその他のものを変更できるように、アプリケーション内にコンソールが必要なので、コンソールは完全に吹き飛ばされたシェルである必要はありません。

現時点では、アプリケーション内に単純なコンソールがありますが、コンソールをどのようにしたいかである端末（シェル）と比較すると、非常に不格好に見えます。

ここに画像の説明を入力

私が持っているコンソールでそれを行った方法は、ユーザーがTABコンソールに表示されているキーを押したときに、コマンド/ラインを入力できるようにすることです。キーが押されると、Return入力した文字列が解析され、コマンドが処理されます。

オブジェクトを使用sf::Textして、アプリケーション ウィンドウにテキストを出力しています。sf::Text以前のコマンド/エラー メッセージ用に 4 つ、現在のコマンド ライン用に 1 つの合計 5 つのオブジェクトが使用されます。Returnキーが押されると、4 番目がsf::Text現在の文字列を 3 番目に、3 番目が 2 番目に、2 番目が 1 番目に、1 番目が現在のコマンド文字列に変更され、現在のコマンド文字列がクリアされ、再び入力できるようになります。そうすれば、コマンドおよび/またはエラーの 4 つの「履歴」の余地があります。最高ではありませんが、私が思いついた最高のものでした。もちろん、sf::Textオブジェクトを追加することで履歴の量を変更できます。最後に、これはコンソールを画面にレンダリングする方法です

sf::RectangleShape rectangle;

rectangle.setSize(sf::Vector2f(App->getSize().x, App->getSize().y / 3));
rectangle.setPosition(0, 0);

rectangle.setFillColor(sf::Color::black);

App->draw(rectangle);   // This renders the console looking background rectangle
App->draw(CLine);   // This renders the current command line

for(int i = 4; i >= 0; --i) // This renders the history as described above, their idevidual positions are setup earlier on in the program
{
    CHistory[i].setString(CS[i]);
    App->draw(CHistory[i]);
}

Appただのsf::RenderWindow*

私の全体的な質問は、上記のようにコンソールのように見えるようにレンダリングされたテキストオブジェクトの単なる画像でなくても、SFML ウィンドウにコンソールを埋め込む方法はありますか?ということです。アプリケーション内に実際のコンソール/シェル/ターミナルが必要です。標準の bash シェルと同様ですが、もちろん独自のシェル インタープリターです。

4

3 に答える 3

4

少し前に書いていたopenglゲームのコンソールとして以下を実装しました。それは決してあなたの質問に対する決定的な答えではありませんが、私にとってはうまくいきました。

2 つのファイルは、この投稿の下部にあります。インクルードしないライブラリ ヘッダー ファイルが 2 つあるため、コードが直接実行される可能性は低いです。完全なソースが必要な場合はお知らせください。

基本的に、コンソール クラスを使用すると、実行時に変更できる変数ポインターを追加できます。Windows イベント メッセージからの入力を受け入れます。(入力の実際の処理は別の場所で行われます) コマンドの解析は ProcessInput() メソッドで行われ、変数は ChangeVariable() メソッドで更新されます。

警告の言葉。このメソッドは、基本的に、コンソール ユーザーが個々の変数のメモリ位置に直接アクセスできるようにします。これには、ユーザーが実行時にアプリケーションをクラッシュさせないようにするために、適切な入力検証が必要です。座って別のコンソールを作ろうとしたことがあるとしたら、おそらく少し違うことをするでしょう. しかし、これがあなたに少しの助けになることを願っています。

ヘッダー ファイル:

#ifndef CONSOLE_H
#define CONSOLE_H

#include <vector>
#include <map>
#include <string>
#include "Singleton.h"
#include <Windows.h>
#include "Enumerations.h"
#include "StringConversion.h"

class Console
{
public:

    Console();
    ~Console();

    void Update(std::vector<WPARAM> pressedKeys);

    void AddInt(std::string varName, int *ptrToInt);
    void AddFloat(std::string varName, float *ptrToFloat);
    void AddLong(std::string varName, long *ptrToLong);
    void AddBool(std::string varName, bool *ptrToBool);

    const std::string &GetCurrentText();
    const std::vector<std::string> &GetPreviousText();

private:
    std::map<std::string, int *> m_Ints;
    std::map<std::string, float *> m_Floats;
    std::map<std::string, long *> m_Longs;
    std::map<std::string, bool *> m_Bools;

    std::map<std::string, std::string> m_Variables;

    std::vector<std::string> m_PrevConsoleText;
    std::string m_CurrInput;

    int m_PrevSelection;

    bool ProcessInput();
    void ChangeVariable(const std::string &varName, const std::string &value);
};

typedef Singleton<Console> g_Console;

#endif // CONSOLE_H

cpp ファイル:

#include "Console.h"

Console::Console()
{
    m_PrevSelection = 0;
}

Console::~Console()
{

}

void Console::AddInt(std::string varName, int *ptrToInt)
{
    m_Ints[varName] = ptrToInt;
    m_Variables[varName] = "int";
}

void Console::AddFloat(std::string varName, float *ptrToFloat)
{
    m_Floats[varName] = ptrToFloat;
    m_Variables[varName] = "float";
}

void Console::AddLong(std::string varName, long *ptrToLong)
{
    m_Longs[varName] = ptrToLong;
    m_Variables[varName] = "long";
}

void Console::AddBool(std::string varName, bool *ptrToBool)
{
    m_Bools[varName] = ptrToBool;
    m_Variables[varName] = "bool";
}

void Console::ChangeVariable(const std::string &varName, const std::string &value)
{
    //*(m_Bools[varName]) = value;

    std::string temp = m_Variables[varName];

    if(temp == "int")
    {
        //*(m_Ints[varName]) = fromString<int>(value);
    }
    else if(temp == "float")
    {
        //*(m_Floats[varName]) = fromString<float>(value);
    }
    else if(temp == "long")
    {
        //*(m_Longs[varName]) = fromString<long>(value);
    }
    else if(temp == "bool")
    {
        if(value == "true" || value == "TRUE" || value == "True")
        {
            *(m_Bools[varName]) = true;
        }
        else if(value == "false" || value == "FALSE" || value == "False")
        {
            *(m_Bools[varName]) = false;
        }
    }
}

const std::string &Console::GetCurrentText()
{
    return m_CurrInput;
}

void Console::Update(std::vector<WPARAM> pressedKeys)
{
    for(int x = 0; x < (int)pressedKeys.size(); x++)
    {
        switch(pressedKeys[x])
        {
        case KEY_A:
            m_CurrInput.push_back('a');
            break;
        case KEY_B:
            m_CurrInput.push_back('b');
            break;
        case KEY_C:
            m_CurrInput.push_back('c');
            break;
        case KEY_D:
            m_CurrInput.push_back('d');
            break;
        case KEY_E:
            m_CurrInput.push_back('e');
            break;
        case KEY_F:
            m_CurrInput.push_back('f');
            break;
        case KEY_G:
            m_CurrInput.push_back('g');
            break;
        case KEY_H:
            m_CurrInput.push_back('h');
            break;
        case KEY_I:
            m_CurrInput.push_back('i');
            break;
        case KEY_J:
            m_CurrInput.push_back('j');
            break;
        case KEY_K:
            m_CurrInput.push_back('k');
            break;
        case KEY_L:
            m_CurrInput.push_back('l');
            break;
        case KEY_M:
            m_CurrInput.push_back('m');
            break;
        case KEY_N:
            m_CurrInput.push_back('n');
            break;
        case KEY_O:
            m_CurrInput.push_back('o');
            break;
        case KEY_P:
            m_CurrInput.push_back('p');
            break;
        case KEY_Q:
            m_CurrInput.push_back('q');
            break;
        case KEY_R:
            m_CurrInput.push_back('r');
            break;
        case KEY_S:
            m_CurrInput.push_back('s');
            break;
        case KEY_T:
            m_CurrInput.push_back('t');
            break;
        case KEY_U:
            m_CurrInput.push_back('u');
            break;
        case KEY_V:
            m_CurrInput.push_back('v');
            break;
        case KEY_W:
            m_CurrInput.push_back('w');
            break;
        case KEY_X:
            m_CurrInput.push_back('x');
            break;
        case KEY_Y:
            m_CurrInput.push_back('y');
            break;
        case KEY_Z:
            m_CurrInput.push_back('z');
            break;
        case KEY_0:
            m_CurrInput.push_back('0');
            break;
        case KEY_1:
            m_CurrInput.push_back('1');
            break;
        case KEY_2:
            m_CurrInput.push_back('2');
            break;
        case KEY_3:
            m_CurrInput.push_back('3');
            break;
        case KEY_4:
            m_CurrInput.push_back('4');
            break;
        case KEY_5:
            m_CurrInput.push_back('5');
            break;
        case KEY_6:
            m_CurrInput.push_back('6');
            break;
        case KEY_7:
            m_CurrInput.push_back('7');
            break;
        case KEY_8:
            m_CurrInput.push_back('8');
            break;
        case KEY_9:
            m_CurrInput.push_back('9');
            break;
        case KEY_QUOTE:
            m_CurrInput.push_back('\"');
            break;
        case KEY_EQUALS:
            m_CurrInput.push_back('=');
            break;
        case KEY_SPACE:
            m_CurrInput.push_back(' ');
            break;
        case KEY_BACKSPACE:
            if(m_CurrInput.size() > 0)
            {
                m_CurrInput.erase(m_CurrInput.end() - 1, m_CurrInput.end());
            }
            break;
        case KEY_ENTER:
            ProcessInput();
            break;
        case KEY_UP:
            m_PrevSelection--;
            if(m_PrevSelection < 1)
            {
                m_PrevSelection = m_PrevConsoleText.size() + 1;
                m_CurrInput = "";
            }
            else
            {
                m_CurrInput = m_PrevConsoleText[m_PrevSelection - 1];
            }

            break;
        case KEY_DOWN:
            if(m_PrevSelection > (int)m_PrevConsoleText.size())
            {
                m_PrevSelection = 0;
                m_CurrInput = "";
            }
            else
            {
                m_CurrInput = m_PrevConsoleText[m_PrevSelection - 1];
            }
            m_PrevSelection++;
            break;
        }
    }
}

bool Console::ProcessInput()
{
    int x;
    std::string variable = "NULL", value;
    bool ok = false;
    std::string::iterator it;

    //Split up the input from the user.
    //variable will be the variable to change
    //ok will = true if the syntax is correct
    //value will be the value to change variable to.
    for(x = 0; x < (int)m_CurrInput.size(); x++)
    {
        if(m_CurrInput[x] == ' ' && variable == "NULL")
        {
            variable = m_CurrInput.substr(0, x);
        }
        else if(m_CurrInput[x] == '=' && m_CurrInput[x - 1] == ' ' && m_CurrInput[x + 1] == ' ')
        {
            ok = true;
        }
        else if(m_CurrInput[x] == ' ')
        {
            value = m_CurrInput.substr(x + 1, m_CurrInput.size());
        }
    }

    if(ok)
    {
        m_PrevConsoleText.push_back(m_CurrInput);
        m_PrevSelection = m_PrevConsoleText.size();

        if(m_PrevConsoleText.size() > 10)
        {
            m_PrevConsoleText.erase(m_PrevConsoleText.begin(), m_PrevConsoleText.begin() + 1);
        }
        m_CurrInput.clear();


        ChangeVariable(variable, value);
    }
    else
    {
        m_PrevConsoleText.push_back("Error invalid console syntax! Use: <variableName> = <value>");
        m_CurrInput.clear();
    }

    return ok;
}

const std::vector<std::string> &Console::GetPreviousText()
{
    return m_PrevConsoleText;
}

編集 1: DrawConsole() を追加コンソール クラスからテキストを取得し、最近のバルブ ゲームで見つかったソース エンジンのコンソール ウィンドウに似た画像をレンダリングし、テキストを適切な場所に描画します。

void View::DrawConsole()
{
    Square console;
    std::vector<std::string> temp;
    temp = g_Console::Instance().GetPreviousText();

    console.top = Vector3f(0.0, 0.0, 1.0);
    console.bottom = Vector3f(640, 480, 1.0);

    g_Render::Instance().SetOrthographicProjection();
    g_Render::Instance().PushMatrix();
    g_Render::Instance().LoadIdentity();

    g_Render::Instance().BindTexture(m_ConsoleTexture);
    g_Render::Instance().DrawPrimative(console, Vector3f(1.0f, 1.0f, 1.0f));
    g_Render::Instance().DisableTexture();

    g_Render::Instance().SetOrthographicProjection();
    //Draw the current console text
    g_Render::Instance().DrawString(g_Console::Instance().GetCurrentText(), 0.6f, 20, 465);

    //Draw the previous console text
    for(int x = (int)temp.size(); x > 0; x--)
    {
        g_Render::Instance().DrawString(temp[x-1], 0.6f, 20, (float)(425 - (abs((int)temp.size() - x) * 20)));
    }

    g_Render::Instance().SetPerspectiveProjection();

    g_Render::Instance().PopMatrix();
    g_Render::Instance().SetPerspectiveProjection();
}
于 2012-06-13T03:54:57.523 に答える
2

これにはいくつかのことがあります。まず、ある種の行編集サポートが必要です。これにはライブラリがあります。たとえば、NetBSD のeditline http://www.thrysoee.dk/editline/

次に、どういうわけかキープレスを処理する必要があります。ここからが楽しみの始まりです。キー イベントを直接処理しようとする代わりに、pipeon (POSIX) / CreatePipeon Windows を使用して作成された匿名パイプにそれらをフィードします。次に、反対側で、それらがstdinから入ったかのように読み取ることができます。2 番目の匿名パイプはstdoutの機能を 2 倍にし、その出力をゲーム内コンソールに表示します。結果として得られる FD のペアをconsoleinとconsoleoutと呼びます。また、緊急のエラー メッセージ用にconsoleerr FD を追加します。コンソールはそれらを別の色で表示したり、フィルタリングしたりできます。

このアプローチの良いところは、標準ライブラリの優れた機能をすべて使用して、コンソールと対話できることです。fprintf(consoleout, ...)などを使用できますfscanf(consolein, ...)。もちろん、C++ iostream でも動作します。しかし、もっと重要なのは、前述のeditlineのようなライブラリに直接アタッチできることです。

最後に、ユーザーがコンソールに入力したコマンドを処理する必要があります。そこでは怠惰な方法で、対話型操作をサポートするスクリプト言語インタープリターを埋め込むだけです。Pythonのように、またはゲーム全体で非常に広く普及しているLua . もちろん、独自のコマンド インタープリターを実装することもできます。

于 2012-06-13T06:27:43.413 に答える
0

コンソールのように感じさせたい場合は、おそらく次のようにします。

  • ワンボタンでON/OFFできるのは、たぶん のようなもの~で、よく使われています。
  • 入力している行に背景色を付けます。おそらく透明ですが、少なくともそれが RenderWindow に浮かぶテキストだけではないことを確認してください。コマンドの出力が複数の行である場合は、それらがすべて表示されるか、少なくとも履歴をスクロールできることを確認してください。
  • コマンドが理解しやすく、一貫していることを確認してください。たとえば、私が間違っていなければ、ソース エンジンの多くのゲームは、cl_レンダリングに関連するものすべてにプレフィックスを使用します。例を参照cl_showfps 1してください。
  • 従来の端末入力はいい感じです。Up は、入力した前のコマンドを表示します。冒険したい場合は、Tab を使用して完了します。
  • 時間が残っている場合は--help、たとえば使用可能なコマンドを表示する方法もいいでしょう。もちろん、ゲームの複雑さに応じて。

残りについては、他のゲームがこれをどのように行ったかを見てください. あなたは、ゲーム内端末の素晴らしい例を持っている Quake について言及しました。私は、多くの Source ゲームの 1 つも使いやすいと思います (Half Life 2、Counter Strike Source、Team Fortress 2、Left 4 Dead などを参照)。OGRE や IrrLicht などの別のフレームワークを除いて、このための標準ライブラリはないと思います。

于 2012-06-13T03:52:23.550 に答える