vos/3D/a3dl/object3d.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 <stdio.h>
#include <math.h>
#include "object3d.hh"

#ifndef M_PI
# define M_PI           3.14159265358979323846
#endif

using namespace A3DL;

Object3D::Object3D(MetaObject* superobject)
    : MetaObject(superobject), accesscontrol(0)
{
}

Object3D::~Object3D()
{
}

void Object3D::setPosition(double x, double y, double z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        setThreeFloatProperty(*this, "a3dl:position", x, y, z, accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::setOrientation(double x, double y, double z, double rot) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    char c[256];
    snprintf(c, 256, "%.15g %.15g %.15g %.15g", x, y, z, rot);
    try {
        Property::setProperty(*this, "a3dl:orientation", string(c), "text/x-vector-float", accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::setScaling(double x, double y, double z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        setThreeFloatProperty(*this, "a3dl:scaling", x, y, z, accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::getPosition(double& x, double& y, double& z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        getThreeFloatProperty(*this, "a3dl:position", &x, &y, &z);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error finding, casting or reading \"position\" property (") + e.what() + ")");
    }

}

void Object3D::getOrientation(double& x, double& y, double& z, double& rot) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        rREF(Vobject&, v, findObject("a3dl:orientation"),
             string n;
             Property* p = meta_cast<Property*>(&v);
             if(!p) throw bad_cast();
             p->read(n);
             sscanf(n.c_str(), "%lg %lg %lg %lg", &x, &y, &z, &rot);
            );
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error finding, casting or reading \"orientation\" property (") + e.what() + ")");
    }
}

void Object3D::getScaling(double& x, double& y, double& z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        getThreeFloatProperty(*this, "a3dl:scaling", &x, &y, &z);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("Error finding, casting or reading \"scaling\" property (") + e.what() + ")");
    }
}

void Object3D::setPositionHT(double x, double y, double z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        setThreeFloatProperty(*this, "a3dl:hardposition", x, y, z, accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::setOrientationHT(double x, double y, double z, double rot) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    char c[256];
    snprintf(c, 256, "%.15g %.15g %.15g %.15g", x, y, z, rot);
    try {
        Property::setProperty(*this, "a3dl:hardorientation", string(c), "text/x-vector-float", accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::setScalingHT(double x, double y, double z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        setThreeFloatProperty(*this, "a3dl:hardscaling", x, y, z, accesscontrol);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error setting \"position\" property (") + e.what() + ")");
    }
}

void Object3D::getPositionHT(double& x, double& y, double& z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        getThreeFloatProperty(*this, "a3dl:hardposition", &x, &y, &z);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error finding, casting or reading \"position\" property (") + e.what() + ")");
    }

}

void Object3D::getOrientationHT(double& x, double& y, double& z, double& rot) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        rREF(Vobject&, v, findObject("a3dl:hardorientation"),
             string n;
             Property* p = meta_cast<Property*>(&v);
             if(!p) throw bad_cast();
             p->read(n);
             sscanf(n.c_str(), "%lg %lg %lg %lg", &x, &y, &z, &rot);
            );
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("error finding, casting or reading \"orientation\" property (") + e.what() + ")");
    }
}

void Object3D::getScalingHT(double& x, double& y, double& z) throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    try {
        getThreeFloatProperty(*this, "a3dl:hardscaling", &x, &y, &z);
    } catch(AccessControlError) {
        throw;
    } catch(RemoteError) {
        throw;
    } catch(exception e) {
        throw NoSuchObjectError(string("Error finding, casting or reading \"scaling\" property (") + e.what() + ")");
    }
}


void Object3D::setThreeFloatProperty(Vobject& vob, const string& name, double x, double y, double z,
                                     PropertyAccessControl* ac)
{
    char s[128];
    snprintf(s, sizeof(s), "%.15g %.15g %.15g", x, y, z);
    Property::setProperty(vob, name, s, "text/x-vector-float", ac);
}

void Object3D::getThreeFloatProperty(Vobject& vob, const string& name, double* x, double* y, double* z) {
    string s;
    vRef<Property> p = meta_cast<Property*>(&vob.findObject(name));
    if(!&p) throw bad_cast();
    p->read(s);
    sscanf(s.c_str(), "%lg %lg %lg", x, y, z);
}

void Object3D::initialize()
{
    setPropertyAccessControl(&NoPropertyAccessControl::static_);
    setPosition(0.0, 0.0, 0.0);
    setOrientation(0.0, 1.0, 0.0, 0.0);
    setScaling(1.0, 1.0, 1.0);
}

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

const string Object3D::getType()
{
    return "a3dl:object3D";
}

void Object3D::registerExtenders()
{
    LocalSite::addLocalObjectExtension(typeid(Object3D).name(), &Object3D::new_Object3D);
    LocalSite::addLocalObjectExtension("a3dl:object3D", &Object3D::new_Object3D);
    RemoteSite::addRemoteObjectExtension(typeid(Object3D).name(), &Object3D::new_Object3D);
    RemoteSite::addRemoteObjectExtension("a3dl:object3D", &Object3D::new_Object3D);
}

