Tamito Kajiyama
ec78eb353f
on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
767 lines
22 KiB
C++
767 lines
22 KiB
C++
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2010 Blender Foundation.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/** \file blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
|
|
* \ingroup freestyle
|
|
*/
|
|
|
|
#include <assert.h>
|
|
|
|
#include "BlenderFileLoader.h"
|
|
|
|
#include "BKE_global.h"
|
|
|
|
BlenderFileLoader::BlenderFileLoader(Render *re, SceneRenderLayer* srl)
|
|
{
|
|
_re = re;
|
|
_srl = srl;
|
|
_Scene = NULL;
|
|
_numFacesRead = 0;
|
|
_minEdgeSize = DBL_MAX;
|
|
_smooth = (srl->freestyleConfig.flags & FREESTYLE_FACE_SMOOTHNESS_FLAG) != 0;
|
|
}
|
|
|
|
BlenderFileLoader::~BlenderFileLoader()
|
|
{
|
|
_Scene = NULL;
|
|
}
|
|
|
|
NodeGroup* BlenderFileLoader::Load()
|
|
{
|
|
ObjectInstanceRen *obi;
|
|
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
cout << "\n=== Importing triangular meshes into Blender ===" << endl;
|
|
}
|
|
|
|
// creation of the scene root node
|
|
_Scene = new NodeGroup;
|
|
|
|
_viewplane_left = _re->viewplane.xmin;
|
|
_viewplane_right = _re->viewplane.xmax;
|
|
_viewplane_bottom = _re->viewplane.ymin;
|
|
_viewplane_top = _re->viewplane.ymax;
|
|
_z_near = -_re->clipsta;
|
|
_z_far = -_re->clipend;
|
|
#if 0
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
cout << "Frustum: l " << _viewplane_left << " r " << _viewplane_right
|
|
<< " b " << _viewplane_bottom << " t " << _viewplane_top
|
|
<< " n " << _z_near << " f " << _z_far << endl;
|
|
}
|
|
#endif
|
|
|
|
int id = 0;
|
|
for (obi = (ObjectInstanceRen *)_re->instancetable.first; obi; obi = obi->next) {
|
|
if (_pRenderMonitor && _pRenderMonitor->testBreak())
|
|
break;
|
|
if (!(obi->lay & _srl->lay))
|
|
continue;
|
|
char *name = obi->ob->id.name;
|
|
//cout << name[0] << name[1] << ":" << (name+2) <<;
|
|
//print_m4("obi->mat", obi->mat);
|
|
|
|
if (obi->obr->totvlak > 0) {
|
|
insertShapeNode(obi, ++id);
|
|
}
|
|
else if (G.debug & G_DEBUG_FREESTYLE) {
|
|
cout << "Warning: " << (name + 2) << " is not a vlak-based object (ignored)" << endl;
|
|
}
|
|
}
|
|
|
|
// Return the built scene.
|
|
return _Scene;
|
|
}
|
|
|
|
#define CLIPPED_BY_NEAR -1
|
|
#define NOT_CLIPPED 0
|
|
#define CLIPPED_BY_FAR 1
|
|
|
|
// check if each vertex of a triangle (V1, V2, V3) is clipped by the near/far plane
|
|
// and calculate the number of triangles to be generated by clipping
|
|
int BlenderFileLoader::countClippedFaces(float v1[3], float v2[3], float v3[3], int clip[3])
|
|
{
|
|
float *v[3];
|
|
int numClipped, sum, numTris;
|
|
|
|
v[0] = v1;
|
|
v[1] = v2;
|
|
v[2] = v3;
|
|
numClipped = sum = 0;
|
|
for (int i = 0; i < 3; i++) {
|
|
if (v[i][2] > _z_near) {
|
|
clip[i] = CLIPPED_BY_NEAR;
|
|
numClipped++;
|
|
}
|
|
else if (v[i][2] < _z_far) {
|
|
clip[i] = CLIPPED_BY_FAR;
|
|
numClipped++;
|
|
}
|
|
else {
|
|
clip[i] = NOT_CLIPPED;
|
|
}
|
|
#if 0
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("%d %s\n", i, (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
|
|
}
|
|
#endif
|
|
sum += clip[i];
|
|
}
|
|
switch (numClipped) {
|
|
case 0:
|
|
numTris = 1; // triangle
|
|
break;
|
|
case 1:
|
|
numTris = 2; // tetragon
|
|
break;
|
|
case 2:
|
|
if (sum == 0)
|
|
numTris = 3; // pentagon
|
|
else
|
|
numTris = 1; // triangle
|
|
break;
|
|
case 3:
|
|
if (sum == 3 || sum == -3)
|
|
numTris = 0;
|
|
else
|
|
numTris = 2; // tetragon
|
|
break;
|
|
}
|
|
return numTris;
|
|
}
|
|
|
|
// find the intersection point C between the line segment from V1 to V2 and
|
|
// a clipping plane at depth Z (i.e., the Z component of C is known, while
|
|
// the X and Y components are unknown).
|
|
void BlenderFileLoader::clipLine(float v1[3], float v2[3], float c[3], float z)
|
|
{
|
|
// Order v1 and v2 by Z values to make sure that clipLine(P, Q, c, z)
|
|
// and clipLine(Q, P, c, z) gives exactly the same numerical result.
|
|
float *p, *q;
|
|
if (v1[2] < v2[2]) {
|
|
p = v1;
|
|
q = v2;
|
|
}
|
|
else {
|
|
p = v2;
|
|
q = v1;
|
|
}
|
|
double d[3];
|
|
for (int i = 0; i < 3; i++)
|
|
d[i] = q[i] - p[i];
|
|
double t = (z - p[2]) / d[2];
|
|
c[0] = p[0] + t * d[0];
|
|
c[1] = p[1] + t * d[1];
|
|
c[2] = z;
|
|
}
|
|
|
|
// clip the triangle (V1, V2, V3) by the near and far clipping plane and
|
|
// obtain a set of vertices after the clipping. The number of vertices
|
|
// is at most 5.
|
|
void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3],
|
|
float triNormals[][3], float n1[3], float n2[3], float n3[3],
|
|
bool edgeMarks[], bool em1, bool em2, bool em3, int clip[3])
|
|
{
|
|
float *v[3], *n[3];
|
|
bool em[3];
|
|
int i, j, k;
|
|
|
|
v[0] = v1; n[0] = n1;
|
|
v[1] = v2; n[1] = n2;
|
|
v[2] = v3; n[2] = n3;
|
|
em[0] = em1; /* edge mark of the edge between v1 and v2 */
|
|
em[1] = em2; /* edge mark of the edge between v2 and v3 */
|
|
em[2] = em3; /* edge mark of the edge between v3 and v1 */
|
|
k = 0;
|
|
for (i = 0; i < 3; i++) {
|
|
j = (i + 1) % 3;
|
|
if (clip[i] == NOT_CLIPPED) {
|
|
copy_v3_v3(triCoords[k], v[i]);
|
|
copy_v3_v3(triNormals[k], n[i]);
|
|
edgeMarks[k] = em[i];
|
|
k++;
|
|
if (clip[j] != NOT_CLIPPED) {
|
|
clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
|
|
copy_v3_v3(triNormals[k], n[j]);
|
|
edgeMarks[k] = false;
|
|
k++;
|
|
}
|
|
}
|
|
else if (clip[i] != clip[j]) {
|
|
if (clip[j] == NOT_CLIPPED) {
|
|
clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
|
|
copy_v3_v3(triNormals[k], n[i]);
|
|
edgeMarks[k] = em[i];
|
|
k++;
|
|
}
|
|
else {
|
|
clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
|
|
copy_v3_v3(triNormals[k], n[i]);
|
|
edgeMarks[k] = em[i];
|
|
k++;
|
|
clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
|
|
copy_v3_v3(triNormals[k], n[j]);
|
|
edgeMarks[k] = false;
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
assert(k == 2 + numTris);
|
|
}
|
|
|
|
void BlenderFileLoader::addTriangle(struct LoaderState *ls, float v1[3], float v2[3], float v3[3],
|
|
float n1[3], float n2[3], float n3[3],
|
|
bool fm, bool em1, bool em2, bool em3)
|
|
{
|
|
float *fv[3], *fn[3], len;
|
|
unsigned int i, j;
|
|
IndexedFaceSet::FaceEdgeMark marks = 0;
|
|
|
|
// initialize the bounding box by the first vertex
|
|
if (ls->currentIndex == 0) {
|
|
copy_v3_v3(ls->minBBox, v1);
|
|
copy_v3_v3(ls->maxBBox, v1);
|
|
}
|
|
|
|
fv[0] = v1; fn[0] = n1;
|
|
fv[1] = v2; fn[1] = n2;
|
|
fv[2] = v3; fn[2] = n3;
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
copy_v3_v3(ls->pv, fv[i]);
|
|
copy_v3_v3(ls->pn, fn[i]);
|
|
|
|
// update the bounding box
|
|
for (j = 0; j < 3; j++) {
|
|
if (ls->minBBox[j] > ls->pv[j])
|
|
ls->minBBox[j] = ls->pv[j];
|
|
|
|
if (ls->maxBBox[j] < ls->pv[j])
|
|
ls->maxBBox[j] = ls->pv[j];
|
|
}
|
|
|
|
len = len_v3v3(fv[i], fv[(i + 1) % 3]);
|
|
if (_minEdgeSize > len)
|
|
_minEdgeSize = len;
|
|
|
|
*ls->pvi = ls->currentIndex;
|
|
*ls->pni = ls->currentIndex;
|
|
*ls->pmi = ls->currentMIndex;
|
|
|
|
ls->currentIndex += 3;
|
|
ls->pv += 3;
|
|
ls->pn += 3;
|
|
|
|
ls->pvi++;
|
|
ls->pni++;
|
|
ls->pmi++;
|
|
}
|
|
|
|
if (fm)
|
|
marks |= IndexedFaceSet::FACE_MARK;
|
|
if (em1)
|
|
marks |= IndexedFaceSet::EDGE_MARK_V1V2;
|
|
if (em2)
|
|
marks |= IndexedFaceSet::EDGE_MARK_V2V3;
|
|
if (em3)
|
|
marks |= IndexedFaceSet::EDGE_MARK_V3V1;
|
|
*(ls->pm++) = marks;
|
|
}
|
|
|
|
// With A, B and P indicating the three vertices of a given triangle, returns:
|
|
// 1 if points A and B are in the same position in the 3D space;
|
|
// 2 if the distance between point P and line segment AB is zero; and
|
|
// zero otherwise.
|
|
int BlenderFileLoader::testDegenerateTriangle(float v1[3], float v2[3], float v3[3])
|
|
{
|
|
#if 0
|
|
float area = area_tri_v3(v1, v2, v3);
|
|
bool verbose = (area < 1.0e-6);
|
|
#endif
|
|
|
|
if (equals_v3v3(v1, v2) || equals_v3v3(v2, v3) || equals_v3v3(v1, v3)) {
|
|
#if 0
|
|
if (verbose && G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("BlenderFileLoader::testDegenerateTriangle = 1\n");
|
|
}
|
|
#endif
|
|
return 1;
|
|
}
|
|
if (dist_to_line_segment_v3(v1, v2, v3) < 1.0e-6 ||
|
|
dist_to_line_segment_v3(v2, v1, v3) < 1.0e-6 ||
|
|
dist_to_line_segment_v3(v3, v1, v2) < 1.0e-6)
|
|
{
|
|
#if 0
|
|
if (verbose && G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("BlenderFileLoader::testDegenerateTriangle = 2\n");
|
|
}
|
|
#endif
|
|
return 2;
|
|
}
|
|
#if 0
|
|
if (verbose && G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("BlenderFileLoader::testDegenerateTriangle = 0\n");
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
// Checks if edge rotation (if necessary) can prevent the given quad from
|
|
// being decomposed into a degenerate triangle
|
|
bool BlenderFileLoader::testEdgeRotation(float v1[3], float v2[3], float v3[3], float v4[3])
|
|
{
|
|
if (testDegenerateTriangle(v1, v2, v3) == 2 || testDegenerateTriangle(v1, v3, v4) == 2) {
|
|
if (testDegenerateTriangle(v1, v2, v4) == 2 || testDegenerateTriangle(v2, v3, v4) == 2) {
|
|
#if 0
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("BlenderFileLoader::testEdgeRotation: edge rotation is unsuccessful.\n");
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void BlenderFileLoader::insertShapeNode(ObjectInstanceRen *obi, int id)
|
|
{
|
|
ObjectRen *obr = obi->obr;
|
|
char *name = obi->ob->id.name + 2;
|
|
|
|
// We parse vlak nodes and count the number of faces after the clipping by
|
|
// the near and far view planes is applied (Note: mesh vertices are in the
|
|
// camera coordinate system).
|
|
VlakRen *vlr;
|
|
unsigned numFaces = 0;
|
|
float v1[3], v2[3], v3[3], v4[3];
|
|
float n1[3], n2[3], n3[3], n4[3], facenormal[3];
|
|
int clip_1[3], clip_2[3];
|
|
int wire_material = 0;
|
|
for (int a = 0; a < obr->totvlak; a++) {
|
|
if ((a & 255) == 0)
|
|
vlr = obr->vlaknodes[a>>8].vlak;
|
|
else
|
|
vlr++;
|
|
if (vlr->mat->material_type == MA_TYPE_WIRE) {
|
|
wire_material = 1;
|
|
continue;
|
|
}
|
|
copy_v3_v3(v1, vlr->v1->co);
|
|
copy_v3_v3(v2, vlr->v2->co);
|
|
copy_v3_v3(v3, vlr->v3->co);
|
|
if (vlr->v4)
|
|
copy_v3_v3(v4, vlr->v4->co);
|
|
if (obi->flag & R_TRANSFORMED) {
|
|
mul_m4_v3(obi->mat, v1);
|
|
mul_m4_v3(obi->mat, v2);
|
|
mul_m4_v3(obi->mat, v3);
|
|
if (vlr->v4)
|
|
mul_m4_v3(obi->mat, v4);
|
|
}
|
|
#if 0
|
|
print_v3("v1", v1);
|
|
print_v3("v2", v2);
|
|
print_v3("v3", v3);
|
|
if (vlr->v4)
|
|
print_v3("v4", v4);
|
|
#endif
|
|
if (!vlr->v4 || !testEdgeRotation(v1, v2, v3, v4)) {
|
|
numFaces += countClippedFaces(v1, v2, v3, clip_1);
|
|
if (vlr->v4)
|
|
numFaces += countClippedFaces(v1, v3, v4, clip_2);
|
|
}
|
|
else {
|
|
numFaces += countClippedFaces(v1, v2, v4, clip_1);
|
|
numFaces += countClippedFaces(v2, v3, v4, clip_2);
|
|
}
|
|
}
|
|
if (wire_material) {
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
cout << "Warning: Object " << name << " has wire materials (ignored)" << endl;
|
|
}
|
|
}
|
|
#if 0
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
cout << "numFaces " << numFaces << endl;
|
|
}
|
|
#endif
|
|
if (numFaces == 0)
|
|
return;
|
|
|
|
// We allocate memory for the meshes to be imported
|
|
NodeTransform *currentMesh = new NodeTransform;
|
|
NodeShape *shape = new NodeShape;
|
|
|
|
unsigned vSize = 3 * 3 * numFaces;
|
|
float *vertices = new float[vSize];
|
|
unsigned nSize = vSize;
|
|
float *normals = new float[nSize];
|
|
unsigned *numVertexPerFaces = new unsigned[numFaces];
|
|
vector<FrsMaterial> meshFrsMaterials;
|
|
|
|
IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
|
|
unsigned i;
|
|
for (i = 0; i <numFaces; i++) {
|
|
faceStyle[i] = IndexedFaceSet::TRIANGLES;
|
|
numVertexPerFaces[i] = 3;
|
|
}
|
|
|
|
IndexedFaceSet::FaceEdgeMark *faceEdgeMarks = new IndexedFaceSet::FaceEdgeMark[numFaces];
|
|
|
|
unsigned viSize = 3 * numFaces;
|
|
unsigned *VIndices = new unsigned[viSize];
|
|
unsigned niSize = viSize;
|
|
unsigned *NIndices = new unsigned[niSize];
|
|
unsigned *MIndices = new unsigned[viSize]; // Material Indices
|
|
|
|
struct LoaderState ls;
|
|
ls.pv = vertices;
|
|
ls.pn = normals;
|
|
ls.pm = faceEdgeMarks;
|
|
ls.pvi = VIndices;
|
|
ls.pni = NIndices;
|
|
ls.pmi = MIndices;
|
|
ls.currentIndex = 0;
|
|
ls.currentMIndex = 0;
|
|
|
|
FrsMaterial tmpMat;
|
|
|
|
// We parse the vlak nodes again and import meshes while applying the clipping
|
|
// by the near and far view planes.
|
|
int p;
|
|
for (p = 0; p < obr->totvlak; ++p) { // we parse the faces of the mesh
|
|
#if 0
|
|
Lib3dsFace *f = &mesh->faceL[p];
|
|
Lib3dsMaterial *mat = NULL;
|
|
#endif
|
|
if ((p & 255) == 0)
|
|
vlr = obr->vlaknodes[p>>8].vlak;
|
|
else
|
|
vlr++;
|
|
copy_v3_v3(v1, vlr->v1->co);
|
|
copy_v3_v3(v2, vlr->v2->co);
|
|
copy_v3_v3(v3, vlr->v3->co);
|
|
if (vlr->v4)
|
|
copy_v3_v3(v4, vlr->v4->co);
|
|
if (obi->flag & R_TRANSFORMED) {
|
|
mul_m4_v3(obi->mat, v1);
|
|
mul_m4_v3(obi->mat, v2);
|
|
mul_m4_v3(obi->mat, v3);
|
|
if (vlr->v4)
|
|
mul_m4_v3(obi->mat, v4);
|
|
}
|
|
if (_smooth && (vlr->flag & R_SMOOTH)) {
|
|
copy_v3_v3(n1, vlr->v1->n);
|
|
copy_v3_v3(n2, vlr->v2->n);
|
|
copy_v3_v3(n3, vlr->v3->n);
|
|
if (vlr->v4)
|
|
copy_v3_v3(n4, vlr->v4->n);
|
|
if (obi->flag & R_TRANSFORMED) {
|
|
mul_m3_v3(obi->nmat, n1);
|
|
mul_m3_v3(obi->nmat, n2);
|
|
mul_m3_v3(obi->nmat, n3);
|
|
normalize_v3(n1);
|
|
normalize_v3(n2);
|
|
normalize_v3(n3);
|
|
if (vlr->v4) {
|
|
mul_m3_v3(obi->nmat, n4);
|
|
normalize_v3(n4);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
RE_vlakren_get_normal(_re, obi, vlr, facenormal);
|
|
copy_v3_v3(n1, facenormal);
|
|
copy_v3_v3(n2, facenormal);
|
|
copy_v3_v3(n3, facenormal);
|
|
if (vlr->v4)
|
|
copy_v3_v3(n4, facenormal);
|
|
}
|
|
|
|
unsigned int numTris_1, numTris_2;
|
|
bool edge_rotation;
|
|
if (!vlr->v4 || !testEdgeRotation(v1, v2, v3, v4)) {
|
|
numTris_1 = countClippedFaces(v1, v2, v3, clip_1);
|
|
numTris_2 = (!vlr->v4) ? 0 : countClippedFaces(v1, v3, v4, clip_2);
|
|
edge_rotation = false;
|
|
}
|
|
else {
|
|
numTris_1 = countClippedFaces(v1, v2, v4, clip_1);
|
|
numTris_2 = countClippedFaces(v2, v3, v4, clip_2);
|
|
edge_rotation = true;
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("BlenderFileLoader::insertShapeNode: edge rotation is performed.\n");
|
|
}
|
|
}
|
|
if (numTris_1 == 0 && numTris_2 == 0)
|
|
continue;
|
|
bool fm, em1, em2, em3, em4;
|
|
fm = (vlr->flag & ME_FREESTYLE_FACE) != 0;
|
|
em1 = (vlr->freestyle_edge_mark & R_EDGE_V1V2) != 0;
|
|
em2 = (vlr->freestyle_edge_mark & R_EDGE_V2V3) != 0;
|
|
if (!vlr->v4) {
|
|
em3 = (vlr->freestyle_edge_mark & R_EDGE_V3V1) != 0;
|
|
em4 = false;
|
|
}
|
|
else {
|
|
em3 = (vlr->freestyle_edge_mark & R_EDGE_V3V4) != 0;
|
|
em4 = (vlr->freestyle_edge_mark & R_EDGE_V4V1) != 0;
|
|
}
|
|
|
|
Material *mat = vlr->mat;
|
|
if (mat) {
|
|
tmpMat.setDiffuse(mat->r, mat->g, mat->b, mat->alpha);
|
|
tmpMat.setSpecular(mat->specr, mat->specg, mat->specb, mat->spectra);
|
|
float s = 1.0 * (mat->har + 1) / 4 ; // in Blender: [1;511] => in OpenGL: [0;128]
|
|
if (s > 128.f)
|
|
s = 128.f;
|
|
tmpMat.setShininess(s);
|
|
}
|
|
|
|
if (meshFrsMaterials.empty()) {
|
|
meshFrsMaterials.push_back(tmpMat);
|
|
shape->setFrsMaterial(tmpMat);
|
|
}
|
|
else {
|
|
// find if the material is aleady in the list
|
|
unsigned int i = 0;
|
|
bool found = false;
|
|
|
|
for (vector<FrsMaterial>::iterator it = meshFrsMaterials.begin(), itend = meshFrsMaterials.end();
|
|
it != itend;
|
|
it++, i++)
|
|
{
|
|
if (*it == tmpMat) {
|
|
ls.currentMIndex = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
meshFrsMaterials.push_back(tmpMat);
|
|
ls.currentMIndex = meshFrsMaterials.size() - 1;
|
|
}
|
|
}
|
|
|
|
float triCoords[5][3], triNormals[5][3];
|
|
bool edgeMarks[5]; // edgeMarks[i] is for the edge between i-th and (i+1)-th vertices
|
|
|
|
if (numTris_1 > 0) {
|
|
if (!edge_rotation) {
|
|
clipTriangle(numTris_1, triCoords, v1, v2, v3, triNormals, n1, n2, n3,
|
|
edgeMarks, em1, em2, (!vlr->v4) ? em3 : false, clip_1);
|
|
}
|
|
else {
|
|
clipTriangle(numTris_1, triCoords, v1, v2, v4, triNormals, n1, n2, n4,
|
|
edgeMarks, em1, false, em4, clip_1);
|
|
}
|
|
for (i = 0; i < numTris_1; i++) {
|
|
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2],
|
|
triNormals[0], triNormals[i+1], triNormals[i+2],
|
|
fm, (i == 0) ? edgeMarks[0] : false, edgeMarks[i+1],
|
|
(i == numTris_1 - 1) ? edgeMarks[i+2] : false);
|
|
_numFacesRead++;
|
|
}
|
|
}
|
|
|
|
if (numTris_2 > 0) {
|
|
if (!edge_rotation) {
|
|
clipTriangle(numTris_2, triCoords, v1, v3, v4, triNormals, n1, n3, n4,
|
|
edgeMarks, false, em3, em4, clip_2);
|
|
}
|
|
else {
|
|
clipTriangle(numTris_2, triCoords, v2, v3, v4, triNormals, n2, n3, n4,
|
|
edgeMarks, em2, em3, false, clip_2);
|
|
}
|
|
for (i = 0; i < numTris_2; i++) {
|
|
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2],
|
|
triNormals[0], triNormals[i+1], triNormals[i+2],
|
|
fm, (i == 0) ? edgeMarks[0] : false, edgeMarks[i+1],
|
|
(i == numTris_2 - 1) ? edgeMarks[i+2] : false);
|
|
_numFacesRead++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We might have several times the same vertex. We want a clean
|
|
// shape with no real-vertex. Here, we are making a cleaning pass.
|
|
real *cleanVertices = NULL;
|
|
unsigned int cvSize;
|
|
unsigned int *cleanVIndices = NULL;
|
|
|
|
GeomCleaner::CleanIndexedVertexArray(vertices, vSize, VIndices, viSize, &cleanVertices, &cvSize, &cleanVIndices);
|
|
|
|
real *cleanNormals = NULL;
|
|
unsigned int cnSize;
|
|
unsigned int *cleanNIndices = NULL;
|
|
|
|
GeomCleaner::CleanIndexedVertexArray(normals, nSize, NIndices, niSize, &cleanNormals, &cnSize, &cleanNIndices);
|
|
|
|
// format materials array
|
|
FrsMaterial** marray = new FrsMaterial*[meshFrsMaterials.size()];
|
|
unsigned int mindex = 0;
|
|
for (vector<FrsMaterial>::iterator m = meshFrsMaterials.begin(), mend = meshFrsMaterials.end();
|
|
m!=mend;
|
|
++m)
|
|
{
|
|
marray[mindex] = new FrsMaterial(*m);
|
|
++mindex;
|
|
}
|
|
|
|
// deallocates memory:
|
|
delete [] vertices;
|
|
delete [] normals;
|
|
delete [] VIndices;
|
|
delete [] NIndices;
|
|
|
|
// Fix for degenerated triangles
|
|
// A degenerate triangle is a triangle such that
|
|
// 1) A and B are in the same position in the 3D space; or
|
|
// 2) the distance between point P and line segment AB is zero.
|
|
// Only those degenerate triangles in the second form are resolved here
|
|
// by adding a small offset to P, whereas those in the first form are
|
|
// addressed later in WShape::MakeFace().
|
|
vector<detri_t> detriList;
|
|
Vec3r zero(0.0, 0.0, 0.0);
|
|
unsigned vi0, vi1, vi2;
|
|
for (i = 0; i < viSize; i += 3) {
|
|
detri_t detri;
|
|
vi0 = cleanVIndices[i];
|
|
vi1 = cleanVIndices[i+1];
|
|
vi2 = cleanVIndices[i+2];
|
|
Vec3r v0(cleanVertices[vi0], cleanVertices[vi0+1], cleanVertices[vi0+2]);
|
|
Vec3r v1(cleanVertices[vi1], cleanVertices[vi1+1], cleanVertices[vi1+2]);
|
|
Vec3r v2(cleanVertices[vi2], cleanVertices[vi2+1], cleanVertices[vi2+2]);
|
|
if (v0 == v1 || v0 == v2 || v1 == v2) {
|
|
continue; // do nothing for now
|
|
}
|
|
else if (GeomUtils::distPointSegment<Vec3r>(v0, v1, v2) < 1.0e-6) {
|
|
detri.viP = vi0;
|
|
detri.viA = vi1;
|
|
detri.viB = vi2;
|
|
}
|
|
else if (GeomUtils::distPointSegment<Vec3r>(v1, v0, v2) < 1.0e-6) {
|
|
detri.viP = vi1;
|
|
detri.viA = vi0;
|
|
detri.viB = vi2;
|
|
}
|
|
else if (GeomUtils::distPointSegment<Vec3r>(v2, v0, v1) < 1.0e-6) {
|
|
detri.viP = vi2;
|
|
detri.viA = vi0;
|
|
detri.viB = vi1;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
|
|
detri.v = zero;
|
|
detri.n = 0;
|
|
for (unsigned int j = 0; j < viSize; j += 3) {
|
|
if (i == j)
|
|
continue;
|
|
vi0 = cleanVIndices[j];
|
|
vi1 = cleanVIndices[j+1];
|
|
vi2 = cleanVIndices[j+2];
|
|
Vec3r v0(cleanVertices[vi0], cleanVertices[vi0+1], cleanVertices[vi0+2]);
|
|
Vec3r v1(cleanVertices[vi1], cleanVertices[vi1+1], cleanVertices[vi1+2]);
|
|
Vec3r v2(cleanVertices[vi2], cleanVertices[vi2+1], cleanVertices[vi2+2]);
|
|
if (detri.viP == vi0 && (detri.viA == vi1 || detri.viB == vi1)) {
|
|
detri.v += (v2 - v0);
|
|
detri.n++;
|
|
}
|
|
else if (detri.viP == vi0 && (detri.viA == vi2 || detri.viB == vi2)) {
|
|
detri.v += (v1 - v0);
|
|
detri.n++;
|
|
}
|
|
else if (detri.viP == vi1 && (detri.viA == vi0 || detri.viB == vi0)) {
|
|
detri.v += (v2 - v1);
|
|
detri.n++;
|
|
}
|
|
else if (detri.viP == vi1 && (detri.viA == vi2 || detri.viB == vi2)) {
|
|
detri.v += (v0 - v1);
|
|
detri.n++;
|
|
}
|
|
else if (detri.viP == vi2 && (detri.viA == vi0 || detri.viB == vi0)) {
|
|
detri.v += (v1 - v2);
|
|
detri.n++;
|
|
}
|
|
else if (detri.viP == vi2 && (detri.viA == vi1 || detri.viB == vi1)) {
|
|
detri.v += (v0 - v2);
|
|
detri.n++;
|
|
}
|
|
}
|
|
if (detri.n > 0) {
|
|
detri.v.normalizeSafe();
|
|
}
|
|
detriList.push_back(detri);
|
|
}
|
|
|
|
if (detriList.size() > 0) {
|
|
vector<detri_t>::iterator v;
|
|
for (v = detriList.begin(); v != detriList.end(); v++) {
|
|
detri_t detri = (*v);
|
|
if (detri.n == 0) {
|
|
cleanVertices[detri.viP] = cleanVertices[detri.viA];
|
|
cleanVertices[detri.viP+1] = cleanVertices[detri.viA+1];
|
|
cleanVertices[detri.viP+2] = cleanVertices[detri.viA+2];
|
|
}
|
|
else if (detri.v.norm() > 0.0) {
|
|
cleanVertices[detri.viP] += 1.0e-5 * detri.v.x();
|
|
cleanVertices[detri.viP+1] += 1.0e-5 * detri.v.y();
|
|
cleanVertices[detri.viP+2] += 1.0e-5 * detri.v.z();
|
|
}
|
|
}
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("Warning: Object %s contains %lu degenerated triangle%s (strokes may be incorrect)\n",
|
|
name, detriList.size(), (detriList.size() > 1) ? "s" : "");
|
|
}
|
|
}
|
|
|
|
// Create the IndexedFaceSet with the retrieved attributes
|
|
IndexedFaceSet *rep;
|
|
rep = new IndexedFaceSet(cleanVertices, cvSize, cleanNormals, cnSize, marray, meshFrsMaterials.size(), 0, 0,
|
|
numFaces, numVertexPerFaces, faceStyle, faceEdgeMarks, cleanVIndices, viSize,
|
|
cleanNIndices, niSize, MIndices, viSize, 0, 0, 0);
|
|
// sets the id of the rep
|
|
rep->setId(Id(id, 0));
|
|
rep->setName(obi->ob->id.name + 2);
|
|
|
|
const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(ls.minBBox[0], ls.minBBox[1], ls.minBBox[2]),
|
|
Vec3r(ls.maxBBox[0], ls.maxBBox[1], ls.maxBBox[2]));
|
|
rep->setBBox(bbox);
|
|
shape->AddRep(rep);
|
|
|
|
Matrix44r meshMat = Matrix44r::identity();
|
|
currentMesh->setMatrix(meshMat);
|
|
currentMesh->Translate(0, 0, 0);
|
|
|
|
currentMesh->AddChild(shape);
|
|
_Scene->AddChild(currentMesh);
|
|
}
|