level.h

#define LEVEL_DIMENSION_X                       50.0f
#define LEVEL_DIMENSION_Y                       50.0f
#define LEVEL_DIMENSION_Z                       50.0f
#define LEVEL_DIMENSION_OFFSET          -128.0f
#define LEVEL_SCALE_X                           0.5f
#define LEVEL_SCALE_Y                           0.5f
#define LEVEL_SCALE_Z                           0.5f
#define LEVEL_ROTATION_OFFSET           -10.0f
#define LEVEL_ROTATION_TRIM                     0.1f



void parseXML(IXMLReader* xml)
{
        stringc nodeName = "";
        int objectCount = 0;

        while(xml && xml->read())
        {
                switch(xml->getNodeType())
                {
                        case EXN_ELEMENT:
                        {
                                nodeName = xml->getNodeName();

                                if ( nodeName.equals_ignore_case(stringc("level")) )
                                {
                                        //levelName = xml->getAttributeValue(L"name");
                                        levelTime = xml->getAttributeValueAsInt(L"time");
                                        //levelPoints = xml->getAttributeValueAsInt(L"points");
                                }
                                else if ( nodeName.equals_ignore_case(stringc("player")) )
                                {
                                        // Setup global cal3D Model
                                        stringc mesh = "";
                                        float x, y, z;
                                        float rx, ry, rz;
                                        float sx, sy, sz;
                                        mesh = xml->getAttributeValue(L"mesh");
                                        x = (xml->getAttributeValueAsFloat(L"pos_x") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_X;
                                        y = (xml->getAttributeValueAsFloat(L"pos_y") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_Y;
                                        z = (xml->getAttributeValueAsFloat(L"pos_z") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_Z;
                                        rx = xml->getAttributeValueAsFloat(L"rot_x") - LEVEL_ROTATION_OFFSET;
                                        ry = xml->getAttributeValueAsFloat(L"rot_y") - LEVEL_ROTATION_OFFSET;
                                        rz = xml->getAttributeValueAsFloat(L"rot_z") - LEVEL_ROTATION_OFFSET;
                                        sx = xml->getAttributeValueAsFloat(L"scale_x") * LEVEL_SCALE_X;
                                        sy = xml->getAttributeValueAsFloat(L"scale_y") * LEVEL_SCALE_X;
                                        sz = xml->getAttributeValueAsFloat(L"scale_z") * LEVEL_SCALE_X;

                                        ISceneNode* parent = smgr->getRootSceneNode();
                                        player.node = new CCal3DSceneNode(makeMediaString(mesh).c_str(), parent, smgr, -1);
                                        if (! player.node->init())
                                        {
                                                stringw text("cannot load: ");
                                                text.append(makeMediaString(mesh).c_str());
                                                text.append(stringw(" !!! wrong path ???"));
                                                device->setWindowCaption(text.c_str());
                                                return;
                                        }
                                        player.node->setPosition(v3(x,y,z));
                                        player.node->setRotation(v3(rx,ry,rz));
                                        player.node->setScale(v3(sx,sy,sz));

                                        // collision
                                        //player.node->setDebugDataVisible(true);
                                }
                                else if ( nodeName.equals_ignore_case(stringc("object")) )
                                {
                                        int objID = -1;
                                        stringc objType = "";
                                        stringc objMesh = "";
                                        float x, y, z;
                                        float rx, ry, rz;
                                        float sx, sy, sz;

                                        if (12 != xml->getAttributeCount())
                                        {
                                                std::cout << "parseXML() inconsistent object attributes: atrCnt=" << xml->getAttributeCount() << " (should be 12)" << endl;
                                        }

                                        objID = xml->getAttributeValueAsInt(L"id");
                    objectCount++;
                                        
                                        if (objectCount != objID)
                                        {
                                                cout << "parseXML() inconsistent object count: objCnt=" << objectCount << " objID=" << objID << endl;
                                        }

                                        objType = xml->getAttributeValue(L"type");
                                        objMesh = xml->getAttributeValue(L"mesh");
                                        x = (xml->getAttributeValueAsFloat(L"pos_x") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_X;
                                        y = (xml->getAttributeValueAsFloat(L"pos_y") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_Y;
                                        z = (xml->getAttributeValueAsFloat(L"pos_z") + LEVEL_DIMENSION_OFFSET) * LEVEL_DIMENSION_Z;
                                        rx = (xml->getAttributeValueAsFloat(L"rot_x") + LEVEL_ROTATION_OFFSET) * LEVEL_ROTATION_TRIM;
                                        ry = (xml->getAttributeValueAsFloat(L"rot_y") + LEVEL_ROTATION_OFFSET) * LEVEL_ROTATION_TRIM;
                                        rz = (xml->getAttributeValueAsFloat(L"rot_z") + LEVEL_ROTATION_OFFSET) * LEVEL_ROTATION_TRIM;
                                        sx = xml->getAttributeValueAsFloat(L"scale_x") * LEVEL_SCALE_X;
                                        sy = xml->getAttributeValueAsFloat(L"scale_y") * LEVEL_SCALE_Y;
                                        sz = xml->getAttributeValueAsFloat(L"scale_z") * LEVEL_SCALE_Z;

                                        IAnimatedMesh* mesh = smgr->getMesh(makeMediaString(objMesh).c_str());
                                        if (mesh)
                                        {
                                                // finaly, create an object
                                                //ISceneNode* newNode = smgr->addMeshSceneNode(mesh->getMesh(0));
                                                ISceneNode* newNode = smgr->addTestSceneNode(100.0f);   //dbg
                                                newNode->setMaterialTexture(0, driver->getTexture("media/wall.bmp"));   // dbg
                                                
                                                //dbg:
                                                //newNode->setDebugDataVisible(true);
                                                //newNode->setMaterialFlag(EMF_LIGHTING, false);
                                                //newNode->setMaterialFlag(EMF_BILINEAR_FILTER, true);
                                                //newNode->setMaterialFlag(EMF_TRILINEAR_FILTER, true);
                                                //newNode->setMaterialFlag(EMF_GOURAUD_SHADING, false);
                                                //newNode->setMaterialFlag(EMF_WIREFRAME, true);

                                                // set properties of object
                                                newNode->setID(objID);
                                                newNode->setPosition(v3(x, y, z));
                                                newNode->setRotation(v3(rx, ry, rz));
                                                newNode->setScale(v3(sx, sy, sz));

                                                // copy into our own structure
                                                Obj* newO = new Obj();
                                                newO->mesh = mesh->getMesh(0);
                                                newO->node = newNode;
                                                
                                                if (objType.equals_ignore_case(stringc("ring").c_str()))
                                                {
                                                        // remove initial rotation on rings
                                                        newO->rot = v3(0,0,0);
                                                        // change ring-color
                                                        newO->node->getMaterial(0).EmissiveColor.set(0,155,0,0); // bright red
                                                }
                                                else
                                                {
                                                        newO->rot = newNode->getRotation();
                                                }
                                                newO->name = objType;

                                                // insert into list
                                                objects.push_back(newO);
                                        }
                                }
                                else
                                {
                                        cout << "parseXML() unknown node-name:" << nodeName.c_str() << endl;
                                }
                        }
                }
        }
}


void loadNextLevel()
{
        // todo: iterate through all levels in folder LEVELPATH
        IXMLReader* xml = device->getFileSystem()->createXMLReader(LEVELPATH);
        if (!xml)
        {
                cout << "loadNextLevel() cannot open file '" << LEVELPATH << "'" << endl;
        }
        else
        {
                cout << "loadNextLevel() parsing xml-file: " << LEVELPATH << endl;
                parseXML(xml);
        }

        if (xml)
        {
                xml->drop(); // don't forget to delete the xml reader 
        }
}

---