class Material : public irr::newton::IMaterial
    {
        public:
        Material(bool colid = true,double soft = 0.0,double elast = 0.0,float staticf = 0.f,float kineticf = 0.f);
        ~Material();

        bool colidable;
        double softness;
        double elasticity;
        float staticFriction;
        float kineticFriction;
    };

    class Materials
    {
        public:
        Materials();
        ~Materials();

        void add(string name,Material* mat);
        Material operator[](string name);

        protected:
        map<string,Material*> mats;
    };

    Materials *initMaterials();

    Material::Material(bool colid,double soft,double elast,float staticf,float kineticf) : IMaterial(data.world->getNewtonWorld())
    {
        colidable = colid;
        softness = soft;
        elasticity = elast;
        staticFriction = staticf;
        kineticFriction = kineticf;
    }

    Material::~Material()
    {
    }




    Materials::Materials()
    {
    }

    Materials::~Materials()
    {
        for(map<string,Material*>::iterator it = mats.begin() ; it != mats.end() ; it++)
            delete it->second;
    }

    void Materials::add(string name,Material* mat)
    {
        mats[name] = mat;

        irr::newton::IMaterial *defaul = new irr::newton::IMaterial(data.world->getNewtonWorld());
        mat->setCollidable(defaul,mat->colidable);
        mat->setContinuousCollisionMode(defaul,false);
        mat->setSoftness(defaul,mat->softness);
        mat->setElasticity(defaul,mat->elasticity);
        mat->setFriction(defaul,mat->staticFriction,mat->kineticFriction);
        for(map<string,Material*>::iterator it = mats.begin() ; it != mats.end() ; it++)
        {
            mat->setCollidable(it->second,mat->colidable && it->second->colidable);
            mat->setContinuousCollisionMode(it->second,false);

            mat->setSoftness(it->second,
                            (mat->softness + it->second->softness)/2);
            mat->setElasticity(it->second,
                              (mat->elasticity + it->second->elasticity)/2 > 1 ? 1 : (mat->elasticity + it->second->elasticity)/2);
            mat->setFriction(it->second,
                            (mat->staticFriction + it->second->staticFriction)/2,
                            (mat->kineticFriction + it->second->kineticFriction)/2);
        }
    }
    Material Materials::operator[](string name)
    {
        return *mats[name];
    }

    Materials *initMaterials()
    {
        Materials *mat = new Materials();
        mat->add("sphere",new Material(true,0.0,1.0));
        return mat;
    }