Skip to main content
Mogre porting example        
1
Page actions
Print

Here you can see how to port C++ to C# code.

As an example we port the snipit Easy debug text.

The result C# code is in this thread.

This example is not ready. Please help to complete and correct it.

You also can add comments to this page.

Important: start each code line with a space char " " (also blank lines) --> wiki will show it in monospace box

Ogre code

acDebug.h

Copy to clipboard
#ifndef acDebug_H
#define acDebug_H

#pragma once

#include <string>
using namespace std;

#include "Ogre.h"

using namespace Ogre;

class _acSystemExport acDebug : public Ogre::Singleton<acDebug>
{

public: 
    acDebug(SceneManager* sm,RenderWindow* window);
    ~acDebug();

    static acDebug& getSingleton(void);
    static acDebug* getSingletonPtr(void);

    void addDebugText(String text);
    void printText();

protected:
    SceneManager* mSceneMgr;
    RenderWindow* mWindow;
    std::list<String>* mDebugLines;
    
};
#endif


acDebug.cpp

Copy to clipboard
#include "acDebug.h"

template<> acDebug* Singleton<acDebug>::ms_Singleton = 0;

acDebug* acDebug::getSingletonPtr(void)
{
    return ms_Singleton;
}
acDebug& acDebug::getSingleton(void)
{  
    assert( ms_Singleton );  return ( *ms_Singleton );  
}

acDebug::acDebug(SceneManager* sm,RenderWindow* window){
    mSceneMgr = sm;
    mWindow = window;
    mDebugLines = new std::list<String>;
}

acDebug::~acDebug(){
    if (mDebugLines)
        delete mDebugLines;
}

void acDebug::addDebugText(String text){
    mDebugLines->push_back(text);
}

void acDebug::printText(){
    String output;
    std::list<String>::iterator itr = mDebugLines->begin();
    std::list<String>::iterator itrEnd = mDebugLines->end();
    for (;itr!=itrEnd;itr++){
        output += (*itr) + ", ";
    }
    mWindow->setDebugText(output);
    mDebugLines->clear();
}

Mogre code

header file
C++ code
C# code

Copy to clipboard
// #ifndef acDebug_H                                               // .h
 // #define acDebug_H                                               // .h
 //                                                                 // .h
 // #pragma once                                                    // .h 
 //                                                                 // .h
 // #include <string>                                               // .h
 // using namespace std;                                            // .h
 //                                                                 // .h
 // #include "Ogre.h"                                               // .h
 //                                                                 // .h
 // using namespace Ogre;                                           // .h

Copy to clipboard
using System;
 // other usings
 using Mogre;
 using std;      // ??

Copy to clipboard
// template<> acDebug* Singleton<acDebug>::ms_Singleton = 0;   // .cpp

Copy to clipboard
// C# ??

Copy to clipboard
// class _acSystemExport acDebug : public Ogre::Singleton<acDebug> // .h
 // {                                                               // .h

Copy to clipboard
public class acDebug        // inheritance of something? ... I found no Mogre.Singleton
 {

Copy to clipboard
// public:                                                     // .h
     //     acDebug(SceneManager* sm,RenderWindow* window);            // .h
     //     ~acDebug();                                                // .h
     //                                                             // .h
     //     static acDebug& getSingleton(void);                        // .h
     //     static acDebug* getSingletonPtr(void);                  // .h
     //                                                             // .h

Copy to clipboard
// acDebug* acDebug::getSingletonPtr(void)                     // .cpp
     // {                                                           // .cpp
     //     return ms_Singleton;                                    // .cpp
     // }                                                           // .cpp
     // acDebug& acDebug::getSingleton(void)                        // .cpp
     // {                                                           // .cpp
     //     assert( ms_Singleton );  return ( *ms_Singleton );      // .cpp
     // }                                                           // .cpp
     //                                                             // .cpp
     //                                                             // .cpp
     // acDebug::acDebug(SceneManager* sm,RenderWindow* window){    // .cpp
     //     mSceneMgr = sm;                                            // .cpp
     //     mWindow = window;                                          // .cpp
     //     mDebugLines = new std::list<String>;                       // .cpp
     // }                                                           // .cpp
     //                                                             // .cpp
     // acDebug::~acDebug(){                                        // .cpp
     //     if (mDebugLines)                                           // .cpp
     //    delete mDebugLines;                                      // .cpp
     // }                                                           // .cpp

Copy to clipboard
public static acDebug SingletonPtr      // needed in C# ??
     {
         get { return ms_Singleton; }        // not defined ??
     }
 
     public static acDebug Singleton         // I think this is wrong ... ??
     {
         get
         {
             assert(ms_Singleton);           // what is assert ??
             return ms_Singleton;            // ... return pointer ?? (C# has no pointer)
         }
     }
     
     public void acDebug(SceneManager sm, Renderwindow window)
     {
         mSceneMgr = sm;
         mWindow = window;
         mDebugLines = new ArrayList();            // ??
     }


The destructor ~acDebug() is not needed under C# / .NET, because of garbage collection.

Destructors are defined by "~". Just ignore such lines.

Copy to clipboard
//  void addDebugText(String text);                            // .h

Copy to clipboard
// void acDebug::addDebugText(String text){                    // .cpp
     //     mDebugLines->push_back(text);                           // .cpp
     // }                                                           // .cpp

Copy to clipboard
public void addDebugText(String text)
     {
         mDebugLines.Add(text);
     }

Copy to clipboard
//  void printText();                                          // .h

Copy to clipboard
// void acDebug::printText(){                                  // .cpp
     //     String output;                                             // .cpp
     //     std::list<String>::iterator itr = mDebugLines->begin();    // .cpp
     //     std::list<String>::iterator itrEnd = mDebugLines->end();   // .cpp
     //     for (;itr!=itrEnd;itr++){                                  // .cpp
     //         output += (*itr) + ", ";                               // .cpp
     //     }                                                          // .cpp
     //     mWindow->setDebugText(output);                             // .cpp
     //     mDebugLines->clear();                                      // .cpp
     // }                                                           // .cpp

Copy to clipboard
public void printText()
     {
         String output = "";
         foreach (String line in mDebugLines)  // instead of iterator
             output += itr + ", ";
         mWindow.setDebugText(output);         // I didn't found a member like this... ??
         mDebugLines.Clear();
     }

Copy to clipboard
// protected:                                                  // .h
     //     SceneManager* mSceneMgr;                                   // .h
     //     RenderWindow* mWindow;                                     // .h
     //     std::list<String>* mDebugLines;                            // .h

Copy to clipboard
protected SceneManager mSceneMgr;
     protected RenderWindow mWindow;
     protected ArrayList mDebugLines;

Copy to clipboard
// };                                                              // .h
 // #endif                                                          // .h

Copy to clipboard
} //  class acDebug


The complete result code you will find in Easy debug text MOGRE.

Remarks

Questions can be asked in the forum thread.

Some words of user Smernesto

Well if you want to port from a language to another the best is to know about both languages. If you don´t know C++ will be a little more hard to port code.

Porting code from C++ and Ogre to C# and Mogre is really not very hard, but if the code es very large it will take you much much time.

Well in C++ templates is similar to generics in C# 2.0.

Generally for OOP you use the .h file to write the interface of the classes and the .cpp file to write the implementation of the methods (member functions).

For example I ported the OSM Loader 2, and the original code uses tinyxml, a xml parsing library for C++, when I ported the code I used System.Xml from .Net, also changed the Ogre Exceptions to .NET exceptions, also used .NET Containers.

I recommend you if you want to port many code that you read some general information about C++.


More helping comments can be places here ...

History Source