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
e9eed190e83eb351aeb435d21287eaf37fcffeb0
blender-archive/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp

665 lines
20 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;
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
_smooth = (srl->freestyleConfig.flags & FREESTYLE_FACE_SMOOTHNESS_FLAG) != 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
}
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
{
Fix for duplicated feature edges due to a numerical instability of line clipping by near/far Z planes. Problem report by vicentecarro together with a .blend file to reproduce the issue, thanks!
2011-11-20 19:03:52 +00:00
// 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;
}
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++)
Fix for duplicated feature edges due to a numerical instability of line clipping by near/far Z planes. Problem report by vicentecarro together with a .blend file to reproduce the issue, thanks!
2011-11-20 19:03:52 +00:00
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];
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.
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3],
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
float triNormals[][3], float n1[3], float n2[3], float n3[3],
bool edgeMarks[], bool em1, bool em2, bool em3, 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
{
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
float *v[3], *n[3];
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
bool em[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;
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
v[0] = v1; n[0] = n1;
v[1] = v2; n[1] = n2;
v[2] = v3; n[2] = n3;
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
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 */
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
k = 0;
for (i = 0; i < 3; i++) {
j = (i + 1) % 3;
if (clip[i] == NOT_CLIPPED) {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
copy_v3_v3(triCoords[k], v[i]);
copy_v3_v3(triNormals[k], n[i]);
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
edgeMarks[k] = em[i];
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
k++;
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) {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
copy_v3_v3(triNormals[k], n[j]);
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
edgeMarks[k] = false;
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
k++;
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
}
} else if (clip[i] != clip[j]) {
if (clip[j] == NOT_CLIPPED) {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
copy_v3_v3(triNormals[k], n[i]);
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
edgeMarks[k] = em[i];
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
k++;
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
} else {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
copy_v3_v3(triNormals[k], n[i]);
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
edgeMarks[k] = em[i];
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
k++;
clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
copy_v3_v3(triNormals[k], n[j]);
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
edgeMarks[k] = false;
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
k++;
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
}
}
}
assert (k == 2 + numTris);
}
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
void BlenderFileLoader::addTriangle(struct LoaderState *ls, float v1[3], float v2[3], float v3[3],
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
float n1[3], float n2[3], float n3[3],
bool fm, bool em1, bool em2, bool em3)
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
{
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
float *fv[3], *fn[3], len;
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 i, j;
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
IndexedFaceSet::FaceEdgeMark marks = 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
// initialize the bounding box by the first vertex
if (ls->currentIndex == 0) {
copy_v3_v3(ls->minBBox, v1);
copy_v3_v3(ls->maxBBox, v1);
}
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
fv[0] = v1; fn[0] = n1;
fv[1] = v2; fn[1] = n2;
fv[2] = v3; fn[2] = n3;
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 < 3; i++) {
copy_v3_v3(ls->pv, fv[i]);
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
copy_v3_v3(ls->pn, fn[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
// 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++;
}
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
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;
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
}
Another possible fix for degenerate triangles in imported mesh data. A motivating example of the problem the present solution aims to address is a quad face such that three of the four vertices are colinear (i.e., they are lying on a line). Depending on how this quad is separated into two triangles, one of them can be a degenerate triangle. Degenerate triangles of this form are easy to avoid by rotating the diagonal edge of quad faces without affecting the visual outcome. The fix implemented in this commit tries to address degenerate triangles in this way.
2012-03-05 19:01:12 +00:00
// 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])
{
//float area = area_tri_v3(v1, v2, v3);
//bool verbose = (area < 1e-6);
if (equals_v3v3(v1, v2) || equals_v3v3(v2, v3) || equals_v3v3(v1, v3)) {
//if (verbose) printf("BlenderFileLoader::testDegenerateTriangle = 1\n");
return 1;
}
if (dist_to_line_segment_v3(v1, v2, v3) < 1e-6 ||
dist_to_line_segment_v3(v2, v1, v3) < 1e-6 ||
dist_to_line_segment_v3(v3, v1, v2) < 1e-6) {
//if (verbose) printf("BlenderFileLoader::testDegenerateTriangle = 2\n");
return 2;
}
//if (verbose) printf("BlenderFileLoader::testDegenerateTriangle = 0\n");
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) {
//printf("BlenderFileLoader::testEdgeRotation: edge rotation is unsuccessful.\n");
return false;
}
return true;
}
return false;
}
Fix for a compilation error with GCC 4.6 (Linux and MinGW32). Problem report by Bastien Montagne, thanks!
2012-03-03 12:01:14 +00:00
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;
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
char *name = obi->ob->id.name+2;
Added support for procedural duplication (such as DupliVerts and DupliFaces).
2010-02-19 01:10:04 +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 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];
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
float n1[3], n2[3], n3[3], n4[3], facenormal[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];
Fix for a crash due to materials of the wire type. Now all faces having wire materials are simply ignored and a warning message is displayed.
2010-06-03 15:06:23 +00:00
int wire_material = 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
for(int a=0; a < obr->totvlak; a++) {
if((a & 255)==0) vlr= obr->vlaknodes[a>>8].vlak;
else vlr++;
Fix for a crash due to materials of the wire type. Now all faces having wire materials are simply ignored and a warning message is displayed.
2010-06-03 15:06:23 +00:00
if (vlr->mat->material_type == MA_TYPE_WIRE) {
wire_material = 1;
continue;
}
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);
Another possible fix for degenerate triangles in imported mesh data. A motivating example of the problem the present solution aims to address is a quad face such that three of the four vertices are colinear (i.e., they are lying on a line). Depending on how this quad is separated into two triangles, one of them can be a degenerate triangle. Degenerate triangles of this form are easy to avoid by rotating the diagonal edge of quad faces without affecting the visual outcome. The fix implemented in this commit tries to address degenerate triangles in this way.
2012-03-05 19:01:12 +00:00
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);
}
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
}
Fix for a crash due to materials of the wire type. Now all faces having wire materials are simply ignored and a warning message is displayed.
2010-06-03 15:06:23 +00:00
if (wire_material)
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
printf("Warning: Object %s has wire materials (ignored)\n", name);
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;
}
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
IndexedFaceSet::FaceEdgeMark *faceEdgeMarks = new IndexedFaceSet::FaceEdgeMark[numFaces];
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 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;
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
ls.pm = faceEdgeMarks;
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.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);
}
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
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);
Fix for incorrect vertex normals in the case of smooth faces with the R_TRANSFORMED flag enabled. Now vertex normals are properly transformed by ObjectInstanceRen::nmat[3][3] and normalized. It is noted that in the case of R_TRANSFORMED flat faces, surface normals are transformed and normalized by RE_vlakren_get_normal(). The bug was reported by Stéphane Grabli via personal communication. Thank you Stéphane for the careful code review!
2010-12-12 13:16:35 +00:00
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);
}
}
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
} 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);
}
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;
Another possible fix for degenerate triangles in imported mesh data. A motivating example of the problem the present solution aims to address is a quad face such that three of the four vertices are colinear (i.e., they are lying on a line). Depending on how this quad is separated into two triangles, one of them can be a degenerate triangle. Degenerate triangles of this form are easy to avoid by rotating the diagonal edge of quad faces without affecting the visual outcome. The fix implemented in this commit tries to address degenerate triangles in this way.
2012-03-05 19:01:12 +00:00
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;
printf("BlenderFileLoader::insertShapeNode: edge rotation is performed.\n");
}
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;
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
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;
}
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: 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
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
float triCoords[5][3], triNormals[5][3];
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
bool edgeMarks[5]; // edgeMarks[i] is for the edge between i-th and (i+1)-th vertices
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) {
Another possible fix for degenerate triangles in imported mesh data. A motivating example of the problem the present solution aims to address is a quad face such that three of the four vertices are colinear (i.e., they are lying on a line). Depending on how this quad is separated into two triangles, one of them can be a degenerate triangle. Degenerate triangles of this form are easy to avoid by rotating the diagonal edge of quad faces without affecting the visual outcome. The fix implemented in this commit tries to address degenerate triangles in this way.
2012-03-05 19:01:12 +00:00
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);
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++) {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2],
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
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);
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
_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) {
Another possible fix for degenerate triangles in imported mesh data. A motivating example of the problem the present solution aims to address is a quad face such that three of the four vertices are colinear (i.e., they are lying on a line). Depending on how this quad is separated into two triangles, one of them can be a degenerate triangle. Degenerate triangles of this form are easy to avoid by rotating the diagonal edge of quad faces without affecting the visual outcome. The fix implemented in this commit tries to address degenerate triangles in this way.
2012-03-05 19:01:12 +00:00
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);
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++) {
New option for taking account of face smoothness in view map calculation. With this option disabled, the smoothness of faces is ignored and jagged feature edges (when seen from a three-dimensional viewpoint) are generated. If the new option is enabled, face smoothness is taken into account during the view map calculation, resulting in smooth feature edges in 3D. This generally leads to more stable strokes, and also permits more stylization possibilities relying on the feature edge smoothness in 3D. The downside of smooth feature edges is that the visibility is mathematically not well-defined and may cause some artefact in rendering results. The new option is thus intended to allow users to try both jagged and smooth feature edges and see which ones would fit individual application needs. This option is disabled by default.
2010-11-27 11:23:11 +00:00
addTriangle(&ls, triCoords[0], triCoords[i+1], triCoords[i+2],
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
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);
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
_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;
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
// Fix for degenerated triangles
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
// 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.
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
// 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;
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
for (i = 0; i < viSize; i += 3) {
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
detri_t detri;
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
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]);
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
if (v0 == v1 || v0 == v2 || v1 == v2) {
// do nothing for now
}
else if (GeomUtils::distPointSegment<Vec3r>(v0, v1, v2) < 1e-6) {
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
detri.viP = vi0; detri.viA = vi1; detri.viB = vi2;
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
}
else if (GeomUtils::distPointSegment<Vec3r>(v1, v0, v2) < 1e-6) {
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
detri.viP = vi1; detri.viA = vi0; detri.viB = vi2;
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
}
else if (GeomUtils::distPointSegment<Vec3r>(v2, v0, v1) < 1e-6) {
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
detri.viP = vi2; detri.viA = vi0; detri.viB = vi1;
}
else {
continue;
}
detri.v = zero;
detri.n = 0;
for (unsigned 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++;
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
}
}
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
if (detri.n > 0) {
detri.v.normalizeSafe();
}
detriList.push_back(detri);
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +00:00
}
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
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] += 1e-5 * detri.v.x();
cleanVertices[detri.viP+1] += 1e-5 * detri.v.y();
cleanVertices[detri.viP+2] += 1e-5 * detri.v.z();
}
}
Better fix for degenerate triangles in imported mesh data. This commit replaces the solution in revision 44534. It is recalled that 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. Unlike the previous solution, the present fix is capable of any mesh topology involving any number of degenerate triangles. Degenerated triangles are removed in two steps. First, degenerate triangles in the second form are transformed into the first form by moving P to the position of either A or B that is closer to P. This modification affects all triangles sharing the vertex P. Then, all degenerate triangles in the first form are removed by just ignoring them. Obviously, the present solution has a disadvantage that resulting strokes may appear incorrect. This drawback is justified by the fact that the present solution is robust and easy to implement. Users are expected to fix incorrect strokes (if any) by manual removal of degenerate triangles from mesh data.
2012-02-29 01:11:37 +00:00
printf("Warning: Object %s contains %d degenerate triangle%s (strokes may be incorrect)\n",
Made another attempt to fix degenerate triangles in imported mesh data. This commit replaces the solution in revision 44539. It is recalled that 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. Degenerate triangles in the second form are now resolved by adding a small offset to P (i.e., the resulting triangles have a non-zero area).
2012-03-03 01:03:20 +00:00
name, detriList.size(), (detriList.size() > 1) ? "s" : "");
Experimental fix for degenerate triangles in imported mesh data. This commit is an attempt to address degenerate triangles (i.e., triangles whose area is zero) that cause incorrect line visibility in Freestyle. There are two forms of degenerate triangles. Let A, B and P denote the three vertices of a triangle. 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. Note that the first form is a special case of the second form. Degenerate triangles in the first form is easy to remove by the Remove Doubles command. This commit is intended to address those degenerate triangles in the second form. The implemented fix cannot address degenerate triangles in general. It fails when a triangle touches with multiple degenerate triangles. A more general solution needs to be implemented.
2012-02-28 20:56:31 +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
// 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,
Fine control of feature edge selection with mesh face and edge marks. New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
2011-10-06 02:04:43 +00:00
faceEdgeMarks,
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
cleanVIndices, viSize,
cleanNIndices, niSize,
MIndices, viSize,
0,0,
0);
// sets the id of the rep
rep->setId(Id(id, 0));
Made object names accessible from within style modules. ViewShape objects in the view map, as well as SShape objects that can be retrieved with ViewShape::sshape(), now have a getName() method that returns the name of the object from which each shape is created. For instance, visible feature edges of specific mesh objects (e.g., Cube.001 and Cube.002) can be selected using custom predicate ObjectNamesUP1D as follows: class ObjectNamesUP1D(UnaryPredicate1D): def __init__(self, names): UnaryPredicate1D.__init__(self) self._names = names def getName(self): return "ObjectNamesUP1D" def __call__(self, viewEdge): return viewEdge.viewShape().getName() in self._names upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ObjectNamesUP1D(["Cube.001", "Cube.002"])) Operators.select(upred)
2010-05-23 17:11:44 +00:00
rep->setName(obi->ob->id.name+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
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