MeshObjectData.cpp

Go to the documentation of this file.

 
#include  "MeshObjectData.h"
 
 
using namespace jbxl;
 
 
// MeshObjectData クラス
//
 
void  MeshObjectData::init(const char* name)
{
    data_name    = make_Buffer_str(name);
    alt_name     = make_Buffer_str(name);
    canonical_filename_Buffer(&data_name, TRUE);
    canonical_filename_Buffer(&alt_name,  TRUE);
 
    ttl_index    = 0;
    ttl_vertex   = 0;
    ttl_texcrd   = 0;
    num_node     = 0;
    num_vcount   = 3;
 
    facet        = NULL;
    facet_end    = NULL;
    affineTrans  = NULL;
 
    num_import   = 0;
    impvtx_value = NULL;
    impnrm_value = NULL;
    impmap_value = NULL;
    impwgt_value = NULL;
}
 
 
void  MeshObjectData::free(void)
{
    free_Buffer(&data_name);
    free_Buffer(&alt_name);
    free_value();
 
    delAffineTrans();
 
    freeMeshFacetList(facet);
    facet = facet_end = NULL;
}
 
 
void  MeshObjectData::free_value(void)
{
    freeNull(impvtx_value);
    freeNull(impnrm_value);
    freeNull(impmap_value);
    freeArrayParams<int>(impwgt_value, num_import);
 
    impvtx_value = NULL;
    impnrm_value = NULL;
    impmap_value = NULL;
    impwgt_value = NULL;
}
 
 
void  MeshObjectData::clear(void)
{
    this->free();
    init();
}
 
 
bool  MeshObjectData::addData(ContourBaseData* contours, MaterialParam* param)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for ContourBaseData: start.\n");
    char* name = NULL;
    if (param!=NULL) name = param->getParamString();
 
    bool ret = addNode(contours, name, param);
    if (ret && param!=NULL) facet_end->setMaterialParam(*param);    // Materialデータを追加
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for ContourBaseData: end.\n");
    return ret;
}
 
 
bool  MeshObjectData::addData(Vector<double>* vct, Vector<double>* nrm, UVMap<double>* map, ArrayParam<int>* wgt, int vnum, MaterialParam* param, bool useBrep)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for Vector<>: start.\n");
    bool ret = importTriData(vct, nrm, map, wgt, vnum);
    if (ret) {
        char* name = NULL;
        if (param!=NULL) name = param->getParamString();
        ret = addNode(name, param, useBrep);
    }
    if (ret && param!=NULL) facet_end->setMaterialParam(*param);    // Materialデータを追加
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for Vector<>: end.\n");
    return ret;
}
 
 
bool  MeshObjectData::addData(TriPolygonData* tridata, int tnum, int pnum, MaterialParam* param, bool useBrep)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for TriPolygonData: start.\n");
 
    bool ret = importTriData(tridata, tnum, pnum);
    if (ret) {
        char* name = NULL;
        if (param!=NULL) name = param->getParamString();
        ret = addNode(name, param, useBrep);
    }
    //
    if (ret) {
        if (pnum>=0)     facet_end->setFacetNo(pnum);
        if (param!=NULL) facet_end->setMaterialParam(*param);       // Materialデータを追加
    }
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::addData(): for TriPolygonData: end.\n");
    return ret;
}
 
 
bool  MeshObjectData::importTriData(Vector<double>* vct, Vector<double>* nrm, UVMap<double>* map, ArrayParam<int>* wgt, int vnum)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::importTriData: for Vector<>: start.\n");
    if (vct==NULL) return false;
    //
    free_value();
 
    int lsize = sizeof(Vector<double>)*vnum;
 
    // Vertex Position
    if (impvtx_value!=NULL) freeNull(impvtx_value);
    impvtx_value = (Vector<double>*)malloc(lsize);
    if (impvtx_value!=NULL) {
        memcpy(impvtx_value, vct, lsize);
    }
    else return false;
 
    // Normal Vector
    if (nrm!=NULL) {
        if (impnrm_value!=NULL) freeNull(impnrm_value);
        impnrm_value = (Vector<double>*)malloc(lsize);
        if (impnrm_value!=NULL) {
            memcpy(impnrm_value, nrm, lsize);
        }
        else {
            freeNull(impvtx_value);
            return false;
        }
    }
 
    // UV Map
    if (map!=NULL) {
        int msize = sizeof(UVMap<double>)*vnum;
        if (impmap_value!=NULL) freeNull(impmap_value);
        impmap_value = (UVMap<double>*)malloc(msize);
        if (impmap_value!=NULL) {
            memcpy(impmap_value, map, msize);
        }
        else {
            freeNull(impvtx_value);
            freeNull(impnrm_value);
            return false;
        }
    }
 
    // Vertex Weight (option)
    if (wgt!=NULL) {
        if (impwgt_value!=NULL) freeArrayParams<int>(impwgt_value, num_import);
        int wsize = sizeof(ArrayParam<int>)*vnum;
        impwgt_value = (ArrayParam<int>*)malloc(wsize);
        if (impwgt_value!=NULL) {
            memset(impwgt_value, 0, wsize);
            for (int i=0; i<vnum; i++) {
                impwgt_value[i].dup(wgt[i]);
            }
        }
    }
 
    //
    num_vcount = 3;         // Contour（ポリゴン）を形成する頂点数
    num_import = vnum;      // 総頂点数
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::importTriData: for Vector<>: end.\n");
    return true;
}
 
 
bool  MeshObjectData::importTriData(TriPolygonData* tridata, int tnum, int pnum)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::importTriData: for TriPolygonData: start.\n");
    if (tridata==NULL) return false;
 
    free_value();
 
    int num = 0;
    if (pnum>=0) {
        for (int i=0; i<tnum; i++) {
            if (tridata[i].polygonNum==pnum) num++;
        }
        if (num==0) return false;
    }
    else num = tnum;
 
    int vnum  = num*3;
    int lsize = sizeof(Vector<double>)*vnum;
 
    // Vertex Position
    if (impvtx_value!=NULL) freeNull(impvtx_value);
    impvtx_value = (Vector<double>*)malloc(lsize);
    if (impvtx_value!=NULL) {
        int n = 0;
        for (int i=0; i<tnum; i++) {
            if (tridata[i].polygonNum==pnum || pnum<0) {
                impvtx_value[n*3]   = tridata[i].vertex[0];
                impvtx_value[n*3+1] = tridata[i].vertex[1];
                impvtx_value[n*3+2] = tridata[i].vertex[2];
                n++;
            }
        }
    }
    else return false;
 
    // Normal Vector
    if (impnrm_value!=NULL) freeNull(impnrm_value);
    if (tridata[0].has_normal) {
        impnrm_value = (Vector<double>*)malloc(lsize);
        if (impnrm_value!=NULL) {
            int n = 0;
            for (int i=0; i<tnum; i++) {
                if (tridata[i].polygonNum==pnum || pnum<0) {
                    impnrm_value[n*3]   = tridata[i].normal[0];
                    impnrm_value[n*3+1] = tridata[i].normal[1];
                    impnrm_value[n*3+2] = tridata[i].normal[2];
                    n++;
                }
            }
        }
        else {
            freeNull(impvtx_value);
            return false;
        }
    }
 
    // UV Map
    if (impmap_value!=NULL) freeNull(impmap_value);
    if (tridata[0].has_texcrd) {
        int msize = sizeof(UVMap<double>)*vnum;
        impmap_value = (UVMap<double>*)malloc(msize);
        if (impmap_value!=NULL) {
            int n = 0;
            for (int i=0; i<tnum; i++) {
                if (tridata[i].polygonNum==pnum || pnum<0) {
                    impmap_value[n*3]   = tridata[i].texcrd[0];
                    impmap_value[n*3+1] = tridata[i].texcrd[1];
                    impmap_value[n*3+2] = tridata[i].texcrd[2];
                    n++;
                }
            }
        }
        else {
            freeNull(impvtx_value);
            freeNull(impnrm_value);
            return false;
        }
 
    }
 
    // Vertex Weight (option)
    if (impwgt_value!=NULL) freeArrayParams<int>(impwgt_value, num_import);
    if (tridata[0].has_weight) {
        int wsize = sizeof(ArrayParam<int>)*vnum;
        impwgt_value = (ArrayParam<int>*)malloc(wsize);
        if (impwgt_value!=NULL) {
            memset(impwgt_value, 0, vnum);
            for (int i=0, n=0; i<tnum; i++) {
                if (tridata[i].polygonNum==pnum || pnum<0) {
                    impwgt_value[n*3]  .dup(tridata[i].weight[0], false);
                    impwgt_value[n*3+1].dup(tridata[i].weight[1], false);
                    impwgt_value[n*3+2].dup(tridata[i].weight[2], false);
                    n++;
                }
            }
        }
    }
 
    //
    num_vcount = 3;         // Contour（ポリゴン）を形成する頂点数
    num_import = vnum;      // 総頂点数
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::importTriData: for TriPolygonData (%d): end.\n", vnum);
    return true;
}
 
 
bool  MeshObjectData::addNode(ContourBaseData* facetdata, const char* name, MaterialParam* param)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::addNode(): for ContourBaseData: start.\n");
    bool ret = false;
 
    MeshFacetNode* node = new MeshFacetNode();
    if (node==NULL) return ret;
    //
    if (param!=NULL) node->setMaterialParam(*param);
    node->setMaterialID(name);
    
    ret = node->computeVertexDirect(facetdata);
 
    if (ret) {
        if (facet==NULL) facet = facet_end = node;
        else             facet_end = AddMeshFacetNode(facet_end, node);
        num_node++;
        ttl_index  += node->num_index;
        ttl_vertex += node->num_vertex;
        ttl_texcrd += node->num_texcrd;
    }
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::addNode(): for ContourBaseData: end.\n");
    return ret;
}
 
 
bool  MeshObjectData::addNode(const char* name, MaterialParam* param, bool useBrep)
{
    DEBUG_MODE PRINT_MESG("MeshObjectData::addNode(): for TriPolygonData or Vector<>: start.\n");
 
    bool ret = false;
    if (impvtx_value==NULL) return ret;
 
    MeshFacetNode* node = new MeshFacetNode();
    if (node==NULL) return ret;
    //
    if (param!=NULL) node->setMaterialParam(*param);
    node->setMaterialID(name);
 
    if (useBrep) {
        ret = node->computeVertexByBREP(impvtx_value, impnrm_value, impmap_value, impwgt_value, num_import, num_vcount);
    }
    else {
        ret = node->computeVertexDirect(impvtx_value, impnrm_value, impmap_value, impwgt_value, num_import, num_vcount);
    }
    if (ret) {
        if (facet==NULL) facet = facet_end = node;
        else             facet_end = AddMeshFacetNode(facet_end, node);
        num_node++;
        ttl_index  += node->num_index;
        ttl_vertex += node->num_vertex;
        ttl_texcrd += node->num_texcrd;
    }
    //
    freeNull(impvtx_value);
    freeNull(impnrm_value);
    freeNull(impmap_value);
    freeArrayParams<int>(impwgt_value, node->num_vertex);
    impwgt_value = NULL;
 
    DEBUG_MODE PRINT_MESG("MeshObjectData::addNode(): for TriPolygonData or Vector<>: end.\n");
    return ret;
}
 
 
void  MeshObjectData::setMaterialParam(MaterialParam param, int num)
{
    MeshFacetNode* node = facet;
 
    if (num>=0) {
        while (node!=NULL) {
            if (node->facet_no==num) {
                node->setMaterialParam(param);
                node->setMaterialID(param.getParamString());
                return;
            }
            node = node->next;
        }
    }
    else {
        while (node!=NULL) {
            if (!node->material_param.enable) {
                node->setMaterialParam(param);
                node->setMaterialID(param.getParamString());
                return;
            }
            node = node->next;
        }
    }
    return;
}
 
 
void  MeshObjectData::joinData(MeshObjectData*& data)
{
    if (data==NULL) return;
 
    ttl_index  += data->ttl_index;
    ttl_vertex += data->ttl_vertex;
    ttl_texcrd += data->ttl_texcrd;
    num_node   += data->num_node;
 
    if (facet_end==NULL) {   //  最初のデータ
        setAffineTrans(*data->affineTrans);
        facet = data->facet;
        facet_end = data->facet_end;
    }
    else if (data->facet!=NULL) {
        facet_end->next = data->facet;
        data->facet->prev = facet_end;
        facet_end = data->facet_end;
    }
 
    data->facet = NULL;
    freeMeshObjectData(data);
 
    return;
}