vos/3D/a3dl/polygonmesh.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 <stdarg.h>

#include <vos/metaobjects/property/property.hh>
#include <vos/metaobjects/misc/cod.hh>
#include "polygonmesh.hh"


// This class uses the COD pack/unpack functions, because they are handy :)

using namespace A3DL;

PolygonMesh::PolygonMesh(MetaObject* superobject)
    : Object3D(superobject), MetaObject(superobject)
{
}

PolygonMesh::~PolygonMesh()
{
}

void PolygonMesh::setVertex(unsigned int which, Vertex& v)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:vertices");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) return;
    pr->read(data);

    unsigned char* newdata;
    int newdatasize;
    if(which * 3 * 4 > data.size()) {
        int existingVerts = data.size() / (3*4);
        int needNew = which - existingVerts;
        newdatasize = (needNew + 1) * 12;
        newdata = (unsigned char*)malloc(newdatasize);
        for(int i = 0; i < needNew; i++) {
            COD::pack(newdata + i*12, newdatasize, "fff", 0.0, 0.0, 0.0);
        }
    } else {
        newdata = (unsigned char*)malloc(12);
        newdatasize = 12;
    }
    COD::pack(newdata + newdatasize - 12, 12, "fff", v.x, v.y, v.z);
    if(which * 3 * 4 > data.size()) pr->write(data.size(), string((char*)newdata, newdatasize));
    else pr->write(which * 12, string((char*)newdata, newdatasize));
    free(newdata);
}

void PolygonMesh::setNormal(unsigned int which, Vertex& v)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:normals");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) return;
    pr->read(data);

    unsigned char* newdata;
    int newdatasize;
    if(which * 3 * 4 > data.size()) {
        int existingVerts = data.size() / (3*4);
        int needNew = which - existingVerts;
        newdatasize = (needNew + 1) * 12;
        newdata = (unsigned char*)malloc(newdatasize);
        for(int i = 0; i < needNew; i++) {
            COD::pack(newdata + i*12, newdatasize, "fff", 0.0, 0.0, 0.0);
        }
    } else {
        newdata = (unsigned char*)malloc(12);
        newdatasize = 12;
    }
    COD::pack(newdata + newdatasize - 12, 12, "fff", v.x, v.y, v.z);
    if(which * 3 * 4 > data.size()) pr->write(data.size(), string((char*)newdata, newdatasize));
    else pr->write(which * 12, string((char*)newdata, newdatasize));
    free(newdata);
}


void PolygonMesh::setPolygon(unsigned int which, Polygon& t)
{
    string data;

    vRef<Vobject> tris = findObject("a3dl:triangles");
    Property* pr = meta_cast<Property*>(&tris);
    if(!pr) return;
    pr->read(data);

    if(pr->getDataType() == "packed/triangle-array") {
        unsigned char* newdata;
        int newdatasize;
        if(which * 3 * 4 > data.size()) {
            int existingTris = data.size() / (3*4);
            int needNew = which - existingTris;
            newdatasize = (needNew + 1) * 12;
            newdata = (unsigned char*)malloc(newdatasize);
            for(int i = 0; i < needNew; i++) {
                COD::pack(newdata + i*12, newdatasize, "lll", 0, 1, 2);
            }
        } else {
            newdata = (unsigned char*)malloc(12);
            newdatasize = 12;
        }
        COD::pack(newdata + newdatasize - 12, 12, "lll", t[0], t[1], t[2]);
        if(which * 3 * 4 > data.size()) pr->write(data.size(), string((char*)newdata, newdatasize));
        else pr->write(which * 12, string((char*)newdata, newdatasize));
        free(newdata);
    } else if(pr->getDataType() == "packed/polygon-list") {
        vector<Polygon> p;
        getPolygons(p);
        if(which >= p.size()) p.resize(which+1);
        p[which] = t;
        setPolygons(p);
    }
}

