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.
for stroke rendering. This fix is intended to improve the
stability of stroke rendering when the output format is AVI
Codec, QuickTime, or one of FFMpeg codecs.
In the Parameter Editor mode, three feature edge detection
options (i.e., Ridges and Valleys, Suggestive Contours, and
Material Boundaries) are automatically configured based on
feature edge selection settings of linesets.
Parameter Editor mode. This is a WIP commit. Only the base line
color, base alpha transparency, and base line thickness are respected.
More additions are anticipated to account for other parameters.
* Added FRS_finish_stroke_rendering() to clean Freestyle-related
temporary resources after stroke rendering.
* Some functions in FRS_freestyle.cpp are now declared as static
functions, so as not to mess up the program-wide name space.
* Made the StyleModule class inheritable, and defined new subclass
BlenderStyleModule that takes a Text object instead of a file name.
criteria. Now the Inclusive/Exclusive and Logical AND/OR options are
only applied to feature edge types, while the conditions on visibility
and edge types are always combined by logical conjunction. Also, the
crease angle, sphere radius and Kr derivative epsilon are treated as
render layer-specific options instead of lineset-specific options.
* Moved render layer-specific Freestyle options to a separate "Freestyle"
tab (in addition to the "Freestyle: Line Style" tab that has been introduced
in the previous commit).
* Added UI controls for specifying feature edge selection criteria in the
Parameter Editor mode. Feature edge selection starts with a set of all
feature edges in the view map. Each line set specifies edge selection
criteria (e.g., to select only visible crease edges) by enabling appropriate
UI controls (e.g., by turning on the "Crease" and "Visibility" toggle
buttons). Selected criteria are combined by logical conjunction. Logical
disjunction (e.g., "crease edges or contours") is represented by two or
more line sets.
* Slightly rearranged several UI controls in the Python Scripting mode.
This commit is just meant to give the new GUI framework a concrete shape.
There is no usefulness in newly introduced elements at the moment.
Freestyle options in render layers now include a pull-down menu named Control
Mode that allows you to choose either the Python Scripting or Parameter Editor
mode. The Python Scripting mode is the conventional way of controlling
Freestyle by directly using style modules written in Python. The Parameter
Editor is a new control mode that is intended to be used by everyone without
relying on Python programming.
In the Parameter Editor mode, you can specify multiple line sets for each
render layer. A line set defines feature edge selection criteria, as
well as a line style for drawing the selected feature edges using specific
line stylization parameters. Line style is a new datablock type, meaning
that a line style can be shared by multiple line sets (possibly those in
different render layers in different scenes).
Much more additions are anticipated in subsequent commits to implement UI
controls for specifying feature edge selection criteria and line stylization
parameters.
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)
An entry "Crease Angle" has been added to the Layers tab of the Render
buttons, to allow users to specify an angle (between 0 and 180) used for
crease edge detection. An edge is considered a crease edge if the angle
between two faces sharing the edge is smaller than the threshold. The
default value is 134.43 degrees (for backward compatibility). Be aware
that a larger threshold leads to a larger number of feature edges and
thus a larger memory consumption.
A checkbox "Material Boundaries" has been added to the Freestyle
options in the Layers tab of the Render buttons. By enabling the
option, any edge between two faces with different materials is
detected as a feature edge. In style modules, edges at material
boundaries can be tested with pyNatureUP1D(Nature.MATERIAL_BOUNDARY).
The render pipeline has been extended to better work with
Freestyle stroke rendering. Struct Render has a new member
ListBase freestyle_renders to keep Render instances generated
through stroke rendering in Freestyle. The number of
elements (LinkData instances with LinkData::data pointing to a
Render instance) in freestyle_renders is the same as the scene
render layers of the scene being rendered. When the k-th scene
render layer has the Freestyle option enabled, the k-th element
of freestyle_renders refers to a Render instance that holds
Freestyle render results for the scene layer. This association
between the scene render layer and the Render instance is used to
merge the Freestyle render results into the corresponding render
results for the scene render layer.
rendering.
RE_BlenderFrame() and RE_BlenderAnim() are Blender's internal
top-level rendering API functions for a single frame and a series of
frames, respectively. These functions rely on global variables to
keep render pipeline states. Freestyle's stroke rendering was also
using RE_BlenderFrame to render a temporary scene of stroke meshes.
These nested calls of the top-level rendering API functions were
causing broken render pipeline states and eventually led to a crash.
This commit is intended to fix the issue, by introducing an rendering
API function RE_RenderFreestyleStrokes specifically used for stroke
rendering in Freestyle. The new function does not do anything with
regard to the global variables in the rendering API implementation.
Transparent strokes are rendered by means of transparent vertex colors.
To make this possible, Blender's internal renderer has been slightly
extended to allow transparent vertex colors. When Material::vcol_alpha
is non-zero, the renderer takes MCol::a into account.
because of incomplete functionality.
When two transparent strokes intersect, the stroke drawn first is
completely overridden by the stroke drawn after the first stroke,
instead of two stroke colors being blended at the intersection.
Availability of pixel-based density and Z depth information depends
on passes of a render layer being rendered.
- Density information is available if the diffuse pass of the render
layer is enabled. It is accessible through the DensityF0D and
DensityF1D functions provided by the Freestyle Python API. These
functions return 0 if the diffuse pass is disabled.
- Z depth information is available if the Z pass is enabled. It can
be accessed through LocalAverageDepthF0D and LocalAverageDepthF1D.
These functions return 0 if the Z pass is disabled.
In Freestyle, strokes are represented with triangle strips, and stroke
colors are realized using vertex colors in order to enable variable
stroke colors (i.e., each triangle has a different color). Stroke
colors in Freestyle are in the RGBA format, while vertex colors in
Blender do not have an alpha component. Therefore, we here employ a
2-pass rendering approach as follows. First, the alpha component of
an image is rendered by using the red component of vertex colors as
the alpha component of stroke colors (1st pass). The render result is
saved into a temporary buffer. Then, the vertex colors of stroke
meshes are replaced with RGB values, and the RGB components of the
image is rendered (2nd pass). Finally, the RGB and alpha components
are merged to produce the render result in the RGBA format.
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.
rendering. When objects exists out of the viewing frustrum and
near the near clipping plane, feature edges in the 3D camera
coordinate system are projected to an extremely far location from
the camera view in the 2D image space. These feature edges
result in very long strokes with a large number of stroke
vertices, which temporarily require a significant memory storage,
causing a fatal "out of memory" error. This problem is partially
addressed by the changes in the present commit.
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.
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).
from within style modules. Calling this function is only valid within
style modules. Calling it from the Python Interactive Console results
in an error as follows:
>>> import Freestyle
>>> Freestyle.getCurrentScene()
Traceback (most recent call last):
File "<console>", line 1, in <module>
TypeError: current scene not available
>>>
The following files were according to the Math Lib reorganization
(see the commit log of revision 24464 for more information):
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.h
The file release/scripts/ui/properties_render.py was also updated
according the RNA UI API renaming in revision 24795.
initializing Freestyle and specifying contexts, making the API a bit messy.
Now FRS_initialize() is only for initialization, and contexts are specified
by new FRS_set_context() function just before starting rendering.
2.4x) from within Freestyle. Now Freestyle configuration parameters
are edited without relying on the notion of the current scene. This
resolved a few related issues as described below:
- A bug in Freestyle configuration management with respect to
multiple scenes was fixed. Now Freestyle configuration parameters
(e.g., style modules, ridges/valleys, suggestive contours) can be
specified for each render layer of each scene. Composition of
multiple render layers from different scenes should work as expected.
- A crash after undoing was fixed as well.
* Removed unused external Freestyle functions and global variables
from FRS_freestyle.h and FRS_freestyle.cpp.
Updated buttons_render.py to have Freestyle buttons
Added "empty" BlenderTextureManager as preliminary step to remove last remnants of OpenGL and to allow Freestyle to run on my machine.
