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

/home/tetron/hack/vos/libs/vos/metaobjects/a3dl/texture.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 _TEXTURE_HH_
#define _TEXTURE_HH_

#include "a3dldefs.hh"
#include <vos/vos/vos.hh>
#include <vos/metaobjects/a3dl/material.hh>

#ifndef A3DL_EXPORTS
IMPORT_METAOBJECT_FACTORIES(A3DL_Texture)
#endif


namespace A3DL
{

    /** @class Texture texture.hh vos/metaobjects/a3dl/texture.hh
     *  @ingroup libmetaobject_a3dl
     *
     *  Represents a texture layer in a 3D object's Material.
     *
     */
    class A3DL_API Texture : public VOS::MetaObject
    {
    public:
        Texture(VOS::VobjectBase* superobject);
        virtual ~Texture();

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

        virtual VUtil::vRef<VOS::Property> getImage();
        virtual void setImage(VOS::Property* p);

        /** Set a file backend for the image for this texture (using
         * FileProperty).
         * @see FileProperty
         * @throw FileAccessError if there is an error opening the file
         */
        virtual void setImageToFile(const std::string& filename, const std::string& datatype);

        /** Set image data */
        virtual void setImageData(const std::string& data, const std::string& datatype);

        /** Set special blend mode.
         *  These blend modes determine how the background
         *  affects the object's material.
         */
        virtual void setBlendMode(Material::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 Material::BlendMode getBlendMode();

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

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

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

        /** Get alpha transparency. Will be between 0 (fully transparent) and
            1 (no transparency)
         */
        virtual double getAlpha();

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

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

        /** Set whether this layer should have shading. */
        virtual void setShaded(bool s);

        /** Get whether this layer should have shading or not.
         */
        virtual bool getShaded();

        /** Get shaded property object
         *  @throws Vobject::NoSuchObjectError if there is no "a3dl:shaded" object
         */
        virtual VUtil::vRef<VOS::Property> getShadedObj();

        /** Set shaded property object */
        virtual void setShadedObj(VOS::Property* obj);

        /** Set a color in the texture to be rendered transparent */
        virtual void setTransparentKeycolor(float r, float g, float b);

        /** Get the color in the texture that is rendered as transparent
         *  If there is no property, sets (r, g, b) to (0, 0, 0)
         *  @todo Throw NoSuchObjectError if there is no object-- need to
         *     disable keycolor if the texture image has an alpha channel.
         */
        virtual void getTransparentKeycolor(float& r, float& g, float& b);

        virtual void setUVScaleAndShift(float uscale, float vscale, float ushift, float vshift);
        virtual void getUVScaleAndShift(float& uscale, float& vscale, float& ushift, float& vshift);
    };

}

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

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

#endif