void PolygonMesh::setTexel(int which, Texel& uv)
{
    string data;

    vRef<Vobject> uvobj = findObject("a3dl:texels");
    Property* pr = meta_cast<Property*>(&uvobj);
    if(!pr) return;
    pr->read(data);

    unsigned char* newdata;
    int newdatasize;
    if(which * 8 > (int)data.size()) {
        int existingVerts = data.size() / 8;
        int needNew = which - existingVerts;
        newdatasize = (needNew + 1) * 8;
        newdata = (unsigned char*)malloc(newdatasize);
        for(int i = 0; i < needNew; i++) {
            COD::pack(newdata + i*8, newdatasize, "ff", 0.0, 0.0);
        }
    } else {
        newdata = (unsigned char*)malloc(8);
        newdatasize = 8;
    }
    COD::pack(newdata + newdatasize - 8, 8, "ff", uv.x, uv.y);
    if(which * 8 > (int)data.size()) pr->write(data.size(), string((char*)newdata, newdatasize));
    else pr->write(which * 8, string((char*)newdata, newdatasize));
    free(newdata);
}


void PolygonMesh::setVertices(const vector<Vertex>& v)
{
    vRef<Vobject> vertices;
    try {
        vertices = findObject("a3dl:vertices");
    } catch(NoSuchObjectError) {
        vRef<Site> s = getSite();
        vertices = s->createMetaObject("vertices", typeid(Property).name(), 0);
        LocalProperty* lp = meta_cast<LocalProperty*>(&vertices);
        if(!lp) throw bad_cast();
        lp->insertPropertyAccessControl(-1, accesscontrol);
        insertChild(-1, "a3dl:vertices", &vertices);
    }
    try {
        Property* pr = meta_cast<Property*>(&vertices);
        if(!pr) throw bad_cast();
        unsigned char* data = (unsigned char*)malloc(v.size() * 12);
        for(unsigned int i = 0; i < v.size(); i++) {
            COD::pack(data + i*12, 12, "fff", v[i].x, v[i].y, v[i].z);
        }
        pr->replace(string((char*)data, v.size() * 12));
        free(data);
    } catch(bad_cast) {
    }
}

void PolygonMesh::setNormals(const vector<Vertex>& v)
{
    vRef<Vobject> vertices;
    try {
        vertices = findObject("a3dl:normals");
    } catch(NoSuchObjectError) {
        vRef<Site> s = getSite();
        vertices = s->createMetaObject("normals", typeid(Property).name(), 0);
        LocalProperty* lp = meta_cast<LocalProperty*>(&vertices);
        if(!lp) throw bad_cast();
        lp->insertPropertyAccessControl(-1, accesscontrol);
        insertChild(-1, "a3dl:normals", &vertices);
    }
    try {
        Property* pr = meta_cast<Property*>(&vertices);
        if(!pr) throw bad_cast();
        unsigned char* data = (unsigned char*)malloc(v.size() * 12);
        for(unsigned int i = 0; i < v.size(); i++) {
            COD::pack(data + i*12, 12, "fff", v[i].x, v[i].y, v[i].z);
        }
        pr->replace(string((char*)data, v.size() * 12));
        free(data);
    } catch(bad_cast) {
    }
}


void PolygonMesh::setPolygons(const vector<Polygon>& t)
{
    vRef<Vobject> polygons;

    try {
        polygons = findObject("a3dl:polygons");
    } catch(NoSuchObjectError) {
        vRef<Site> s = getSite();
        polygons = s->createMetaObject("a3dl:polygons", typeid(Property).name(), 0);
        LocalProperty* lp = meta_cast<LocalProperty*>(&polygons);
        if(!lp) throw bad_cast();
        lp->insertPropertyAccessControl(-1, accesscontrol);
        insertChild(-1, "a3dl:polygons", &polygons);
    }
    bool onlytris = true;
    for(vector<Polygon>::size_type i = 0; i < t.size(); i++) {
        if(t[i].size() > 3) {
            onlytris = false;
            break;
        }
    }
    Property* pr = meta_cast<Property*>(&polygons);
    if(!pr) return;
    if(onlytris) {
        unsigned char* data = (unsigned char*)malloc(t.size() * 12);
        for(unsigned int i = 0; i < t.size(); i++) {
            COD::pack(data + i*12, 12, "lll", t[i][0], t[i][1], t[i][2]);
        }
        pr->replace(string((char*)data, t.size() * 12), "packed/triangle-array");
        free(data);
    } else {
        int numvertices = 0;
        for(vector<Polygon>::size_type i = 0; i < t.size(); i++) {
            numvertices += t[i].size();
        }

        unsigned char* data = (unsigned char*)malloc(t.size() + numvertices*4);
        int offset = 0;
        for(vector<Polygon>::size_type i = 0; i < t.size(); i++) {
            offset += COD::pack(data + offset, 1, "c", t[i].size());
            for(vector<int>::size_type n = 0; n < t[i].size(); n++) {
                offset += COD::pack(data + offset, 4, "l", t[i][n]);
            }
        }
        pr->replace(string((char*)data, t.size() + numvertices*4), "packed/polygon-list");
        free(data);
    }
}

