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

634 lines
19 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"
#include "DNA_camera_types.h"
#include "DNA_listBase.h"
#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"
#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 */
#include "BKE_main.h" /* struct Main */
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"
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: 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"
}
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 {
A big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00: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
{
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_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;
Fix #35353: Freestyle + Compositor + Auto-render renders freestyle lines in the wrong place.
2013-06-12 17:59:03 +00:00
freestyle_scene->r.scemode = old_scene->r.scemode & ~(R_SINGLE_LAYER | R_NO_FRAME_UPDATE);
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;
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
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
BKE_scene_disable_color_management(freestyle_scene);
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) {
printf("%s: %d threads\n", __func__, freestyle_scene->r.threads);
}
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
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
Object *object_camera = BKE_object_add(freestyle_bmain, freestyle_scene, OB_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
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;
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);
}
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;
}
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
void BlenderStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const
{
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
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");
ma->mode |= MA_VERTEXCOLP;
ma->mode |= MA_TRANSP;
ma->mode |= MA_SHLESS;
ma->vcol_alpha = 1;
// Textures
//for (int a = 0; a < MAX_MTEX; a++) {
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.
if (ma->mtex[a]->texflag & MTEX_TIPS) {
BLI_strncpy(ma->mtex[a]->uvname, "along_stroke_tips", sizeof(ma->mtex[a]->uvname));
}
else {
BLI_strncpy(ma->mtex[a]->uvname, "along_stroke", sizeof(ma->mtex[a]->uvname));
}
a++;
}
iStrokeRep->setMaterial(ma);
}
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
RenderStrokeRepBasic(iStrokeRep);
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: 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
// Build a mesh object representing a stroke
void BlenderStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) 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
vector<Strip*>& strips = iStrokeRep->getStrips();
Freestyle: time/space optimization in stroke rendering without textures. When strokes do not have textures assigned, UV coordinates are not computed now. This will save a bit of time and space in stroke rendering.
2014-05-07 23:14:36 +09:00
const bool hasTex = iStrokeRep->getMTex(0) != NULL;
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
Strip::vertex_container::iterator v[3];
StrokeVertexRep *svRep[3];
unsigned int vertex_index, edge_index, loop_index;
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
int totvert = 0, totedge = 0, totpoly = 0, totloop = 0;
int visible_faces, visible_segments;
bool visible;
A big code clean-up patch from Bastien Montagne, many thanks!
2013-03-07 23:17:23 +00:00
for (vector<Strip*>::iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
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
Strip::vertex_container& strip_vertices = (*s)->vertices();
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: 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
// count visible faces and strip segments
test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
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
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
totvert += visible_faces + visible_segments * 2;
totedge += visible_faces * 2 + visible_segments;
totpoly += visible_faces;
totloop += visible_faces * 3;
}
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);
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;
mesh->mat = (Material **)MEM_mallocN(1 * sizeof(Material *), "MaterialList");
mesh->mat[0] = iStrokeRep->getMaterial();
mesh->totcol = 1;
test_object_materials(freestyle_bmain, (ID *)mesh);
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: 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
// vertices allocation
mesh->totvert = totvert; // visible_faces + visible_segments * 2;
mesh->mvert = (MVert *)CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_CALLOC, NULL, mesh->totvert);
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
// edges allocation
mesh->totedge = totedge; // visible_faces * 2 + visible_segments;
mesh->medge = (MEdge *)CustomData_add_layer(&mesh->edata, CD_MEDGE, CD_CALLOC, NULL, mesh->totedge);
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: 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
// faces allocation
mesh->totpoly = totpoly; // visible_faces;
mesh->mpoly = (MPoly *)CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_CALLOC, NULL, mesh->totpoly);
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
// loops allocation
mesh->totloop = totloop; // visible_faces * 3;
mesh->mloop = (MLoop *)CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_CALLOC, NULL, mesh->totloop);
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
// colors allocation
mesh->mloopcol = (MLoopCol *)CustomData_add_layer(&mesh->ldata, CD_MLOOPCOL, CD_CALLOC, NULL, mesh->totloop);
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
////////////////////
MVert *vertices = mesh->mvert;
MEdge *edges = mesh->medge;
MPoly *polys = mesh->mpoly;
MLoop *loops = mesh->mloop;
MLoopCol *colors = mesh->mloopcol;
MLoopUV *loopsuv[2] = {NULL};
if (hasTex) {
// First UV layer
CustomData_add_layer_named(&mesh->pdata, CD_MTEXPOLY, CD_CALLOC, NULL, mesh->totpoly, "along_stroke");
CustomData_add_layer_named(&mesh->ldata, CD_MLOOPUV, CD_CALLOC, NULL, mesh->totloop, "along_stroke");
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, "along_stroke_tips");
CustomData_add_layer_named(&mesh->ldata, CD_MLOOPUV, CD_CALLOC, NULL, mesh->totloop, "along_stroke_tips");
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;
}
vertex_index = edge_index = loop_index = 0;
for (vector<Strip*>::iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
Strip::vertex_container& strip_vertices = (*s)->vertices();
int strip_vertex_count = strip_vertices.size();
// count visible faces and strip segments
test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
if (visible_faces == 0)
continue;
v[0] = strip_vertices.begin();
v[1] = v[0] + 1;
v[2] = v[0] + 2;
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
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
// Note: Mesh generation in the following loop assumes stroke strips
// to be triangle strips.
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
for (int n = 2; n < strip_vertex_count; n++, v[0]++, v[1]++, v[2]++) {
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
svRep[0] = *(v[0]);
svRep[1] = *(v[1]);
svRep[2] = *(v[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
if (!test_triangle_visibility(svRep)) {
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
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
}
else {
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
if (!visible) {
// first vertex
vertices->co[0] = svRep[0]->point2d()[0];
vertices->co[1] = svRep[0]->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;
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
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
// second vertex
vertices->co[0] = svRep[1]->point2d()[0];
vertices->co[1] = svRep[1]->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;
// first edge
edges->v1 = vertex_index - 2;
edges->v2 = vertex_index - 1;
++edges;
++edge_index;
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
}
visible = true;
// 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;
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
++vertices;
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
++vertex_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
// edges
edges->v1 = vertex_index - 1;
edges->v2 = vertex_index - 3;
++edges;
++edge_index;
edges->v1 = vertex_index - 1;
edges->v2 = vertex_index - 2;
++edges;
++edge_index;
// poly
polys->loopstart = loop_index;
polys->totloop = 3;
++polys;
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
// Even and odd loops connect triangles vertices differently
bool is_odd = n % 2;
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
// loops
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
if (is_odd) {
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
loops[0].v = vertex_index - 1;
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
loops[0].e = edge_index - 2;
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
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
loops[1].v = 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
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
loops[2].v = vertex_index - 2;
loops[2].e = edge_index - 1;
Another big code clean-up patch by Bastien Montagne (GPL headers, indentation, spaces around operators, and so forth). Many thanks!
2012-12-18 00:51:25 +00:00
}
else {
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
loops[0].v = vertex_index - 1;
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
loops[0].e = edge_index - 1;
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
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
loops[1].v = vertex_index - 2;
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
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
loops[2].v = vertex_index - 3;
loops[2].e = edge_index - 2;
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
}
loops += 3;
loop_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
// UV
Freestyle: time/space optimization in stroke rendering without textures. When strokes do not have textures assigned, UV coordinates are not computed now. This will save a bit of time and space in stroke rendering.
2014-05-07 23:14:36 +09:00
if (hasTex) {
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
// 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;
}
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
}
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
// colors
if (is_odd) {
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
colors[0].r = (short)(255.0f * svRep[2]->color()[0]);
colors[0].g = (short)(255.0f * svRep[2]->color()[1]);
colors[0].b = (short)(255.0f * svRep[2]->color()[2]);
colors[0].a = (short)(255.0f * svRep[2]->alpha());
colors[1].r = (short)(255.0f * svRep[0]->color()[0]);
colors[1].g = (short)(255.0f * svRep[0]->color()[1]);
colors[1].b = (short)(255.0f * svRep[0]->color()[2]);
colors[1].a = (short)(255.0f * svRep[0]->alpha());
colors[2].r = (short)(255.0f * svRep[1]->color()[0]);
colors[2].g = (short)(255.0f * svRep[1]->color()[1]);
colors[2].b = (short)(255.0f * svRep[1]->color()[2]);
colors[2].a = (short)(255.0f * svRep[1]->alpha());
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
}
else {
colors[0].r = (short)(255.0f * svRep[2]->color()[0]);
colors[0].g = (short)(255.0f * svRep[2]->color()[1]);
colors[0].b = (short)(255.0f * svRep[2]->color()[2]);
colors[0].a = (short)(255.0f * svRep[2]->alpha());
colors[1].r = (short)(255.0f * svRep[1]->color()[0]);
colors[1].g = (short)(255.0f * svRep[1]->color()[1]);
colors[1].b = (short)(255.0f * svRep[1]->color()[2]);
colors[1].a = (short)(255.0f * svRep[1]->alpha());
colors[2].r = (short)(255.0f * svRep[0]->color()[0]);
colors[2].g = (short)(255.0f * svRep[0]->color()[1]);
colors[2].b = (short)(255.0f * svRep[0]->color()[2]);
colors[2].a = (short)(255.0f * svRep[0]->alpha());
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
}
colors += 3;
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
}
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
} // loop over strip vertices
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
} // loop over strips
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
#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
BLI_assert(totvert == vertex_index);
BLI_assert(totedge == edge_index);
BLI_assert(totloop == loop_index);
BKE_mesh_validate(mesh, 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);
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;
}
Fix #35561: freestyle + read full sample layers = crash. Now add_freestyle() in pipeline.c takes a second argument to enable/disable stroke rendering. When stroke rendering is disabled, the function allocates data structures but does not perform stroke rendering. The allocated data structures (mostly left unpopulated with data elements) are intended to allow for the Read Full Sample Layers (Shift-R) command in the compositor.
2013-06-11 02:32:01 +00: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
Merged changes in the trunk up to revision 27817.
2010-03-28 22:45:14 +00:00
Render *freestyle_render = RE_NewRender(freestyle_scene->id.name);
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 #35561: freestyle + read full sample layers = crash. Now add_freestyle() in pipeline.c takes a second argument to enable/disable stroke rendering. When stroke rendering is disabled, the function allocates data structures but does not perform stroke rendering. The allocated data structures (mostly left unpopulated with data elements) are intended to allow for the Read Full Sample Layers (Shift-R) command in the compositor.
2013-06-11 02:32:01 +00:00
RE_RenderFreestyleStrokes(freestyle_render, freestyle_bmain, freestyle_scene, render);
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