[Irrlicht] Mesh - operacje na wierzchołkach

#include <irrlicht.h>
#include "driverChoice.h"

using namespace irr;

#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif

class CSampleSceneNode
    : public scene::ISceneNode
{
   
    core::aabbox3d < f32 > Box;
    video::S3DVertex Vertices[ 3 ];
    video::SMaterial Material;
   
public:
   
    CSampleSceneNode( scene::ISceneNode * parent, scene::ISceneManager * mgr, s32 id )
        : scene::ISceneNode( parent, mgr, id )
    {
        Material.Wireframe = false;
        Material.Lighting = false;
       
        // verticves of triangle
        Vertices[ 0 ] = video::S3DVertex( 0, 5, 0, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 1 ] = video::S3DVertex( 5, 0, 0, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 2 ] = video::S3DVertex( - 5, 0, 0, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
       
        Box.reset( Vertices[ 0 ].Pos );
        for( s32 i = 1; i < 3; ++i )
             Box.addInternalPoint( Vertices[ i ].Pos );
       
    }
   
    virtual void OnRegisterSceneNode()
    {
        if( IsVisible )
             SceneManager->registerNodeForRendering( this );
       
        ISceneNode::OnRegisterSceneNode();
    }
   
    virtual void render()
    {
        u16 indices[ ] = { 0, 1, 2 };
        video::IVideoDriver * driver = SceneManager->getVideoDriver();
       
        driver->setMaterial( Material );
        driver->setTransform( video::ETS_WORLD, AbsoluteTransformation );
        driver->drawVertexPrimitiveList( & Vertices[ 0 ], 3, & indices[ 0 ], 1, video::EVT_STANDARD, scene::EPT_TRIANGLES, video::EIT_16BIT );
    }
   
    virtual const core::aabbox3d < f32 > & getBoundingBox() const
    {
        return Box;
    }
   
    virtual u32 getMaterialCount() const
    {
        return 1;
    }
   
    virtual video::SMaterial & getMaterial( u32 i )
    {
        return Material;
    }
};

int main()
{
    // ask user for driver
    video::E_DRIVER_TYPE driverType = driverChoiceConsole();
    if( driverType == video::EDT_COUNT )
         return 1;
   
    // create device
    IrrlichtDevice * device = createDevice( driverType,
    core::dimension2d < u32 >( 640, 480 ), 16, false );
   
    if( device == 0 )
         return 1; // could not create selected driver.
   
    device->setWindowCaption( L"Rotating Triangle Renderer" );
   
    video::IVideoDriver * driver = device->getVideoDriver();
    scene::ISceneManager * smgr = device->getSceneManager();
   
    smgr->addCameraSceneNode( 0, core::vector3df( 0, 10, 0 ), core::vector3df( 0, 0, 0 ) );
   
    CSampleSceneNode * myNode =
    new CSampleSceneNode( smgr->getRootSceneNode(), smgr, 666 );
   
   
    scene::ISceneNodeAnimator * anim =
    smgr->createRotationAnimator( core::vector3df( 0.8f, 0, 0.8f ) );
   
    if( anim )
    {
        myNode->addAnimator( anim );
       
        anim->drop();
        anim = 0;
    }
   
    myNode->drop();
    myNode = 0; // As I shouldn't refer to it again, ensure that I can't
   
    while( device->run() )
    {
        driver->beginScene( true, true, video::SColor( 0, 100, 100, 100 ) );
        smgr->drawAll();
        driver->endScene();
    }
   
    device->drop();
   
    return 0;
}

#include <irrlicht.h>

using namespace irr; // I don't want to use it irr::

using namespace core; // also ( irr::core:: )
using namespace scene; // also ( irr::scene::)
using namespace video; // also ...
using namespace io; // ...
using namespace gui; // ...

#include<iostream>
#include<set>

// device
int screenWidth = 1080;
int screenHeight = 720;
int bitsPerPixel = 32;
bool fullscreen = false;
bool stencilbuffer = false; // Specifies if we want to use the stencil buffer (for drawing shadows)
bool vsync = false; // Specifies if we want to have vsync enabled, this is only useful in fullscreen mode.
int eventReceiver = 0; // An object to receive events.We do not want to use this parameter here, and set it to 0.

// clearing screen colors
int clear_r = 48; int clear_g = 48; int clear_b = 48; int clear_a = 256;

// Basic things
IrrlichtDevice * device;
IVideoDriver * driver;
ISceneManager * sceneManager;
IGUIEnvironment * GUI;

// Fonts
IGUIFont * basicFont;
IGUIFont * boldFont;

// Textures
ITexture * TWTexture;



// Buttons ID's
enum
{
    // World
    GUI_ID_CREATEWORLD, GUI_ID_LOADWORLD, GUI_ID_SAVEWORLD, GUI_ID_GENERATEWORLD,
    // Help
    GUI_ID_TUTORIAL, GUI_ID_INFO
};

float outerRadius = 10.0f;
float innerRadius = outerRadius * 0.866025404f;

class HexTile
    : public scene::ISceneNode
{
   
    core::aabbox3d < f32 > Box;
    video::S3DVertex Vertices[ 8 ];
    video::SMaterial Material;
   
public:
   
    HexTile( scene::ISceneNode * parent, scene::ISceneManager * mgr, s32 id )
        : scene::ISceneNode( parent, mgr, id )
    {
        Material.Wireframe = false;
        Material.Lighting = false;
        //Material.setTexture(0,driver->getTexture("Media/grass.png"));
       
        // verticves of hexagons
        Vertices[ 0 ] = video::S3DVertex( 0, 0, 0, 0, 0, 0, video::SColor( 255, 48, 48, 48 ), 0, 0 ); // CENTER OF HEXTILE
        Vertices[ 1 ] = video::S3DVertex( 0.0f, 0, outerRadius, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 2 ] = video::S3DVertex( innerRadius, 0, outerRadius * 0.5f, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 3 ] = video::S3DVertex( innerRadius, 0, - outerRadius * 0.5f, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 4 ] = video::S3DVertex( 0.0f, 0, - outerRadius, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 5 ] = video::S3DVertex( - innerRadius, 0, - outerRadius * 0.5f, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 6 ] = video::S3DVertex( - innerRadius, 0, outerRadius * 0.5f, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
        Vertices[ 7 ] = video::S3DVertex( 0.0f, 0, outerRadius, 0, 0, 0, video::SColor( 255, 128, 48, 48 ), 0, 0 );
       
        Box.reset( Vertices[ 0 ].Pos );
        for( s32 i = 1; i < 7; ++i )
             Box.addInternalPoint( Vertices[ i ].Pos );
       
    }
   
    virtual void OnRegisterSceneNode()
    {
        if( IsVisible )
             SceneManager->registerNodeForRendering( this );
       
        ISceneNode::OnRegisterSceneNode();
    }
   
    virtual void render()
    {
        u16 indices[ ] = { 0, 1, 2, /**/ 0, 2, 3, /**/ 0, 3, 4, /**/ 0, 4, 5, /**/ 0, 5, 6, /**/ 0, 6, 7 };
        IVideoDriver * driver = SceneManager->getVideoDriver();
        driver->setMaterial( Material );
        driver->setTransform( video::ETS_WORLD, AbsoluteTransformation );
        driver->drawVertexPrimitiveList( & Vertices[ 0 ], 3, & indices[ 0 ], 6, video::EVT_STANDARD, scene::EPT_TRIANGLES, video::EIT_16BIT );
       
    }
   
    virtual const core::aabbox3d < f32 > & getBoundingBox() const
    {
        return Box;
    }
   
    virtual u32 getMaterialCount() const
    {
        return 1;
    }
   
    virtual video::SMaterial & getMaterial( u32 i )
    {
        return Material;
    }
};

class HexMap
{
public:
    std::set < HexTile * > tiles;
   
    HexMap();
    ~HexMap();
    void addTile( HexTile * );
};

HexMap::HexMap()
{
    tiles.clear();
}

HexMap::~HexMap()
{
   
}

void HexMap::addTile( HexTile * tile )
{
    tiles.insert( tile );
}

void thisIsNotBuildYet()
{
    int rectWidth = 300;
    int rectHeight = 300;
    int x1 =( screenWidth - rectWidth ) / 2;
    int x2 =( screenWidth + rectWidth ) / 2;
    int y1 =( screenHeight - rectHeight ) / 2;
    int y2 =( screenHeight + rectHeight ) / 2;
   
    rect < s32 > rectangle = rect < s32 >( x1, y1, x2, y2 );
   
    IGUIWindow * window = GUI->addWindow( rectangle );
   
    const wchar_t * t = L"This section is not build yed";
    IGUIStaticText * text = GUI->addStaticText( t, rect < s32 >( 0, 20, rectWidth, rectHeight ), true, true, window, - 1, true );
    text->setTextAlignment( EGUIA_CENTER, EGUIA_CENTER );
   
}



class MyEventReceiver
    : public IEventReceiver
{
public:
    bool KeyIsDown[ KEY_KEY_CODES_COUNT ];
   
    MyEventReceiver();
    virtual bool OnEvent( const SEvent & );
    virtual bool IsKeyDown( EKEY_CODE );
    bool OnMenuItemSelected( IGUIContextMenu * menu );
};


MyEventReceiver::MyEventReceiver()
{
    for( u32 i = 0; i < KEY_KEY_CODES_COUNT; ++i )
         KeyIsDown[ i ] = false;
   
}

bool MyEventReceiver::OnEvent( const SEvent & event )
{
    // Remember whether each key is down or up
    if( event.EventType == irr::EET_KEY_INPUT_EVENT )
    {
        KeyIsDown[ event.KeyInput.Key ] = event.KeyInput.PressedDown;
        return true;
    }
   
    if( event.EventType == EET_GUI_EVENT )
    {
        switch( event.GUIEvent.EventType )
        {
        case EGET_MENU_ITEM_SELECTED: // main menu events
            {
                IGUIContextMenu * menu =( IGUIContextMenu * ) event.GUIEvent.Caller;
                s32 id = menu->getItemCommandId( menu->getSelectedItem() );
               
            }
            break;
           
            default:
            break;
        }
    }
   
    return false;
}

bool MyEventReceiver::IsKeyDown( EKEY_CODE keyCode )
{
    return KeyIsDown[ keyCode ];
} //#include "HexTile.hpp"

int main()
{
    MyEventReceiver receiver;
    // CREATE DEVICE ( OpenGL )
    device = createDevice( EDT_SOFTWARE, dimension2d < u32 >( screenWidth, screenHeight ), bitsPerPixel, fullscreen, stencilbuffer, vsync, & receiver );
   
    if( !device ) // if no Device then error
         return 1;
   
    // GET THE BASIC THINGS
    driver = device->getVideoDriver(); // get the Video Driver
    sceneManager = device->getSceneManager(); // get the Scene
    GUI = device->getGUIEnvironment(); // get the GUI Manager
   
    // ADD CAMERA
    ICameraSceneNode * cam = sceneManager->addCameraSceneNode( 0, vector3df( 0, 30, - 40 ), vector3df( 0, 5, 0 ) );
    cam->setFOV( 1 );
   
    // CURSOR IS HIDDEN
    device->getCursorControl()->setVisible( true );
   
    // Create HexMap
    HexMap * hexMap = new HexMap();
    float xpos, zpos;
    for( int z = 0; z < 10; z++ )
    for( int x = 0; x < 10; x++ )
    {
        HexTile * tile = new HexTile( sceneManager->getRootSceneNode(), sceneManager, 666 );
       
        xpos = float( x ) * 2.0f * innerRadius +( z % 2 ) * innerRadius;
        zpos = float( z ) * 1.5f * outerRadius;
       
        tile->setPosition( vector3df( xpos, 0, zpos ) );
        hexMap->addTile( tile );
    }
   
   
    // MAIN "TW Editor" LOOP
    while( device->run() )
    {
        if( device->isWindowActive() )
        {
           
            // UPDATE
            if( receiver.IsKeyDown( irr::KEY_ESCAPE ) ) // if press ESCAPE then exit
            {
                device->drop();
                return 0;
            }
           
            // RENDER
            driver->beginScene( true, true, SColor( clear_a, clear_r, clear_g, clear_b ) ); // clear screen
            sceneManager->drawAll(); // render scene
            GUI->drawAll(); // render GUI
            position2d < s32 > m = device->getCursorControl()->getPosition(); // render cursor
            driver->endScene(); // render submit
           
            // FPS
            int currentFPS = driver->getFPS();
            core::stringw str = L"FPS: ";
            str += currentFPS;
            device->setWindowCaption( str.c_str() );
        }
        else
             device->yield(); // if window is inactive not use CPU
       
    }
   
    // In the end, delete the Irrlicht device.
    device->drop();
    return 0;
}

class HexTile
    : public scene::ISceneNode
{
    SMesh * mesh;
    SMeshBuffer * meshBuffer;
   
public:
    terrainType ttype;
   
    HexTile( ISceneNode * parent, ISceneManager * smgr, s32 id );
    virtual void OnRegisterSceneNode();
    virtual void render();
    virtual const aabbox3d < f32 > & getBoundingBox() const;
    virtual u32 getMaterialCount() const;
    virtual SMaterial & getMaterial( u32 i );
    void setTexture( ITexture * );
    void setTerrainType( terrainType );
    SMesh * getMesh();
};

HexTile::HexTile( ISceneNode * parent, ISceneManager * smgr, s32 id )
    : ISceneNode( parent, smgr, id )
{
    ttype = terrainType::grass;
   
    meshBuffer = new SMeshBuffer();
   
    // SET THE INDICES
   
    meshBuffer->Indices.set_used( 18 );
    for( u32 i = 0; i < 18; ++i )
         meshBuffer->Indices[ i ] = hexIndices[ i ];
   
    // SET THE VERTICES
    SColor color = SColor( 255, 255, 255, 255 );
   
    meshBuffer->Vertices.push_back( S3DVertex( 0, 0, 0, 0, 0, 0, color, 0, 0 ) );
    for( int i = 0; i < 7; i++ )
    {
        //meshBuffer->Vertices.push_back(S3DVertex(hexVertices[2 * i] * 0.9f, 0.0f, hexVertices[2 * i + 1] * 0.9f, 0, 0, 0, color, texture_uv[2 * i], texture_uv[2 * i + 1]));
        meshBuffer->Vertices.push_back( S3DVertex( hexVertices[ 2 * i ], 0.0f, hexVertices[ 2 * i + 1 ], 0, 0, 0, color, texture_uv[ 2 * i ], texture_uv[ 2 * i + 1 ] ) );
       
    }
   
    // SET THE BOUNDING BOX
    meshBuffer->BoundingBox.reset( vector3df( hexVertices[ 0 ], 0, hexVertices[ 1 ] ) );
    for( s32 i = 1; i < 7; ++i )
         meshBuffer->BoundingBox.addInternalPoint( vector3df( hexVertices[ 2 * i ], 0, hexVertices[ 2 * i + 1 ] ) );
   
   
    // SET THE MATERIAL
    meshBuffer->Material.Wireframe = false;
    meshBuffer->Material.Lighting = false;
    meshBuffer->Material.setTexture( 0, getTexture( ttype ) );
   
    mesh = new SMesh();
    mesh->addMeshBuffer( meshBuffer );
    mesh->recalculateBoundingBox();
   
}

void HexTile::OnRegisterSceneNode()
{
    if( IsVisible )
         SceneManager->registerNodeForRendering( this );
   
    ISceneNode::OnRegisterSceneNode();
}

void HexTile::render()
{
    IVideoDriver * driver = smgr->getVideoDriver();
    driver->setMaterial( meshBuffer->Material );
    driver->setTransform( video::ETS_WORLD, AbsoluteTransformation );
    driver->drawMeshBuffer( meshBuffer );
   
}

const aabbox3d < f32 > & HexTile::getBoundingBox() const
{
    return meshBuffer->BoundingBox;
}

u32 HexTile::getMaterialCount() const
{
    return 1;
}

SMaterial & HexTile::getMaterial( u32 i )
{
    return meshBuffer->Material;
}

void HexTile::setTexture( ITexture * tex )
{
    meshBuffer->Material.setTexture( 0, tex );
}

void HexTile::setTerrainType( terrainType ttype )
{
    this->ttype = ttype;
    setTexture( getTexture( ttype ) );
}

SMesh * HexTile::getMesh()
{
    return mesh;
}