void PolygonMesh::setTexels(const vector<Texel>& uv)
{
    vRef<Vobject> uvobj;
    try {
        uvobj = findObject("a3dl:texels");
    } catch(NoSuchObjectError) {
        vRef<Site> s = getSite();
        uvobj = s->createMetaObject("a3dl:texels", typeid(Property).name(), 0);
        LocalProperty* lp = meta_cast<LocalProperty*>(&uvobj);
        if(!lp) throw bad_cast();
        lp->insertPropertyAccessControl(-1, accesscontrol);
        insertChild(-1, "a3dl:texels", &uvobj);
    }
    try {
        Property* pr = meta_cast<Property*>(&uvobj);
        if(!pr) throw bad_cast();
        unsigned char* data = (unsigned char*)malloc(uv.size() * 8);
        for(unsigned int i = 0; i < uv.size(); i++) {
            COD::pack(data + i*8, 8, "ff", uv[i].x, uv[i].y);
        }
        pr->replace(string((char*)data, uv.size() * 8));
        free(data);
    } catch(bad_cast) {
    }
}

void PolygonMesh::getVertices(vector<Vertex>& v)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:vertices");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) throw bad_cast();
    pr->read(data);

    int numvert = data.size() / 12;
    v.resize(numvert);
    for(int i = 0; i < numvert; i++) {
        COD::unpack((unsigned char*)data.c_str() + i*12, data.size(), "fff", &v[i].x, &v[i].y, &v[i].z);
    }
}

void PolygonMesh::getNormals(vector<Vertex>& n)
{
    string data;

    vRef<Vobject> norm = findObject("a3dl:normals");
    Property* pr = meta_cast<Property*>(&norm);
    if(!pr) throw bad_cast();
    pr->read(data);

    int numvert = data.size() / 12;
    n.resize(numvert);
    for(int i = 0; i < numvert; i++) {
        COD::unpack((unsigned char*)data.c_str() + i*12, data.size(), "fff", &n[i].x, &n[i].y, &n[i].z);
    }
}


void PolygonMesh::getPolygons(vector<Polygon>& t)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:polygons");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) throw bad_cast();
    pr->read(data);

    if(pr->getDataType() == "packed/triangle-array") {
        int numtri = data.size() / 12;
        t.resize(numtri);
        for(int i = 0; i < numtri; i++) {
            t[i].resize(3);
            COD::unpack((unsigned char*)data.c_str() + i*12, data.size(), "lll", &t[i][0], &t[i][1], &t[i][2]);
        }
    } else  if(pr->getDataType() == "packed/polygon-list") {
        string::size_type offset = 0;
        while(offset < data.size()) {
            unsigned char n;
            offset += COD::unpack((unsigned char*)data.c_str() + offset, 1, "c", &n);
            Polygon p;
            for(int i = 0; i < n; i++) {
                int v;
                offset += COD::unpack((unsigned char*)data.c_str() + offset, 4, "l", &v);
                p.push_back(v);
            }
            t.push_back(p);
        }
    }
}

void PolygonMesh::getTexels(vector<Texel>& uv)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:texels");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) throw bad_cast();
    pr->read(data);

    int numuv = data.size() / 8;
    uv.resize(numuv);
    for(int i = 0; i < numuv; i++) {
        COD::unpack((unsigned char*)data.c_str() + i*8, data.size(), "ff",
                    &uv[i].x, &uv[i].y);
    }
}

