#include "BasicBlocks.h"
#include <Model3D.h>
#include <Globals.h>
#include <GraphicsApi.h>
#include <Bild.h>
#include <Model3DList.h>
#include "Globals.h"


BasicBlock::BasicBlock( const BlockType* zType, ItemType* zTool, Framework::Vec3<int> pos, Framework::Textur* t )
    : Block( zType, zTool, pos, false )
{
    Model3DData* data = 0;
    if( Framework::zM3DRegister()->hatModel( "cube" ) )
        data = Framework::zM3DRegister()->getModel( "cube" );
    else
    {
        data = new Model3DData();
        data->setAmbientFactor( 0.2f );
        data->setDiffusFactor( 0.4f );
        data->setSpecularFactor( 0.4f );
        Framework::zM3DRegister()->addModel( dynamic_cast<Model3DData*>(data->getThis()), "cube" );
        float size = 1;
        float left, right, top, bottom;
        // Calculate the screen coordinates of the left side of the bitmap.
        left = (float)((size / 2.0) * -1);
        // Calculate the screen coordinates of the right side of the bitmap.
        right = left + (float)size;
        // Calculate the screen coordinates of the top of the bitmap.
        top = (float)(size / 2.0);
        // Calculate the screen coordinates of the bottom of the bitmap.
        bottom = top - (float)size;
        float front = -size / 2;
        float back = front + size;

        Vertex3D* vertecies = new Vertex3D[ 24 ];
        for( int i = 0; i < 24; i++ )
            vertecies[ i ].knochenId = 0;
        vertecies[ 0 ].pos = Vec3<float >( left, top, front );
        vertecies[ 0 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 1 ].pos = Vec3<float >( right, top, front );
        vertecies[ 1 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 2 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 2 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 3 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 3 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 4 ].pos = Vec3<float >( left, top, back );
        vertecies[ 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 5 ].pos = Vec3<float >( right, top, back );
        vertecies[ 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 6 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 7 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 7 ].tPos = Vec2< float >( 1.0f, 1.0f );

        vertecies[ 8 ].pos = Vec3<float >( left, top, front );
        vertecies[ 8 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 9 ].pos = Vec3<float >( right, top, front );
        vertecies[ 9 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 10 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 10 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 11 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 11 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 12 ].pos = Vec3<float >( left, top, back );
        vertecies[ 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 13 ].pos = Vec3<float >( right, top, back );
        vertecies[ 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 14 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 15 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 15 ].tPos = Vec2< float >( 1.0f, 1.0f );

        vertecies[ 16 ].pos = Vec3<float >( left, top, front );
        vertecies[ 16 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 17 ].pos = Vec3<float >( right, top, front );
        vertecies[ 17 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 18 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 18 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 19 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 19 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 20 ].pos = Vec3<float >( left, top, back );
        vertecies[ 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 21 ].pos = Vec3<float >( right, top, back );
        vertecies[ 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 22 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 23 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 23 ].tPos = Vec2< float >( 1.0f, 1.0f );

        data->setVertecies( vertecies, 24 );

        // front side
        Polygon3D* p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 0;
        p->indexList[ 1 ] = 3;
        p->indexList[ 2 ] = 2;
        p->indexList[ 3 ] = 0;
        p->indexList[ 4 ] = 1;
        p->indexList[ 5 ] = 3;
        data->addPolygon( p );
        // back side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 4;
        p->indexList[ 1 ] = 6;
        p->indexList[ 2 ] = 7;
        p->indexList[ 3 ] = 4;
        p->indexList[ 4 ] = 7;
        p->indexList[ 5 ] = 5;
        data->addPolygon( p );
        // right side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 1 + 8;
        p->indexList[ 1 ] = 7 + 8;
        p->indexList[ 2 ] = 3 + 8;
        p->indexList[ 3 ] = 1 + 8;
        p->indexList[ 4 ] = 5 + 8;
        p->indexList[ 5 ] = 7 + 8;
        data->addPolygon( p );
        // left side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 0 + 8;
        p->indexList[ 1 ] = 2 + 8;
        p->indexList[ 2 ] = 6 + 8;
        p->indexList[ 3 ] = 0 + 8;
        p->indexList[ 4 ] = 6 + 8;
        p->indexList[ 5 ] = 4 + 8;
        data->addPolygon( p );
        // top side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 4 + 16;
        p->indexList[ 1 ] = 1 + 16;
        p->indexList[ 2 ] = 0 + 16;
        p->indexList[ 3 ] = 4 + 16;
        p->indexList[ 4 ] = 5 + 16;
        p->indexList[ 5 ] = 1 + 16;
        data->addPolygon( p );
        // down side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 6 + 16;
        p->indexList[ 1 ] = 2 + 16;
        p->indexList[ 2 ] = 3 + 16;
        p->indexList[ 3 ] = 6 + 16;
        p->indexList[ 4 ] = 3 + 16;
        p->indexList[ 5 ] = 7 + 16;
        data->addPolygon( p );
        data->calculateNormals();
    }
    setModelDaten( data );
    Bild* b = new Bild();
    b->neuBild( 10, 10, 0xFFFFFFFF );
    Textur* tex = currentGame->zScreen()->zGraphicsApi()->createOrGetTextur( "dirt", b );
    Model3DTextur* textur = new Model3DTextur();
    textur->setPolygonTextur( 0, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 1, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 2, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 3, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 4, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 5, tex );
    setModelTextur( textur );
}


DirtBlockType::DirtBlockType()
    : BlockType( ID )
{}

void DirtBlockType::loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader )
{
    BlockType::loadSuperBlock( zBlock, zReader );
}

Block* DirtBlockType::createBlock( Framework::Vec3<int> position )
{
    // TODO: load texture
    Block* b = new BasicBlock( DirtBlockType::INSTANCE, 0, position, 0 ); // TODO: add efective tool
    initializeSuperBlock( b );
    return b;
}

void DirtBlockType::initializeSuperBlock( Block* zBlock )
{
    BasicBlock* block = dynamic_cast<BasicBlock*>(zBlock);
    if( !block )
        throw "DirtBlockType::createSuperBlock was called with a block witch is not an instance of BasicBlock";
    block->transparent = 0;
    block->passable = 0;
    block->hp = 100;
    block->maxHP = 100;
    block->hardness = 1;
    block->zTool = 0;
    block->speedModifier = 1;
}

bool DirtBlockType::needsInstance() const
{
    return 1;
}


DirtBlockItemType::DirtBlockItemType()
    : BasicBlockItemType( ID )
{}

Item* DirtBlockItemType::createItem() const
{
    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, "Dirt" );
    return item;
}