spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//
// ========== "SoftPixel Sandbox" Level Loader Example for "Irrlicht Engine 1.8" - (05/03/2013) ==========
//

#include <irrlicht.h>

#include "SpSbImportExport/spsImporter.h"

using namespace irr;

using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


/* === Global members === */

IrrlichtDevice* irrDevice = 0;

IVideoDriver* irrDriver = 0;
ISceneManager* irrSmngr = 0;


/* === Global functions === */

IMeshSceneNode* LoadMesh(const std::string &Filename)
{
    IAnimatedMesh* mesh = irrSmngr->getMesh(stringc(Filename.c_str()));
    
    if (mesh)
        return irrSmngr->addMeshSceneNode(mesh);
    
    return 0;
}


/* === Classes === */

using namespace sps;

class SpSbLoader : public SpSceneImporter
{
    
    public:
        
        SpSbLoader() : SpSceneImporter()
        {
        }
        ~SpSbLoader()
        {
        }
        
    private:
        
        /* === Functions === */
        
        void SetupBaseObject(ISceneNode* Node, const SpBaseObject &ObjectDesc)
        {
            if (Node)
            {
                Node->setPosition(Convert(ObjectDesc.Position));
                Node->setRotation(Convert(ObjectDesc.Rotation).getRotationDegrees());
                Node->setScale(Convert(ObjectDesc.Scaling));
            }
        }
        
        bool CatchMesh(const SpMesh &Object)
        {
            switch (Object.Construct.BuildType)
            {
                case 1:
                {
                    if (Object.Construct.BasicMesh.BasicMeshType == 0)
                    {
                        IMeshSceneNode* Node = irrSmngr->addCubeSceneNode(1.0f);
                        SetupBaseObject(Node, Object.BaseObject);
                    }
                }
                break;
                
                case 3:
                {
                    IMeshSceneNode* Node = LoadMesh(Object.Construct.ResourceMesh.Filename);
                    
                    if (Node)
                    {
                        SetupBaseObject(Node, Object.BaseObject);
                        Node->setMaterialFlag(EMF_LIGHTING, false);
                    }
                }
                break;
            }
            return true;
        }
        
        bool CatchLight(const SpLight &Object)
        {
            irrSmngr->addLightSceneNode(
                0,
                Convert(Object.BaseObject.Position),
                SColorf(1.0f, 1.0f, 1.0f),
                Object.VolumetricRadius
            );
            return true;
        }
        
        /* === Inline functions === */
        
        inline vector3df Convert(const SpVector3 &Vec) const
        {
            return vector3df(Vec.x, Vec.y, Vec.z);
        }
        
        inline matrix4 Convert(const SpMatrix4 &Mat4x4) const
        {
            matrix4 Mat;
            
            for (unsigned int i = 0; i < 16; ++i)
                Mat[i] = Mat4x4.m[i];
            
            return Mat;
        }
        
        /* === Members === */
        
        
};


/* === Global functions === */

int main()
{
    // Create irrlicht device
    irrDevice = createDevice(
        video::EDT_OPENGL, dimension2d<u32>(800, 600), 16, false, false, false, 0
    );
    
    if (!irrDevice)
        return 1;
    
    irrDevice->setWindowCaption(L"\"SoftPixel Sandbox\" Level Loader Example for \"Irrlicht Engine 1.8\"");
    
    irrDriver = irrDevice->getVideoDriver();
    irrSmngr = irrDevice->getSceneManager();
    
    irrSmngr->addCameraSceneNode(0, vector3df(15, 5, -15), vector3df(0, 0, 0));
    
    // Load SpSb scene file.
    SpSbLoader SceneLoader;
    
    SceneLoader.ImportScene("Media/DemoScene.spsb");
    
    while (irrDevice->run())
    {
        irrDriver->beginScene(true, true, SColor(255, 200, 200, 255));
        
        irrSmngr->drawAll();
        
        irrDriver->endScene();
    }
    
    irrDevice->drop();
    
    return 0;
}

Quellcode

 * Added Mesh Browser.
   
 * Added some new functionality to the toolbar.
   
 * Increased performance.
   
 * Updated lightmap generator -> now supporting multi-threaded lightmap generation.
   
 * Updated Storyboard Designer.
   
 * Updated level file format to v.1.09.
   
 * Finally using relative path for texture-, mesh- and script filenames.

Quellcode

struct SpScriptTemplateData
{
    SpScriptTemplateData()
    {
    }
    ~SpScriptTemplateData()
    {
    }
    
    /* Members */
    std::string TemplateName;               //!< Template name.
    std::vector<std::string> Parameters;    //!< Parameter values.
};

struct SpStoryboardItem
{
    SpStoryboardItem() :
        Id              (0),
        Type            (0),
        ViewPosX        (0),
        ViewPosY        (0),
        LogicGateType   (0)
    {
    }
    ~SpStoryboardItem()
    {
    }
    
    /* Members */
    uint32 Id;
    int8 Type;                              //!< Item type: 0 -> Logic gate, 1 -> Event, 2 -> Trigger.
    
    int32 ViewPosX;
    int32 ViewPosY;
    
    int8 LogicGateType;                     //!< Only used for logic-gates.
    SpScriptTemplateData ScriptTemplate;    //!< Only used for events and triggers.
    
    std::vector<uint32> LinkIds;
};