void PolygonMesh::packTextureSpace(unsigned char* data, const TextureSpace& t)
{
    // the "portal" flag is the high bit of the "type" field
    unsigned char type = (unsigned char)t.type;

    if(t.isPortal) type |= 0x80;

    switch(t.type) {
    case NoTexture:
        COD::pack(data, 50, "cc", type, t.material);
        break;
    case UVcoord:
        COD::pack(data, 50, "cclfflfflff",
                  type, t.material,
                  t.Rep.UVcoord.vert1,
                  t.Rep.UVcoord.u1,
                  t.Rep.UVcoord.v1,
                  t.Rep.UVcoord.vert2,
                  t.Rep.UVcoord.u2,
                  t.Rep.UVcoord.v2,
                  t.Rep.UVcoord.vert3,
                  t.Rep.UVcoord.u3,
                  t.Rep.UVcoord.v3);
        break;
    case PolygonPlane:
        COD::pack(data, 50, "ccfffffff",
                  type, t.material,
                  t.Rep.PolygonPlane.xorg,
                  t.Rep.PolygonPlane.yorg,
                  t.Rep.PolygonPlane.zorg,
                  t.Rep.PolygonPlane.x,
                  t.Rep.PolygonPlane.y,
                  t.Rep.PolygonPlane.z,
                  t.Rep.PolygonPlane.len);
        break;
    case ArbitraryPlane:
        COD::pack(data, 50, "ccfffffffffff",
                  type, t.material,
                  t.Rep.ArbitraryPlane.xorg,
                  t.Rep.ArbitraryPlane.yorg,
                  t.Rep.ArbitraryPlane.zorg,
                  t.Rep.ArbitraryPlane.x1,
                  t.Rep.ArbitraryPlane.y1,
                  t.Rep.ArbitraryPlane.z1,
                  t.Rep.ArbitraryPlane.len1,
                  t.Rep.ArbitraryPlane.x2,
                  t.Rep.ArbitraryPlane.y2,
                  t.Rep.ArbitraryPlane.z2,
                  t.Rep.ArbitraryPlane.len2);
        break;
    case TexMatrix:
        COD::pack(data, 50, "ccffffffffffff",
                  type, t.material,
                  t.Rep.Matrix.m11, t.Rep.Matrix.m12, t.Rep.Matrix.m13,
                  t.Rep.Matrix.m21, t.Rep.Matrix.m22, t.Rep.Matrix.m23,
                  t.Rep.Matrix.m31, t.Rep.Matrix.m32, t.Rep.Matrix.m33,
                  t.Rep.Matrix.x,   t.Rep.Matrix.y,   t.Rep.Matrix.z);
        break;
    }
}

void PolygonMesh::unpackTextureSpace(const unsigned char* data, TextureSpace& t)
{
    // the "portal" flag is the high bit of the "type" field
    unsigned int type;
    COD::unpack(data, 2, "cc", &type, &t.material);
    t.type = (TextureType)(type & 0x0F);
    t.isPortal = ((type & 0x80) == 0x80);

    switch(t.type) {
    case UVcoord:
        COD::unpack(data + 2, 48, "lfflfflff",
                    &t.Rep.UVcoord.vert1,
                    &t.Rep.UVcoord.u1,
                    &t.Rep.UVcoord.v1,
                    &t.Rep.UVcoord.vert2,
                    &t.Rep.UVcoord.u2,
                    &t.Rep.UVcoord.v2,
                    &t.Rep.UVcoord.vert3,
                    &t.Rep.UVcoord.u3,
                    &t.Rep.UVcoord.v3);
        break;
    case PolygonPlane:
        COD::unpack(data + 2, 48, "fffffff",
                    &t.Rep.PolygonPlane.xorg,
                    &t.Rep.PolygonPlane.yorg,
                    &t.Rep.PolygonPlane.zorg,
                    &t.Rep.PolygonPlane.x,
                    &t.Rep.PolygonPlane.y,
                    &t.Rep.PolygonPlane.z,
                    &t.Rep.PolygonPlane.len);
        break;
    case ArbitraryPlane:
        COD::unpack(data + 2, 48, "fffffffffff",
                    &t.Rep.ArbitraryPlane.xorg,
                    &t.Rep.ArbitraryPlane.yorg,
                    &t.Rep.ArbitraryPlane.zorg,
                    &t.Rep.ArbitraryPlane.x1,
                    &t.Rep.ArbitraryPlane.y1,
                    &t.Rep.ArbitraryPlane.z1,
                    &t.Rep.ArbitraryPlane.len1,
                    &t.Rep.ArbitraryPlane.x2,
                    &t.Rep.ArbitraryPlane.y2,
                    &t.Rep.ArbitraryPlane.z2,
                    &t.Rep.ArbitraryPlane.len2);
        break;
    case TexMatrix:
        COD::unpack(data + 2, 48, "ffffffffffff",
                    &t.Rep.Matrix.m11, &t.Rep.Matrix.m12, &t.Rep.Matrix.m13,
                    &t.Rep.Matrix.m21, &t.Rep.Matrix.m22, &t.Rep.Matrix.m23,
                    &t.Rep.Matrix.m31, &t.Rep.Matrix.m32, &t.Rep.Matrix.m33,
                    &t.Rep.Matrix.x,   &t.Rep.Matrix.y,   &t.Rep.Matrix.z);
        break;
    }
}

