diff --git a/jet.cpp b/jet.cpp
index 168c1a6..e54278f 100755
--- a/jet.cpp
+++ b/jet.cpp
@@ -138,9 +138,9 @@ namespace battleship{
 
     void Jet::pitch(float angle) {
         Quaternion rotQuat = Quaternion(-angle / 180 * PI, leftVec);
-        dirVec = rotQuat*dirVec, upVec = rotQuat*upVec;
+        dirVec = rotQuat * dirVec, upVec = rotQuat * upVec;
         horAngle = angle;
-        float yAngle = node->getOrientation().y;
+        float yAngle = model->getOrientation().y;
 				/*
         node->setOrientation(vector3df(angle, 0, 0));
         node->setOrientation(vector3df(angle, yAngle, 0));
diff --git a/submarine.cpp b/submarine.cpp
index e3211df..b915c1f 100755
--- a/submarine.cpp
+++ b/submarine.cpp
@@ -1,5 +1,5 @@
 #include <time.h>
-#include <node.h>
+#include <model.h>
 
 #include "submarine.h"
 #include "defConfigs.h"
@@ -9,7 +9,7 @@
 using namespace vb01;
 
 namespace battleship{
-    Submarine::Submarine(Player *player, Vector3 pos, int id) : Unit(player,pos, id) {}
+    Submarine::Submarine(Player *player, Vector3 pos, int id) : Unit(player, pos, id) {}
 
     void Submarine::attack(Order order) {
         float angle = dirVec.getAngleBetween(*(order.targetPos[0]) - pos);
@@ -20,19 +20,19 @@ namespace battleship{
         if (canFire()) {
             Vector3 p = pos + leftVec * projectileData::pos[id][0][0].x + upVec * projectileData::pos[id][0][0].y - dirVec * projectileData::pos[id][0][0].z;
             addProjectile(new Torpedo(this, p, dirVec, leftVec, upVec, getId(), 0, 0));
-            lastShotTime=getTime();
+            lastShotTime = getTime();
         }
     }
     
     void Submarine::emerge() {
         submerged = false;
         pos.y += 5;
-        node->setPosition(pos);
+        model->setPosition(pos);
     }
     
     void Submarine::submerge() {
         submerged = true;
         pos.y -= 5;
-        node->setPosition(pos);
+        model->setPosition(pos);
     }
 }
diff --git a/unit.cpp b/unit.cpp
index ed900d7..7c4126c 100755
--- a/unit.cpp
+++ b/unit.cpp
@@ -1,4 +1,5 @@
 #include <model.h>
+#include <material.h>
 #include <texture.h>
 
 #include <stateManager.h>
@@ -28,24 +29,28 @@ namespace battleship{
         length = unitData::unitCornerPoints[id][3].z - unitData::unitCornerPoints[id][0].z;
 
 				GameManager *gm = GameManager::getSingleton();
-				node = new Model(basePath[id] + meshPath[id]);
-        placeUnit(pos);
-				/*
-        node->setMaterialFlag(EMF_LIGHTING, false);
-        ITriangleSelector *tr = smgr->createTriangleSelector((IAnimatedMeshSceneNode*)node);
-        node->setTriangleSelector(tr);
-        tr->drop();
-				*/
-				string f[]{basePath[id] + "diffuseMap.png"};
+				model = new Model(basePath[id] + meshPath[id]);
+				Root *root = Root::getSingleton();
+
+				Material *mat = new Material(root->getLibPath() + "texture");
+				string f[]{DEFAULT_TEXTURE};
         Texture *diffuseTexture = new Texture(f, 1, false);
+				mat->addBoolUniform("texturingEnabled", true);
+				mat->addBoolUniform("lightingEnabled", false);
+				mat->addTexUniform("textures[0]", diffuseTexture, true);
+
+				model->setMaterial(mat);
+				root->getRootNode()->attachChild(model);
+        placeUnit(pos);
 
 				/*
         light = smgr->addLightSceneNode(node, vector3df(0, 2, 0), SColor(255, 255, 255, 255), lineOfSight);
         light->setVisible(false);
-        node->setVisible(false);
+        model->setVisible(false);
 				*/
+
         selectionSfxBuffer = new sf::SoundBuffer();
-        string p = PATH+"Sounds/"+unitData::name[id]+"s/selection.ogg";
+        string p = PATH + "Sounds/" + unitData::name[id] + "s/selection.ogg";
 
         if(selectionSfxBuffer->loadFromFile(p.c_str()))
             selectionSfx = new sf::Sound(*selectionSfxBuffer);
@@ -62,20 +67,20 @@ namespace battleship{
 
     void Unit::update() {
         if (orders.size() > 0){
-            if(selected&&canDisplayOrderLine()){
-                int r=0,g=0,b=0;
+            if(selected && canDisplayOrderLine()){
+                int r = 0, g = 0, b = 0;
 
                 switch(orders[0].type){
                     case Order::TYPE::MOVE:
-                        g=255;
+                        g = 255;
                         break;
                     case Order::TYPE::ATTACK:
-                        r=255;
+                        r = 255;
                         break;
                     case Order::TYPE::PATROL:
-                        b=255;
+                        b = 255;
                     case Order::TYPE::LAUNCH:
-                        r=255,g=255;
+                        r = 255, g = 255;
                         break;
                 }
 
@@ -283,7 +288,7 @@ namespace battleship{
 
     void Unit::advance(float speed) {
         pos = pos + dirVec * speed;
-        node->setPosition(pos);
+        model->setPosition(pos);
     }
 
     void Unit::turn(float angle) {// rad
@@ -301,13 +306,15 @@ namespace battleship{
 
     float Unit::getCircleRadius() {
         float radius = 0.;
+
         for (int i = 0; i <= 90 / maxTurnAngle; i++)
             radius += cos(i * (maxTurnAngle / 180 * PI)) * speed;
+
         return radius;
     }
 
     void Unit::placeUnit(Vector3 p) {
-        node->setPosition(p);
+        model->setPosition(p);
         pos = p;
     }
 
@@ -334,10 +341,10 @@ namespace battleship{
 
     std::vector<Projectile*> Unit::getProjectiles(){
         std::vector<Projectile*> projectiles;
-        InGameAppState *inGameState=((InGameAppState*)GameManager::getSingleton()->getStateManager()->getAppStateByType((int)AppStateType::IN_GAME_STATE));
+        InGameAppState *inGameState = ((InGameAppState*)GameManager::getSingleton()->getStateManager()->getAppStateByType((int)AppStateType::IN_GAME_STATE));
 
         for(Projectile *p: inGameState->getProjectiles())
-            if(p->getUnit()==this)
+            if(p->getUnit() == this)
                 projectiles.push_back(p);
 
         return projectiles;
@@ -366,7 +373,7 @@ namespace battleship{
         if(selection && selectionSfx)
             selectionSfx->play();
 
-        orderLineDispTime=getTime();
+        orderLineDispTime = getTime();
     }
 
 		/*
diff --git a/unit.h b/unit.h
index c690199..494b26e 100755
--- a/unit.h
+++ b/unit.h
@@ -59,7 +59,7 @@ namespace battleship{
         inline float getWidth() {return width;}
         inline float getHeight() {return height;}
         inline float getLength() {return length;}
-        inline vb01::Node* getNode() {return node;}
+        inline vb01::Model* getNode() {return model;}
         inline Player* getPlayer(){return player;}
         inline unitData::UNIT_TYPE getType() {return type;}
         inline void toggleDebugging(bool d){this->debugging=d;}
@@ -75,9 +75,9 @@ namespace battleship{
         inline int getNextPatrolPointId() {return patrolPointId == patrolPoints.size() - 1 ? 0 : patrolPointId + 1;}
         inline bool canDisplayOrderLine(){return vb01::getTime() - orderLineDispTime < orderVecDispLength;}
         //ILightSceneNode *light;
-        const int orderVecDispLength=2000;
+        const int orderVecDispLength = 2000;
         sf::SoundBuffer *selectionSfxBuffer;
-        sf::Sound *selectionSfx=nullptr;
+        sf::Sound *selectionSfx = nullptr;
     protected:
         Player *player;
         MoveDir moveDir = MoveDir::FORWARD;
@@ -89,11 +89,11 @@ namespace battleship{
         std::vector<vb01::Vector3> patrolPoints;
 				vb01::Vector3 pos = vb01::Vector3(0, 0, 0), upVec = vb01::Vector3(0, 1, 0), dirVec = vb01::Vector3(0, 0, -1), leftVec = vb01::Vector3(1, 0, 0);
         int health, cost, id, patrolPointId = 0, playerId;
-        s64 orderLineDispTime=0;
-				vb01::Mesh *mesh;
-				vb01::Node *node;
-        bool selected = false, selectable, debugging = false, working=true;
+        s64 orderLineDispTime = 0;
+				vb01::Model *model;
+        bool selected = false, selectable, debugging = false, working = true;
         float lineOfSight, speed, maxTurnAngle, range, width, height, length;
+
         void removeOrder(int);
         virtual void executeOrders();
         virtual void attack(Order);
diff --git a/unitData.h b/unitData.h
index 12d4a4e..e901bea 100755
--- a/unitData.h
+++ b/unitData.h
@@ -272,11 +272,11 @@ namespace battleship {
             "Jet", "Jet"
         };
         const std::string meshPath[numberOfUnits]{
-            "hull00.x", "hull01.x",
-            "hull00.x", "hull01.x", 
-            "hull00.x", "hull01.x", 
-            "hull00.x", "hull01.x",
-            "hull.x",
+            "battleship00.vb", "battleship01.vb",
+            "destroyer00.vb", "destroyer01.vb", 
+            "cruiser00.vb", "cruiser01.vb", 
+            "aircraftCarrier00.vb", "aircraftCarrier01.vb",
+            "submarine.vb",
             "jet00.x", "jet01.x"
         };
         const std::string basePath[numberOfUnits]{
diff --git a/vessel.cpp b/vessel.cpp
index 9bbc6db..fcd880f 100755
--- a/vessel.cpp
+++ b/vessel.cpp
@@ -1,6 +1,8 @@
 #include <algorithm>
 #include <quaternion.h>
 #include <model.h>
+#include <mesh.h>
+#include <material.h>
 #include <texture.h>
 
 #include "vessel.h"
@@ -18,48 +20,32 @@ namespace battleship{
 
     Vessel::Turret::Turret(Unit *vessel, int unitId, int turretId) {
         this->vessel = vessel;
-        //hullNode = vessel->getNode();
+        hull = vessel->getNode()->getChild(0);
         this->unitId = unitId;
         this->turretId = turretId;
 
+				string fr[]{DEFAULT_TEXTURE};
+        Texture *turretDiffTex = new Texture(fr, 1, false);
+
         GameManager *gm = GameManager::getSingleton();
-				/*
-        turretMesh = smgr->getMesh(basePath[unitId] + turretNames[unitId][turretId] + ".x");
-        turretNode = smgr->addAnimatedMeshSceneNode(turretMesh);
-        turretNode->setMaterialFlag(EMF_LIGHTING, false);
-				*/
-				string fr[]{basePath[unitId] + turretNames[unitId][turretId] + "DiffuseMap.png"};
-        Texture *turretDiffuseTexture = new Texture(fr, 1, false);
+				Root *root = Root::getSingleton();
+				string libPath = root->getLibPath();
+				Material *turretMat = new Material(libPath + "texture");
+				turretMat->addBoolUniform("texturingEnabled", true);
+				turretMat->addBoolUniform("lightingEnabled", false);
+				turretMat->addTexUniform("textures[0]", turretDiffTex, true);
 
+				turret = hull->getChild(turretId);
+				turret->getMesh(0)->setMaterial(turretMat);
 
-				/*
-        turretNode->setParent(vessel->getNode());
-        turretNode->setPosition(turretPos[unitId][turretId]);
-        quaternion rotQuat = rotQuat.fromAngleAxis(PI / 180 * turretAngleOffset[unitId][turretId], vector3df(0, 1, 0));
-        turretNode->setRotation(vector3df(0, turretAngleOffset[unitId][turretId], 0));
-        dirVec = rotQuat*dirVec, leftVec = rotQuat*leftVec;
-        rotationSpeed = unitData::turretRotationSpeed[unitId][turretId];
-        maxAngle = unitData::turretMaxAngle[unitId][turretId];
-        this->rateOfFire = unitData::turretRateOfFire[unitId][turretId];
-				*/
-        
-				/*
-        for (int i = 0; i < numberOfMantlets[unitId][turretId]; i++) {
-            IAnimatedMesh *mantletMesh = smgr->getMesh(basePath[unitId] + mantletNames[unitId][turretId] + ".x");
-            IAnimatedMesh *barrelMesh = smgr->getMesh(basePath[unitId] + barrelNames[unitId][turretId] + ".x");
-            ISceneNode *mantletNode = initMantletNode(driver, smgr, mantletMesh, unitId, turretId);
-            ISceneNode *barrelNode = initBarrelNode(driver, smgr, barrelMesh, mantletNode, unitId, turretId);
-            turretMantletMeshes.push_back(mantletMesh);
-            turretMantletNodes.push_back(mantletNode);
-            turretBarrelMeshes.push_back(barrelMesh);
-            turretBarrelNodes.push_back(barrelNode);
-        }
-
-        if (turretMantletNodes.size() > 1) {
-            turretMantletNodes[0]->setPosition(turretMantletNodes[0]->getPosition() + vector3df(mantletPosSideOffset[unitId][turretId], 0, 0));
-            turretMantletNodes[1]->setPosition(turretMantletNodes[1]->getPosition() - vector3df(mantletPosSideOffset[unitId][turretId], 0, 0));
-        }
-				*/
+				for(int i = 0; i < numberOfMantlets[unitId][turretId]; i++){
+						Mantlet mantlet;
+						mantlet.mantletNode = turret->getChild(i);
+						mantlet.mantletNode->getMesh(0)->setMaterial(turretMat);
+						mantlet.barrelNode = mantlet.mantletNode->getChild(0);
+						mantlet.barrelNode->getMesh(0)->setMaterial(turretMat);
+						mantlets.push_back(mantlet);
+				}
 
 				/*
         fxNode=smgr->addParticleSystemSceneNode(false);
@@ -89,44 +75,16 @@ namespace battleship{
             sfx = new sf::Sound(*sfxBuffer);
     }
 
-		/*
-    ISceneNode* Vessel::Turret::initMantletNode(IVideoDriver *driver, ISceneManager *smgr, IAnimatedMesh *mantletMesh, int unitId, int turretId) {
-        ISceneNode *mantletNode = smgr->addAnimatedMeshSceneNode(mantletMesh);
-        mantletNode->setMaterialFlag(EMF_LIGHTING, false);
-        ITexture *mantletDiffuseTexture = driver->getTexture(basePath[unitId] + mantletNames[unitId][turretId] + "DiffuseMap.png");
-        if (mantletDiffuseTexture)
-            mantletNode->setMaterialTexture(0, mantletDiffuseTexture);
-        else
-            mantletNode->setMaterialTexture(0, driver->getTexture(DEFAULT_TEXTURE));
-        mantletNode->setParent(turretNode);
-        mantletNode->setPosition(mantletPos[unitId][turretId]);
-        return mantletNode;
-    }
-
-    ISceneNode* Vessel::Turret::initBarrelNode(IVideoDriver *driver, ISceneManager *smgr, IAnimatedMesh *barrelMesh, ISceneNode *mantletNode, int unitId, int turretId) {
-        ISceneNode *barrelNode = smgr->addAnimatedMeshSceneNode(barrelMesh);
-        barrelNode->setMaterialFlag(EMF_LIGHTING, false);
-        ITexture *barrelDiffuseTexture = driver->getTexture(basePath[unitId] + barrelNames[unitId][turretId] + "DiffuseMap.png");
-        if (barrelDiffuseTexture)
-            barrelNode->setMaterialTexture(0, barrelDiffuseTexture);
-        else
-            barrelNode->setMaterialTexture(0, driver->getTexture(DEFAULT_TEXTURE));
-        barrelNode->setParent(mantletNode);
-        barrelNode->setPosition(barrelPos[unitId][turretId]);
-        return barrelNode;
-    }
-		*/
-
     void Vessel::Turret::rotate(double angle) {
         Quaternion rotQuat = Quaternion(PI / 180 * angle, Vector3(0, 1, 0));
         //turret->setOrientation(vector3df(0, turret->getRotation().Y + angle, 0));
-        dirVec = rotQuat*dirVec, leftVec = rotQuat*leftVec;
+        dirVec = rotQuat * dirVec, leftVec = rotQuat * leftVec;
         this->angle += angle;
     }
 
     void Vessel::Turret::update() {
 				Node *rootNode = Root::getSingleton()->getRootNode();
-        turretPosition = rootNode->localToGlobalPosition(turret->getPosition());
+        Vector3 turretPosition = turret->localToGlobalPosition(Vector3::VEC_ZERO);
         float hullAngle = PI / 180 /* hullNode->getRotation().Y*/;
         float turretAngle = PI / 180 * angle;
 				/*
@@ -139,7 +97,7 @@ namespace battleship{
                */
     }
 
-    void Vessel::Turret::debug(const Material &mat) {
+    void Vessel::Turret::debug() {
 				/*
         float length = turretAxisLength[unitId][turretId]*0 + 1;
         IVideoDriver *driver = GameManager::getSingleton()->getDevice()->getVideoDriver();
@@ -153,22 +111,23 @@ namespace battleship{
 
     Vector3* Vessel::Turret::getInitDirs(){
         Vector3 *initDirs = new Vector3[2];
+
         switch(unitData::initDirs[unitId][turretId]){
             case unitData::FORWARD:
-                initDirs[0]=vessel->getDirVec();
-                initDirs[1]=vessel->getLeftVec();
+                initDirs[0] = vessel->getDirVec();
+                initDirs[1] = vessel->getLeftVec();
                 break;
             case unitData::BACKWARD:
-                initDirs[0]=-vessel->getDirVec();
-                initDirs[1]=-vessel->getLeftVec();
+                initDirs[0] = -vessel->getDirVec();
+                initDirs[1] = -vessel->getLeftVec();
                 break;
             case unitData::LEFT:
-                initDirs[0]=vessel->getLeftVec();
-                initDirs[1]=-vessel->getDirVec();
+                initDirs[0] = vessel->getLeftVec();
+                initDirs[1] = -vessel->getDirVec();
                 break;
             case unitData::RIGHT:
-                initDirs[0]=-vessel->getLeftVec();
-                initDirs[1]=vessel->getDirVec();
+                initDirs[0] = -vessel->getLeftVec();
+                initDirs[1] = vessel->getDirVec();
                 break;
         }
         return initDirs;
@@ -189,7 +148,7 @@ namespace battleship{
 				*/
     }
 
-    Vessel::Vessel(Player *player, Vector3 pos, int id) : Unit(player,pos, id) {
+    Vessel::Vessel(Player *player, Vector3 pos, int id) : Unit(player, pos, id) {
         if (numberOfTurrets[id] > 0)
             for (int i = 0; i < numberOfTurrets[id]; i++)
                 turrets.push_back(new Turret(this, id, i));
@@ -197,8 +156,10 @@ namespace battleship{
 
     void Vessel::update() {
         Unit::update();
+
         for (Turret *t : turrets) {
             t->update();
+
             if ((orders.size() > 0 && orders[0].type != Order::TYPE::ATTACK) || orders.size() == 0) {
                 float rotAngle = abs(t->getAngle()) < t->getRotationSpeed() ? abs(t->getAngle()) : t->getRotationSpeed();
                 t->rotate(t->getAngle() > 0 ? -rotAngle : rotAngle);
@@ -212,8 +173,11 @@ namespace battleship{
 
         for (Turret *t : turrets) {
 						Vector3 *initDirs = t->getInitDirs();
-            bool right = t->getLeftVec().getAngleBetween(target - t->getPos()) > PI / 2;
-            float angle = initDirs[0].getAngleBetween(target - t->getPos()) / PI * 180;
+						Node *rootNode = Root::getSingleton()->getRootNode();
+      			Vector3 turrPos = t->getNode()->localToGlobalPosition(Vector3::VEC_ZERO);
+
+            bool right = t->getLeftVec().getAngleBetween(target - turrPos) > PI / 2;
+            float angle = initDirs[0].getAngleBetween(target - turrPos) / PI * 180;
             float rotAngle = t->getRotationSpeed() > angle ? angle : t->getRotationSpeed()*(right?1:-1);
 
             if (-t->getMaxAngle() <= t->getAngle() + rotAngle 
@@ -228,9 +192,7 @@ namespace battleship{
     }
 
     void Vessel::debug() {
-        /*
         for (Turret *t : turrets)
-            t->debug(createLineMaterial());
-				*/
+            t->debug();
     }
 }
diff --git a/vessel.h b/vessel.h
index 5b12c45..547ccfd 100755
--- a/vessel.h
+++ b/vessel.h
@@ -19,42 +19,41 @@ namespace battleship {
         Vessel(Player*, vb01::Vector3, int);
         void update();
     protected:
-    void attack(Order);
+    	void attack(Order);
     private:
         void debug();
 
         class Turret {
         public:
+						struct Mantlet{
+								vb01::Node *mantletNode = nullptr, *barrelNode = nullptr;
+						};
+
             Turret(Unit*, int, int);
             void update();
             void fire();
             void rotate(double);
-            void debug(const vb01::Material&);
+            void debug();
 						vb01::Vector3* getInitDirs();
             inline vb01::Vector3 getDirVec(){return dirVec;}
             inline vb01::Vector3 getLeftVec(){return leftVec;}
             inline vb01::Vector3 getUpVec(){return upVec;}
-            inline vb01::Vector3 getPos(){return turretPosition;}
+						inline vb01::Node* getNode(){return turret;}
             inline float getMaxAngle(){return maxAngle;}
             inline float getRotationSpeed(){return rotationSpeed;}
             inline float getAngle(){return angle;}
             inline bool canFire(){return vb01::getTime() - lastShotTime > rateOfFire;}
         private:
             inline std::string getExplosionSfxPath(){return configData::PATH + "Sounds/Explosions/explosion0" + std::to_string(rand() % 4) + ".ogg";}
+
             vb01::Node *fxNode;
             vb01::ParticleEmitter *emitter;
             Unit *vessel;
-            vb01::Model *turret, *hull;
-            std::vector<vb01::Model*> turretMantlets, turretBarrels;
-            std::vector<vb01::Vector3> turretMantletPos;
-            vb01::Vector3 turretBarrelPos, turretPosition;
+            vb01::Node *turret = nullptr, *hull = nullptr;
+            std::vector<Mantlet> mantlets;
             vb01::Vector3 upVec = vb01::Vector3(0, 1, 0), dirVec = vb01::Vector3(0, 0, -1), initDir, leftVec = vb01::Vector3(1, 0, 0);
             float angle = 0., barrelAngle = 0., maxAngle, rotationSpeed,maxBarrelAngle;
             int rateOfFire, damage, unitId, turretId;
-						/*
-						vb01::Model* initMantletNode(irr::scene::IAnimatedMesh*, int, int);
-						vb01::Model* initBarrelNode(irr::scene::IAnimatedMesh*, irr::scene::ISceneNode*, int, int);
-						*/
             s64 lastShotTime;
             sf::SoundBuffer *sfxBuffer;
             sf::Sound *sfx = nullptr;