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

969 lines
32 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.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
* \ingroup freestyle
*/
#include "BlenderStrokeRenderer.h"
#include "../application/AppConfig.h"
#include "../stroke/Canvas.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
extern "C" {
#include "MEM_guardedalloc.h"
Fix for hard-coded #include file paths.
2014-06-27 16:00:22 +09:00
#include "RNA_access.h"
Freestyle: Fix for missing quality control on line rendering in Cycles. Freestyle was using the default Cycles rendering settings (e.g., the number of samples) and users could not change them. Now all render parameters (except for film_transparent) are inherited for Freestyle stroke rendering. Problem report by Danny Grimm on Facebook, thanks!
2014-09-11 13:41:14 +09:00
#include "RNA_types.h"
Fix for hard-coded #include file paths.
2014-06-27 16:00:22 +09:00
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "DNA_camera_types.h"
#include "DNA_listBase.h"
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
#include "DNA_linestyle_types.h"
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
#include "DNA_material_types.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "DNA_meshdata_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_mesh_types.h"
Slightly reduced the memory consumption during stroke rendering by removing ListBase BlenderStrokeRenderer::objects and relying on Base freestyle_scene::base instead.
2010-03-28 18:12:45 +00:00
#include "DNA_object_types.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "DNA_screen_types.h"
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
#include "DNA_scene_types.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "BKE_customdata.h"
Fix T38054: High CPU usage with many objects This is a regression since threaded dependency graph landed to master. Root of the issue goes to the loads of graph preparation being done even if there's nothing to be updated. The idea of this change is to use ID type recalc bits to determine whether there're objects to be updated. Generally speaking, we now check object and object data datablocks with DAG_id_type_tagged() and if there's no such IDs tagged we skip the whole task pool creation and so, The only difficult aspect was that in some circumstances it was possible that there are tagged objects but nothing in ID recalc bit fields. There were several different circumstances when it was possible: * When one assigns object->recalc flag directly DAG flush didn't set corresponding bits to ID recalc bits. Partially it is fixed by making it so flush will set bitfield, but also for object types there's no reason to assign recalc flag directly. Using generic DAG_id_type_tag works almost the same fast as direct assignment, ensures all the bitflags are set properly and for the long run it seems it's what we would actually want to. * DAG_on_visible_update() didn't set recalc bits at all. * Some areas were checking for object->recalc != 0, however it is was possible that object recalc flag contains PSYS_RECALC_CHILD which was never cleaned from there. No idea why would we need to assign such a flag when enabling scene simplification, this is to be investigated separately. * It is possible that scene_update_post and frame_update_post handlers will modify objects. The issue is that DAG_ids_clear_recalc is called just after callbacks, which leaves objects with recalc flags but no corresponding bit in ID recalc bitfield. This leads to some kind of regression when using ID type tag fields to check whether there objects to be updated internally comparing threaded DAG with legacy one. For now let's have a workaround which will preserve tag for ID_OB if there're objects with OB_RECALC_ALL bits. This keeps behavior unchanged comparing with 2.69 release.
2014-01-09 19:13:26 +06:00
#include "BKE_depsgraph.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "BKE_global.h"
#include "BKE_library.h" /* free_libblock */
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 "BKE_material.h"
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
#include "BKE_mesh.h"
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
#include "BKE_node.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "BKE_object.h"
#include "BKE_scene.h"
Freestyle: Caching of auto-generated materials from line style shader nodes.
2014-07-19 23:42:15 +09:00
#include "BLI_ghash.h"
WIP commit just for a record of a working snapshot of code revisions for node-based textured strokes.
2014-07-19 15:38:56 +09:00
#include "BLI_listbase.h"
Fix T44048: freestyle lines in Cycles are in the wrong color space.
2015-10-10 18:44:19 +02:00
#include "BLI_math_color.h"
#include "BLI_math_vector.h"
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
#include "BLI_utildefines.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
#include "RE_pipeline.h"
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
#include "render_types.h"
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
}
Freestyle: quiet BMESH validator warnings of zero normals.
2014-04-24 13:57:10 +09:00
#include <limits.h>
Attempt to fix a potential name conflict between Freestyle and the compositor. A crash in the Freestyle renderer was reported by Ton on IRC with a stack trace below. Note that #2 is in Freestyle, whereas #1 is in the compositor. The problem was observed in a debug build on OS X 10.7 (gcc 4.2, openmp disabled, no llvm). ---------------------------------------------------------------------- Program received signal EXC_BAD_ACCESS, Could not access memory. Reason: 13 at address: 0x0000000000000000 [Switching to process 72386 thread 0xf303] 0x0000000100c129f3 in NodeBase::~NodeBase (this=0x10e501c80) at COM_NodeBase.cpp:43 43 delete (this->m_outputsockets.back()); Current language: auto; currently c++ (gdb) where #0 0x0000000100c129f3 in NodeBase::~NodeBase (this=0x10e501c80) at COM_NodeBase.cpp:43 #1 0x0000000100c29066 in Node::~Node (this=0x10e501c80) at COM_Node.h:49 #2 0x000000010089c273 in NodeShape::~NodeShape (this=0x10e501c80) at NodeShape.cpp:43 #3 0x000000010089910b in NodeGroup::destroy (this=0x10e501da0) at NodeGroup.cpp:61 #4 0x00000001008990cd in NodeGroup::destroy (this=0x10e5014b0) at NodeGroup.cpp:59 #5 0x00000001008990cd in NodeGroup::destroy (this=0x114e18da0) at NodeGroup.cpp:59 #6 0x00000001007e6602 in Controller::ClearRootNode (this=0x114e19640) at Controller.cpp:329 #7 0x00000001007ea52e in Controller::LoadMesh (this=0x114e19640, re=0x10aba4638, srl=0x1140f5258) at Controller.cpp:302 #8 0x00000001008030ad in prepare (re=0x10aba4638, srl=0x1140f5258) at FRS_freestyle.cpp:302 #9 0x000000010080457a in FRS_do_stroke_rendering (re=0x10aba4638, srl=0x1140f5258) at FRS_freestyle.cpp:600 #10 0x00000001006aeb9d in add_freestyle (re=0x10aba4638) at pipeline.c:1584 #11 0x00000001006aceb7 in do_render_3d (re=0x10aba4638) at pipeline.c:1094 #12 0x00000001006ae061 in do_render_fields_blur_3d (re=0x10aba4638) at pipeline.c:1367 #13 0x00000001006afa16 in do_render_composite_fields_blur_3d (re=0x10aba4638) at pipeline.c:1815 #14 0x00000001006b04e4 in do_render_all_options (re=0x10aba4638) at pipeline.c:2021 ---------------------------------------------------------------------- Apparently a name conflict between the two Blender modules is taking place. The present commit hence intends to address it by putting all the Freestyle C++ classes in the namespace 'Freestyle'. This revision will also prevent potential name conflicts with other Blender modules in the future. Special thanks to Lukas Toenne for the help with C++ namespace.
2013-04-09 00:46:49 +00:00
namespace Freestyle {
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
const char *BlenderStrokeRenderer::uvNames[] = {"along_stroke", "along_stroke_tips"};
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
BlenderStrokeRenderer::BlenderStrokeRenderer(Render *re, int render_count) : StrokeRenderer()
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
{
Second attempt to fix T40833: Crash when rendering with freestyle. The cause of the crash was identified in an uninitialized member variable `Main->lock`. Now that struct Main has a few member variables whose values are dynamically allocated, per-render Freestyle-specific Main data structures will be allocated and released using `BKE_main_new()` and `BKE_main_free()`, respectively. This revision complements the commit rB6135556f4556.
2014-07-01 23:35:09 +09:00
freestyle_bmain = re->freestyle_bmain;
Make freestyle use local Main for temporary objects This means main database is no longer pollutes with temporary scene and objects needed for freestyle render. Actually, there're few of separated temporary mains now. Ideally it's better to use single one, but it's not so much trivial to pass it to all classes. Not so big deal actually. Required some changes to blender kernel, to make it possible to add object to a given main, also to check on mesh materials for objects in given main. This is all straightforward changes. As an additional, solved issue with main database being infinitely polluted with text blocks created by create_lineset_handler function. This fixes: - #35003: Freestyle crashes if user expands objects in FRS1_Scene - #35012: ctrl+f12 rendering crashes when using Freestyle
2013-04-18 08:58:21 +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 stroke mesh generation
_width = re->winx;
_height = re->winy;
Fix for a crash when two scenes in the compositor have different render resolution (i.e., image width and height, scaled by the size factor). Problem report by flokkievids together with a .blend file for reproducing the bug, thanks!
2011-11-06 12:23:44 +00:00
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
old_scene = re->scene;
Second attempt for properly releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 23:27:10 +00:00
Replaced a hard-coded array length with MAX_ID_NAME.
2013-06-10 10:58:49 +00:00
char name[MAX_ID_NAME - 2];
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_snprintf(name, sizeof(name), "FRS%d_%s", render_count, re->scene->id.name + 2);
Fix for full-sample anti-aliasing (FSAA) not working with Freestyle. Reverted the trunk revision 56136 and part of revision 56127 concerning the local Main for Freestyle and temporary scene generation for stroke rendering. The function do_merge_fullsample() in pipeline.c has access to the Scene of each Render, so that the temporary Scene generated by Freestyle has to be kept for FSAA even after stroke rendering has been done. By the same token, the local Main has been moved from the BlenderStrokeRenderer class to Render. It is noted that free_all_freestyle_renders() in pipeline.c is intended to get the temporary Scene of each Render released specifically taking account of the FSAA case.
2013-04-23 22:40:13 +00:00
freestyle_scene = BKE_scene_add(freestyle_bmain, name);
Fix for composite node parameter animation not working with Freestyle. The problem was reported by ikeahloe together with a .blend file for reproducing the issue. Thanks!
2011-04-17 02:47:32 +00:00
freestyle_scene->r.cfra = old_scene->r.cfra;
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_scene->r.mode = old_scene->r.mode &
~(R_EDGE_FRS | R_SHADOW | R_SSS | R_PANORAMA | R_ENVMAP | R_MBLUR | R_BORDER);
freestyle_scene->r.xsch = re->rectx; // old_scene->r.xsch
freestyle_scene->r.ysch = re->recty; // old_scene->r.ysch
freestyle_scene->r.xasp = 1.0f; // old_scene->r.xasp;
freestyle_scene->r.yasp = 1.0f; // old_scene->r.yasp;
freestyle_scene->r.tilex = old_scene->r.tilex;
freestyle_scene->r.tiley = old_scene->r.tiley;
freestyle_scene->r.size = 100; // old_scene->r.size
Freestyle changes: - Revert some stylistic changes made in branch They weren't directly related on freestyle project and better be handled in trunk. Helps reading patches ad prevents possible merge conflicts. - Solved issue introduced with recent deprecation of RenderData.maximize,
2013-03-26 09:59:43 +00:00
//freestyle_scene->r.maximsize = old_scene->r.maximsize; /* DEPRECATED */
Fixed a bug in the initialization of a temporary Scene struct for stroke rendering. This fix is intended to improve the stability of stroke rendering when the output format is AVI Codec, QuickTime, or one of FFMpeg codecs.
2010-08-16 16:51:44 +00:00
freestyle_scene->r.ocres = old_scene->r.ocres;
Fix for color management not working properly with Freestyle.
2012-01-21 21:58:47 +00:00
freestyle_scene->r.color_mgt_flag = 0; // old_scene->r.color_mgt_flag;
Freestyle: Fix for stroke rendering performed with multi-views enabled. Per-view Freestyle stroke rendering needs to be done without multi-views.
2015-05-16 23:57:37 +09:00
freestyle_scene->r.scemode = old_scene->r.scemode & ~(R_SINGLE_LAYER | R_NO_FRAME_UPDATE | R_MULTIVIEW);
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_scene->r.flag = old_scene->r.flag;
freestyle_scene->r.threads = old_scene->r.threads;
freestyle_scene->r.border.xmin = old_scene->r.border.xmin;
freestyle_scene->r.border.ymin = old_scene->r.border.ymin;
freestyle_scene->r.border.xmax = old_scene->r.border.xmax;
freestyle_scene->r.border.ymax = old_scene->r.border.ymax;
Fixed a bug in the initialization of a temporary Scene struct for stroke rendering. This fix is intended to improve the stability of stroke rendering when the output format is AVI Codec, QuickTime, or one of FFMpeg codecs.
2010-08-16 16:51:44 +00:00
strcpy(freestyle_scene->r.pic, old_scene->r.pic);
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_scene->r.safety.xmin = old_scene->r.safety.xmin;
freestyle_scene->r.safety.ymin = old_scene->r.safety.ymin;
freestyle_scene->r.safety.xmax = old_scene->r.safety.xmax;
freestyle_scene->r.safety.ymax = old_scene->r.safety.ymax;
freestyle_scene->r.osa = old_scene->r.osa;
freestyle_scene->r.filtertype = old_scene->r.filtertype;
freestyle_scene->r.gauss = old_scene->r.gauss;
freestyle_scene->r.dither_intensity = old_scene->r.dither_intensity;
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
BLI_strncpy(freestyle_scene->r.engine, old_scene->r.engine, sizeof(freestyle_scene->r.engine));
Merged changes in the trunk up to revision 42116.
2011-11-26 13:11:55 +00:00
freestyle_scene->r.im_format.planes = R_IMF_PLANES_RGBA;
freestyle_scene->r.im_format.imtype = R_IMF_IMTYPE_PNG;
Fix for OCIO-based color management (reported in the commit log of revision 50832). The solution is exactly the same with revision 43584 for a similar issue in pre-OCIO color management: i.e., just disabling color management during the nested invocation of BI for stroke rendering.
2012-10-20 20:46:42 +00:00
A patch set from Bastien Montagne (thanks!) for silencing build warnings (from gcc 4.7), mostly by commenting out unused variables, or using the BLI's SET_UINT_IN_POINTER macro.
2013-01-18 02:13:36 +00:00
if (G.debug & G_DEBUG_FREESTYLE) {
Fix for a wrong threads count shown in Freestyle debug mode (--debug-freestyle).
2014-07-04 15:18:06 +09:00
printf("%s: %d thread(s)\n", __func__, BKE_render_num_threads(&freestyle_scene->r));
A patch set from Bastien Montagne (thanks!) for silencing build warnings (from gcc 4.7), mostly by commenting out unused variables, or using the BLI's SET_UINT_IN_POINTER macro.
2013-01-18 02:13:36 +00:00
}
Merged changes in the trunk up to revision 53584. Conflicts resolved: release/scripts/startup/bl_ui/properties_render.py source/blender/blenloader/intern/readfile.c source/blender/editors/interface/interface_templates.c source/blender/makesrna/RNA_enum_types.h Also made additional code updates for: r53355 UIList - Python-extendable list of UI items r53460 Alpha premul pipeline cleanup
2013-01-05 22:24:05 +00:00
// Render layer
SceneRenderLayer *srl = (SceneRenderLayer *)freestyle_scene->r.layers.first;
srl->layflag = SCE_LAY_SOLID | SCE_LAY_ZTRA;
Fix for full-sample anti-aliasing (FSAA) not working with Freestyle. Reverted the trunk revision 56136 and part of revision 56127 concerning the local Main for Freestyle and temporary scene generation for stroke rendering. The function do_merge_fullsample() in pipeline.c has access to the Scene of each Render, so that the temporary Scene generated by Freestyle has to be kept for FSAA even after stroke rendering has been done. By the same token, the local Main has been moved from the BlenderStrokeRenderer class to Render. It is noted that free_all_freestyle_renders() in pipeline.c is intended to get the temporary Scene of each Render released specifically taking account of the FSAA case.
2013-04-23 22:40:13 +00:00
BKE_scene_set_background(freestyle_bmain, freestyle_scene);
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
// Camera
Freestyle: Compilation error fix after recent changes in BKE_object_add()
2015-05-04 13:51:51 +05:00
Object *object_camera = BKE_object_add(freestyle_bmain, freestyle_scene, OB_CAMERA, NULL);
Depsgraph: Add additional relations/id update tags This calls are not strictly speaking needed for the old dependency graph, but due to more granular nature of upcoming depsgraph more actions requires update of relations of IDs. On the one hand this extra tags could be wrapped with if() statements, but on the other hand it makes sense to keep tag in sync so it's clear if some issue is caused by missing/extra tag or by depsgraph itself.
2015-05-12 13:29:00 +05:00
DAG_relations_tag_update(freestyle_bmain);
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 big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00:00
Camera *camera = (Camera *)object_camera->data;
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
camera->type = CAM_ORTHO;
Fix for a crash when two scenes in the compositor have different render resolution (i.e., image width and height, scaled by the size factor). Problem report by flokkievids together with a .blend file for reproducing the bug, thanks!
2011-11-06 12:23:44 +00:00
camera->ortho_scale = max(re->rectx, re->recty);
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->clipsta = 0.1f;
camera->clipend = 100.0f;
Added support for transparent stroke colors (again). Transparent strokes are rendered by means of transparent vertex colors. To make this possible, Blender's internal renderer has been slightly extended to allow transparent vertex colors. When Material::vcol_alpha is non-zero, the renderer takes MCol::a into account.
2010-02-16 02:10: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
_z_delta = 0.00001f;
_z = camera->clipsta + _z_delta;
Added support for transparent stroke colors (again). Transparent strokes are rendered by means of transparent vertex colors. To make this possible, Blender's internal renderer has been slightly extended to allow transparent vertex colors. When Material::vcol_alpha is non-zero, the renderer takes MCol::a into account.
2010-02-16 02:10:27 +00:00
Fix for a crash when two scenes in the compositor have different render resolution (i.e., image width and height, scaled by the size factor). Problem report by flokkievids together with a .blend file for reproducing the bug, thanks!
2011-11-06 12:23:44 +00:00
object_camera->loc[0] = re->disprect.xmin + 0.5f * re->rectx;
object_camera->loc[1] = re->disprect.ymin + 0.5f * re->recty;
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
object_camera->loc[2] = 1.0f;
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
freestyle_scene->camera = object_camera;
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 a static variable in BlenderStrokeRenderer::RenderStrokeRep() left after quick trials of different approaches to performance improvement.
2013-02-14 19:19:44 +00:00
// Reset serial mesh ID (used for BlenderStrokeRenderer::NewMesh())
_mesh_id = 0xffffffff;
Freestyle: Caching of auto-generated materials from line style shader nodes.
2014-07-19 23:42:15 +09:00
// Check if the rendering engine uses new shading nodes
_use_shading_nodes = BKE_scene_use_new_shading_nodes(freestyle_scene);
// Create a bNodeTree-to-Material hash table
if (_use_shading_nodes)
_nodetree_hash = BLI_ghash_ptr_new("BlenderStrokeRenderer::_nodetree_hash");
else
_nodetree_hash = NULL;
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +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
BlenderStrokeRenderer::~BlenderStrokeRenderer()
{
Minor comment fixes.
2010-06-26 16:35:56 +00:00
// The freestyle_scene object is not released here. Instead,
// the scene is released in free_all_freestyle_renders() in
// source/blender/render/intern/source/pipeline.c, after the
// compositor has finished.
Second attempt for properly releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 23:27:10 +00:00
// release objects and data blocks
A big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00:00
for (Base *b = (Base *)freestyle_scene->base.first; b; b = b->next) {
Slightly reduced the memory consumption during stroke rendering by removing ListBase BlenderStrokeRenderer::objects and relying on Base freestyle_scene::base instead.
2010-03-28 18:12:45 +00:00
Object *ob = b->object;
Second attempt for properly releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 23:27:10 +00:00
void *data = ob->data;
Fix for a buffer overflow, by simply removing the unnecessary string copy. Review comment from Campbell.
2013-03-02 18:43:06 +00:00
char *name = ob->id.name;
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 << "removing " << name[0] << name[1] << ":" << (name+2) << endl;
}
#endif
Second attempt for properly releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 23:27:10 +00:00
switch (ob->type) {
Made changes for releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 00:01:34 +00:00
case OB_MESH:
Fix collada and freestyle module compile errors after recent commit, forgot to compile with those enabled.
2014-01-15 19:15:51 +01:00
BKE_libblock_free(freestyle_bmain, ob);
BKE_libblock_free(freestyle_bmain, data);
Made changes for releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 00:01:34 +00:00
break;
case OB_CAMERA:
Fix collada and freestyle module compile errors after recent commit, forgot to compile with those enabled.
2014-01-15 19:15:51 +01:00
BKE_libblock_free(freestyle_bmain, ob);
BKE_libblock_free(freestyle_bmain, data);
Slightly reduced the memory consumption during stroke rendering by removing ListBase BlenderStrokeRenderer::objects and relying on Base freestyle_scene::base instead.
2010-03-28 18:12:45 +00:00
freestyle_scene->camera = NULL;
Made changes for releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 00:01:34 +00:00
break;
default:
A big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00:00
cerr << "Warning: unexpected object in the scene: " << name[0] << name[1] << ":" << (name + 2) << endl;
Made changes for releasing temporary objects and their data blocks in BlenderStrokeRenderer::~BlenderStrokeRenderer().
2009-07-22 00:01:34 +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
BLI_freelistN(&freestyle_scene->base);
Fix for an occasional crash in Freestyle stroke rendering. Materials were freed before releasing meshes that may have references to the materials.
2014-05-09 11:38:36 +09:00
// release materials
Link *lnk = (Link *)freestyle_bmain->mat.first;
while (lnk)
{
Material *ma = (Material*)lnk;
// We want to retain the linestyle mtexs, so let's detach them first
for (int a = 0; a < MAX_MTEX; a++) {
if (ma->mtex[a]) {
ma->mtex[a] = NULL;
}
else {
break; // Textures are ordered, no empty slots between two textures
}
}
lnk = lnk->next;
BKE_libblock_free(freestyle_bmain, ma);
}
Freestyle: Caching of auto-generated materials from line style shader nodes.
2014-07-19 23:42:15 +09:00
if (_use_shading_nodes)
BLI_ghash_free(_nodetree_hash, NULL, NULL);
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
FreeStrokeGroups();
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +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
float BlenderStrokeRenderer::get_stroke_vertex_z(void) const
{
float z = _z;
BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this);
if (!(_z < _z_delta * 100000.0f))
self->_z_delta *= 10.0f;
self->_z += _z_delta;
return -z;
Added support for transparent stroke colors (again). Transparent strokes are rendered by means of transparent vertex colors. To make this possible, Blender's internal renderer has been slightly extended to allow transparent vertex colors. When Material::vcol_alpha is non-zero, the renderer takes MCol::a into account.
2010-02-16 02:10:27 +00:00
}
Fix for a static variable in BlenderStrokeRenderer::RenderStrokeRep() left after quick trials of different approaches to performance improvement.
2013-02-14 19:19:44 +00:00
unsigned int BlenderStrokeRenderer::get_stroke_mesh_id(void) const
{
unsigned mesh_id = _mesh_id;
BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this);
self->_mesh_id--;
return mesh_id;
}
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
Material* BlenderStrokeRenderer::GetStrokeShader(Main *bmain, bNodeTree *iNodeTree, bool do_id_user)
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: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Material *ma = BKE_material_add(bmain, "stroke_shader");
bNodeTree *ntree;
bNode *output_linestyle = NULL;
bNodeSocket *fromsock, *tosock;
PointerRNA fromptr, toptr;
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
NodeShaderAttribute *storage;
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Fix T48045: Freestyle ID user decrement error. This fixes reported issue, but there could be more of those hidden in Freestyle code, it did not handle user refcount at all (and the fact it by-passes BKE in some places for efficiency does not help here). Note that this should be relatively harmless, since freestyle uses own Main during render, so everything is cleaned up in the end in any case... But better try to handle IDs correctly here too. :)
2016-04-04 15:43:45 +02:00
id_us_min(&ma->id);
Freestyle: an improved workflow of line style shading nodes. Removed the previous changes for passing a line style through the Controller, and revised the BlenderTextureShader to assign the shader node tree of a line style (if specified) to strokes. This way the assignment of shading nodes can be done through both the Freestyle GUI and Python scripting.
2014-07-19 18:52:32 +09:00
if (iNodeTree) {
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
// make a copy of linestyle->nodetree
Freestyle: Fix for an increasing reference count of images in copied Image Texture shader nodes.
2014-07-20 17:41:36 +09:00
ntree = ntreeCopyTree_ex(iNodeTree, bmain, do_id_user);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
// find the active Output Line Style node
for (bNode *node = (bNode *)ntree->nodes.first; node; node = node->next) {
if (node->type == SH_NODE_OUTPUT_LINESTYLE && (node->flag & NODE_DO_OUTPUT)) {
output_linestyle = node;
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
break;
}
}
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
}
else {
ntree = ntreeAddTree(NULL, "stroke_shader", "ShaderNodeTree");
}
ma->nodetree = ntree;
ma->use_nodes = 1;
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *input_attr_color = nodeAddStaticNode(NULL, ntree, SH_NODE_ATTRIBUTE);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
input_attr_color->locx = 0.0f;
input_attr_color->locy = -200.0f;
storage = (NodeShaderAttribute *)input_attr_color->storage;
Fix for vertex colors not working properly. Looks like the issue was caused by a UV map name starting with a lower case letter (e.g., "color"). Capitalizing the name fixed the problem. Also adjusted the creation of custom data layers to optimize things a bit.
2014-07-21 18:49:27 +09:00
BLI_strncpy(storage->name, "Color", sizeof(storage->name));
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *mix_rgb_color = nodeAddStaticNode(NULL, ntree, SH_NODE_MIX_RGB);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
mix_rgb_color->custom1 = MA_RAMP_BLEND; // Mix
mix_rgb_color->locx = 200.0f;
mix_rgb_color->locy = -200.0f;
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
RNA_float_set(&toptr, "default_value", 0.0f);
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *input_attr_alpha = nodeAddStaticNode(NULL, ntree, SH_NODE_ATTRIBUTE);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
input_attr_alpha->locx = 400.0f;
input_attr_alpha->locy = 300.0f;
storage = (NodeShaderAttribute *)input_attr_alpha->storage;
Fix for vertex colors not working properly. Looks like the issue was caused by a UV map name starting with a lower case letter (e.g., "color"). Capitalizing the name fixed the problem. Also adjusted the creation of custom data layers to optimize things a bit.
2014-07-21 18:49:27 +09:00
BLI_strncpy(storage->name, "Alpha", sizeof(storage->name));
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *mix_rgb_alpha = nodeAddStaticNode(NULL, ntree, SH_NODE_MIX_RGB);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
mix_rgb_alpha->custom1 = MA_RAMP_BLEND; // Mix
mix_rgb_alpha->locx = 600.0f;
mix_rgb_alpha->locy = 300.0f;
Fix for wrong link in the line style shader nodes due to a typo.
2014-07-21 18:47:19 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
Freestyle: Fix for stroke_shader node default values copied from the Output Line Style node.
2014-07-16 15:27:40 +09:00
RNA_float_set(&toptr, "default_value", 0.0f);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *shader_emission = nodeAddStaticNode(NULL, ntree, SH_NODE_EMISSION);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
shader_emission->locx = 400.0f;
shader_emission->locy = -200.0f;
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *input_light_path = nodeAddStaticNode(NULL, ntree, SH_NODE_LIGHT_PATH);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
input_light_path->locx = 400.0f;
input_light_path->locy = 100.0f;
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *mix_shader_color = nodeAddStaticNode(NULL, ntree, SH_NODE_MIX_SHADER);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
mix_shader_color->locx = 600.0f;
mix_shader_color->locy = -100.0f;
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *shader_transparent = nodeAddStaticNode(NULL, ntree, SH_NODE_BSDF_TRANSPARENT);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
shader_transparent->locx = 600.0f;
shader_transparent->locy = 100.0f;
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *mix_shader_alpha = nodeAddStaticNode(NULL, ntree, SH_NODE_MIX_SHADER);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
mix_shader_alpha->locx = 800.0f;
mix_shader_alpha->locy = 100.0f;
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *output_material = nodeAddStaticNode(NULL, ntree, SH_NODE_OUTPUT_MATERIAL);
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
output_material->locx = 1000.0f;
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
output_material->locy = 100.0f;
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&input_attr_color->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 1); // Color1
nodeAddLink(ntree, input_attr_color, fromsock, mix_rgb_color, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->outputs, 0); // Color
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
tosock = (bNodeSocket *)BLI_findlink(&shader_emission->inputs, 0); // Color
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
nodeAddLink(ntree, mix_rgb_color, fromsock, shader_emission, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&shader_emission->outputs, 0); // Emission
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 2); // Shader (second)
nodeAddLink(ntree, shader_emission, fromsock, mix_shader_color, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&input_light_path->outputs, 0); // In Camera Ray
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 0); // Fac
nodeAddLink(ntree, input_light_path, fromsock, mix_shader_color, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 0); // Fac
nodeAddLink(ntree, mix_rgb_alpha, fromsock, mix_shader_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&input_attr_alpha->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 1); // Color1
nodeAddLink(ntree, input_attr_alpha, fromsock, mix_rgb_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&shader_transparent->outputs, 0); // BSDF
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 1); // Shader (first)
nodeAddLink(ntree, shader_transparent, fromsock, mix_shader_alpha, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_color->outputs, 0); // Shader
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 2); // Shader (second)
nodeAddLink(ntree, mix_shader_color, fromsock, mix_shader_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->outputs, 0); // Shader
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
tosock = (bNodeSocket *)BLI_findlink(&output_material->inputs, 0); // Surface
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
nodeAddLink(ntree, mix_shader_alpha, fromsock, output_material, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
if (output_linestyle) {
bNodeSocket *outsock;
bNodeLink *link;
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
mix_rgb_color->custom1 = output_linestyle->custom1; // blend_type
mix_rgb_color->custom2 = output_linestyle->custom2; // use_clamp
Freestyle: Added "blend_type" and "use_clamp" options to the Output Line Style shader node.
2014-07-16 22:25:37 +09:00
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 0); // Color
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 2); // Color2
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
}
Freestyle: Fix for stroke_shader node default values copied from the Output Line Style node.
2014-07-16 15:27:40 +09:00
else {
float color[4];
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock, &fromptr);
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
RNA_float_get_array(&fromptr, "default_value", color);
RNA_float_set_array(&toptr, "default_value", color);
}
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 1); // Color Fac
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
}
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
else {
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock, &fromptr);
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
RNA_float_set(&toptr, "default_value", RNA_float_get(&fromptr, "default_value"));
}
outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 2); // Alpha
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 2); // Color2
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
}
else {
float color[4];
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock, &fromptr);
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
color[0] = color[1] = color[2] = RNA_float_get(&fromptr, "default_value");
color[3] = 1.0f;
RNA_float_set_array(&toptr, "default_value", color);
}
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 3); // Alpha Fac
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
}
else {
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock, &fromptr);
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock, &toptr);
RNA_float_set(&toptr, "default_value", RNA_float_get(&fromptr, "default_value"));
}
WIP commit just for a record of a working snapshot of code revisions for node-based textured strokes.
2014-07-19 15:38:56 +09:00
for (bNode *node = (bNode *)ntree->nodes.first; node; node = node->next) {
Freestyle: Properly reconnect links from a UV Along Stroke node to a UV Map node.
2014-07-20 16:21:05 +09:00
if (node->type == SH_NODE_UVALONGSTROKE) {
// UV output of the UV Along Stroke node
bNodeSocket *sock = (bNodeSocket *)BLI_findlink(&node->outputs, 0);
// add new UV Map node
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
bNode *input_uvmap = nodeAddStaticNode(NULL, ntree, SH_NODE_UVMAP);
WIP commit just for a record of a working snapshot of code revisions for node-based textured strokes.
2014-07-19 15:38:56 +09:00
input_uvmap->locx = node->locx - 200.0f;
input_uvmap->locy = node->locy;
NodeShaderUVMap *storage = (NodeShaderUVMap *)input_uvmap->storage;
Freestyle: Properly reconnect links from a UV Along Stroke node to a UV Map node.
2014-07-20 16:21:05 +09:00
if (node->custom1 & 1) { // use_tips
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
BLI_strncpy(storage->uv_map, uvNames[1], sizeof(storage->uv_map));
Freestyle: Properly reconnect links from a UV Along Stroke node to a UV Map node.
2014-07-20 16:21:05 +09:00
}
else {
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
BLI_strncpy(storage->uv_map, uvNames[0], sizeof(storage->uv_map));
Freestyle: Properly reconnect links from a UV Along Stroke node to a UV Map node.
2014-07-20 16:21:05 +09:00
}
WIP commit just for a record of a working snapshot of code revisions for node-based textured strokes.
2014-07-19 15:38:56 +09:00
fromsock = (bNodeSocket *)BLI_findlink(&input_uvmap->outputs, 0); // UV
Freestyle: Properly reconnect links from a UV Along Stroke node to a UV Map node.
2014-07-20 16:21:05 +09:00
// replace links from the UV Along Stroke node by links from the UV Map node
for (bNodeLink *link = (bNodeLink *)ntree->links.first; link; link = link->next) {
if (link->fromnode == node && link->fromsock == sock) {
nodeAddLink(ntree, input_uvmap, fromsock, link->tonode, link->tosock);
}
}
nodeRemSocketLinks(ntree, sock);
WIP commit just for a record of a working snapshot of code revisions for node-based textured strokes.
2014-07-19 15:38:56 +09:00
}
}
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
}
Freestyle: Proper support for alpha transparency in line style shader nodes for Cycles.
2014-07-21 15:08:07 +09:00
nodeSetActive(ntree, output_material);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
ntreeUpdateTree(bmain, ntree);
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
return ma;
}
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
void BlenderStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
{
RenderStrokeRepBasic(iStrokeRep);
}
void BlenderStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) const
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
{
Freestyle: Caching of auto-generated materials from line style shader nodes.
2014-07-19 23:42:15 +09:00
if (_use_shading_nodes) {
bNodeTree *nt = iStrokeRep->getNodeTree();
Material *ma = (Material *)BLI_ghash_lookup(_nodetree_hash, nt);
if (!ma) {
Freestyle: Removed the stored bContext from the Controller class. The stored context object was used for creation of shade nodes. A closer look at the node system showed that the context is not actually used when shader nodes are added to a shader node tree. Relying on this fact, now a NULL pointer is passed to nodeAddStaticNode() instead of the stored bContext pointer.
2014-08-01 10:18:25 +09:00
ma = BlenderStrokeRenderer::GetStrokeShader(freestyle_bmain, nt, false);
Freestyle: Caching of auto-generated materials from line style shader nodes.
2014-07-19 23:42:15 +09:00
BLI_ghash_insert(_nodetree_hash, nt, ma);
}
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
Cleanup: de-duplicate engine-id's
2014-10-28 12:49:04 +01:00
if (STREQ(freestyle_scene->r.engine, RE_engine_id_CYCLES)) {
Freestyle: Fix for missing quality control on line rendering in Cycles. Freestyle was using the default Cycles rendering settings (e.g., the number of samples) and users could not change them. Now all render parameters (except for film_transparent) are inherited for Freestyle stroke rendering. Problem report by Danny Grimm on Facebook, thanks!
2014-09-11 13:41:14 +09:00
PointerRNA scene_ptr, freestyle_scene_ptr;
RNA_pointer_create(NULL, &RNA_Scene, old_scene, &scene_ptr);
RNA_pointer_create(NULL, &RNA_Scene, freestyle_scene, &freestyle_scene_ptr);
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
PointerRNA cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
Freestyle: Fix for missing quality control on line rendering in Cycles. Freestyle was using the default Cycles rendering settings (e.g., the number of samples) and users could not change them. Now all render parameters (except for film_transparent) are inherited for Freestyle stroke rendering. Problem report by Danny Grimm on Facebook, thanks!
2014-09-11 13:41:14 +09:00
PointerRNA freestyle_cycles_ptr = RNA_pointer_get(&freestyle_scene_ptr, "cycles");
int flag;
RNA_STRUCT_BEGIN(&freestyle_cycles_ptr, prop)
{
flag = RNA_property_flag(prop);
if (flag & PROP_HIDDEN)
continue;
RNA_property_copy(&freestyle_cycles_ptr, &cycles_ptr, prop, -1);
}
RNA_STRUCT_END;
RNA_boolean_set(&freestyle_cycles_ptr, "film_transparent", 1);
Initial implementation of Cycles materials for Freestyle stroke rendering.
2014-06-27 00:40:41 +09:00
}
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
iStrokeRep->setMaterial(ma);
}
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
else {
bool has_mat = false;
int a = 0;
// Look for a good existing material
for (Link *lnk = (Link *)freestyle_bmain->mat.first; lnk; lnk = lnk->next) {
Material *ma = (Material*)lnk;
bool texs_are_good = true;
// as soon as textures differ it's not the right one
for (int a = 0; a < MAX_MTEX; a++) {
if (ma->mtex[a] != iStrokeRep->getMTex(a)) {
texs_are_good = false;
break;
}
}
if (texs_are_good) {
iStrokeRep->setMaterial(ma);
has_mat = true;
break; // if textures are good, no need to search anymore
}
}
// If still no material, create one
if (!has_mat) {
Material *ma = BKE_material_add(freestyle_bmain, "stroke_material");
Depsgraph: Add additional relations/id update tags This calls are not strictly speaking needed for the old dependency graph, but due to more granular nature of upcoming depsgraph more actions requires update of relations of IDs. On the one hand this extra tags could be wrapped with if() statements, but on the other hand it makes sense to keep tag in sync so it's clear if some issue is caused by missing/extra tag or by depsgraph itself.
2015-05-12 13:29:00 +05:00
DAG_relations_tag_update(freestyle_bmain);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
ma->mode |= MA_VERTEXCOLP;
ma->mode |= MA_TRANSP;
ma->mode |= MA_SHLESS;
ma->vcol_alpha = 1;
Fix T48045: Freestyle ID user decrement error. This fixes reported issue, but there could be more of those hidden in Freestyle code, it did not handle user refcount at all (and the fact it by-passes BKE in some places for efficiency does not help here). Note that this should be relatively harmless, since freestyle uses own Main during render, so everything is cleaned up in the end in any case... But better try to handle IDs correctly here too. :)
2016-04-04 15:43:45 +02:00
id_us_min(&ma->id);
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
// Textures
while (iStrokeRep->getMTex(a)) {
ma->mtex[a] = (MTex *)iStrokeRep->getMTex(a);
// We'll generate both with tips and without tips
// coordinates, on two different UV layers.
Cleanup: style
2017-06-02 15:38:04 +10:00
if (ma->mtex[a]->texflag & MTEX_TIPS) {
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
BLI_strncpy(ma->mtex[a]->uvname, uvNames[1], sizeof(ma->mtex[a]->uvname));
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
}
else {
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
BLI_strncpy(ma->mtex[a]->uvname, uvNames[0], sizeof(ma->mtex[a]->uvname));
Freestyle: Added preliminary support for textured strokes in Cycles. Now the shader node tree of a line style ID datablock is used to define textures as well as their mapping and influence. TODO: Textures alpha channel mapping and influence. TODO: Blend mode in the Output Line Style shader node.
2014-07-16 00:21:27 +09:00
}
a++;
}
iStrokeRep->setMaterial(ma);
}
}
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
const vector<Strip*>& strips = iStrokeRep->getStrips();
const bool hasTex = iStrokeRep->hasTex();
int totvert = 0, totedge = 0, totpoly = 0, totloop = 0;
int visible_faces, visible_segments;
for (vector<Strip*>::const_iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
Strip::vertex_container& strip_vertices = (*s)->vertices();
// count visible faces and strip segments
test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
if (visible_faces == 0)
continue;
totvert += visible_faces + visible_segments * 2;
totedge += visible_faces * 2 + visible_segments;
totpoly += visible_faces;
totloop += visible_faces * 3;
}
BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this); // FIXME
vector<StrokeGroup*> *groups = hasTex ? &self->texturedStrokeGroups : &self->strokeGroups;
StrokeGroup *group;
if (groups->empty() || !(groups->back()->totvert + totvert < MESH_MAX_VERTS &&
groups->back()->totcol + 1 < MAXMAT))
{
group = new StrokeGroup;
groups->push_back(group);
}
else {
group = groups->back();
}
group->strokes.push_back(iStrokeRep);
group->totvert += totvert;
group->totedge += totedge;
group->totpoly += totpoly;
group->totloop += totloop;
group->totcol++;
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
}
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
// Check if the triangle is visible (i.e., within the render image boundary)
bool BlenderStrokeRenderer::test_triangle_visibility(StrokeVertexRep *svRep[3]) const
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: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
int xl, xu, yl, yu;
Vec2r p;
xl = xu = yl = yu = 0;
for (int i = 0; i < 3; i++) {
p = svRep[i]->point2d();
if (p[0] < 0.0)
xl++;
else if (p[0] > _width)
xu++;
if (p[1] < 0.0)
yl++;
else if (p[1] > _height)
yu++;
}
return !(xl == 3 || xu == 3 || yl == 3 || yu == 3);
}
// Check the visibility of faces and strip segments.
void BlenderStrokeRenderer::test_strip_visibility(Strip::vertex_container& strip_vertices,
int *visible_faces, int *visible_segments) const
{
const int strip_vertex_count = strip_vertices.size();
Strip::vertex_container::iterator v[3];
StrokeVertexRep *svRep[3];
bool visible;
// iterate over all vertices and count visible faces and strip segments
// (note: a strip segment is a series of visible faces, while two strip
// segments are separated by one or more invisible faces)
v[0] = strip_vertices.begin();
v[1] = v[0] + 1;
v[2] = v[0] + 2;
*visible_faces = *visible_segments = 0;
visible = false;
for (int n = 2; n < strip_vertex_count; n++, v[0]++, v[1]++, v[2]++) {
svRep[0] = *(v[0]);
svRep[1] = *(v[1]);
svRep[2] = *(v[2]);
if (test_triangle_visibility(svRep)) {
(*visible_faces)++;
if (!visible)
(*visible_segments)++;
visible = true;
}
else {
visible = false;
}
}
}
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: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// Release allocated memory for stroke groups
void BlenderStrokeRenderer::FreeStrokeGroups()
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
{
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
vector<StrokeGroup*>::const_iterator it, itend;
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: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
for (it = strokeGroups.begin(), itend = strokeGroups.end();
it != itend; ++it)
{
delete (*it);
}
for (it = texturedStrokeGroups.begin(), itend = texturedStrokeGroups.end();
it != itend; ++it)
{
delete (*it);
}
}
Made an attempt to improve memory consumption during stroke rendering. When objects exists out of the viewing frustrum and near the near clipping plane, feature edges in the 3D camera coordinate system are projected to an extremely far location from the camera view in the 2D image space. These feature edges result in very long strokes with a large number of stroke vertices, which temporarily require a significant memory storage, causing a fatal "out of memory" error. This problem is partially addressed by the changes in the present commit.
2010-01-26 22:24:53 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// Build a scene populated by mesh objects representing stylized strokes
int BlenderStrokeRenderer::GenerateScene()
{
vector<StrokeGroup*>::const_iterator it, itend;
Made an attempt to improve memory consumption during stroke rendering. When objects exists out of the viewing frustrum and near the near clipping plane, feature edges in the 3D camera coordinate system are projected to an extremely far location from the camera view in the 2D image space. These feature edges result in very long strokes with a large number of stroke vertices, which temporarily require a significant memory storage, causing a fatal "out of memory" error. This problem is partially addressed by the changes in the present commit.
2010-01-26 22:24:53 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
for (it = strokeGroups.begin(), itend = strokeGroups.end();
it != itend; ++it)
{
GenerateStrokeMesh(*it, false);
}
for (it = texturedStrokeGroups.begin(), itend = texturedStrokeGroups.end();
it != itend; ++it)
{
GenerateStrokeMesh(*it, true);
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
}
Fix T43090: Cycles + Freestyle + border render = black render. The reported problem was due to a special case where there are no strokes to be rendered. Since rendering an empty scene is a waste of time, the issue was addressed here by skipping the stroke rendering process entirely.
2015-01-17 22:33:13 +09:00
return get_stroke_count();
}
// Return the number of strokes
int BlenderStrokeRenderer::get_stroke_count() const
{
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
return strokeGroups.size() + texturedStrokeGroups.size();
}
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// Build a mesh object representing a group of stylized strokes
void BlenderStrokeRenderer::GenerateStrokeMesh(StrokeGroup *group, bool hasTex)
{
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
#if 0
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Object *object_mesh = BKE_object_add(freestyle_bmain, freestyle_scene, OB_MESH);
Depsgraph: Add additional relations/id update tags This calls are not strictly speaking needed for the old dependency graph, but due to more granular nature of upcoming depsgraph more actions requires update of relations of IDs. On the one hand this extra tags could be wrapped with if() statements, but on the other hand it makes sense to keep tag in sync so it's clear if some issue is caused by missing/extra tag or by depsgraph itself.
2015-05-12 13:29:00 +05:00
DAG_relations_tag_update(freestyle_bmain);
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
#else
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Object *object_mesh = NewMesh();
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
#endif
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Mesh *mesh = (Mesh *)object_mesh->data;
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
mesh->totvert = group->totvert;
mesh->totedge = group->totedge;
mesh->totpoly = group->totpoly;
mesh->totloop = group->totloop;
mesh->totcol = group->totcol;
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
mesh->mvert = (MVert *)CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_CALLOC, NULL, mesh->totvert);
mesh->medge = (MEdge *)CustomData_add_layer(&mesh->edata, CD_MEDGE, CD_CALLOC, NULL, mesh->totedge);
mesh->mpoly = (MPoly *)CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_CALLOC, NULL, mesh->totpoly);
mesh->mloop = (MLoop *)CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_CALLOC, NULL, mesh->totloop);
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
MVert *vertices = mesh->mvert;
MEdge *edges = mesh->medge;
MPoly *polys = mesh->mpoly;
MLoop *loops = mesh->mloop;
Fix for vertex colors not working properly. Looks like the issue was caused by a UV map name starting with a lower case letter (e.g., "color"). Capitalizing the name fixed the problem. Also adjusted the creation of custom data layers to optimize things a bit.
2014-07-21 18:49:27 +09:00
MLoopUV *loopsuv[2] = { NULL };
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
if (hasTex) {
// First UV layer
CustomData_add_layer_named(&mesh->pdata, CD_MTEXPOLY, CD_CALLOC, NULL, mesh->totpoly, uvNames[0]);
CustomData_add_layer_named(&mesh->ldata, CD_MLOOPUV, CD_CALLOC, NULL, mesh->totloop, uvNames[0]);
CustomData_set_layer_active(&mesh->pdata, CD_MTEXPOLY, 0);
CustomData_set_layer_active(&mesh->ldata, CD_MLOOPUV, 0);
BKE_mesh_update_customdata_pointers(mesh, true);
loopsuv[0] = mesh->mloopuv;
// Second UV layer
CustomData_add_layer_named(&mesh->pdata, CD_MTEXPOLY, CD_CALLOC, NULL, mesh->totpoly, uvNames[1]);
CustomData_add_layer_named(&mesh->ldata, CD_MLOOPUV, CD_CALLOC, NULL, mesh->totloop, uvNames[1]);
CustomData_set_layer_active(&mesh->pdata, CD_MTEXPOLY, 1);
CustomData_set_layer_active(&mesh->ldata, CD_MLOOPUV, 1);
BKE_mesh_update_customdata_pointers(mesh, true);
loopsuv[1] = mesh->mloopuv;
Fix for vertex colors not working properly. Looks like the issue was caused by a UV map name starting with a lower case letter (e.g., "color"). Capitalizing the name fixed the problem. Also adjusted the creation of custom data layers to optimize things a bit.
2014-07-21 18:49:27 +09:00
}
// colors and transparency (the latter represented by grayscale colors)
MLoopCol *colors = (MLoopCol *)CustomData_add_layer_named(&mesh->ldata, CD_MLOOPCOL, CD_CALLOC, NULL, mesh->totloop, "Color");
MLoopCol *transp = (MLoopCol *)CustomData_add_layer_named(&mesh->ldata, CD_MLOOPCOL, CD_CALLOC, NULL, mesh->totloop, "Alpha");
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
mesh->mloopcol = colors;
Fix for vertex colors not working properly. Looks like the issue was caused by a UV map name starting with a lower case letter (e.g., "color"). Capitalizing the name fixed the problem. Also adjusted the creation of custom data layers to optimize things a bit.
2014-07-21 18:49:27 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
mesh->mat = (Material **)MEM_mallocN(sizeof(Material *) * mesh->totcol, "MaterialList");
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
////////////////////
// Data copy
////////////////////
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
int vertex_index = 0, edge_index = 0, loop_index = 0, material_index = 0;
int visible_faces, visible_segments;
bool visible;
Strip::vertex_container::iterator v[3];
StrokeVertexRep *svRep[3];
Vec2r p;
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
for (vector<StrokeRep*>::const_iterator it = group->strokes.begin(), itend = group->strokes.end();
it != itend; ++it)
{
mesh->mat[material_index] = (*it)->getMaterial();
Fix T48045: Freestyle ID user decrement error. This fixes reported issue, but there could be more of those hidden in Freestyle code, it did not handle user refcount at all (and the fact it by-passes BKE in some places for efficiency does not help here). Note that this should be relatively harmless, since freestyle uses own Main during render, so everything is cleaned up in the end in any case... But better try to handle IDs correctly here too. :)
2016-04-04 15:43:45 +02:00
id_us_plus(&mesh->mat[material_index]->id);
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
vector<Strip*>& strips = (*it)->getStrips();
for (vector<Strip*>::const_iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
Strip::vertex_container& strip_vertices = (*s)->vertices();
int strip_vertex_count = strip_vertices.size();
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// count visible faces and strip segments
test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
if (visible_faces == 0)
continue;
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
v[0] = strip_vertices.begin();
v[1] = v[0] + 1;
v[2] = v[0] + 2;
Freestyle: Stroke rendering optimization. Previously mesh objects were created for individual visible stroke segments (recalling that a stroke may consist of alternate visible and invisible segments). This could result in an excessive memory consumption in stroke rendering when strokes are composed of many short visible segments (for instance by means of dashed lines and/or blueprint geometry modifiers). Now mesh objects represent individual strokes instead of stroke segments, which tends to reduce the number of generated mesh objects by an order of magnitude.
2014-05-09 11:58:25 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
visible = false;
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// Note: Mesh generation in the following loop assumes stroke strips
// to be triangle strips.
for (int n = 2; n < strip_vertex_count; n++, v[0]++, v[1]++, v[2]++) {
svRep[0] = *(v[0]);
svRep[1] = *(v[1]);
svRep[2] = *(v[2]);
if (!test_triangle_visibility(svRep)) {
visible = false;
}
else {
if (!visible) {
// first vertex
vertices->co[0] = svRep[0]->point2d()[0];
vertices->co[1] = svRep[0]->point2d()[1];
vertices->co[2] = get_stroke_vertex_z();
vertices->no[0] = 0;
vertices->no[1] = 0;
vertices->no[2] = SHRT_MAX;
++vertices;
++vertex_index;
// second vertex
vertices->co[0] = svRep[1]->point2d()[0];
vertices->co[1] = svRep[1]->point2d()[1];
vertices->co[2] = get_stroke_vertex_z();
vertices->no[0] = 0;
vertices->no[1] = 0;
vertices->no[2] = SHRT_MAX;
++vertices;
++vertex_index;
// first edge
edges->v1 = vertex_index - 2;
edges->v2 = vertex_index - 1;
++edges;
++edge_index;
}
visible = 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
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// vertex
vertices->co[0] = svRep[2]->point2d()[0];
vertices->co[1] = svRep[2]->point2d()[1];
Added support for transparent stroke colors (again). Transparent strokes are rendered by means of transparent vertex colors. To make this possible, Blender's internal renderer has been slightly extended to allow transparent vertex colors. When Material::vcol_alpha is non-zero, the renderer takes MCol::a into account.
2010-02-16 02:10:27 +00:00
vertices->co[2] = get_stroke_vertex_z();
Freestyle: quiet BMESH validator warnings of zero normals.
2014-04-24 13:57:10 +09:00
vertices->no[0] = 0;
vertices->no[1] = 0;
vertices->no[2] = SHRT_MAX;
Made an attempt to improve memory consumption during stroke rendering. When objects exists out of the viewing frustrum and near the near clipping plane, feature edges in the 3D camera coordinate system are projected to an extremely far location from the camera view in the 2D image space. These feature edges result in very long strokes with a large number of stroke vertices, which temporarily require a significant memory storage, causing a fatal "out of memory" error. This problem is partially addressed by the changes in the present commit.
2010-01-26 22:24:53 +00:00
++vertices;
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
++vertex_index;
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// edges
edges->v1 = vertex_index - 1;
edges->v2 = vertex_index - 3;
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
++edges;
++edge_index;
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
edges->v1 = vertex_index - 1;
edges->v2 = vertex_index - 2;
++edges;
++edge_index;
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
// poly
polys->loopstart = loop_index;
polys->totloop = 3;
Fix T43624: Freestyle uses wrong colour on second Line Set with textured lines in Cycles. This is a regression introduced by rBd8b00a3bf5c1 (Freestyle: memory consumption optimization in stroke rendering). The issue was caused by uninitialized MPoly::mat_nr values. Before the stroke rendering optimization, individual Freestyle strokes were represented by distinct mesh objects, and thus MPoly::mat_nr was left unset (i.e., was always zero). Now that the stroke rendering optimization has been done and mesh objects may represent multiple strokes of different materials, MPoly::mat_nr had to be properly set to the material index that refers to the material of the poly face.
2015-03-07 10:35:54 +09:00
polys->mat_nr = material_index;
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
++polys;
// Even and odd loops connect triangles vertices differently
bool is_odd = n % 2;
// loops
if (is_odd) {
loops[0].v = vertex_index - 1;
loops[0].e = edge_index - 2;
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
loops[1].v = vertex_index - 3;
loops[1].e = edge_index - 3;
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
loops[2].v = vertex_index - 2;
loops[2].e = edge_index - 1;
}
else {
loops[0].v = vertex_index - 1;
loops[0].e = edge_index - 1;
loops[1].v = vertex_index - 2;
loops[1].e = edge_index - 3;
loops[2].v = vertex_index - 3;
loops[2].e = edge_index - 2;
}
loops += 3;
loop_index += 3;
// UV
if (hasTex) {
// First UV layer (loopsuv[0]) has no tips (texCoord(0)).
// Second UV layer (loopsuv[1]) has tips: (texCoord(1)).
for (int L = 0; L < 2; L++) {
if (is_odd) {
loopsuv[L][0].uv[0] = svRep[2]->texCoord(L).x();
loopsuv[L][0].uv[1] = svRep[2]->texCoord(L).y();
loopsuv[L][1].uv[0] = svRep[0]->texCoord(L).x();
loopsuv[L][1].uv[1] = svRep[0]->texCoord(L).y();
loopsuv[L][2].uv[0] = svRep[1]->texCoord(L).x();
loopsuv[L][2].uv[1] = svRep[1]->texCoord(L).y();
}
else {
loopsuv[L][0].uv[0] = svRep[2]->texCoord(L).x();
loopsuv[L][0].uv[1] = svRep[2]->texCoord(L).y();
loopsuv[L][1].uv[0] = svRep[1]->texCoord(L).x();
loopsuv[L][1].uv[1] = svRep[1]->texCoord(L).y();
loopsuv[L][2].uv[0] = svRep[0]->texCoord(L).x();
loopsuv[L][2].uv[1] = svRep[0]->texCoord(L).y();
}
loopsuv[L] += 3;
Patch D246: Texture Marks for freestyle strokes, written and contributed by Paolo Acampora. Reviewers: brecht, kjym3, #freestyle Reviewed By: brecht, kjym3 Differential Revision: https://developer.blender.org/D246
2014-05-03 18:51:53 +09:00
}
}
Fix T44048: freestyle lines in Cycles are in the wrong color space.
2015-10-10 18:44:19 +02:00
// colors and alpha transparency. vertex colors are in sRGB
// space by convention, so convert from linear
float rgba[3][4];
for (int i = 0; i < 3; i++) {
copy_v3fl_v3db(rgba[i], &svRep[i]->color()[0]);
rgba[i][3] = svRep[i]->alpha();
}
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
if (is_odd) {
Fix T44048: freestyle lines in Cycles are in the wrong color space.
2015-10-10 18:44:19 +02:00
linearrgb_to_srgb_uchar4(&colors[0].r, rgba[2]);
linearrgb_to_srgb_uchar4(&colors[1].r, rgba[0]);
linearrgb_to_srgb_uchar4(&colors[2].r, rgba[1]);
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
}
else {
Fix T44048: freestyle lines in Cycles are in the wrong color space.
2015-10-10 18:44:19 +02:00
linearrgb_to_srgb_uchar4(&colors[0].r, rgba[2]);
linearrgb_to_srgb_uchar4(&colors[1].r, rgba[1]);
linearrgb_to_srgb_uchar4(&colors[2].r, rgba[0]);
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
}
transp[0].r = transp[0].g = transp[0].b = colors[0].a;
transp[1].r = transp[1].g = transp[1].b = colors[1].a;
transp[2].r = transp[2].g = transp[2].b = colors[2].a;
colors += 3;
transp += 3;
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
}
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
} // loop over strip vertices
} // loop over strips
Fix T43624: Freestyle uses wrong colour on second Line Set with textured lines in Cycles. This is a regression introduced by rBd8b00a3bf5c1 (Freestyle: memory consumption optimization in stroke rendering). The issue was caused by uninitialized MPoly::mat_nr values. Before the stroke rendering optimization, individual Freestyle strokes were represented by distinct mesh objects, and thus MPoly::mat_nr was left unset (i.e., was always zero). Now that the stroke rendering optimization has been done and mesh objects may represent multiple strokes of different materials, MPoly::mat_nr had to be properly set to the material index that refers to the material of the poly face.
2015-03-07 10:35:54 +09:00
material_index++;
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
} // loop over strokes
Cleanup: Get rid of G.main in BKE_material. Note that in some cases, this only moves the G.main case to somne other places - in particular, RNA getters/setters are becoming annoying here...
2018-05-29 15:49:21 +02:00
test_object_materials(freestyle_bmain, object_mesh, (ID *)mesh);
Freestyle: memory consumption optimization in stroke rendering. Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
2014-08-08 22:29:02 +09:00
#if 0 // XXX
BLI_assert(mesh->totvert == vertex_index);
BLI_assert(mesh->totedge == edge_index);
BLI_assert(mesh->totloop == loop_index);
BLI_assert(mesh->totcol == material_index);
Mesh validate: add an option to not clean temp/cache CDLayers. This is mandatory for incoming custom normal imports from io scripts, because often geometry here is corrupted, so we need to call mesh.validate() to clean it up. Issue is, we cannot set custom normals before geometry is clean, so we need to store temporary plain loop normals in a CD_NORMAL layer, validate, and then set custom normals. So we need a way to prevent 'temp' lnors to be freed by validate.
2015-02-05 14:03:01 +01:00
BKE_mesh_validate(mesh, true, true);
Fix for persistent failures of BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX)); in CDDM_calc_normals_mapping_ex() in source/blender/blenkernel/intern/cdderivedmesh.c. Problem report by flokkievids with an example .blend file for reproducing the issue. Thanks! The issue was caused by the fact that Freestyle was using the pre-BMesh way for constructing mesh data with the aim of generating a temporary 3D scene for stroke rendering. Specifically, the MFace struct was used for defining triangular faces. Now BMesh is in the trunk, MFace is internally used for tessellated faces only, and MPoly and MLoop are used for general mesh data construction. This commit is intended to update the Freestyle stroke rendering code in the BMesh way.
2012-06-16 21:49:52 +00:00
#endif
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
}
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
// A replacement of BKE_object_add() for better performance.
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
Object *BlenderStrokeRenderer::NewMesh() const
{
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
Object *ob;
Base *base;
char name[MAX_ID_NAME];
Fix for a static variable in BlenderStrokeRenderer::RenderStrokeRep() left after quick trials of different approaches to performance improvement.
2013-02-14 19:19:44 +00:00
unsigned int mesh_id = get_stroke_mesh_id();
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
Removed a Freestyle hack for DAG updates introduced in commit rBae58968e0a61. Now that Freestyle employs a separate Main, this workaround is no longer necessary. Reviewers: sergey Reviewed By: sergey Differential Revision: https://developer.blender.org/D513
2014-05-08 18:42:03 +09:00
BLI_snprintf(name, MAX_ID_NAME, "0%08xOB", mesh_id);
Fix for full-sample anti-aliasing (FSAA) not working with Freestyle. Reverted the trunk revision 56136 and part of revision 56127 concerning the local Main for Freestyle and temporary scene generation for stroke rendering. The function do_merge_fullsample() in pipeline.c has access to the Scene of each Render, so that the temporary Scene generated by Freestyle has to be kept for FSAA even after stroke rendering has been done. By the same token, the local Main has been moved from the BlenderStrokeRenderer class to Render. It is noted that free_all_freestyle_renders() in pipeline.c is intended to get the temporary Scene of each Render released specifically taking account of the FSAA case.
2013-04-23 22:40:13 +00:00
ob = BKE_object_add_only_object(freestyle_bmain, OB_MESH, name);
Removed a Freestyle hack for DAG updates introduced in commit rBae58968e0a61. Now that Freestyle employs a separate Main, this workaround is no longer necessary. Reviewers: sergey Reviewed By: sergey Differential Revision: https://developer.blender.org/D513
2014-05-08 18:42:03 +09:00
BLI_snprintf(name, MAX_ID_NAME, "0%08xME", mesh_id);
Fix for full-sample anti-aliasing (FSAA) not working with Freestyle. Reverted the trunk revision 56136 and part of revision 56127 concerning the local Main for Freestyle and temporary scene generation for stroke rendering. The function do_merge_fullsample() in pipeline.c has access to the Scene of each Render, so that the temporary Scene generated by Freestyle has to be kept for FSAA even after stroke rendering has been done. By the same token, the local Main has been moved from the BlenderStrokeRenderer class to Render. It is noted that free_all_freestyle_renders() in pipeline.c is intended to get the temporary Scene of each Render released specifically taking account of the FSAA case.
2013-04-23 22:40:13 +00:00
ob->data = BKE_mesh_add(freestyle_bmain, name);
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
ob->lay = 1;
base = BKE_scene_base_add(freestyle_scene, ob);
Depsgraph: Add additional relations/id update tags This calls are not strictly speaking needed for the old dependency graph, but due to more granular nature of upcoming depsgraph more actions requires update of relations of IDs. On the one hand this extra tags could be wrapped with if() statements, but on the other hand it makes sense to keep tag in sync so it's clear if some issue is caused by missing/extra tag or by depsgraph itself.
2015-05-12 13:29:00 +05:00
DAG_relations_tag_update(freestyle_bmain);
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
BKE_scene_base_deselect_all(scene);
BKE_scene_base_select(scene, base);
A patch set from Bastien Montagne (thanks!) for silencing build warnings (from gcc 4.7), mostly by commenting out unused variables, or using the BLI's SET_UINT_IN_POINTER macro.
2013-01-18 02:13:36 +00:00
#else
(void)base;
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
#endif
Fix for infinite freestyle re-render in the viewport Was a regression since e618d8238e0e and was caused by the wrong main being tagged for update.
2014-01-15 17:42:01 +06:00
DAG_id_tag_update_ex(freestyle_bmain, &ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
An attempt to improve the performance of temporary scene generation for stroke rendering. Many thanks to Joshua Leung (aligorith) for the performance analysis of BKE_object_add function: http://lists.blender.org/pipermail/bf-committers/2012-October/037759.html
2012-10-06 14:06:40 +00:00
return ob;
}
Freestyle: Code cleanup, prepare for strict C++ flags
2015-03-27 15:50:18 +05:00
Render *BlenderStrokeRenderer::RenderScene(Render * /*re*/, bool render)
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 big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00:00
Camera *camera = (Camera *)freestyle_scene->camera->data;
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 (camera->clipend < _z)
camera->clipend = _z + _z_delta * 100.0f;
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 << "clipsta " << camera->clipsta << ", clipend " << camera->clipend << endl;
}
#endif
Added support for transparent stroke colors (again). Transparent strokes are rendered by means of transparent vertex colors. To make this possible, Blender's internal renderer has been slightly extended to allow transparent vertex colors. When Material::vcol_alpha is non-zero, the renderer takes MCol::a into account.
2010-02-16 02:10:27 +00:00
Fix T52653: Render output of linked scenes conflicts with other scenes with the same name The issue was caused by render result identifier only consist of scene name, which could indeed cause conflicts. On the one hand, there are quite some areas in Blender where we need identifier to be unique to properly address things. Usually this is required for sub-data of IDs, like bones. On another hand, it's not that hard to support this particular case and avoid possible frustration. The idea is, we add library name to render identifier for linked scenes. We use library name and not pointer so we preserve render results through undo stack. Reviewers: campbellbarton, mont29, brecht Reviewed By: mont29 Differential Revision: https://developer.blender.org/D2836
2017-09-12 11:27:22 +05:00
Render *freestyle_render = RE_NewSceneRender(freestyle_scene);
Added support for transparent stroke colors. In Freestyle, strokes are represented with triangle strips, and stroke colors are realized using vertex colors in order to enable variable stroke colors (i.e., each triangle has a different color). Stroke colors in Freestyle are in the RGBA format, while vertex colors in Blender do not have an alpha component. Therefore, we here employ a 2-pass rendering approach as follows. First, the alpha component of an image is rendered by using the red component of vertex colors as the alpha component of stroke colors (1st pass). The render result is saved into a temporary buffer. Then, the vertex colors of stroke meshes are replaced with RGB values, and the RGB components of the image is rendered (2nd pass). Finally, the RGB and alpha components are merged to produce the render result in the RGBA format.
2010-02-08 02:19:17 +00:00
Fix T43090: Cycles + Freestyle + border render = black render. The reported problem was due to a special case where there are no strokes to be rendered. Since rendering an empty scene is a waste of time, the issue was addressed here by skipping the stroke rendering process entirely.
2015-01-17 22:33:13 +09:00
RE_RenderFreestyleStrokes(freestyle_render, freestyle_bmain, freestyle_scene,
render && get_stroke_count() > 0);
Fix for access freed scene when doing freestyle render It's more like an ownership thing, but it's not so much clear who actually is an owner of temporary scene, so for now just ensure Render does not have link to it after strokes are rendered. There're also suspicious thing related on why separate RE_free_database is needed for freestyle renders, but that's also another story.
2013-04-18 12:11:50 +00:00
Reverted the changes for adding support for transparent stroke colors, because of incomplete functionality. When two transparent strokes intersect, the stroke drawn first is completely overridden by the stroke drawn after the first stroke, instead of two stroke colors being blended at the intersection.
2010-02-15 00:07:15 +00:00
return freestyle_render;
The GL-based renderer was removed. Freestyle now uses Blender's internal renderer to raster strokes. The render generated from Freestyle's data is currently stored in the original scene's render structure ( as 'freestyle_render'): when the render database is generated, the scene's geometrical data is first imported into Freestyle and strokes are calculated. The generated strokes are used to create a Blender scene, rendered independently. The render result is used in the rendering loop. The final rendering is performed the same way edge rendering is, in a function ('freestyle_enhance_add') operating on each individual render part. Freestyle strokes are only included if the toggle button "Freestyle" (in the 'Output' panel) is active and if the "Freestyle" render layer is also selected. Freestyle's panel appears when the toggle button 'Freestyle' is active. IMPORTANT: as of now, rendering ONLY works when OSA is disabled and when Xparts = Yparts = 1. If these settings are not set, a bogus image will be created. To make the render happen, many modifications had to be made: - the Canvas::Draw and Operators::create methods no longer render strokes. They only generate shading and locational information. - a BlenderStrokeRenderer class was added to turn Freestyle's strokes into a Blender scene. Basically, the scene consists of strokes in their projected image 2D coordinates and an orthographic camera centered in the middle of the corresponding canvas. The scene is rendered using vertex colors, in shadeless mode (therefore, no lamp is needed). BlenderStrokeRenderer uses the old GLTextureManager to load textures (as required by the StrokeRenderer class), even though stroke textures are probably not supported (not tested). After the scene is rendered, it is safely and automatically discarded. - AppCanvas' code was greatly reduced to the bare minimum. The former AppCanvas would use an OpenGL-based back buffer and z buffer to determine the scene's color and depth information. In the future, this data will be determined from the corresponding render passes. Currently, the integration is not achieved so all style modules using depth/color information are sure to fail. - before, Freestyle needed an OpenGL context to determine the camera's information and to compute the view map. As of now, the modelview and projection matrices are fully determined using data provided by Blender. This means both perspective and orthographic projections are supported. The AppGLWidget will very soon be removed completely.
2008-12-01 21:30:44 +00:00
}
Attempt to fix a potential name conflict between Freestyle and the compositor. A crash in the Freestyle renderer was reported by Ton on IRC with a stack trace below. Note that #2 is in Freestyle, whereas #1 is in the compositor. The problem was observed in a debug build on OS X 10.7 (gcc 4.2, openmp disabled, no llvm). ---------------------------------------------------------------------- Program received signal EXC_BAD_ACCESS, Could not access memory. Reason: 13 at address: 0x0000000000000000 [Switching to process 72386 thread 0xf303] 0x0000000100c129f3 in NodeBase::~NodeBase (this=0x10e501c80) at COM_NodeBase.cpp:43 43 delete (this->m_outputsockets.back()); Current language: auto; currently c++ (gdb) where #0 0x0000000100c129f3 in NodeBase::~NodeBase (this=0x10e501c80) at COM_NodeBase.cpp:43 #1 0x0000000100c29066 in Node::~Node (this=0x10e501c80) at COM_Node.h:49 #2 0x000000010089c273 in NodeShape::~NodeShape (this=0x10e501c80) at NodeShape.cpp:43 #3 0x000000010089910b in NodeGroup::destroy (this=0x10e501da0) at NodeGroup.cpp:61 #4 0x00000001008990cd in NodeGroup::destroy (this=0x10e5014b0) at NodeGroup.cpp:59 #5 0x00000001008990cd in NodeGroup::destroy (this=0x114e18da0) at NodeGroup.cpp:59 #6 0x00000001007e6602 in Controller::ClearRootNode (this=0x114e19640) at Controller.cpp:329 #7 0x00000001007ea52e in Controller::LoadMesh (this=0x114e19640, re=0x10aba4638, srl=0x1140f5258) at Controller.cpp:302 #8 0x00000001008030ad in prepare (re=0x10aba4638, srl=0x1140f5258) at FRS_freestyle.cpp:302 #9 0x000000010080457a in FRS_do_stroke_rendering (re=0x10aba4638, srl=0x1140f5258) at FRS_freestyle.cpp:600 #10 0x00000001006aeb9d in add_freestyle (re=0x10aba4638) at pipeline.c:1584 #11 0x00000001006aceb7 in do_render_3d (re=0x10aba4638) at pipeline.c:1094 #12 0x00000001006ae061 in do_render_fields_blur_3d (re=0x10aba4638) at pipeline.c:1367 #13 0x00000001006afa16 in do_render_composite_fields_blur_3d (re=0x10aba4638) at pipeline.c:1815 #14 0x00000001006b04e4 in do_render_all_options (re=0x10aba4638) at pipeline.c:2021 ---------------------------------------------------------------------- Apparently a name conflict between the two Blender modules is taking place. The present commit hence intends to address it by putting all the Freestyle C++ classes in the namespace 'Freestyle'. This revision will also prevent potential name conflicts with other Blender modules in the future. Special thanks to Lukas Toenne for the help with C++ namespace.
2013-04-09 00:46:49 +00:00
} /* namespace Freestyle */
Copy Permalink