[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/metaobjects/a3dl/material.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/
#ifndef _MATERIAL_HH_
#define _MATERIAL_HH_


#include "a3dldefs.hh"
#include <vos/vos/vos.hh>

#ifndef A3DL_EXPORTS
IMPORT_METAOBJECT_FACTORIES(A3DL_Material)
#endif

namespace A3DL
{
    class TextureIterator;
    class Texture;


    /** @class Material material.hh vos/metaobjects/a3dl/material.hh
     *  @ingroup libmetaobject_a3dl
     *  Contains material (appearence) information for a 3D object.
     *  Materials hold one or more texture layers, solid colors,
     *  transparency value and various lighting parameters.
     *
     *  @todo Need to add functions for setting shading (CS mixmode |=
     *  CS_FX_GORAUD), keycolor (CS mixmode |= CS_FX_KEYCOLOR), tiling (CS
     *  mixmode |= CS_FX_TILING)
     */
    class A3DL_API Material : public VOS::MetaObject
    {
    public:

        /** Special blend modes for setBlendMode() and getBlendMode() */
        enum BlendMode {BLEND_ADD, BLEND_MULTIPLY, BLEND_DOUBLE_MULTIPLY, BLEND_NORMAL};


    public:
        Material(VOS::VobjectBase* superobject);
        virtual ~Material();

        static VOS::MetaObject* new_Material(VOS::VobjectBase* superobject, const std::string& type);
        virtual const std::string getVOSType();

        /** Get pointers to texture layers. */
        virtual TextureIterator getTextureLayers();

        /** Use a VUtil::vRef or call release on the returned object.
            @return 0 if idx is greater than the number of texture layers.
        */
        virtual VUtil::vRef<Texture> getTextureLayer(int idx);

        /** Insert a texture layer at the given index.
         *  Textures are applied to an object from lowest to highest index.
         */
        virtual void insertTextureLayer(int idx, Texture& t);

        /** Insert a new texture layer into this material at the given index,
         *  using the given file as the image backend source (using FileProperty)
         *  @see FileProperty
         *  @throw FileAccessError if there is an error opening the file
         */
        virtual VUtil::vRef<Texture> insertTextureLayerFromFile(int idx, const std::string& filename,
                                                              const std::string& datatype);

        /** Create a new Texture object using given image data and datatype
         * identifiel, and insert it into this material at the
         * given index.
         */
        virtual VUtil::vRef<Texture> insertTextureLayer(int idx, const std::string& data, const std::string& datatype, double alpha = 1.0, BlendMode blendMode = BLEND_NORMAL);

        virtual void replaceTextureLayer(int idx, Texture& t);
        virtual void replaceTextureLayer(int idx, Texture* t) {
            assert(t);
            replaceTextureLayer(idx, *t);
        }
        virtual void removeTextureLayer(int idx);

        /** Set the "base" color of the material: a color to use if there are no
         * texture layers.
         */
        virtual void setColor(float r, float g, float b);

        /** Get the "base" color of the material: a color to use if there are no
         * texture layers.
         */
        virtual void getColor(float& r, float& g, float& b);

        /** Convert an HTML-style hex triplet ("#RRGGBB") to three normalized
         * (0.0-1.0) floating-point values.
         * @todo Move this out into just the A3DL namespace?
         * */
        static void hexStringToFloats(const std::string& str, float& r, float& g, float& b);

        /** Convert three normalized floats (0.0-1.0) to an HTML-style hex
         *  tripplet ("#RRGGBB). If any input parameter is less than 0.0,
         *  it is considered to be 0. If any parameter is greater than 1.0,
         *  it is considered to be 1.
         * @todo Move this out into just the A3DL namespace?
         */
        static void floatsToHexString(float r, float g, float b, std::string& str);

        /** Set alpha transparency of the object.
            @param t    A value between 0 (fully transparent) and 1 (no
                        transparency). Some renderers may round to certain
                        values (e.g. 1.0, 0.75, 0.5, 0.25, 0.0)
                        If t is > 1, 1 will be used. If t < 0, 0 will be
                        used.
        */
        virtual void setAlpha(double t);

        /** Get alpha. Will be between 0 (fully transparent) and
            1 (no transparency)
            @throws Vobject:NoSuchObjectError if there is no "a3dl:alpha" object.
         */
        virtual double getAlpha();

        /** Get transparency property. */
        virtual VUtil::vRef<VOS::Property> getAlphaObj();

        /** Set transparency property object */
        virtual void setAlphaObj(VOS::Property* obj);

        /** Set special blend mode.
         *  These blend modes determine how the background
         *  affects the object's material.
         */
        virtual void setBlendMode(BlendMode mode);

        /** Get special blend mode.
         *  These blend modes determine how the background affects the
         *  object's material.
         *  @throws Vobject::NoSuchObjectError if there is no "a3dl:blend-mode"
         *  property.
         */
        virtual BlendMode getBlendMode();

        /** Get blend mode property object. */
        virtual VUtil::vRef<VOS::Property> getBlendModeObj();

        /** Set blend mode property object. */
        virtual void setBlendModeObj(VOS::Property* obj);


        /** Set blend color: this color modifies the blending of this object
         * against its background.
         */
        virtual void setBlendColor(float r, float g, float b);

        /** Get blend color
         * @throws Vobject::NoSuchObjectError if there is no "a3dl:blend-mode"
         * property.
         */
        virtual void getBlendColor(float& r, float& g, float& b);


        /** Set a3dl:blend-color property object */
        virtual void setBlendColorObj(VOS::Property* obj);

        /** Get a3dl:blende-color property object */
        virtual VUtil::vRef<VOS::Property> getBlendColorObj();
    };
}

namespace VUtil {
    template<> inline void iteratorReleaseItem(A3DL::Material** v)
    {
        (*v)->release();
    }
}

namespace A3DL {
    class MaterialIterator : public VUtil::Iterator<Material*>
    {
    public:
        MaterialIterator() : VUtil::Iterator<Material*>() { }
        MaterialIterator(const MaterialIterator& i) : VUtil::Iterator<Material*>(i) { }
        MaterialIterator(std::vector<Material*>& vec) {
            items->resize(vec.size());
            int c = 0;
            for(std::vector<Material*>::const_iterator i = vec.begin();
                i != vec.end();
                i++)
            {
                (*i)->acquire();
                (*items)[c] = (*i);
                c++;
            }
        }
        VUtil::vRef<Material> operator*() {
            if(pos < items->size()) return VUtil::vRef<Material>((*items)[pos], true);
            else return VUtil::vRef<Material>();
        }
    };
}

#endif