void PolygonMesh::setTextureSpaces(const vector<TextureSpace>& t)
{
    vRef<Vobject> tsobj;
    try {
        tsobj = findObject("a3dl:texturespaces");
    } catch(NoSuchObjectError) {
        vRef<Site> s = getSite();
        tsobj = s->createMetaObject("a3dl:texturespaces", typeid(Property).name(), 0);
        LocalProperty* lp = meta_cast<LocalProperty*>(&tsobj);
        if(!lp) throw bad_cast();
        lp->insertPropertyAccessControl(-1, accesscontrol);
        insertChild(-1, "a3dl:texturespaces", &tsobj);
    }
    Property* pr = meta_cast<Property*>(&tsobj);
    if(!pr) return;
    unsigned char* data = (unsigned char*)malloc(t.size() * 50);
    memset(data, 0, t.size() * 50);
    for(unsigned int i = 0; i < t.size(); i++) {
        packTextureSpace(data + i*50, t[i]);
    }
    pr->replace(string((char*)data, t.size() * 50), "packed/texture-space-array");
    free(data);
}



void PolygonMesh::getTextureSpaces(vector<TextureSpace>& t)
{
    string data;

    vRef<Vobject> tris = findObject("a3dl:texturespaces");
    Property* pr = meta_cast<Property*>(&tris);
    if(!pr) return;
    pr->read(data);

    if(pr->getDataType() == "packed/texture-space-array") {
        int numts = data.size() / 50;
        t.resize(numts);
        for(int i = 0; i < numts; i++) {
            unpackTextureSpace((unsigned char*)data.c_str() + i*50, t[i]);
        }
    }
}

void PolygonMesh::setTextureSpace(unsigned int which, const TextureSpace& t)
{
    string data;

    vRef<Vobject> vert = findObject("a3dl:texturespaces");
    Property* pr = meta_cast<Property*>(&vert);
    if(!pr) return;
    pr->read(data);

    unsigned char* newdata;
    int newdatasize;
    if(which * 50 > data.size()) {
        int existingVerts = data.size() / 50;
        int needNew = which - existingVerts;
        newdatasize = (needNew + 1) * 50;
        newdata = (unsigned char*)malloc(newdatasize);
        for(int i = 0; i < needNew; i++) {
            memset(newdata + i*50, 0, 50);
        }
    } else {
        newdata = (unsigned char*)malloc(50);
        newdatasize = 50;
    }

    packTextureSpace(newdata + newdatasize - 50, t);

    if(which * 50 > data.size()) pr->write(data.size(), string((char*)newdata, newdatasize));
    else pr->write(which * 50, string((char*)newdata, newdatasize));
    free(newdata);
}


void PolygonMesh::setDoubleSided(bool ds)
{
    Property::setProperty(*this, "a3dl:doublesided", ds ? "yes" : "no", "text/x-yes-no", accesscontrol);
}

bool PolygonMesh::getDoubleSided()
{
    try {
        vRef<Vobject> prop = findObject("a3dl:doublesided");
        Property& pr = meta_cast<Property&>(*prop);
        return (pr.read() == "yes");
    } catch(...) {
        return false;
    }
}

vector<Portal*> PolygonMesh::getPortals()
{
    vector<Portal*> t;
    const ChildList& cl = getChildren();
    for(unsigned int i = 0; i < cl.size(); i++) {
        if(cl[i]->contextual_name == "a3dl:portal") {
            if(Portal* p = meta_cast<Portal*>(cl[i]->child)) t.push_back(p);
        }
    }
    return t;
}


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

const string PolygonMesh::getType()
{
    return "a3dl:object3D.polygonmesh";
}

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

---