vos/3D/a3dl/texture.cc

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 <tetron@interreality.org>
*/

#include "texture.hh"
#include <vos/metaobjects/property/fileproperty.hh>
#include "material.hh"

using namespace A3DL;

Texture::Texture(MetaObject* superobject)
    : MetaObject(superobject)
{
}

Texture::~Texture()
{
}

MetaObject* Texture::new_Texture(MetaObject* superobject, const string& type)
{
    return new Texture(superobject);
}

const string Texture::getType()
{
    return "a3dl:texture";
}

void Texture::registerExtenders()
{
    LocalSite::addLocalObjectExtension(typeid(Texture).name(), &Texture::new_Texture);
    LocalSite::addLocalObjectExtension("a3dl:texture", &Texture::new_Texture);
    RemoteSite::addRemoteObjectExtension(typeid(Texture).name(), &Texture::new_Texture);
    RemoteSite::addRemoteObjectExtension("a3dl:texture", &Texture::new_Texture);
}

void Texture::setImage(Property* p) {
    try {
        vRef<ParentChildRelation> pcr = findChild("a3dl:image");
        setChild(pcr->position, "a3dl:image", p);
    } catch(NoSuchObjectError) {
        insertChild(-1, "a3dl:image", p);
    }
}

void Texture::setImageData(const string& data, const string& datatype) {
    Property::setProperty(*this, "a3dl:image", data, datatype, accesscontrol);
}

Property* Texture::getImage() {
    return meta_cast<Property*>(&findObject("a3dl:image"));
}

void Texture::setImageToFile(const string& filename, const string& datatype)
{
    int i;
    for(i = filename.size()-1; i > 0 && filename[i] != '/'; i--);
    if(filename[i] == '/') i++;

    vRef<FileProperty> fp = meta_cast<FileProperty*>(Site::getDefaultPeer()->createMetaObject(filename.substr(i).c_str(),
                                                                                              typeid(FileProperty).name(), 0));
     if(&fp) {
         fp->setFileBackend(filename, datatype);
         fp->insertPropertyAccessControl(-1, accesscontrol);
         int pos = -1;
         try {
             vRef<ParentChildRelation> pcr = findChild("a3dl:image");
             pos = pcr->position;
         } catch(NoSuchObjectError) {
         } catch(AccessControlError) {
         } catch(RemoteError) {
         }
         if(pos > -1) setChild(pos, "a3dl:image", &fp);
         else insertChild(-1, "a3dl:image", &fp);
     } else {
         LOG("meshbase", 2, "You don't seem to have the FileProperty plugin initialized!");
     }
}

void Texture::setBlendMode(short m) {
    string ms("none");
    switch(m) {
        case Material::BLEND_ADD:
            ms = "add";
            break;
        case Material::BLEND_MULTIPLY:
            ms = "multiply";
            break;
        case Material::BLEND_DOUBLE_MULTIPLY:
            ms = "double multiply";
            break;
    }
    Property::setProperty(*this, "a3dl:blend-mode", ms, "text/plain", accesscontrol);
}

short Texture::getBlendMode() {
    string s;
    try {
    vRef<Property> p = meta_cast<Property*>(&findObject("a3dl:blend-mode"));
    if(!&p) return Material::BLEND_NORMAL;
    p->read(s);
    if(s == "add")
        return Material::BLEND_ADD;
    if(s == "multiply")
        return Material::BLEND_MULTIPLY;
    if(s == "double multiply")
        return Material::BLEND_DOUBLE_MULTIPLY;
    return Material::BLEND_NORMAL;
    } catch(...) {
        return Material::BLEND_NORMAL;
    }
}


Property* Texture::getBlendModeObj() {
    return meta_cast<Property*>(&findObject("a3dl:blend-mode"));
}

void Texture::setBlendModeObj(Property* p) {
    try {
        vRef<ParentChildRelation> pcr = findChild("a3dl:blend-mode");
        setChild(pcr->position, "a3dl:blend-mode", p);
    } catch(NoSuchObjectError) {
        insertChild(-1, "a3dl:blend-mode", p);
    }
}

void Texture::setTransparency(double t, PropertyAccessControl* ac) {
    Property::setFloatProperty(*this, "a3dl:transparency", t, 0.0, 1.0, ac);
}

double Texture::getTransparency() {
    return Property::getFloatProperty(*this, "a3dl:transparency", 0.0, 1.0);
}

Property* Texture::getTransparencyObj() {
    return meta_cast<Property*>(&findObject("a3dl:transparency"));
}

void Texture::setTransparencyObj(Property* p) {
    try {
        vRef<ParentChildRelation> pcr = findChild("a3dl:transparency");
        setChild(pcr->position, "a3dl:transparency", p);
    } catch(NoSuchObjectError) {
        insertChild(-1, "a3dl:transparency", p);
    }
}

void Texture::setUVScaleAndShift(float uscale, float vscale, float ushift, float vshift)
{
    char s[256];
    sprintf(s, "%f %f %f %f", uscale, vscale, ushift, vshift);
    Property::setProperty(*this, "a3dl:uv-scale-shift", s, "text/x-vector", accesscontrol);
}

void Texture::getUVScaleAndShift(float& uscale, float& vscale, float& ushift, float& vshift)
{
    string s;
    try {
    vRef<Property> p = meta_cast<Property*>(&findObject("a3dl:blend-mode"));
    if(!&p) throw bad_cast();
    p->read(s);

    sscanf(s.c_str(), " %f %f %f %f ", &uscale, &vscale, &ushift, &vshift);
    } catch(bad_cast) {
        uscale = vscale = ushift = vshift = 0;
    } catch(NoSuchObjectError) {
        uscale = vscale = ushift = vshift = 0;
    }
}


void Texture::setTransparentKeycolor(float r, float g, float b)
{
    char s[256];
    sprintf(s, "%f %f %f", r, g, b);
    Property::setProperty(*this, "a3dl:transparent-keycolor", s, "text/x-vector", accesscontrol);
}

void Texture::getTransparentKeycolor(float& r, float& g, float& b)
{
    string s;
    try {
    vRef<Property> p = meta_cast<Property*>(&findObject("a3dl:transparent-keycolor"));
    if(!&p) throw bad_cast();
    p->read(s);

    sscanf(s.c_str(), " %f %f %f ", &r, &g, &b);
    } catch(bad_cast) {
        r = g = b = 0;
    } catch(NoSuchObjectError) {
        r = g = b = 0;
    }
}

void Texture::setShaded(bool s, PropertyAccessControl* ac) {
    Property::setBoolProperty(*this, "a3dl:shaded", s, ac);
}

bool Texture::getShaded() {
    return Property::getBoolProperty(*this, "a3dl:shaded");
}


Property* Texture::getShadedObj() {
    return meta_cast<Property*>(&findObject("a3dl:shaded"));
}

void Texture::setShadedObj(Property* p) {
    try {
        vRef<ParentChildRelation> pcr = findChild("a3dl:shaded");
        setChild(pcr->position, "a3dl:shaded", p);
    } catch(NoSuchObjectError) {
        insertChild(-1, "a3dl:shaded", p);
    }
}

---