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

933 lines
27 KiB
C++
Raw Normal View History

Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2010 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/freestyle/intern/blender_interface/FRS_freestyle.cpp
* \ingroup freestyle
*/
soc-2008-mxcurioni: Big update. Finally works (links and compiles). So far, the following steps work: 1. instantiates the config path, the controller and the view 2. sets the controller’s view 3. loads a 3ds file (right now a fixed file) 4. inserts a style module (right now, also fixed) 5. computes the view map The next and final step is running the Python script. A lot of information are fixed and should be changed to test the following code: see source/blender/freestyle/app_blender/*.cpp and search for fixed paths (starting in /Users/). I am currently evaluating whether it's worth making Python run on its own environment (right now, the program crashes because of PyImport_AddModule) or whether it should use Blender's Python capabilities. Also, I need to figure out how to integrate the SWIG wrapper dynamic library into the current scheme.
2008-05-25 17:34:21 +00:00
soc-2008-mxcurioni: uploaded missing files. Still NOT linking so do not use this version yet :(
2008-05-19 05:34:31 +00:00
#include <iostream>
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
#include <map>
#include <set>
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
#include "../application/AppCanvas.h"
#include "../application/AppConfig.h"
#include "../application/AppView.h"
#include "../application/Controller.h"
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
#include "BKE_global.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
using namespace std;
soc-2008-mxcurioni: uploaded missing files. Still NOT linking so do not use this version yet :(
2008-05-19 05:34:31 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// XXX Are those "ifdef __cplusplus" useful here?
soc-2008-mxcurioni: First render ! It should render the teapot upside down on a black background. The correction was made by following Yafray's rendering and display implementation, which is very clear.
2008-05-29 00:27:09 +00:00
#ifdef __cplusplus
extern "C" {
#endif
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
#include "MEM_guardedalloc.h"
Made changes to enable features line parameters (ridges/valleys and suggestive contours) and add corresponding UI controls to the Freestyle tab in the Scene buttons.
2008-11-09 13:14:41 +00:00
soc-2008-mxcurioni: renamed libQGLWidget's Camera class to AppGLWidget_Camera to use Blender's Camera struct, integrated the camera parameters from Blender. Perspective projection (precisely field of view) is now correct. Orthographic projection still having issues.
2008-07-02 12:16:36 +00:00
#include "DNA_camera_types.h"
SUMMARY: The main contribution of this commit is the possibility to save Freestyle configuration information inside .blend files. It required an extensive refactoring of the previous interface code. The code has been tested and does not crash on my machine. If you encounter issues, please let me know (and if possible, sending me an sample .blend file). DETAILS: - refactored code to notify Freestyle when adding/removing render layers (FRS_freestyle_config.{h,cpp}) - corrected the freeing of style modules when files are read from / written to disk - moved Freestyle configuration information into scene renderlayers, to allow loading / saving .blend files (DNA_scene_types.h DNA_freestyle_types.h FRS_freestyle.cpp) - inserted temporary trick to prevent crashes when orthographic camera is used (SilhouetteGeomEngine.cpp), but outputting incorrect feature line calculations
2009-08-04 00:40:36 +00:00
#include "DNA_freestyle_types.h"
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
#include "DNA_group_types.h"
#include "DNA_text_types.h"
soc-2008-mxcurioni: renamed libQGLWidget's Camera class to AppGLWidget_Camera to use Blender's Camera struct, integrated the camera parameters from Blender. Perspective projection (precisely field of view) is now correct. Orthographic projection still having issues.
2008-07-02 12:16:36 +00:00
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_linestyle.h"
Migration of Freestyle to Blender 2.5 codebase (continued): - proper Freestyle initialization, with support for undo/redo - re-added FreestyleStyleConfig data structure - Freestyle Python interpreter updated This commit should compile without errors. More work is necessary to complete the migration: - add Freestyle in the UI - set up RNA support
2009-09-28 03:56:31 +00:00
#include "BKE_main.h"
* Implemented the basic stroke rendering functionality for the new 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.
2010-07-26 01:23:27 +00:00
#include "BKE_text.h"
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
soc-2008-mxcurioni: now supports current scene drawing (instead of fixed scene object), still with fixed style and fixed camera. Initialization is properly handled, which limits memory problems and speed-ups subsequent rendering. The viewing ratio should be correct now too. I also removed linking references to former lib3ds library path (caused some linking problems).
2008-06-08 19:35:20 +00:00
#include "BLI_blenlib.h"
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
#include "BLI_math.h"
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
soc-2008-mxcurioni: now supports current scene drawing (instead of fixed scene object), still with fixed style and fixed camera. Initialization is properly handled, which limits memory problems and speed-ups subsequent rendering. The viewing ratio should be correct now too. I also removed linking references to former lib3ds library path (caused some linking problems).
2008-06-08 19:35:20 +00:00
#include "BPY_extern.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
#include "renderpipeline.h"
#include "pixelblending.h"
soc-2008-mxcurioni: uploaded missing files. Still NOT linking so do not use this version yet :(
2008-05-19 05:34:31 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
#include "FRS_freestyle.h"
#include "FRS_freestyle_config.h"
Improved context handling. Previously FRS_initialize() was used for both 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.
2009-11-10 00:03:31 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
#define DEFAULT_SPHERE_RADIUS 1.0f
#define DEFAULT_DKR_EPSILON 0.0f
Fix for invalid pointers within a copied line set. Now the line set buffer is cleared when a new .blend file is opened, so that a line set may not be copied and pasted between two .blend files.
2012-01-23 23:32:09 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// Freestyle configuration
static short freestyle_is_initialized = 0;
static Config::Path *pathconfig = NULL;
static Controller *controller = NULL;
static AppView *view = NULL;
soc-2008-mxcurioni: now supports current scene drawing (instead of fixed scene object), still with fixed style and fixed camera. Initialization is properly handled, which limits memory problems and speed-ups subsequent rendering. The viewing ratio should be correct now too. I also removed linking references to former lib3ds library path (caused some linking problems).
2008-06-08 19:35:20 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// line set buffer for copy & paste
static FreestyleLineSet lineset_buffer;
static bool lineset_copied = false;
New options for specifying unit line thickness. The Post Processing tab in the Render buttons has new Line Thickness options for defining unit line thickness in two different modes as follows: 1. Absolute mode: The unit line thickness is given by a user-specified number in units of pixels. The default value is 1. 2. Relative mode: The unit line thickness is scaled by the proportion of the present vertical image resolution to 480 pixels. For instance, the unit line thickness is 1 with the image height set to 480, 1.5 with 720, and 2 with 960.
2012-04-10 23:53:46 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// camera information
float freestyle_viewpoint[3];
float freestyle_mv[4][4];
float freestyle_proj[4][4];
int freestyle_viewport[4];
soc-2008-mxcurioni: foundations for Freestyle as a render layer - new UI buttons and mode flags, Freestyle API refactoring, modified pipeline to incorporate the new render layer. Compared to previously, the layer functionality is available when selecting 'Blender Internal' as the rendering engine. Freestyle's result is not available in the layer yet. I need to integrate OpenGL offscreen rendering properly (with framebuffer objects) to reach that goal.
2008-07-04 07:59:19 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// current scene
Scene *freestyle_scene;
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
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
string default_module_path;
soc-2008-mxcurioni: refactored Freestyle API to prepare for both rendering modes (OpenGL and Blender internal), applied a patch to allow CMake to be used for compilation.
2008-10-01 15:03:35 +00:00
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
// function declarations
static void copy_lineset(FreestyleLineSet *new_lineset, FreestyleLineSet *lineset);
static void copy_module(FreestyleModuleConfig *new_module, FreestyleModuleConfig *module);
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
//=======================================================
// Initialization
//=======================================================
void FRS_initialize()
{
if (freestyle_is_initialized)
return;
pathconfig = new Config::Path;
controller = new Controller();
view = new AppView;
controller->setView(view);
controller->Clear();
freestyle_scene = NULL;
lineset_copied = false;
default_module_path = pathconfig->getProjectDir() + Config::DIR_SEP + "style_modules" +
Config::DIR_SEP + "contour.py";
freestyle_is_initialized = 1;
}
void FRS_set_context(bContext *C)
{
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "FRS_set_context: context 0x" << C << " scene 0x" << CTX_data_scene(C) << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
controller->setContext(C);
}
void FRS_read_file(bContext *C)
{
lineset_copied = false;
}
void FRS_exit()
{
delete pathconfig;
delete controller;
delete view;
}
//=======================================================
// Rendering
//=======================================================
static void init_view(Render *re)
{
int width = re->winx;
int height = re->winy;
int xmin = re->disprect.xmin;
int ymin = re->disprect.ymin;
int xmax = re->disprect.xmax;
int ymax = re->disprect.ymax;
float thickness = 1.0f;
switch (re->r.line_thickness_mode) {
case R_LINE_THICKNESS_ABSOLUTE:
thickness = re->r.unit_line_thickness * (re->r.size / 100.f);
break;
case R_LINE_THICKNESS_RELATIVE:
thickness = height / 480.f;
break;
}
freestyle_viewport[0] = freestyle_viewport[1] = 0;
freestyle_viewport[2] = width;
freestyle_viewport[3] = height;
view->setWidth(width);
view->setHeight(height);
view->setBorder(xmin, ymin, xmax, ymax);
view->setThickness(thickness);
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "\n=== Dimensions of the 2D image coordinate system ===" << endl;
cout << "Width : " << width << endl;
cout << "Height : " << height << endl;
if (re->r.mode & R_BORDER)
cout << "Border : (" << xmin << ", " << ymin << ") - (" << xmax << ", " << ymax << ")" << endl;
cout << "Unit line thickness : " << thickness << " pixel(s)" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
static void init_camera(Render *re)
{
// It is assumed that imported meshes are in the camera coordinate system.
// Therefore, the view point (i.e., camera position) is at the origin, and
// the the model-view matrix is simply the identity matrix.
freestyle_viewpoint[0] = 0.0;
freestyle_viewpoint[1] = 0.0;
freestyle_viewpoint[2] = 0.0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
freestyle_mv[i][j] = (i == j) ? 1.0 : 0.0;
* Fix for a freeze issue in stroke rendering when using round/square caps. The problem was caused by a stroke with only one vertex. Such a stroke was generated when for some unknown reason a chained curve consisted of only two vertices such that their 3D positions were exactly or almost the same. * Fix for the Parameter Editor mode that failed when scene render layers and/or linesets contain a single quote in their names.
2010-12-06 22:17:19 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
freestyle_proj[i][j] = re->winmat[i][j];
* Implemented the basic stroke rendering functionality for the new 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.
2010-07-26 01:23:27 +00:00
}
soc-2008-mxcurioni: clean up
2008-08-08 08:53:13 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
#if 0
print_m4("mv", freestyle_mv);
print_m4("proj", freestyle_proj);
#endif
}
static char *escape_quotes(char *name)
{
char *s = (char*)MEM_mallocN(strlen(name) * 2 + 1, "escape_quotes");
char *p = s;
while (*name) {
if (*name == '\'')
*(p++) = '\\';
*(p++) = *(name++);
}
*p = '\0';
return s;
}
static Text *create_lineset_handler(char *layer_name, char *lineset_name)
{
char *s1 = escape_quotes(layer_name);
char *s2 = escape_quotes(lineset_name);
Merged changes in the trunk up to revision 54421. Conflicts resolved: release/datafiles/startup.blend release/scripts/startup/bl_ui/properties_render.py source/blender/SConscript source/blender/blenloader/intern/readfile.c
2013-02-10 10:17:59 +00:00
Text *text = BKE_text_add(G.main, lineset_name);
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
BKE_text_write(text, "import parameter_editor; parameter_editor.process('");
BKE_text_write(text, s1);
BKE_text_write(text, "', '");
BKE_text_write(text, s2);
BKE_text_write(text, "')\n");
MEM_freeN(s1);
MEM_freeN(s2);
return text;
}
struct edge_type_condition
{
int edge_type, value;
};
// examines the conditions and returns true if the target edge type needs to be computed
static bool test_edge_type_conditions(struct edge_type_condition *conditions,
int num_edge_types, bool logical_and, int target, bool distinct)
{
int target_condition = 0;
int num_non_target_positive_conditions = 0;
int num_non_target_negative_conditions = 0;
for (int i = 0; i < num_edge_types; i++) {
if (conditions[i].edge_type == target)
target_condition = conditions[i].value;
else if (conditions[i].value > 0)
++num_non_target_positive_conditions;
else if (conditions[i].value < 0)
++num_non_target_negative_conditions;
}
if (distinct) {
// In this case, the 'target' edge type is assumed to appear on distinct edge
// of its own and never together with other edge types.
if (logical_and) {
if (num_non_target_positive_conditions > 0)
return false;
if (target_condition > 0)
return true;
if (target_condition < 0)
return false;
if (num_non_target_negative_conditions > 0)
return true;
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
else {
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
if (target_condition > 0)
return true;
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
if (num_non_target_negative_conditions > 0)
return true;
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
if (target_condition < 0)
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return false;
if (num_non_target_positive_conditions > 0)
return false;
}
}
else {
// In this case, the 'target' edge type may appear together with other edge types.
if (target_condition > 0)
return true;
if (target_condition < 0)
return true;
if (logical_and) {
if (num_non_target_positive_conditions > 0)
return false;
if (num_non_target_negative_conditions > 0)
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
return true;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
else {
if (num_non_target_negative_conditions > 0)
return true;
if (num_non_target_positive_conditions > 0)
return false;
}
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return true;
}
Extended the set of conditions for feature edge selection by edge types. In the Parameter Editor mode, each edge type check button in the Selection by Edge Types has now an associated toggle button to exclude the edge type from the feature edge selection. This allows you to select, for instance, those edges that are silhouette lines but not external contours.
2011-10-27 20:57:14 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
static void prepare(Render *re, SceneRenderLayer *srl)
{
// load mesh
re->i.infostr = "Freestyle: Mesh loading";
re->stats_draw(re->sdh, &re->i);
re->i.infostr = NULL;
if (controller->LoadMesh(re, srl)) // returns if scene cannot be loaded or if empty
return;
if (re->test_break(re->tbh))
return;
// add style modules
FreestyleConfig *config = &srl->freestyleConfig;
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "\n=== Rendering options ===" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
int layer_count = 0;
switch (config->mode) {
case FREESTYLE_CONTROL_SCRIPT_MODE:
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Modules :" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (FreestyleModuleConfig *module_conf = (FreestyleModuleConfig*)config->modules.first;
module_conf;
module_conf = module_conf->next)
{
if(module_conf->is_displayed) {
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << " " << layer_count+1 << ": " << module_conf->module_path << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
controller->InsertStyleModule(layer_count, module_conf->module_path);
controller->toggleLayer(layer_count, true);
layer_count++;
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
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
controller->setComputeRidgesAndValleysFlag((config->flags & FREESTYLE_RIDGES_AND_VALLEYS_FLAG) ? true : false);
controller->setComputeSuggestiveContoursFlag((config->flags & FREESTYLE_SUGGESTIVE_CONTOURS_FLAG) ? true : false);
controller->setComputeMaterialBoundariesFlag((config->flags & FREESTYLE_MATERIAL_BOUNDARIES_FLAG) ? true : false);
break;
case FREESTYLE_CONTROL_EDITOR_MODE:
int use_ridges_and_valleys = 0;
int use_suggestive_contours = 0;
int use_material_boundaries = 0;
struct edge_type_condition conditions[] = {
{FREESTYLE_FE_SILHOUETTE, 0},
{FREESTYLE_FE_BORDER, 0},
{FREESTYLE_FE_CREASE, 0},
{FREESTYLE_FE_RIDGE_VALLEY, 0},
{FREESTYLE_FE_SUGGESTIVE_CONTOUR, 0},
{FREESTYLE_FE_MATERIAL_BOUNDARY, 0},
{FREESTYLE_FE_CONTOUR, 0},
{FREESTYLE_FE_EXTERNAL_CONTOUR, 0},
{FREESTYLE_FE_EDGE_MARK, 0}
};
int num_edge_types = sizeof(conditions) / sizeof(struct edge_type_condition);
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Linesets:" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (FreestyleLineSet *lineset = (FreestyleLineSet*)config->linesets.first;
lineset;
lineset = lineset->next)
{
if (lineset->flags & FREESTYLE_LINESET_ENABLED) {
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << " " << layer_count+1 << ": " << lineset->name << " - "
<< lineset->linestyle->id.name+2 << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
Text *text = create_lineset_handler(srl->name, lineset->name);
controller->InsertStyleModule(layer_count, lineset->name, text);
controller->toggleLayer(layer_count, true);
if (!(lineset->selection & FREESTYLE_SEL_EDGE_TYPES) || !lineset->edge_types) {
++use_ridges_and_valleys;
++use_suggestive_contours;
++use_material_boundaries;
}
else {
// conditions for feature edge selection by edge types
for (int i = 0; i < num_edge_types; i++) {
if (!(lineset->edge_types & conditions[i].edge_type))
conditions[i].value = 0; // no condition specified
else if (!(lineset->exclude_edge_types & conditions[i].edge_type))
conditions[i].value = 1; // condition: X
else
conditions[i].value = -1; // condition: NOT X
}
// logical operator for the selection conditions
bool logical_and = ((lineset->flags & FREESTYLE_LINESET_FE_AND) != 0);
// negation operator
if (lineset->flags & FREESTYLE_LINESET_FE_NOT) {
// convert an Exclusive condition into an Inclusive equivalent using De Morgan's laws:
// NOT (X OR Y) --> (NOT X) AND (NOT Y)
// NOT (X AND Y) --> (NOT X) OR (NOT Y)
for (int i = 0; i < num_edge_types; i++)
conditions[i].value *= -1;
logical_and = !logical_and;
}
if (test_edge_type_conditions(conditions, num_edge_types, logical_and,
FREESTYLE_FE_RIDGE_VALLEY, true))
{
Automatic configuration of feature edge detection options. 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.
2010-08-07 22:48:25 +00:00
++use_ridges_and_valleys;
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
if (test_edge_type_conditions(conditions, num_edge_types, logical_and,
FREESTYLE_FE_SUGGESTIVE_CONTOUR, true))
{
Automatic configuration of feature edge detection options. 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.
2010-08-07 22:48:25 +00:00
++use_suggestive_contours;
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
if (test_edge_type_conditions(conditions, num_edge_types, logical_and,
FREESTYLE_FE_MATERIAL_BOUNDARY, true))
{
Automatic configuration of feature edge detection options. 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.
2010-08-07 22:48:25 +00:00
++use_material_boundaries;
}
* Implemented the basic stroke rendering functionality for the new 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.
2010-07-26 01:23:27 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
layer_count++;
* Implemented the basic stroke rendering functionality for the new 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.
2010-07-26 01:23:27 +00:00
}
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
controller->setComputeRidgesAndValleysFlag(use_ridges_and_valleys > 0);
controller->setComputeSuggestiveContoursFlag(use_suggestive_contours > 0);
controller->setComputeMaterialBoundariesFlag(use_material_boundaries > 0);
break;
}
// set parameters
if (config->flags & FREESTYLE_ADVANCED_OPTIONS_FLAG) {
controller->setSphereRadius(config->sphere_radius);
controller->setSuggestiveContourKrDerivativeEpsilon(config->dkr_epsilon);
}
else {
controller->setSphereRadius(DEFAULT_SPHERE_RADIUS);
controller->setSuggestiveContourKrDerivativeEpsilon(DEFAULT_DKR_EPSILON);
}
controller->setFaceSmoothness((config->flags & FREESTYLE_FACE_SMOOTHNESS_FLAG) ? true : false);
controller->setCreaseAngle(RAD2DEGF(config->crease_angle));
controller->setVisibilityAlgo((config->flags & FREESTYLE_CULLING) ?
FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE :
FREESTYLE_ALGO_ADAPTIVE_CUMULATIVE);
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Crease angle : " << controller->getCreaseAngle() << endl;
cout << "Sphere radius : " << controller->getSphereRadius() << endl;
cout << "Face smoothness : " << (controller->getFaceSmoothness() ? "enabled" : "disabled") << endl;
cout << "Redges and valleys : " << (controller->getComputeRidgesAndValleysFlag() ? "enabled" : "disabled")
<< endl;
cout << "Suggestive contours : " << (controller->getComputeSuggestiveContoursFlag() ? "enabled" : "disabled")
<< endl;
cout << "Suggestive contour Kr derivative epsilon : " << controller->getSuggestiveContourKrDerivativeEpsilon()
<< endl;
cout << "Material boundaries : " << (controller->getComputeMaterialBoundariesFlag() ? "enabled" : "disabled")
<< endl;
cout << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// set diffuse and z depth passes
RenderLayer *rl = RE_GetRenderLayer(re->result, srl->name);
bool diffuse = false, z = false;
for (RenderPass *rpass = (RenderPass*)rl->passes.first; rpass; rpass = rpass->next) {
switch (rpass->passtype) {
case SCE_PASS_DIFFUSE:
controller->setPassDiffuse(rpass->rect, rpass->rectx, rpass->recty);
diffuse = true;
break;
case SCE_PASS_Z:
controller->setPassZ(rpass->rect, rpass->rectx, rpass->recty);
z = true;
break;
Reorganization of two view map construction parameters. * Sphere radius and Kr derivative epsilon were removed from the Parameter Editor mode. Now sphere radius of 1.0 and Kr derivative epsilon of 0.0 are used by default. The rationale of the removal is two-fold: little predictability and very minor artistic values. The effects of these parameters are hard to estimate in advance, which likely leads to a frustration of users due to repeated trials and unpredicted results. Therefore, the two parameters are considered to have quite limited artistic values. Proper definitions of the two parameters more and less require the knowledge of differential geometry and would not make sense to most artists for which the Parameter Editor is intended. * Sphere radius and Kr derivative epsilon are still available in the Python Scripting mode, but now in an "advanced options" section that is disabled and hidden by default. This way new users are properly warned, while expert users with specific technical needs can enable these options if they want. The same default values mentioned above are used when the two parameters are disabled.
2012-02-05 11:37:39 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Passes :" << endl;
cout << " Diffuse = " << (diffuse ? "enabled" : "disabled") << endl;
cout << " Z = " << (z ? "enabled" : "disabled") << endl;
}
Added support for pixel-based density and Z depth information. 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.
2010-02-14 03:17:52 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// compute view map
re->i.infostr = "Freestyle: View map creation";
re->stats_draw(re->sdh, &re->i);
re->i.infostr = NULL;
controller->ComputeViewMap();
}
Made changes to enable features line parameters (ridges/valleys and suggestive contours) and add corresponding UI controls to the Freestyle tab in the Scene buttons.
2008-11-09 13:14:41 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_composite_result(Render* re, SceneRenderLayer* srl, Render* freestyle_render)
{
RenderLayer *rl;
float *src, *dest, *pixSrc, *pixDest;
int x, y, rectx, recty;
if (freestyle_render == NULL || freestyle_render->result == NULL)
return;
rl = render_get_active_layer( freestyle_render, freestyle_render->result );
if (!rl || rl->rectf == NULL) {
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Cannot find Freestyle result image" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return;
}
src = rl->rectf;
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
#if 0
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "src: " << rl->rectx << " x " << rl->recty << endl;
}
#endif
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
rl = RE_GetRenderLayer(re->result, srl->name);
if (!rl || rl->rectf == NULL) {
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "No layer to composite to" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return;
}
dest = rl->rectf;
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
#if 0
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "dest: " << rl->rectx << " x " << rl->recty << endl;
}
#endif
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
rectx = re->rectx;
recty = re->recty;
for (y = 0; y < recty; y++) {
for (x = 0; x < rectx; x++) {
pixSrc = src + 4 * (rectx * y + x);
if (pixSrc[3] > 0.0) {
pixDest = dest + 4 * (rectx * y + x);
addAlphaOverFloat(pixDest, pixSrc);
Fixed the border option that was not functional when the crop option was turned off.
2010-03-29 21:58:58 +00:00
}
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
}
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
Fixed the full sample anti-aliasing support in Freestyle. 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.
2010-03-28 17:46:10 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
static int displayed_layer_count(SceneRenderLayer *srl)
{
int count = 0;
switch (srl->freestyleConfig.mode) {
case FREESTYLE_CONTROL_SCRIPT_MODE:
for (FreestyleModuleConfig *module = (FreestyleModuleConfig*)srl->freestyleConfig.modules.first;
module;
module = module->next)
{
if (module->is_displayed)
count++;
}
break;
case FREESTYLE_CONTROL_EDITOR_MODE:
for (FreestyleLineSet *lineset = (FreestyleLineSet*)srl->freestyleConfig.linesets.first;
lineset;
lineset = lineset->next)
{
if (lineset->flags & FREESTYLE_LINESET_ENABLED)
count++;
}
break;
Fixed the full sample anti-aliasing support in Freestyle. 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.
2010-03-28 17:46:10 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return count;
}
int FRS_is_freestyle_enabled(SceneRenderLayer *srl)
{
return (!(srl->layflag & SCE_LAY_DISABLE) && srl->layflag & SCE_LAY_FRS && displayed_layer_count(srl) > 0);
}
Fixed the full sample anti-aliasing support in Freestyle. 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.
2010-03-28 17:46:10 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_init_stroke_rendering(Render *re)
{
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << endl;
cout << "#===============================================================" << endl;
cout << "# Freestyle" << endl;
cout << "#===============================================================" << endl;
}
Fixed the full sample anti-aliasing support in Freestyle. 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.
2010-03-28 17:46:10 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
init_view(re);
init_camera(re);
controller->ResetRenderCount();
}
Fixed the full sample anti-aliasing support in Freestyle. 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.
2010-03-28 17:46:10 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
Render *FRS_do_stroke_rendering(Render *re, SceneRenderLayer *srl)
{
Render *freestyle_render = NULL;
RenderMonitor monitor(re);
controller->setRenderMonitor(&monitor);
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << endl;
cout << "----------------------------------------------------------" << endl;
cout << "| " << (re->scene->id.name + 2) << "|" << srl->name << endl;
cout << "----------------------------------------------------------" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// prepare Freestyle:
// - load mesh
// - add style modules
// - set parameters
// - compute view map
prepare(re, srl);
if (re->test_break(re->tbh)) {
controller->CloseFile();
New command-line option --debug-freestyle to enable verbose debug messages on the console during Freestyle rendering. The debug prints are turned off by default now. Errors are still printed on the console. A patch set implementing this functionality was provided by Bastien Montagne. Many thanks! :)
2013-01-03 23:27:20 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
cout << "Break" << endl;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return NULL;
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
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
// render and composite Freestyle result
if (controller->_ViewMap) {
// render strokes
re->i.infostr = "Freestyle: Stroke rendering";
re->stats_draw(re->sdh, &re->i);
re->i.infostr = NULL;
freestyle_scene = re->scene;
controller->DrawStrokes();
freestyle_render = controller->RenderStrokes(re);
controller->CloseFile();
freestyle_scene = NULL;
// composite result
FRS_composite_result(re, srl, freestyle_render);
RE_FreeRenderResult(freestyle_render->result);
freestyle_render->result = NULL;
* Implemented the basic stroke rendering functionality for the new 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.
2010-07-26 01:23:27 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return freestyle_render;
}
void FRS_finish_stroke_rendering(Render *re) {
// clear canvas
controller->Clear();
}
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
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
//=======================================================
// Freestyle Panel Configuration
//=======================================================
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
void FRS_init_freestyle_config(FreestyleConfig *config)
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
{
config->mode = FREESTYLE_CONTROL_SCRIPT_MODE;
config->modules.first = config->modules.last = NULL;
config->flags = 0;
config->sphere_radius = DEFAULT_SPHERE_RADIUS;
config->dkr_epsilon = DEFAULT_DKR_EPSILON;
config->crease_angle = DEG2RADF(120.0f);
config->linesets.first = config->linesets.last = NULL;
}
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
void FRS_free_freestyle_config(FreestyleConfig *config)
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
{
FreestyleLineSet *lineset;
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
for (lineset = (FreestyleLineSet*)config->linesets.first; lineset; lineset = lineset->next) {
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
if (lineset->group) {
lineset->group->id.us--;
lineset->group = NULL;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
lineset->linestyle->id.us--;
lineset->linestyle = NULL;
Freestyle was changed from a tile-based process to a post-processing effect. This will allow style modules to process the underlying color buffer ( AppCanvas::readColorPixels ) and depth buffer ( AppCanvas::readDepthPixels ), as was supported in the original program. Corrected crash when Freestyle is rendered in "Single" render layer mode (for example, in the compositor)
2009-03-22 16:25:14 +00:00
}
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
BLI_freelistN(&config->linesets);
BLI_freelistN(&config->modules);
}
void FRS_copy_freestyle_config(FreestyleConfig *new_config, FreestyleConfig *config)
{
FreestyleLineSet *lineset, *new_lineset;
FreestyleModuleConfig *module, *new_module;
new_config->mode = config->mode;
new_config->raycasting_algorithm = config->raycasting_algorithm; /* deprecated */
new_config->flags = config->flags;
new_config->sphere_radius = config->sphere_radius;
new_config->dkr_epsilon = config->dkr_epsilon;
new_config->crease_angle = config->crease_angle;
new_config->linesets.first = new_config->linesets.last = NULL;
for (lineset = (FreestyleLineSet*)config->linesets.first; lineset; lineset = lineset->next) {
new_lineset = FRS_alloc_lineset();
copy_lineset(new_lineset, lineset);
BLI_addtail(&new_config->linesets, (void*)new_lineset);
}
new_config->modules.first = new_config->modules.last = NULL;
for (module = (FreestyleModuleConfig*)config->modules.first; module; module = module->next) {
new_module = FRS_alloc_module();
copy_module(new_module, module);
BLI_addtail(&new_config->modules, (void*)new_module);
}
}
static void copy_lineset(FreestyleLineSet *new_lineset, FreestyleLineSet *lineset)
{
new_lineset->linestyle = lineset->linestyle;
new_lineset->linestyle->id.us++;
new_lineset->flags = lineset->flags;
new_lineset->selection = lineset->selection;
new_lineset->qi = lineset->qi;
new_lineset->qi_start = lineset->qi_start;
new_lineset->qi_end = lineset->qi_end;
new_lineset->edge_types = lineset->edge_types;
new_lineset->exclude_edge_types = lineset->exclude_edge_types;
new_lineset->group = lineset->group;
if (new_lineset->group) {
new_lineset->group->id.us++;
}
strcpy(new_lineset->name, lineset->name);
}
FreestyleModuleConfig *FRS_alloc_module()
{
return (FreestyleModuleConfig*)MEM_callocN(sizeof(FreestyleModuleConfig), "style module configuration");
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
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
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_add_module(FreestyleConfig *config)
{
FreestyleModuleConfig *module_conf = (FreestyleModuleConfig*)MEM_callocN(sizeof(FreestyleModuleConfig),
"style module configuration");
BLI_addtail(&config->modules, (void*)module_conf);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
strcpy(module_conf->module_path, default_module_path.c_str());
module_conf->is_displayed = 1;
}
Replaced the changes in revision 41810 with a better implementation of copy/paste functionality. Instead of making a copy of the active line set, now the settings of the active line set are copied to and pasted from a buffer. This allows for copying and pasting line set settings among different scenes and render layers.
2011-11-20 23:44:50 +00:00
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
static void copy_module(FreestyleModuleConfig *new_module, FreestyleModuleConfig *module)
{
strcpy(new_module->module_path, module->module_path);
new_module->is_displayed = module->is_displayed;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_delete_module(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
{
BLI_freelinkN(&config->modules, module_conf);
}
Added a new operator in the Parameter Editor mode to make a copy of the active line set.
2011-11-13 21:55:13 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_move_module_up(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
{
BLI_remlink(&config->modules, module_conf);
BLI_insertlinkbefore(&config->modules, module_conf->prev, module_conf);
}
Added a new operator in the Parameter Editor mode to make a copy of the active line set.
2011-11-13 21:55:13 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_move_module_down(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
{
BLI_remlink(&config->modules, module_conf);
BLI_insertlinkafter(&config->modules, module_conf->next, module_conf);
}
static void unique_lineset_name(FreestyleConfig *config, FreestyleLineSet *lineset)
{
BLI_uniquename(&config->linesets, lineset, "FreestyleLineSet", '.', offsetof(FreestyleLineSet, name),
sizeof(lineset->name));
}
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
FreestyleLineSet *FRS_alloc_lineset()
{
return (FreestyleLineSet*)MEM_callocN(sizeof(FreestyleLineSet), "Freestyle line set");
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
FreestyleLineSet *FRS_add_lineset(FreestyleConfig *config)
{
int lineset_index = BLI_countlist(&config->linesets);
Fix for a crash when freeing copied scenes. The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy" to duplicate render layers including lineset settings without taking care of pointers in the linesets. For this reason, freeing the original scene and copied one resulted in freeing allocated memory buffers twice. Now BKE_scene_copy() properly duplicates linesets as part of render layers. Also some code clean-up was made in the modified files. Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
2013-01-29 03:12:49 +00:00
FreestyleLineSet *lineset = FRS_alloc_lineset();
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
BLI_addtail(&config->linesets, (void*)lineset);
FRS_set_active_lineset_index(config, lineset_index);
lineset->linestyle = FRS_new_linestyle("LineStyle", NULL);
lineset->flags |= FREESTYLE_LINESET_ENABLED;
lineset->selection = FREESTYLE_SEL_IMAGE_BORDER;
lineset->qi = FREESTYLE_QI_VISIBLE;
lineset->qi_start = 0;
lineset->qi_end = 100;
lineset->edge_types = FREESTYLE_FE_SILHOUETTE | FREESTYLE_FE_BORDER | FREESTYLE_FE_CREASE;
lineset->exclude_edge_types = 0;
lineset->group = NULL;
if (lineset_index > 0)
sprintf(lineset->name, "LineSet %i", lineset_index + 1);
else
strcpy(lineset->name, "LineSet");
unique_lineset_name(config, lineset);
return lineset;
}
void FRS_copy_active_lineset(FreestyleConfig *config)
{
FreestyleLineSet *lineset = FRS_get_active_lineset(config);
if (lineset) {
lineset_buffer.linestyle = lineset->linestyle;
lineset_buffer.flags = lineset->flags;
lineset_buffer.selection = lineset->selection;
lineset_buffer.qi = lineset->qi;
lineset_buffer.qi_start = lineset->qi_start;
lineset_buffer.qi_end = lineset->qi_end;
lineset_buffer.edge_types = lineset->edge_types;
lineset_buffer.exclude_edge_types = lineset->exclude_edge_types;
lineset_buffer.group = lineset->group;
strcpy(lineset_buffer.name, lineset->name);
lineset_copied = true;
Replaced the changes in revision 41810 with a better implementation of copy/paste functionality. Instead of making a copy of the active line set, now the settings of the active line set are copied to and pasted from a buffer. This allows for copying and pasting line set settings among different scenes and render layers.
2011-11-20 23:44:50 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
Replaced the changes in revision 41810 with a better implementation of copy/paste functionality. Instead of making a copy of the active line set, now the settings of the active line set are copied to and pasted from a buffer. This allows for copying and pasting line set settings among different scenes and render layers.
2011-11-20 23:44:50 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_paste_active_lineset(FreestyleConfig *config)
{
if (!lineset_copied)
return;
FreestyleLineSet *lineset = FRS_get_active_lineset(config);
if (lineset) {
lineset->linestyle->id.us--;
lineset->linestyle = lineset_buffer.linestyle;
lineset->linestyle->id.us++;
lineset->flags = lineset_buffer.flags;
lineset->selection = lineset_buffer.selection;
lineset->qi = lineset_buffer.qi;
lineset->qi_start = lineset_buffer.qi_start;
lineset->qi_end = lineset_buffer.qi_end;
lineset->edge_types = lineset_buffer.edge_types;
lineset->exclude_edge_types = lineset_buffer.exclude_edge_types;
if (lineset->group) {
lineset->group->id.us--;
lineset->group = NULL;
}
if (lineset_buffer.group) {
lineset->group = lineset_buffer.group;
lineset->group->id.us++;
Added a new operator in the Parameter Editor mode to make a copy of the active line set.
2011-11-13 21:55:13 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
strcpy(lineset->name, lineset_buffer.name);
unique_lineset_name(config, lineset);
lineset->flags |= FREESTYLE_LINESET_CURRENT;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_delete_active_lineset(FreestyleConfig *config)
{
FreestyleLineSet *lineset = FRS_get_active_lineset(config);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
if (lineset) {
if (lineset->group) {
lineset->group->id.us--;
lineset->group = NULL;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
lineset->linestyle->id.us--;
lineset->linestyle = NULL;
BLI_remlink(&config->linesets, lineset);
MEM_freeN(lineset);
FRS_set_active_lineset_index(config, 0);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_move_active_lineset_up(FreestyleConfig *config)
{
FreestyleLineSet *lineset = FRS_get_active_lineset(config);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
if (lineset) {
BLI_remlink(&config->linesets, lineset);
BLI_insertlinkbefore(&config->linesets, lineset->prev, lineset);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_move_active_lineset_down(FreestyleConfig *config)
{
FreestyleLineSet *lineset = FRS_get_active_lineset(config);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
if (lineset) {
BLI_remlink(&config->linesets, lineset);
BLI_insertlinkafter(&config->linesets, lineset->next, lineset);
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
FreestyleLineSet *FRS_get_active_lineset(FreestyleConfig *config)
{
FreestyleLineSet *lineset;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (lineset = (FreestyleLineSet*)config->linesets.first; lineset; lineset = lineset->next) {
if (lineset->flags & FREESTYLE_LINESET_CURRENT)
return lineset;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return NULL;
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
short FRS_get_active_lineset_index(FreestyleConfig *config)
{
FreestyleLineSet *lineset;
short i;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (lineset = (FreestyleLineSet*)config->linesets.first, i = 0; lineset; lineset = lineset->next, i++) {
if (lineset->flags & FREESTYLE_LINESET_CURRENT)
return i;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
return 0;
}
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_set_active_lineset_index(FreestyleConfig *config, short index)
{
FreestyleLineSet *lineset;
short i;
A step toward a new user-friendly GUI for manipulating line style parameters. 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.
2010-06-25 22:45:42 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (lineset = (FreestyleLineSet*)config->linesets.first, i = 0; lineset; lineset = lineset->next, i++) {
if (i == index)
lineset->flags |= FREESTYLE_LINESET_CURRENT;
else
lineset->flags &= ~FREESTYLE_LINESET_CURRENT;
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
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
* Removed a back pointer to a Scene (the "current" scene as in Blender 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.
2009-11-01 01:11:15 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void FRS_unlink_target_object(FreestyleConfig *config, Object *ob)
{
FreestyleLineSet *lineset;
Fix for properly unlinking target object pointers when objects are deleted from scenes.
2010-11-29 21:24:55 +00:00
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
for (lineset = (FreestyleLineSet*)config->linesets.first; lineset; lineset = lineset->next) {
FRS_unlink_linestyle_target_object(lineset->linestyle, ob);
Fix for properly unlinking target object pointers when objects are deleted from scenes.
2010-11-29 21:24:55 +00:00
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
Fix for properly unlinking target object pointers when objects are deleted from scenes.
2010-11-29 21:24:55 +00:00
soc-2008-mxcurioni: uploaded missing files. Still NOT linking so do not use this version yet :(
2008-05-19 05:34:31 +00:00
#ifdef __cplusplus
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
} // extern "C"
soc-2008-mxcurioni: uploaded missing files. Still NOT linking so do not use this version yet :(
2008-05-19 05:34:31 +00:00
#endif
Copy Permalink