]> git.lizzy.rs Git - dragonfireclient.git/blobdiff - src/content_cao.cpp
Bump protocol version
[dragonfireclient.git] / src / content_cao.cpp
index c2cce3d588ae17ba26153ec3c32d2ee2e09f009a..925855288f58ea025e6894fd51e40a56403c2d1b 100644 (file)
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -40,6 +40,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/serialize.h"
 #include "util/mathconstants.h"
 #include "map.h"
+#include "main.h" // g_settings
 #include <IMeshManipulator.h>
 #include <IAnimatedMeshSceneNode.h>
 #include <IBoneSceneNode.h>
@@ -49,9 +50,7 @@ struct ToolCapabilities;
 
 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
 
-core::map<u16, ClientActiveObject::Factory> ClientActiveObject::m_types;
-
-std::vector<core::vector2d<int> > attachment_list; // X is child ID, Y is parent ID
+std::map<u16, ClientActiveObject::Factory> ClientActiveObject::m_types;
 
 /*
        SmoothTranslator
@@ -175,6 +174,7 @@ class TestCAO : public ClientActiveObject
 
        void processMessage(const std::string &data);
 
+       bool getCollisionBox(aabb3f *toset) { return false; }
 private:
        scene::IMeshSceneNode *m_node;
        v3f m_position;
@@ -223,7 +223,7 @@ void TestCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
        // Set material
        buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
        buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
-       buf->getMaterial().setTexture(0, tsrc->getTextureRaw("rat.png"));
+       buf->getMaterial().setTexture(0, tsrc->getTexture("rat.png"));
        buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
        buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
        buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
@@ -330,6 +330,7 @@ class ItemCAO : public ClientActiveObject
        std::string infoText()
                {return m_infotext;}
 
+       bool getCollisionBox(aabb3f *toset) { return false; }
 private:
        core::aabbox3d<f32> m_selection_box;
        scene::IMeshSceneNode *m_node;
@@ -392,7 +393,7 @@ void ItemCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
        buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
        buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
        // Initialize with a generated placeholder texture
-       buf->getMaterial().setTexture(0, tsrc->getTextureRaw(""));
+       buf->getMaterial().setTexture(0, tsrc->getTexture(""));
        buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
        buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
        buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
@@ -473,7 +474,7 @@ void ItemCAO::updateTexture()
                IItemDefManager *idef = m_gamedef->idef();
                ItemStack item;
                item.deSerialize(is, idef);
-               texture = item.getDefinition(idef).inventory_texture;
+               texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_gamedef);
        }
        catch(SerializationError &e)
        {
@@ -579,13 +580,14 @@ class GenericCAO : public ClientActiveObject
        v2s16 m_tx_basepos;
        bool m_initial_tx_basepos_set;
        bool m_tx_select_horiz_by_yawpitch;
-       v2f m_frames;
-       int m_frame_speed;
-       int m_frame_blend;
-       std::map<std::string, core::vector2d<v3f> > m_bone_posrot; // stores position and rotation for each bone name
+       v2f m_animation_range;
+       int m_animation_speed;
+       int m_animation_blend;
+       std::map<std::string, core::vector2d<v3f> > m_bone_position; // stores position and rotation for each bone name
        std::string m_attachment_bone;
        v3f m_attachment_position;
        v3f m_attachment_rotation;
+       bool m_attached_to_local;
        int m_anim_frame;
        int m_anim_num_frames;
        float m_anim_framelength;
@@ -621,13 +623,14 @@ class GenericCAO : public ClientActiveObject
                m_tx_basepos(0,0),
                m_initial_tx_basepos_set(false),
                m_tx_select_horiz_by_yawpitch(false),
-               m_frames(v2f(0,0)),
-               m_frame_speed(15),
-               m_frame_blend(0),
-               // Nothing to do for m_bone_posrot
+               m_animation_range(v2f(0,0)),
+               m_animation_speed(15),
+               m_animation_blend(0),
+               m_bone_position(std::map<std::string, core::vector2d<v3f> >()),
                m_attachment_bone(""),
                m_attachment_position(v3f(0,0,0)),
                m_attachment_rotation(v3f(0,0,0)),
+               m_attached_to_local(false),
                m_anim_frame(0),
                m_anim_num_frames(1),
                m_anim_framelength(0.2),
@@ -642,26 +645,60 @@ class GenericCAO : public ClientActiveObject
                        ClientActiveObject::registerType(getType(), create);
        }
 
+       bool getCollisionBox(aabb3f *toset) {
+               if (m_prop.physical) {
+                       aabb3f retval;
+                       //update collision box
+                       toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
+                       toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
+
+                       toset->MinEdge += m_position;
+                       toset->MaxEdge += m_position;
+
+                       return true;
+               }
+
+               return false;
+       }
+
+       bool collideWithObjects() {
+               return m_prop.collideWithObjects;
+       }
+
        void initialize(const std::string &data)
        {
                infostream<<"GenericCAO: Got init data"<<std::endl;
                std::istringstream is(data, std::ios::binary);
+               int num_messages = 0;
                // version
                u8 version = readU8(is);
                // check version
-               if(version != 0){
+               if(version == 1) // In PROTOCOL_VERSION 14
+               {
+                       m_name = deSerializeString(is);
+                       m_is_player = readU8(is);
+                       m_id = readS16(is);
+                       m_position = readV3F1000(is);
+                       m_yaw = readF1000(is);
+                       m_hp = readS16(is);
+                       num_messages = readU8(is);
+               }
+               else if(version == 0) // In PROTOCOL_VERSION 13
+               {
+                       m_name = deSerializeString(is);
+                       m_is_player = readU8(is);
+                       m_position = readV3F1000(is);
+                       m_yaw = readF1000(is);
+                       m_hp = readS16(is);
+                       num_messages = readU8(is);
+               }
+               else
+               {
                        errorstream<<"GenericCAO: Unsupported init data version"
                                        <<std::endl;
                        return;
                }
-               m_name = deSerializeString(is);
-               m_is_player = readU8(is);
-               m_id = readS16(is);
-               m_position = readV3F1000(is);
-               m_yaw = readF1000(is);
-               m_hp = readS16(is);
-               
-               int num_messages = readU8(is);
+
                for(int i=0; i<num_messages; i++){
                        std::string message = deSerializeLongString(is);
                        processMessage(message);
@@ -675,11 +712,15 @@ class GenericCAO : public ClientActiveObject
                        if(player && player->isLocal()){
                                m_is_local_player = true;
                        }
+                       m_env->addPlayerName(m_name.c_str());
                }
        }
 
        ~GenericCAO()
        {
+               if(m_is_player){
+                       m_env->removePlayerName(m_name.c_str());
+               }
        }
 
        static ClientActiveObject* create(IGameDef *gamedef, ClientEnvironment *env)
@@ -706,7 +747,7 @@ class GenericCAO : public ClientActiveObject
                                return m_animated_meshnode->getAbsolutePosition();
                        if(m_spritenode)
                                return m_spritenode->getAbsolutePosition();
-                       return v3f(0,0,0); // Just in case
+                       return m_position;
                }
                return pos_translator.vect_show;
        }
@@ -742,7 +783,7 @@ class GenericCAO : public ClientActiveObject
                return m_is_local_player;
        }
 
-       void updateParent()
+       void setAttachments()
        {
                updateAttachments();
        }
@@ -750,9 +791,9 @@ class GenericCAO : public ClientActiveObject
        ClientActiveObject *getParent()
        {
                ClientActiveObject *obj = NULL;
-               for(std::vector<core::vector2d<int> >::const_iterator cii = attachment_list.begin(); cii != attachment_list.end(); cii++)
+               for(std::vector<core::vector2d<int> >::const_iterator cii = m_env->attachment_list.begin(); cii != m_env->attachment_list.end(); cii++)
                {
-                       if(cii->X == this->getId()){ // This ID is our child
+                       if(cii->X == getId()){ // This ID is our child
                                if(cii->Y > 0){ // A parent ID exists for our child
                                        if(cii->X != cii->Y){ // The parent and child ID are not the same
                                                obj = m_env->getActiveObject(cii->Y);
@@ -768,50 +809,26 @@ class GenericCAO : public ClientActiveObject
 
        void removeFromScene(bool permanent)
        {
-               // bool permanent should be true when removing the object permanently and false when it's only refreshed (and comes back in a few frames)
-
-               // If this object is being permanently removed, delete it from the attachments list
-               if(permanent)
+               if(permanent) // Should be true when removing the object permanently and false when refreshing (eg: updating visuals)
                {
-                       for(std::vector<core::vector2d<int> >::iterator ii = attachment_list.begin(); ii != attachment_list.end(); ii++)
+                       // Detach this object's children
+                       for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
                        {
-                               if(ii->X == this->getId()) // This is the ID of our object
+                               if(ii->Y == getId()) // Is a child of our object
                                {
-                                       attachment_list.erase(ii);
-                                       break;
+                                       ii->Y = 0;
+                                       ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
+                                       if(obj)
+                                               obj->setAttachments();
                                }
                        }
-               }
-
-               // If this object is being removed, either permanently or just to refresh it, then all
-               // objects attached to it must be unparented else Irrlicht causes a segmentation fault.
-               for(std::vector<core::vector2d<int> >::iterator ii = attachment_list.begin(); ii != attachment_list.end(); ii++)
-               {
-                       if(ii->Y == this->getId()) // This is a child of our parent
+                       // Delete this object from the attachments list
+                       for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
                        {
-                               ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
-                               if(obj)
+                               if(ii->X == getId()) // Is our object
                                {
-                                       if(permanent)
-                                       {
-                                               // The parent is being permanently removed, so the child stays detached
-                                               ii->Y = 0;
-                                               obj->updateParent();
-                                       }
-                                       else
-                                       {
-                                               // The parent is being refreshed, detach our child enough to avoid bad memory reads
-                                               // This only stays into effect for a few frames, as addToScene will parent its children back
-                                               scene::IMeshSceneNode *m_child_meshnode = obj->getMeshSceneNode();
-                                               scene::IAnimatedMeshSceneNode *m_child_animated_meshnode = obj->getAnimatedMeshSceneNode();
-                                               scene::IBillboardSceneNode *m_child_spritenode = obj->getSpriteSceneNode();
-                                               if(m_child_meshnode)
-                                                       m_child_meshnode->setParent(m_smgr->getRootSceneNode());
-                                               if(m_child_animated_meshnode)
-                                                       m_child_animated_meshnode->setParent(m_smgr->getRootSceneNode());
-                                               if(m_child_spritenode)
-                                                       m_child_spritenode->setParent(m_smgr->getRootSceneNode());
-                                       }
+                                       m_env->attachment_list.erase(ii);
+                                       break;
                                }
                        }
                }
@@ -836,18 +853,6 @@ class GenericCAO : public ClientActiveObject
                m_smgr = smgr;
                m_irr = irr;
 
-               // If this object has attachments and is being re-added after having been refreshed, parent its children back.
-               // The parent ID for this child hasn't been changed in attachment_list, so just update its attachments.
-               for(std::vector<core::vector2d<int> >::iterator ii = attachment_list.begin(); ii != attachment_list.end(); ii++)
-               {
-                       if(ii->Y == this->getId()) // This is a child of our parent
-                       {
-                               ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
-                               if(obj)
-                                       obj->updateParent();
-                       }
-               }
-
                if(m_meshnode != NULL || m_animated_meshnode != NULL || m_spritenode != NULL)
                        return;
                
@@ -863,7 +868,7 @@ class GenericCAO : public ClientActiveObject
                        m_spritenode = smgr->addBillboardSceneNode(
                                        NULL, v2f(1, 1), v3f(0,0,0), -1);
                        m_spritenode->setMaterialTexture(0,
-                                       tsrc->getTextureRaw("unknown_block.png"));
+                                       tsrc->getTexture("unknown_node.png"));
                        m_spritenode->setMaterialFlag(video::EMF_LIGHTING, false);
                        m_spritenode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
                        m_spritenode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
@@ -927,7 +932,7 @@ class GenericCAO : public ClientActiveObject
                        mesh->addMeshBuffer(buf);
                        buf->drop();
                        }
-                       m_meshnode = smgr->addMeshSceneNode(mesh, m_smgr->getRootSceneNode());
+                       m_meshnode = smgr->addMeshSceneNode(mesh, NULL);
                        mesh->drop();
                        // Set it to use the materials of the meshbuffers directly.
                        // This is needed for changing the texture in the future
@@ -936,7 +941,7 @@ class GenericCAO : public ClientActiveObject
                else if(m_prop.visual == "cube"){
                        infostream<<"GenericCAO::addToScene(): cube"<<std::endl;
                        scene::IMesh *mesh = createCubeMesh(v3f(BS,BS,BS));
-                       m_meshnode = smgr->addMeshSceneNode(mesh, m_smgr->getRootSceneNode());
+                       m_meshnode = smgr->addMeshSceneNode(mesh, NULL);
                        mesh->drop();
                        
                        m_meshnode->setScale(v3f(m_prop.visual_size.X,
@@ -944,19 +949,29 @@ class GenericCAO : public ClientActiveObject
                                        m_prop.visual_size.X));
                        u8 li = m_last_light;
                        setMeshColor(m_meshnode->getMesh(), video::SColor(255,li,li,li));
+
+                       m_meshnode->setMaterialFlag(video::EMF_LIGHTING, false);
+                       m_meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
+                       m_meshnode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
+                       m_meshnode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
                }
                else if(m_prop.visual == "mesh"){
                        infostream<<"GenericCAO::addToScene(): mesh"<<std::endl;
                        scene::IAnimatedMesh *mesh = smgr->getMesh(m_prop.mesh.c_str());
                        if(mesh)
                        {
-                               m_animated_meshnode = smgr->addAnimatedMeshSceneNode(mesh, m_smgr->getRootSceneNode());
+                               m_animated_meshnode = smgr->addAnimatedMeshSceneNode(mesh, NULL);
                                m_animated_meshnode->animateJoints(); // Needed for some animations
                                m_animated_meshnode->setScale(v3f(m_prop.visual_size.X,
                                                m_prop.visual_size.Y,
                                                m_prop.visual_size.X));
                                u8 li = m_last_light;
                                setMeshColor(m_animated_meshnode->getMesh(), video::SColor(255,li,li,li));
+
+                               m_animated_meshnode->setMaterialFlag(video::EMF_LIGHTING, false);
+                               m_animated_meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
+                               m_animated_meshnode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
+                               m_animated_meshnode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
                        }
                        else
                                errorstream<<"GenericCAO::addToScene(): Could not load mesh "<<m_prop.mesh<<std::endl;
@@ -968,14 +983,14 @@ class GenericCAO : public ClientActiveObject
                                infostream<<"textures[0]: "<<m_prop.textures[0]<<std::endl;
                                IItemDefManager *idef = m_gamedef->idef();
                                ItemStack item(m_prop.textures[0], 1, 0, "", idef);
-                               scene::IMesh *item_mesh = item.getDefinition(idef).wield_mesh;
+                               scene::IMesh *item_mesh = idef->getWieldMesh(item.getDefinition(idef).name, m_gamedef);
                                
                                // Copy mesh to be able to set unique vertex colors
                                scene::IMeshManipulator *manip =
                                                irr->getVideoDriver()->getMeshManipulator();
                                scene::IMesh *mesh = manip->createMeshUniquePrimitives(item_mesh);
 
-                               m_meshnode = smgr->addMeshSceneNode(mesh, m_smgr->getRootSceneNode());
+                               m_meshnode = smgr->addMeshSceneNode(mesh, NULL);
                                mesh->drop();
                                
                                m_meshnode->setScale(v3f(m_prop.visual_size.X/2,
@@ -1005,8 +1020,11 @@ class GenericCAO : public ClientActiveObject
                                        wname.c_str(), video::SColor(255,255,255,255), node);
                        m_textnode->setPosition(v3f(0, BS*1.1, 0));
                }
-               
+
                updateNodePos();
+               updateAnimation();
+               updateBonePosition();
+               updateAttachments();
        }
 
        void expireVisuals()
@@ -1016,28 +1034,16 @@ class GenericCAO : public ClientActiveObject
                
        void updateLight(u8 light_at_pos)
        {
-               // Objects attached to the local player should always be hidden
-               if(getParent() != NULL && getParent()->isLocalPlayer())
-                       m_is_visible = false;
-               else
-                       m_is_visible = (m_hp != 0);
                u8 li = decode_light(light_at_pos);
-
                if(li != m_last_light){
                        m_last_light = li;
                        video::SColor color(255,li,li,li);
-                       if(m_meshnode){
+                       if(m_meshnode)
                                setMeshColor(m_meshnode->getMesh(), color);
-                               m_meshnode->setVisible(m_is_visible);
-                       }
-                       if(m_animated_meshnode){
+                       if(m_animated_meshnode)
                                setMeshColor(m_animated_meshnode->getMesh(), color);
-                               m_animated_meshnode->setVisible(m_is_visible);
-                       }
-                       if(m_spritenode){
+                       if(m_spritenode)
                                m_spritenode->setColor(color);
-                               m_spritenode->setVisible(m_is_visible);
-                       }
                }
        }
 
@@ -1070,32 +1076,74 @@ class GenericCAO : public ClientActiveObject
 
        void step(float dtime, ClientEnvironment *env)
        {
-               v3f lastpos = pos_translator.vect_show;
-
                if(m_visuals_expired && m_smgr && m_irr){
                        m_visuals_expired = false;
+
+                       // Attachments, part 1: All attached objects must be unparented first, or Irrlicht causes a segmentation fault
+                       for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
+                       {
+                               if(ii->Y == getId()) // This is a child of our parent
+                               {
+                                       ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
+                                       if(obj)
+                                       {
+                                               scene::IMeshSceneNode *m_child_meshnode = obj->getMeshSceneNode();
+                                               scene::IAnimatedMeshSceneNode *m_child_animated_meshnode = obj->getAnimatedMeshSceneNode();
+                                               scene::IBillboardSceneNode *m_child_spritenode = obj->getSpriteSceneNode();
+                                               if(m_child_meshnode)
+                                                       m_child_meshnode->setParent(m_smgr->getRootSceneNode());
+                                               if(m_child_animated_meshnode)
+                                                       m_child_animated_meshnode->setParent(m_smgr->getRootSceneNode());
+                                               if(m_child_spritenode)
+                                                       m_child_spritenode->setParent(m_smgr->getRootSceneNode());
+                                       }
+                               }
+                       }
+
                        removeFromScene(false);
                        addToScene(m_smgr, m_gamedef->tsrc(), m_irr);
-                       updateAnimations();
-                       updateBonePosRot();
-                       updateAttachments();
-                       return;
+
+                       // Attachments, part 2: Now that the parent has been refreshed, put its attachments back
+                       for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
+                       {
+                               if(ii->Y == getId()) // This is a child of our parent
+                               {
+                                       ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
+                                       if(obj)
+                                               obj->setAttachments();
+                               }
+                       }
                }
 
+               // Make sure m_is_visible is always applied
+               if(m_meshnode)
+                       m_meshnode->setVisible(m_is_visible);
+               if(m_animated_meshnode)
+                       m_animated_meshnode->setVisible(m_is_visible);
+               if(m_spritenode)
+                       m_spritenode->setVisible(m_is_visible);
+               if(m_textnode)
+                       m_textnode->setVisible(m_is_visible);
+
                if(getParent() != NULL) // Attachments should be glued to their parent by Irrlicht
                {
                        // Set these for later
-                       if(m_meshnode)
-                               m_position = m_meshnode->getAbsolutePosition();
-                       if(m_animated_meshnode)
-                               m_position = m_animated_meshnode->getAbsolutePosition();
-                       if(m_spritenode)
-                               m_position = m_spritenode->getAbsolutePosition();
+                       m_position = getPosition();
                        m_velocity = v3f(0,0,0);
                        m_acceleration = v3f(0,0,0);
+                       pos_translator.vect_show = m_position;
+
+                       if(m_is_local_player) // Update local player attachment position
+                       {
+                               LocalPlayer *player = m_env->getLocalPlayer();
+                               player->overridePosition = getParent()->getPosition();
+                               m_env->getLocalPlayer()->parent = getParent();
+                       }
                }
                else
                {
+                       v3f lastpos = pos_translator.vect_show;
+
                        if(m_prop.physical){
                                core::aabbox3d<f32> box = m_prop.collisionbox;
                                box.MinEdge *= BS;
@@ -1106,10 +1154,10 @@ class GenericCAO : public ClientActiveObject
                                v3f p_pos = m_position;
                                v3f p_velocity = m_velocity;
                                v3f p_acceleration = m_acceleration;
-                               IGameDef *gamedef = env->getGameDef();
-                               moveresult = collisionMoveSimple(&env->getMap(), gamedef,
+                               moveresult = collisionMoveSimple(env,env->getGameDef(),
                                                pos_max_d, box, stepheight, dtime,
-                                               p_pos, p_velocity, p_acceleration);
+                                               p_pos, p_velocity, p_acceleration,
+                                               this, m_prop.collideWithObjects);
                                // Apply results
                                m_position = p_pos;
                                m_velocity = p_velocity;
@@ -1217,39 +1265,47 @@ class GenericCAO : public ClientActiveObject
        {
                ITextureSource *tsrc = m_gamedef->tsrc();
 
+               bool use_trilinear_filter = g_settings->getBool("trilinear_filter");
+               bool use_bilinear_filter = g_settings->getBool("bilinear_filter");
+               bool use_anisotropic_filter = g_settings->getBool("anisotropic_filter");
+
                if(m_spritenode)
                {
                        if(m_prop.visual == "sprite")
                        {
-                               std::string texturestring = "unknown_block.png";
+                               std::string texturestring = "unknown_node.png";
                                if(m_prop.textures.size() >= 1)
                                        texturestring = m_prop.textures[0];
                                texturestring += mod;
                                m_spritenode->setMaterialTexture(0,
-                                               tsrc->getTextureRaw(texturestring));
+                                               tsrc->getTexture(texturestring));
 
                                // This allows setting per-material colors. However, until a real lighting
                                // system is added, the code below will have no effect. Once MineTest
                                // has directional lighting, it should work automatically.
                                if(m_prop.colors.size() >= 1)
                                {
-                                       m_meshnode->getMaterial(0).AmbientColor = m_prop.colors[0];
-                                       m_meshnode->getMaterial(0).DiffuseColor = m_prop.colors[0];
-                                       m_meshnode->getMaterial(0).SpecularColor = m_prop.colors[0];
+                                       m_spritenode->getMaterial(0).AmbientColor = m_prop.colors[0];
+                                       m_spritenode->getMaterial(0).DiffuseColor = m_prop.colors[0];
+                                       m_spritenode->getMaterial(0).SpecularColor = m_prop.colors[0];
                                }
+
+                               m_spritenode->getMaterial(0).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+                               m_spritenode->getMaterial(0).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+                               m_spritenode->getMaterial(0).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
                        }
                }
                if(m_animated_meshnode)
                {
                        if(m_prop.visual == "mesh")
                        {
-                               for (u32 i = 0; i < m_prop.textures.size(); ++i)
+                               for (u32 i = 0; i < m_prop.textures.size() && i < m_animated_meshnode->getMaterialCount(); ++i)
                                {
                                        std::string texturestring = m_prop.textures[i];
                                        if(texturestring == "")
                                                continue; // Empty texture string means don't modify that material
                                        texturestring += mod;
-                                       video::ITexture* texture = tsrc->getTextureRaw(texturestring);
+                                       video::ITexture* texture = tsrc->getTexture(texturestring);
                                        if(!texture)
                                        {
                                                errorstream<<"GenericCAO::updateTextures(): Could not load texture "<<texturestring<<std::endl;
@@ -1257,12 +1313,16 @@ class GenericCAO : public ClientActiveObject
                                        }
 
                                        // Set material flags and texture
-                                       m_animated_meshnode->setMaterialTexture(i, texture);
                                        video::SMaterial& material = m_animated_meshnode->getMaterial(i);
+                                       material.TextureLayer[0].Texture = texture;
                                        material.setFlag(video::EMF_LIGHTING, false);
                                        material.setFlag(video::EMF_BILINEAR_FILTER, false);
+
+                                       m_animated_meshnode->getMaterial(i).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+                                       m_animated_meshnode->getMaterial(i).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+                                       m_animated_meshnode->getMaterial(i).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
                                }
-                               for (u32 i = 0; i < m_prop.colors.size(); ++i)
+                               for (u32 i = 0; i < m_prop.colors.size() && i < m_animated_meshnode->getMaterialCount(); ++i)
                                {
                                        // This allows setting per-material colors. However, until a real lighting
                                        // system is added, the code below will have no effect. Once MineTest
@@ -1279,24 +1339,19 @@ class GenericCAO : public ClientActiveObject
                        {
                                for (u32 i = 0; i < 6; ++i)
                                {
-                                       std::string texturestring = "unknown_block.png";
+                                       std::string texturestring = "unknown_node.png";
                                        if(m_prop.textures.size() > i)
                                                texturestring = m_prop.textures[i];
                                        texturestring += mod;
-                                       AtlasPointer ap = tsrc->getTexture(texturestring);
 
-                                       // Get the tile texture and atlas transformation
-                                       video::ITexture* atlas = ap.atlas;
-                                       v2f pos = ap.pos;
-                                       v2f size = ap.size;
 
                                        // Set material flags and texture
                                        video::SMaterial& material = m_meshnode->getMaterial(i);
                                        material.setFlag(video::EMF_LIGHTING, false);
                                        material.setFlag(video::EMF_BILINEAR_FILTER, false);
-                                       material.setTexture(0, atlas);
-                                       material.getTextureMatrix(0).setTextureTranslate(pos.X, pos.Y);
-                                       material.getTextureMatrix(0).setTextureScale(size.X, size.Y);
+                                       material.setTexture(0,
+                                                       tsrc->getTexture(texturestring));
+                                       material.getTextureMatrix(0).makeIdentity();
 
                                        // This allows setting per-material colors. However, until a real lighting
                                        // system is added, the code below will have no effect. Once MineTest
@@ -1307,6 +1362,10 @@ class GenericCAO : public ClientActiveObject
                                                m_meshnode->getMaterial(i).DiffuseColor = m_prop.colors[i];
                                                m_meshnode->getMaterial(i).SpecularColor = m_prop.colors[i];
                                        }
+
+                                       m_meshnode->getMaterial(i).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+                                       m_meshnode->getMaterial(i).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+                                       m_meshnode->getMaterial(i).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
                                }
                        }
                        else if(m_prop.visual == "upright_sprite")
@@ -1319,7 +1378,7 @@ class GenericCAO : public ClientActiveObject
                                        tname += mod;
                                        scene::IMeshBuffer *buf = mesh->getMeshBuffer(0);
                                        buf->getMaterial().setTexture(0,
-                                                       tsrc->getTextureRaw(tname));
+                                                       tsrc->getTexture(tname));
                                        
                                        // This allows setting per-material colors. However, until a real lighting
                                        // system is added, the code below will have no effect. Once MineTest
@@ -1330,6 +1389,10 @@ class GenericCAO : public ClientActiveObject
                                                buf->getMaterial().DiffuseColor = m_prop.colors[0];
                                                buf->getMaterial().SpecularColor = m_prop.colors[0];
                                        }
+
+                                       buf->getMaterial().setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+                                       buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+                                       buf->getMaterial().setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
                                }
                                {
                                        std::string tname = "unknown_object.png";
@@ -1340,7 +1403,7 @@ class GenericCAO : public ClientActiveObject
                                        tname += mod;
                                        scene::IMeshBuffer *buf = mesh->getMeshBuffer(1);
                                        buf->getMaterial().setTexture(0,
-                                                       tsrc->getTextureRaw(tname));
+                                                       tsrc->getTexture(tname));
 
                                        // This allows setting per-material colors. However, until a real lighting
                                        // system is added, the code below will have no effect. Once MineTest
@@ -1357,28 +1420,32 @@ class GenericCAO : public ClientActiveObject
                                                buf->getMaterial().DiffuseColor = m_prop.colors[0];
                                                buf->getMaterial().SpecularColor = m_prop.colors[0];
                                        }
+
+                                       buf->getMaterial().setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+                                       buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+                                       buf->getMaterial().setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
                                }
                        }
                }
        }
 
-       void updateAnimations()
+       void updateAnimation()
        {
                if(m_animated_meshnode == NULL)
                        return;
 
-               m_animated_meshnode->setFrameLoop((int)m_frames.X, (int)m_frames.Y);
-               m_animated_meshnode->setAnimationSpeed(m_frame_speed);
-               m_animated_meshnode->setTransitionTime(m_frame_blend);
+               m_animated_meshnode->setFrameLoop((int)m_animation_range.X, (int)m_animation_range.Y);
+               m_animated_meshnode->setAnimationSpeed(m_animation_speed);
+               m_animated_meshnode->setTransitionTime(m_animation_blend);
        }
 
-       void updateBonePosRot()
+       void updateBonePosition()
        {
-               if(!m_bone_posrot.size() || m_animated_meshnode == NULL)
+               if(!m_bone_position.size() || m_animated_meshnode == NULL)
                        return;
 
                m_animated_meshnode->setJointMode(irr::scene::EJUOR_CONTROL); // To write positions to the mesh on render
-               for(std::map<std::string, core::vector2d<v3f> >::const_iterator ii = m_bone_posrot.begin(); ii != m_bone_posrot.end(); ++ii){
+               for(std::map<std::string, core::vector2d<v3f> >::const_iterator ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){
                        std::string bone_name = (*ii).first;
                        v3f bone_pos = (*ii).second.X;
                        v3f bone_rot = (*ii).second.Y;
@@ -1393,7 +1460,10 @@ class GenericCAO : public ClientActiveObject
        
        void updateAttachments()
        {
-               if(getParent() == NULL || getParent()->isLocalPlayer()) // Detach
+               m_attached_to_local = getParent() != NULL && getParent()->isLocalPlayer();
+               m_is_visible = !m_attached_to_local; // Objects attached to the local player should always be hidden
+
+               if(getParent() == NULL || m_attached_to_local) // Detach or don't attach
                {
                        if(m_meshnode)
                        {
@@ -1422,6 +1492,11 @@ class GenericCAO : public ClientActiveObject
                                m_spritenode->setRotation(old_rotation);
                                m_spritenode->updateAbsolutePosition();
                        }
+                       if(m_is_local_player)
+                       {
+                               LocalPlayer *player = m_env->getLocalPlayer();
+                               player->isAttached = false;
+                       }
                }
                else // Attach
                {
@@ -1528,6 +1603,11 @@ class GenericCAO : public ClientActiveObject
                                        }
                                }
                        }
+                       if(m_is_local_player)
+                       {
+                               LocalPlayer *player = m_env->getLocalPlayer();
+                               player->isAttached = true;
+                       }
                }
        }
 
@@ -1557,7 +1637,8 @@ class GenericCAO : public ClientActiveObject
                }
                else if(cmd == GENERIC_CMD_UPDATE_POSITION)
                {
-                       // Not sent by the server if the object is an attachment
+                       // Not sent by the server if this object is an attachment.
+                       // We might however get here if the server notices the object being detached before the client.
                        m_position = readV3F1000(is);
                        m_velocity = readV3F1000(is);
                        m_acceleration = readV3F1000(is);
@@ -1567,14 +1648,14 @@ class GenericCAO : public ClientActiveObject
                        bool is_end_position = readU8(is);
                        float update_interval = readF1000(is);
 
-                       if(getParent() != NULL) // Just in case
-                               return;
-
                        // Place us a bit higher if we're physical, to not sink into
                        // the ground due to sucky collision detection...
                        if(m_prop.physical)
                                m_position += v3f(0,0.002,0);
-                               
+
+                       if(getParent() != NULL) // Just in case
+                               return;
+
                        if(do_interpolate){
                                if(!m_prop.physical)
                                        pos_translator.update(m_position, is_end_position, update_interval);
@@ -1602,35 +1683,48 @@ class GenericCAO : public ClientActiveObject
 
                        updateTexturePos();
                }
-               else if(cmd == GENERIC_CMD_SET_ANIMATIONS)
+               else if(cmd == GENERIC_CMD_SET_PHYSICS_OVERRIDE)
+               {
+                       float override_speed = readF1000(is);
+                       float override_jump = readF1000(is);
+                       float override_gravity = readF1000(is);
+                       if(m_is_local_player)
+                       {
+                               LocalPlayer *player = m_env->getLocalPlayer();
+                               player->physics_override_speed = override_speed;
+                               player->physics_override_jump = override_jump;
+                               player->physics_override_gravity = override_gravity;
+                       }
+               }
+               else if(cmd == GENERIC_CMD_SET_ANIMATION)
                {
-                       m_frames = readV2F1000(is);
-                       m_frame_speed = readF1000(is);
-                       m_frame_blend = readF1000(is);
+                       m_animation_range = readV2F1000(is);
+                       m_animation_speed = readF1000(is);
+                       m_animation_blend = readF1000(is);
 
-                       updateAnimations();
+                       updateAnimation();
                }
-               else if(cmd == GENERIC_CMD_SET_BONE_POSROT)
+               else if(cmd == GENERIC_CMD_SET_BONE_POSITION)
                {
                        std::string bone = deSerializeString(is);
                        v3f position = readV3F1000(is);
                        v3f rotation = readV3F1000(is);
-                       m_bone_posrot[bone] = core::vector2d<v3f>(position, rotation);
+                       m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
 
-                       updateBonePosRot();
+                       updateBonePosition();
                }
                else if(cmd == GENERIC_CMD_SET_ATTACHMENT)
                {
                        // If an entry already exists for this object, delete it first to avoid duplicates
-                       for(std::vector<core::vector2d<int> >::iterator ii = attachment_list.begin(); ii != attachment_list.end(); ii++)
+                       for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
                        {
-                               if(ii->X == this->getId()) // This is the ID of our object
+                               if(ii->X == getId()) // This is the ID of our object
                                {
-                                       attachment_list.erase(ii);
+                                       m_env->attachment_list.erase(ii);
                                        break;
                                }
                        }
-                       attachment_list.push_back(core::vector2d<int>(this->getId(), readS16(is)));
+                       m_env->attachment_list.push_back(core::vector2d<int>(getId(), readS16(is)));
                        m_attachment_bone = deSerializeString(is);
                        m_attachment_position = readV3F1000(is);
                        m_attachment_rotation = readV3F1000(is);