archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
1234b55330f533ea9e52cd65ff8f9eda37808c6f
blender-archive/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp

428 lines
11 KiB
C++
Raw Normal View History

soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
#include "BlenderFileLoader.h"
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
#include <assert.h>
SUMMARY: Freestyle's pipeline is now fully controllable at the layer level. It can be used: - in any render layer - with as many style modules per layer DETAILS: Freestyle usage has not changed: - all the configuration happens in the "Freestyle" render panel, after it is enabled in the "Output" panel with the 'Freestyle' toggle. - each render layer can choose to render Freestyle strokes by togglingo on 'FrSt' (in the "Render Layers" panel) - it is fully compatible with compositor nodes In the "Freestyle" panel, a render layer is selected via the menu list next to the "Render Layer:" label. The options displayed below are those of the currently selected render layer (and are not global to all render layers, as was previously the case). Style modules are added by pressing the lower button "Add style module". Once added, the following operations are possible: - deletion (cross) - reordering (up/down arrows) - toggling of display (check) The order of the style modules follows Freestyle's original convention: the modules in the list from top to bottom are respectively the first to the last composited in the render layer. For example, if the module list is "contour" followed by "cartoon", the "cartoon" strokes are rendered on top of the "contour" strokes. The "Freestyle" panel is constantly synchronized with the "Render Layers" panel: if render layers are added, deleted or toggled off display, Freestyle will take note of the changes. The current pipeline works as follows: ---------------------------------------------------------------------------------------------- for every scene that is being rendered if Freestyle is enabled globally Freestyle is initialized camera and view settings are transferred from Blender to Freestyle for every render layer if: - layer is enabled - layer enabled Freestyle - the number of displayed style modules is non-zero canvas is cleared geometry is transferred from Blender to Freestyle settings are fixed for current iteration view map is calculated strokes are computed in the canvas (based on view map and style modules) strokes are rendered in separate Blender scene scene is composited in current layer ---------------------------------------------------------------------------------------------- A number of changes were made on the codebase: - the rendering interface between Freestyle and Blender was simplified. The following naming convention was used: functions that are called from within Blender pipeline are prefixed with 'FRS_', while the variables are prefixed with 'freestyle_' - Freestyle data structures that were put in Blender's render pipeline were removed - Freestyle cleans up its data structures on Blender exit and shouldn't leak memory - to ease the configuration in the "Freestyle" panel, a centralized configuration data structure was used and can be easily extended LIMITATIONS Even though the current commit is stable and achieves the intended result, it is not as efficient as it could be: - the canvas and the style modules are at cleared at each layer-level render - geometry is reloaded at each frame and is duplicated across render layers This revision clarifies my understanding of the future role of the view map in the compositor. Unfortunately, contrary to what the original proposal said, it is impossible to provide the view map as a render pass because render passes are defined (RE_pipeline.h) as raw floating-point rects. We will have to determine whether or not to extend the notion of render pass to fully integrate the view map in the compositor.
2009-04-07 18:38:23 +00:00
BlenderFileLoader::BlenderFileLoader(Render *re, SceneRenderLayer* srl)
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
{
_re = re;
SUMMARY: Freestyle's pipeline is now fully controllable at the layer level. It can be used: - in any render layer - with as many style modules per layer DETAILS: Freestyle usage has not changed: - all the configuration happens in the "Freestyle" render panel, after it is enabled in the "Output" panel with the 'Freestyle' toggle. - each render layer can choose to render Freestyle strokes by togglingo on 'FrSt' (in the "Render Layers" panel) - it is fully compatible with compositor nodes In the "Freestyle" panel, a render layer is selected via the menu list next to the "Render Layer:" label. The options displayed below are those of the currently selected render layer (and are not global to all render layers, as was previously the case). Style modules are added by pressing the lower button "Add style module". Once added, the following operations are possible: - deletion (cross) - reordering (up/down arrows) - toggling of display (check) The order of the style modules follows Freestyle's original convention: the modules in the list from top to bottom are respectively the first to the last composited in the render layer. For example, if the module list is "contour" followed by "cartoon", the "cartoon" strokes are rendered on top of the "contour" strokes. The "Freestyle" panel is constantly synchronized with the "Render Layers" panel: if render layers are added, deleted or toggled off display, Freestyle will take note of the changes. The current pipeline works as follows: ---------------------------------------------------------------------------------------------- for every scene that is being rendered if Freestyle is enabled globally Freestyle is initialized camera and view settings are transferred from Blender to Freestyle for every render layer if: - layer is enabled - layer enabled Freestyle - the number of displayed style modules is non-zero canvas is cleared geometry is transferred from Blender to Freestyle settings are fixed for current iteration view map is calculated strokes are computed in the canvas (based on view map and style modules) strokes are rendered in separate Blender scene scene is composited in current layer ---------------------------------------------------------------------------------------------- A number of changes were made on the codebase: - the rendering interface between Freestyle and Blender was simplified. The following naming convention was used: functions that are called from within Blender pipeline are prefixed with 'FRS_', while the variables are prefixed with 'freestyle_' - Freestyle data structures that were put in Blender's render pipeline were removed - Freestyle cleans up its data structures on Blender exit and shouldn't leak memory - to ease the configuration in the "Freestyle" panel, a centralized configuration data structure was used and can be easily extended LIMITATIONS Even though the current commit is stable and achieves the intended result, it is not as efficient as it could be: - the canvas and the style modules are at cleared at each layer-level render - geometry is reloaded at each frame and is duplicated across render layers This revision clarifies my understanding of the future role of the view map in the compositor. Unfortunately, contrary to what the original proposal said, it is impossible to provide the view map as a render pass because render passes are defined (RE_pipeline.h) as raw floating-point rects. We will have to determine whether or not to extend the notion of render pass to fully integrate the view map in the compositor.
2009-04-07 18:38:23 +00:00
_srl = srl;
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
_Scene = NULL;
_numFacesRead = 0;
_minEdgeSize = DBL_MAX;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
BlenderFileLoader::~BlenderFileLoader()
{
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
_Scene = NULL;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
NodeGroup* BlenderFileLoader::Load()
{
ObjectInstanceRen *obi;
improved Freestyle IO formatting
2008-12-10 22:06:27 +00:00
cout << "\n=== Importing triangular meshes into Blender ===" << endl;
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
Fixed a bug in SilhouetteGeomEngine::ImageToWorldParameter() that caused instability issues regarding the view map creation. A new iterative solver of the 2D-to-3D inverse projection transformation problem was implemented. Instead of directly solving the problem in the direction from the 2D to 3D space, the new solver starts with an initial guess of an approximated solution and asymptotically approaches to the true solution by iteratively performing the forward 3D-to-2D projection transformation and improving the approximation. Preliminary tests with one simple and another complex scenes showed that the solver converges quickly (more and less 20 iterations in many cases, with a stopping criterion of a residual distance between the true and approximated solutions less than 1e-6 Blender Unit).
2010-01-10 14:08:59 +00:00
// 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;
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
_z_near= -_re->clipsta;
_z_far= -_re->clipend;
Fixed a bug in SilhouetteGeomEngine::ImageToWorldParameter() that caused instability issues regarding the view map creation. A new iterative solver of the 2D-to-3D inverse projection transformation problem was implemented. Instead of directly solving the problem in the direction from the 2D to 3D space, the new solver starts with an initial guess of an approximated solution and asymptotically approaches to the true solution by iteratively performing the forward 3D-to-2D projection transformation and improving the approximation. Preliminary tests with one simple and another complex scenes showed that the solver converges quickly (more and less 20 iterations in many cases, with a stopping criterion of a residual distance between the true and approximated solutions less than 1e-6 Blender Unit).
2010-01-10 14:08:59 +00:00
#if 0
cout << "frustrum: l " << _viewplane_left << " r " << _viewplane_right
<< " b " << _viewplane_bottom << " t " << _viewplane_top
<< " n " << _z_near << " f " << _z_far << endl;
#endif
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
int id = 0;
for(obi= (ObjectInstanceRen *) _re->instancetable.first; obi; obi=obi->next) {
SUMMARY: Freestyle's pipeline is now fully controllable at the layer level. It can be used: - in any render layer - with as many style modules per layer DETAILS: Freestyle usage has not changed: - all the configuration happens in the "Freestyle" render panel, after it is enabled in the "Output" panel with the 'Freestyle' toggle. - each render layer can choose to render Freestyle strokes by togglingo on 'FrSt' (in the "Render Layers" panel) - it is fully compatible with compositor nodes In the "Freestyle" panel, a render layer is selected via the menu list next to the "Render Layer:" label. The options displayed below are those of the currently selected render layer (and are not global to all render layers, as was previously the case). Style modules are added by pressing the lower button "Add style module". Once added, the following operations are possible: - deletion (cross) - reordering (up/down arrows) - toggling of display (check) The order of the style modules follows Freestyle's original convention: the modules in the list from top to bottom are respectively the first to the last composited in the render layer. For example, if the module list is "contour" followed by "cartoon", the "cartoon" strokes are rendered on top of the "contour" strokes. The "Freestyle" panel is constantly synchronized with the "Render Layers" panel: if render layers are added, deleted or toggled off display, Freestyle will take note of the changes. The current pipeline works as follows: ---------------------------------------------------------------------------------------------- for every scene that is being rendered if Freestyle is enabled globally Freestyle is initialized camera and view settings are transferred from Blender to Freestyle for every render layer if: - layer is enabled - layer enabled Freestyle - the number of displayed style modules is non-zero canvas is cleared geometry is transferred from Blender to Freestyle settings are fixed for current iteration view map is calculated strokes are computed in the canvas (based on view map and style modules) strokes are rendered in separate Blender scene scene is composited in current layer ---------------------------------------------------------------------------------------------- A number of changes were made on the codebase: - the rendering interface between Freestyle and Blender was simplified. The following naming convention was used: functions that are called from within Blender pipeline are prefixed with 'FRS_', while the variables are prefixed with 'freestyle_' - Freestyle data structures that were put in Blender's render pipeline were removed - Freestyle cleans up its data structures on Blender exit and shouldn't leak memory - to ease the configuration in the "Freestyle" panel, a centralized configuration data structure was used and can be easily extended LIMITATIONS Even though the current commit is stable and achieves the intended result, it is not as efficient as it could be: - the canvas and the style modules are at cleared at each layer-level render - geometry is reloaded at each frame and is duplicated across render layers This revision clarifies my understanding of the future role of the view map in the compositor. Unfortunately, contrary to what the original proposal said, it is impossible to provide the view map as a render pass because render passes are defined (RE_pipeline.h) as raw floating-point rects. We will have to determine whether or not to extend the notion of render pass to fully integrate the view map in the compositor.
2009-04-07 18:38:23 +00:00
if (!(obi->lay & _re->scene->lay & _srl->lay))
Fixed an issue regarding render layers. Now the Freestyle renderer builds a view map based on selected object layers in a render layer, instead of the global selection of object layers. This allows, for example, to have two render layers, one for rendering solid faces in all object layers, and the other for rendering outlines of objects in selected object layers by Freestyle. At the moment, the number of Freestyle-enabled render layers is restricted to one -- a better fix is in the future work.
2009-03-02 03:30:59 +00:00
continue;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
char *name = obi->ob->id.name;
//cout << name[0] << name[1] << ":" << (name+2) <<;
//print_m4("obi->mat", obi->mat);
Fixed an issue regarding render layers. Now the Freestyle renderer builds a view map based on selected object layers in a render layer, instead of the global selection of object layers. This allows, for example, to have two render layers, one for rendering solid faces in all object layers, and the other for rendering outlines of objects in selected object layers by Freestyle. At the moment, the number of Freestyle-enabled render layers is restricted to one -- a better fix is in the future work.
2009-03-02 03:30:59 +00:00
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
if( obi->obr->totvlak > 0)
insertShapeNode(obi, ++id);
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
else
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
cout << "Warning: " << (name+2) << " is not a vlak-based object (ignored)" << endl;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
Fixed a bug in SilhouetteGeomEngine::ImageToWorldParameter() that caused instability issues regarding the view map creation. A new iterative solver of the 2D-to-3D inverse projection transformation problem was implemented. Instead of directly solving the problem in the direction from the 2D to 3D space, the new solver starts with an initial guess of an approximated solution and asymptotically approaches to the true solution by iteratively performing the forward 3D-to-2D projection transformation and improving the approximation. Preliminary tests with one simple and another complex scenes showed that the solver converges quickly (more and less 20 iterations in many cases, with a stopping criterion of a residual distance between the true and approximated solutions less than 1e-6 Blender Unit).
2010-01-10 14:08:59 +00:00
//Returns the built scene.
return _Scene;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
#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
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
int BlenderFileLoader::countClippedFaces(float v1[3], float v2[3], float v3[3], int clip[3])
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
{
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
float *v[3];
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
int numClipped, sum, numTris;
v[0] = v1;
v[1] = v2;
v[2] = v3;
numClipped = sum = 0;
for (int i = 0; i < 3; i++) {
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
if (v[i][2] > _z_near) {
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
clip[i] = CLIPPED_BY_NEAR;
numClipped++;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
} else if (v[i][2] < _z_far) {
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
clip[i] = CLIPPED_BY_FAR;
numClipped++;
} else {
clip[i] = NOT_CLIPPED;
}
// printf("%d %s\n", i, (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
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).
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
void BlenderFileLoader::clipLine(float v1[3], float v2[3], float c[3], float z)
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
{
double d[3];
for (int i = 0; i < 3; i++)
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
d[i] = v2[i] - v1[i];
double t = (z - v1[2]) / d[2];
c[0] = v1[0] + t * d[0];
c[1] = v1[1] + t * d[1];
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
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.
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3], int clip[3])
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
{
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
float *v[3];
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
int i, j, k;
v[0] = v1;
v[1] = v2;
v[2] = v3;
k = 0;
for (i = 0; i < 3; i++) {
j = (i + 1) % 3;
if (clip[i] == NOT_CLIPPED) {
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
copy_v3_v3(triCoords[k++], v[i]);
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
if (clip[j] != NOT_CLIPPED) {
clipLine(v[i], v[j], triCoords[k++], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
}
} 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);
} else {
clipLine(v[i], v[j], triCoords[k++], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
clipLine(v[i], v[j], triCoords[k++], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
}
}
}
assert (k == 2 + numTris);
}
void BlenderFileLoader::addTriangle(struct LoaderState *ls, float v1[3], float v2[3], float v3[3])
{
float v12[3], v13[3], n[3];
float *fv[3], len;
unsigned i, j;
// initialize the bounding box by the first vertex
if (ls->currentIndex == 0) {
copy_v3_v3(ls->minBBox, v1);
copy_v3_v3(ls->maxBBox, v1);
}
// compute the normal of the triangle
sub_v3_v3v3(v12, v1, v2);
sub_v3_v3v3(v13, v1, v3);
cross_v3_v3v3(n, v12, v13);
normalize_v3(n);
fv[0] = v1;
fv[1] = v2;
fv[2] = v3;
for (i = 0; i < 3; i++) {
copy_v3_v3(ls->pv, fv[i]);
copy_v3_v3(ls->pn, n);
// 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++;
}
}
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
void BlenderFileLoader::insertShapeNode(ObjectInstanceRen *obi, int id)
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
{
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
ObjectRen *obr = obi->obr;
Improvements of mesh importing. Previously mesh vertices imported from vlak nodes were transformed from the camera coordinate system to the object local coordinate system. This causes a difficulty in recovering object local vertices when mesh deforming modifiers (e.g., curve, cloth, and soft body) have been applied. Now the view map creation is done based on mesh vertices in the camera coordinate system. Advantages of this approach includes: 1) faster mesh importing because of less matrix-based transformations; and 2) proper handling of meshes with deforming modifiers.
2010-01-30 01:36:12 +00:00
// 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).
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
VlakRen *vlr;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
unsigned numFaces = 0;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
float v1[3], v2[3], v3[3], v4[3];
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
int clip_1[3], clip_2[3];
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
for(int a=0; a < obr->totvlak; a++) {
if((a & 255)==0) vlr= obr->vlaknodes[a>>8].vlak;
else vlr++;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
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);
}
// print_v3("v1", v1);
// print_v3("v2", v2);
// print_v3("v3", v3);
// if (vlr->v4) print_v3("v4", v4);
numFaces += countClippedFaces(v1, v2, v3, clip_1);
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
if (vlr->v4)
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
numFaces += countClippedFaces(v1, v3, v4, clip_2);
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
// cout <<"numFaces " <<numFaces<<endl;
if (numFaces == 0)
return;
Improvements of mesh importing. Previously mesh vertices imported from vlak nodes were transformed from the camera coordinate system to the object local coordinate system. This causes a difficulty in recovering object local vertices when mesh deforming modifiers (e.g., curve, cloth, and soft body) have been applied. Now the view map creation is done based on mesh vertices in the camera coordinate system. Advantages of this approach includes: 1) faster mesh importing because of less matrix-based transformations; and 2) proper handling of meshes with deforming modifiers.
2010-01-30 01:36:12 +00:00
// We allocate memory for the meshes to be imported
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
NodeTransform *currentMesh = new NodeTransform;
NodeShape * shape = new NodeShape;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
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;
}
unsigned viSize = 3*numFaces;
unsigned *VIndices = new unsigned[viSize];
unsigned niSize = viSize;
unsigned *NIndices = new unsigned[niSize];
unsigned *MIndices = new unsigned[viSize]; // Material Indices
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
struct LoaderState ls;
ls.pv = vertices;
ls.pn = normals;
ls.pvi = VIndices;
ls.pni = NIndices;
ls.pmi = MIndices;
ls.currentIndex = 0;
ls.currentMIndex = 0;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
FrsMaterial tmpMat;
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
Improvements of mesh importing. Previously mesh vertices imported from vlak nodes were transformed from the camera coordinate system to the object local coordinate system. This causes a difficulty in recovering object local vertices when mesh deforming modifiers (e.g., curve, cloth, and soft body) have been applied. Now the view map creation is done based on mesh vertices in the camera coordinate system. Advantages of this approach includes: 1) faster mesh importing because of less matrix-based transformations; and 2) proper handling of meshes with deforming modifiers.
2010-01-30 01:36:12 +00:00
// We parse the vlak nodes again and import meshes while applying the clipping
// by the near and far view planes.
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
int p;
for(p=0; p < obr->totvlak; ++p) // we parse the faces of the mesh
{
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
// Lib3dsFace *f=&mesh->faceL[p];
// Lib3dsMaterial *mat=0;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
if((p & 255)==0) vlr = obr->vlaknodes[p>>8].vlak;
else vlr++;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
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);
}
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
unsigned numTris_1, numTris_2;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
numTris_1 = countClippedFaces(v1, v2, v3, clip_1);
numTris_2 = (vlr->v4) ? countClippedFaces(v1, v3, v4, clip_2) : 0;
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
if (numTris_1 == 0 && numTris_2 == 0)
continue;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
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 i=0;
bool found = false;
for(vector<FrsMaterial>::iterator it=meshFrsMaterials.begin(), itend=meshFrsMaterials.end();
it!=itend;
++it){
if(*it == tmpMat){
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
ls.currentMIndex = i;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
found = true;
break;
}
++i;
}
if(!found){
meshFrsMaterials.push_back(tmpMat);
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
ls.currentMIndex = meshFrsMaterials.size()-1;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
}
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
float triCoords[5][3];
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
if (numTris_1 > 0) {
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
clipTriangle(numTris_1, triCoords, v1, v2, v3, clip_1);
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
for (i = 0; i < numTris_1; i++) {
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2]);
_numFacesRead++;
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
}
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
}
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
if (numTris_2 > 0) {
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +00:00
clipTriangle(numTris_2, triCoords, v1, v3, v4, clip_2);
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
for (i = 0; i < numTris_2; i++) {
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2]);
_numFacesRead++;
soc-2008-mxcurioni: finished removing lib3ds. Freestyle now runs correctly within Blender without using a 3ds import format. Most shapes tested work, the only exception being strands and halos.
2008-08-08 08:25:50 +00:00
}
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
}
}
// 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 cvSize;
unsigned *cleanVIndices = NULL;
GeomCleaner::CleanIndexedVertexArray(
vertices, vSize,
VIndices, viSize,
&cleanVertices, &cvSize,
&cleanVIndices);
real *cleanNormals = NULL;
unsigned cnSize;
unsigned *cleanNIndices = NULL;
GeomCleaner::CleanIndexedVertexArray(
normals, nSize,
NIndices, niSize,
&cleanNormals, &cnSize,
&cleanNIndices);
// format materials array
FrsMaterial** marray = new FrsMaterial*[meshFrsMaterials.size()];
unsigned 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;
// Create the IndexedFaceSet with the retrieved attributes
Improvements of mesh importing. Previously mesh vertices imported from vlak nodes were transformed from the camera coordinate system to the object local coordinate system. This causes a difficulty in recovering object local vertices when mesh deforming modifiers (e.g., curve, cloth, and soft body) have been applied. Now the view map creation is done based on mesh vertices in the camera coordinate system. Advantages of this approach includes: 1) faster mesh importing because of less matrix-based transformations; and 2) proper handling of meshes with deforming modifiers.
2010-01-30 01:36:12 +00:00
IndexedFaceSet *rep;
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
rep = new IndexedFaceSet(cleanVertices, cvSize,
cleanNormals, cnSize,
marray, meshFrsMaterials.size(),
0, 0,
numFaces, numVertexPerFaces, faceStyle,
cleanVIndices, viSize,
cleanNIndices, niSize,
MIndices, viSize,
0,0,
0);
// sets the id of the rep
rep->setId(Id(id, 0));
Clipping of imported meshes by the near and far view planes. A straightforward clipping algorithm was implemented to eliminate vertices that are out of the interval from the near to far clipping distance defined by the active camera. Previously, objects that come behind the camera could lead to a crash. The changes in this commit is intended to address this issue. When meshes are partially clipped, new edges are added. These edges can result in visible strokes if they are within the camera view.
2010-01-24 23:12:57 +00:00
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]));
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
rep->setBBox(bbox);
shape->AddRep(rep);
soc-2008-mxcurioni: corrected matrix used to import meshes. Despite providing the exact same information (verified by the same bounding box and grid), the ViewMap does not have any view edge yet. The lib3ds-less iteration does NOT work yet.
2008-08-07 16:15:10 +00:00
Matrix44r meshMat = Matrix44r::identity();
currentMesh->setMatrix(meshMat);
soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to be debugged. It can be activate in app_blender/api.cpp by replacing the FRS_scene_3ds_export call in FRS_prepare, by FRS_load_mesh. All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.
2008-08-07 15:04:25 +00:00
currentMesh->Translate(0,0,0);
currentMesh->AddChild(shape);
_Scene->AddChild(currentMesh);
}
Copy Permalink