void Object3D::setOrientationWithQuaternion(double x, double y, double z, double w)
    throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    w = 2.0 * acos(w);
    double sp = sin(w/2.0);
    if(sp > .0000000001) {
        x = x / sp;
        y = y / sp;
        z = z / sp;
        w *= 180.0/M_PI;
    } else {
        x = y = 0;
        z = 1;
        w = 0;
    }
    setOrientation(x, y, z, w);
}

void Object3D::getOrientationAsQuaternion(double& x, double& y, double& z, double& w)
    throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    double ax, ay, az, phi;
    getOrientation(ax, ay, az, phi);

    double len = sqrt(ax*ax + ay*ay + az*az);
    if(len < .000000001) {
        x = 0;
        y = 0;
        z = 0;
        w = 1;
        return;
    } else {
        ax /= len;
        ay /= len;
        az /= len;
    }

    double p2 = phi/2.0 * M_PI/180.0;
    double ss = sin(p2);
    w = cos(p2);
    x = ax * ss;
    y = ay * ss;
    z = az * ss;
}

void Object3D::setOrientationWithQuaternionHT(double x, double y, double z, double w)
    throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    w = 2.0 * acos(w);
    double sp = sin(w/2.0);
    if(sp > .0000000001) {
        x = x / sp;
        y = y / sp;
        z = z / sp;
        w *= 180.0/M_PI;
    } else {
        x = y = 0;
        z = 1;
        w = 0;
    }
    setOrientationHT(x, y, z, w);
}

void Object3D::getOrientationAsQuaternionHT(double& x, double& y, double& z, double& w)
    throw(NoSuchObjectError, AccessControlError, RemoteError)
{
    double ax, ay, az, phi;
    getOrientationHT(ax, ay, az, phi);

    double len = sqrt(ax*ax + ay*ay + az*az);
    if(len < .000000001) {
        x = 0;
        y = 0;
        z = 0;
        w = 1;
        return;
    } else {
        ax /= len;
        ay /= len;
        az /= len;
    }

    double p2 = phi/2.0 * M_PI/180.0;
    double ss = sin(p2);
    w = cos(p2);
    x = ax * ss;
    y = ay * ss;
    z = az * ss;
}


void Object3D::setOrInsertChild(const string& name, Vobject* obj) {
    try {
        vRef<ParentChildRelation> pcr = findChild(name);
        setChild(pcr->position, name, obj);
    } catch(NoSuchObjectError) {
        insertChild(-1, name, obj);
    }
}

void Object3D::setPositionObj(Property* obj) {
    setOrInsertChild("a3dl:position", obj);
}

void Object3D::setOrientationObj(Property* obj) {
    setOrInsertChild("a3dl:orientation", obj);
}

void Object3D::setScalingObj(Property* obj) {
    setOrInsertChild("a3dl:scaling", obj);
}

Property* Object3D::getPositionObj() {
    Property* p = meta_cast<Property*>(&findObject("a3dl:position"));
    if(!p) throw bad_cast();
    return p;
}

Property* Object3D::getOrientationObj() {
    Property* p = meta_cast<Property*>(&findObject("a3dl:orientation"));
    if(!p) throw bad_cast();
    return p;
}

Property* Object3D::getScalingObj() {
    Property* p = meta_cast<Property*>(&findObject("a3dl:scaling"));
    if(!p) throw bad_cast();
    return p;
}

Material* Object3D::getMaterial(bool create) {
    try {
        return meta_cast<Material*>(&findObject("a3dl:material"));
    } catch(NoSuchObjectError) {
        if(create) {
            vRef<LocalSite> site = Site::getDefaultPeer();
            vRef<Material> mat = meta_cast<Material*>(site->createMetaObject("a3dl:material",
                                                                                         typeid(Material).name(), 0));
            mat->setPropertyAccessControl(accesscontrol);
            insertChild(-1, "a3dl:material", &mat);
            mat->acquire();
            return &mat;
        } else throw;
    }
}

void Object3D::setMaterial(Material* p) {
    try {
        vRef<ParentChildRelation> pcr = findChild("a3dl:material");
        setChild(pcr->position, "a3dl:material", p);
    } catch(NoSuchObjectError) {
        insertChild(-1, "a3dl:material", p);
    }
}

vector<Material*> Object3D::getMaterials()
{
    vector<Material*> t;
    const ChildList& cl = getChildren();
    for(unsigned int i = 0; i < cl.size(); i++) {
        if(cl[i]->contextual_name == "a3dl:material") {
            if(Material* tx = meta_cast<Material*>(cl[i]->child)) t.push_back(tx);
        }
    }
    return t;
}

---