2014-03-06 04:33:15 +11: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.
|
|
|
|
*
|
|
|
|
* Contributor(s): Blender Foundation
|
|
|
|
*
|
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** \file blender/blenloader/intern/versioning_270.c
|
|
|
|
* \ingroup blenloader
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BLI_compiler_attrs.h"
|
|
|
|
|
2014-03-11 21:46:12 +02:00
|
|
|
/* for MinGW32 definition of NULL, could use BLI_blenlib.h instead too */
|
|
|
|
#include <stddef.h>
|
|
|
|
|
2014-03-06 04:33:15 +11:00
|
|
|
/* allow readfile to use deprecated functionality */
|
|
|
|
#define DNA_DEPRECATED_ALLOW
|
|
|
|
|
2016-05-18 03:19:06 +12:00
|
|
|
#include "DNA_armature_types.h"
|
2014-07-21 12:02:05 +02:00
|
|
|
#include "DNA_brush_types.h"
|
2015-02-12 18:54:41 +01:00
|
|
|
#include "DNA_camera_types.h"
|
2014-08-26 15:30:59 +02:00
|
|
|
#include "DNA_cloth_types.h"
|
2014-04-07 12:10:37 +02:00
|
|
|
#include "DNA_constraint_types.h"
|
2015-12-13 21:03:13 +13:00
|
|
|
#include "DNA_gpencil_types.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "DNA_sdna_types.h"
|
2015-03-24 12:24:30 +01:00
|
|
|
#include "DNA_sequence_types.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "DNA_space_types.h"
|
|
|
|
#include "DNA_screen_types.h"
|
2015-08-26 14:27:44 +02:00
|
|
|
#include "DNA_object_force.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "DNA_object_types.h"
|
2014-04-13 12:18:51 +02:00
|
|
|
#include "DNA_mesh_types.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "DNA_modifier_types.h"
|
2014-08-26 15:30:59 +02:00
|
|
|
#include "DNA_particle_types.h"
|
2014-04-18 14:59:02 +09:00
|
|
|
#include "DNA_linestyle_types.h"
|
2014-07-14 17:36:56 -07:00
|
|
|
#include "DNA_actuator_types.h"
|
2015-04-06 10:40:12 -03:00
|
|
|
#include "DNA_view3d_types.h"
|
2016-09-24 21:41:16 +02:00
|
|
|
#include "DNA_smoke_types.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
|
|
|
|
#include "DNA_genfile.h"
|
|
|
|
|
2015-10-27 19:00:51 +05:00
|
|
|
#include "BKE_colortools.h"
|
Split id->flag in two, persistent flags and runtime tags.
This is purely internal sanitizing/cleanup, no change in behavior is expected at all.
This change was also needed because we were getting short on ID flags, and
future enhancement of 'user_one' ID behavior requires two new ones.
id->flag remains for persistent data (fakeuser only, so far!), this also allows us
100% backward & forward compatibility.
New id->tag is used for most flags. Though written in .blend files, its content
is cleared at read time.
Note that .blend file version was bumped, so that we can clear runtimeflags from
old .blends, important in case we add new persistent flags in future.
Also, behavior of tags (either status ones, or whether they need to be cleared before/after use)
has been added as comments to their declaration.
Reviewers: sergey, campbellbarton
Differential Revision: https://developer.blender.org/D1683
2015-12-27 11:53:50 +01:00
|
|
|
#include "BKE_library.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "BKE_main.h"
|
2015-02-13 13:51:10 +05:00
|
|
|
#include "BKE_modifier.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "BKE_node.h"
|
2015-04-06 10:40:12 -03:00
|
|
|
#include "BKE_scene.h"
|
2015-03-24 12:24:30 +01:00
|
|
|
#include "BKE_sequencer.h"
|
2015-02-11 00:09:45 +01:00
|
|
|
#include "BKE_screen.h"
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
#include "BKE_tracking.h"
|
2016-08-03 23:31:48 +02:00
|
|
|
#include "BKE_gpencil.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
|
Bake API - bpy.ops.object.bake()
New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api.
The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result.
The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit
Python Operator:
----------------
The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake
bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False)
Note: external save mode is currently disabled.
Supported Features:
------------------
* Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture.
* Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object.
* Cage Extrusion - distance to use for the inward ray cast when using selected to active
* Custom Cage - object to use as cage (instead of the lowpoly object).
* Normal swizzle - change the axis that gets mapped to RGB
* Normal space - save as tangent or object normal spaces
Supported Passes:
-----------------
Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled"
Development Notes for External Engines:
---------------------------------------
(read them in bake_api.c)
* For a complete implementation example look at the Cycles Bake commit (next).
Review: D421
Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge
Normal map pipeline "consulting" by Andy Davies (metalliandy)
Original design by Brecht van Lommel.
The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
|
|
|
#include "BLI_math.h"
|
2014-11-27 23:24:13 +01:00
|
|
|
#include "BLI_listbase.h"
|
Bake API - bpy.ops.object.bake()
New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api.
The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result.
The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit
Python Operator:
----------------
The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake
bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False)
Note: external save mode is currently disabled.
Supported Features:
------------------
* Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture.
* Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object.
* Cage Extrusion - distance to use for the inward ray cast when using selected to active
* Custom Cage - object to use as cage (instead of the lowpoly object).
* Normal swizzle - change the axis that gets mapped to RGB
* Normal space - save as tangent or object normal spaces
Supported Passes:
-----------------
Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled"
Development Notes for External Engines:
---------------------------------------
(read them in bake_api.c)
* For a complete implementation example look at the Cycles Bake commit (next).
Review: D421
Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge
Normal map pipeline "consulting" by Andy Davies (metalliandy)
Original design by Brecht van Lommel.
The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
|
|
|
#include "BLI_string.h"
|
|
|
|
|
2014-03-06 04:33:15 +11:00
|
|
|
#include "BLO_readfile.h"
|
|
|
|
|
|
|
|
#include "readfile.h"
|
|
|
|
|
2015-02-11 00:09:45 +01:00
|
|
|
#include "MEM_guardedalloc.h"
|
2014-03-06 04:33:15 +11:00
|
|
|
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
/**
|
|
|
|
* Setup rotation stabilization from ancient single track spec.
|
|
|
|
* Former Version of 2D stabilization used a single tracking marker to determine the rotation
|
|
|
|
* to be compensated. Now several tracks can contribute to rotation detection and this feature
|
|
|
|
* is enabled by the MovieTrackingTrack#flag on a per track base.
|
|
|
|
*/
|
|
|
|
static void migrate_single_rot_stabilization_track_settings(MovieTrackingStabilization *stab)
|
|
|
|
{
|
|
|
|
if (stab->rot_track) {
|
|
|
|
if (!(stab->rot_track->flag & TRACK_USE_2D_STAB_ROT)) {
|
|
|
|
stab->tot_rot_track++;
|
|
|
|
stab->rot_track->flag |= TRACK_USE_2D_STAB_ROT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
stab->rot_track = NULL; /* this field is now ignored */
|
|
|
|
}
|
|
|
|
|
2014-04-07 19:43:21 +02:00
|
|
|
static void do_version_constraints_radians_degrees_270_1(ListBase *lb)
|
|
|
|
{
|
|
|
|
bConstraint *con;
|
|
|
|
|
|
|
|
for (con = lb->first; con; con = con->next) {
|
|
|
|
if (con->type == CONSTRAINT_TYPE_TRANSFORM) {
|
|
|
|
bTransformConstraint *data = (bTransformConstraint *)con->data;
|
|
|
|
const float deg_to_rad_f = DEG2RADF(1.0f);
|
|
|
|
|
|
|
|
if (data->from == TRANS_ROTATION) {
|
|
|
|
mul_v3_fl(data->from_min, deg_to_rad_f);
|
|
|
|
mul_v3_fl(data->from_max, deg_to_rad_f);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->to == TRANS_ROTATION) {
|
|
|
|
mul_v3_fl(data->to_min, deg_to_rad_f);
|
|
|
|
mul_v3_fl(data->to_max, deg_to_rad_f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-28 13:20:37 +02:00
|
|
|
static void do_version_constraints_radians_degrees_270_5(ListBase *lb)
|
|
|
|
{
|
|
|
|
bConstraint *con;
|
|
|
|
|
|
|
|
for (con = lb->first; con; con = con->next) {
|
|
|
|
if (con->type == CONSTRAINT_TYPE_TRANSFORM) {
|
|
|
|
bTransformConstraint *data = (bTransformConstraint *)con->data;
|
|
|
|
|
|
|
|
if (data->from == TRANS_ROTATION) {
|
|
|
|
copy_v3_v3(data->from_min_rot, data->from_min);
|
|
|
|
copy_v3_v3(data->from_max_rot, data->from_max);
|
|
|
|
}
|
|
|
|
else if (data->from == TRANS_SCALE) {
|
|
|
|
copy_v3_v3(data->from_min_scale, data->from_min);
|
|
|
|
copy_v3_v3(data->from_max_scale, data->from_max);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->to == TRANS_ROTATION) {
|
|
|
|
copy_v3_v3(data->to_min_rot, data->to_min);
|
|
|
|
copy_v3_v3(data->to_max_rot, data->to_max);
|
|
|
|
}
|
|
|
|
else if (data->to == TRANS_SCALE) {
|
|
|
|
copy_v3_v3(data->to_min_scale, data->to_min);
|
|
|
|
copy_v3_v3(data->to_max_scale, data->to_max);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-04-07 19:43:21 +02:00
|
|
|
|
2014-10-14 11:49:58 +02:00
|
|
|
static void do_version_constraints_stretch_to_limits(ListBase *lb)
|
|
|
|
{
|
|
|
|
bConstraint *con;
|
|
|
|
|
|
|
|
for (con = lb->first; con; con = con->next) {
|
|
|
|
if (con->type == CONSTRAINT_TYPE_STRETCHTO) {
|
|
|
|
bStretchToConstraint *data = (bStretchToConstraint *)con->data;
|
|
|
|
data->bulge_min = 1.0f;
|
|
|
|
data->bulge_max = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-08 14:38:30 +12:00
|
|
|
static void do_version_action_editor_properties_region(ListBase *regionbase)
|
|
|
|
{
|
|
|
|
ARegion *ar;
|
|
|
|
|
|
|
|
for (ar = regionbase->first; ar; ar = ar->next) {
|
|
|
|
if (ar->regiontype == RGN_TYPE_UI) {
|
|
|
|
/* already exists */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (ar->regiontype == RGN_TYPE_WINDOW) {
|
|
|
|
/* add new region here */
|
|
|
|
ARegion *arnew = MEM_callocN(sizeof(ARegion), "buttons for action");
|
|
|
|
|
|
|
|
BLI_insertlinkbefore(regionbase, ar, arnew);
|
|
|
|
|
|
|
|
arnew->regiontype = RGN_TYPE_UI;
|
|
|
|
arnew->alignment = RGN_ALIGN_RIGHT;
|
|
|
|
arnew->flag = RGN_FLAG_HIDDEN;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-18 03:19:06 +12:00
|
|
|
static void do_version_bones_super_bbone(ListBase *lb)
|
|
|
|
{
|
|
|
|
for (Bone *bone = lb->first; bone; bone = bone->next) {
|
|
|
|
bone->scaleIn = 1.0f;
|
|
|
|
bone->scaleOut = 1.0f;
|
|
|
|
|
|
|
|
do_version_bones_super_bbone(&bone->childbase);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-06 04:33:15 +11:00
|
|
|
void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
|
|
|
|
{
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 0)) {
|
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "BevelModifierData", "float", "profile")) {
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Bevel) {
|
|
|
|
BevelModifierData *bmd = (BevelModifierData *)md;
|
|
|
|
bmd->profile = 0.5f;
|
|
|
|
bmd->val_flags = MOD_BEVEL_AMT_OFFSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* nodes don't use fixed node->id any more, clean up */
|
|
|
|
FOREACH_NODETREE(main, ntree, id) {
|
|
|
|
if (ntree->type == NTREE_COMPOSIT) {
|
|
|
|
bNode *node;
|
|
|
|
for (node = ntree->nodes.first; node; node = node->next) {
|
|
|
|
if (ELEM(node->type, CMP_NODE_COMPOSITE, CMP_NODE_OUTPUT_FILE)) {
|
|
|
|
node->id = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} FOREACH_NODETREE_END
|
|
|
|
|
|
|
|
{
|
|
|
|
bScreen *screen;
|
|
|
|
|
|
|
|
for (screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
ScrArea *area;
|
|
|
|
for (area = screen->areabase.first; area; area = area->next) {
|
|
|
|
SpaceLink *space_link;
|
|
|
|
for (space_link = area->spacedata.first; space_link; space_link = space_link->next) {
|
|
|
|
if (space_link->spacetype == SPACE_CLIP) {
|
|
|
|
SpaceClip *space_clip = (SpaceClip *) space_link;
|
|
|
|
if (space_clip->mode != SC_MODE_MASKEDIT) {
|
|
|
|
space_clip->mode = SC_MODE_TRACKING;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingSettings", "float", "default_weight")) {
|
|
|
|
MovieClip *clip;
|
|
|
|
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
|
|
|
|
clip->tracking.settings.default_weight = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-04-07 12:10:37 +02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 1)) {
|
2014-04-11 13:08:57 +02:00
|
|
|
Scene *sce;
|
2014-04-07 12:10:37 +02:00
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
/* Update Transform constraint (another deg -> rad stuff). */
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
2014-04-07 19:43:21 +02:00
|
|
|
do_version_constraints_radians_degrees_270_1(&ob->constraints);
|
2014-04-07 12:10:37 +02:00
|
|
|
|
2014-04-07 19:43:21 +02:00
|
|
|
if (ob->pose) {
|
|
|
|
/* Bones constraints! */
|
|
|
|
bPoseChannel *pchan;
|
|
|
|
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
|
|
|
do_version_constraints_radians_degrees_270_1(&pchan->constraints);
|
2014-04-07 12:10:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-04-11 13:08:57 +02:00
|
|
|
|
|
|
|
for (sce = main->scene.first; sce; sce = sce->id.next) {
|
|
|
|
if (sce->r.raytrace_structure == R_RAYSTRUCTURE_BLIBVH) {
|
|
|
|
sce->r.raytrace_structure = R_RAYSTRUCTURE_AUTO;
|
|
|
|
}
|
|
|
|
}
|
2014-04-07 12:10:37 +02:00
|
|
|
}
|
2014-04-13 12:18:51 +02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 2)) {
|
|
|
|
Mesh *me;
|
|
|
|
|
|
|
|
/* Mesh smoothresh deg->rad. */
|
|
|
|
for (me = main->mesh.first; me; me = me->id.next) {
|
|
|
|
me->smoothresh = DEG2RADF(me->smoothresh);
|
|
|
|
}
|
|
|
|
}
|
2014-04-18 14:59:02 +09:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 3)) {
|
|
|
|
FreestyleLineStyle *linestyle;
|
|
|
|
|
|
|
|
for (linestyle = main->linestyle.first; linestyle; linestyle = linestyle->id.next) {
|
|
|
|
linestyle->flag |= LS_NO_SORTING;
|
|
|
|
linestyle->sort_key = LS_SORT_KEY_DISTANCE_FROM_CAMERA;
|
|
|
|
linestyle->integration_type = LS_INTEGRATION_MEAN;
|
|
|
|
}
|
|
|
|
}
|
2014-04-23 15:02:06 +09:00
|
|
|
|
2014-04-23 17:59:35 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 4)) {
|
|
|
|
/* ui_previews were not handled correctly when copying areas, leading to corrupted files (see T39847).
|
|
|
|
* This will always reset situation to a valid state.
|
|
|
|
*/
|
|
|
|
bScreen *sc;
|
|
|
|
|
|
|
|
for (sc = main->screen.first; sc; sc = sc->id.next) {
|
|
|
|
ScrArea *sa;
|
|
|
|
for (sa = sc->areabase.first; sa; sa = sa->next) {
|
|
|
|
SpaceLink *sl;
|
|
|
|
|
|
|
|
for (sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
ARegion *ar;
|
|
|
|
ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
|
|
|
|
|
|
|
|
for (ar = lb->first; ar; ar = ar->next) {
|
|
|
|
BLI_listbase_clear(&ar->ui_previews);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-28 13:20:37 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 270, 5)) {
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
/* Update Transform constraint (again :|). */
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
do_version_constraints_radians_degrees_270_5(&ob->constraints);
|
|
|
|
|
|
|
|
if (ob->pose) {
|
|
|
|
/* Bones constraints! */
|
|
|
|
bPoseChannel *pchan;
|
|
|
|
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
|
|
|
do_version_constraints_radians_degrees_270_5(&pchan->constraints);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 271, 0)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Material", "int", "mode2")) {
|
|
|
|
Material *ma;
|
2014-04-23 15:02:06 +09:00
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
for (ma = main->mat.first; ma; ma = ma->id.next)
|
|
|
|
ma->mode2 = MA_CASTSHADOW;
|
|
|
|
}
|
Bake API - bpy.ops.object.bake()
New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api.
The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result.
The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit
Python Operator:
----------------
The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake
bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False)
Note: external save mode is currently disabled.
Supported Features:
------------------
* Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture.
* Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object.
* Cage Extrusion - distance to use for the inward ray cast when using selected to active
* Custom Cage - object to use as cage (instead of the lowpoly object).
* Normal swizzle - change the axis that gets mapped to RGB
* Normal space - save as tangent or object normal spaces
Supported Passes:
-----------------
Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled"
Development Notes for External Engines:
---------------------------------------
(read them in bake_api.c)
* For a complete implementation example look at the Cycles Bake commit (next).
Review: D421
Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge
Normal map pipeline "consulting" by Andy Davies (metalliandy)
Original design by Brecht van Lommel.
The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "BakeData", "bake")) {
|
|
|
|
Scene *sce;
|
|
|
|
|
|
|
|
for (sce = main->scene.first; sce; sce = sce->id.next) {
|
|
|
|
sce->r.bake.flag = R_BAKE_CLEAR;
|
|
|
|
sce->r.bake.width = 512;
|
|
|
|
sce->r.bake.height = 512;
|
|
|
|
sce->r.bake.margin = 16;
|
|
|
|
sce->r.bake.normal_space = R_BAKE_SPACE_TANGENT;
|
|
|
|
sce->r.bake.normal_swizzle[0] = R_BAKE_POSX;
|
|
|
|
sce->r.bake.normal_swizzle[1] = R_BAKE_POSY;
|
|
|
|
sce->r.bake.normal_swizzle[2] = R_BAKE_POSZ;
|
|
|
|
BLI_strncpy(sce->r.bake.filepath, U.renderdir, sizeof(sce->r.bake.filepath));
|
|
|
|
|
|
|
|
sce->r.bake.im_format.planes = R_IMF_PLANES_RGBA;
|
|
|
|
sce->r.bake.im_format.imtype = R_IMF_IMTYPE_PNG;
|
|
|
|
sce->r.bake.im_format.depth = R_IMF_CHAN_DEPTH_8;
|
|
|
|
sce->r.bake.im_format.quality = 90;
|
|
|
|
sce->r.bake.im_format.compress = 15;
|
|
|
|
}
|
Bake API - bpy.ops.object.bake()
New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api.
The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result.
The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit
Python Operator:
----------------
The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake
bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False)
Note: external save mode is currently disabled.
Supported Features:
------------------
* Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture.
* Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object.
* Cage Extrusion - distance to use for the inward ray cast when using selected to active
* Custom Cage - object to use as cage (instead of the lowpoly object).
* Normal swizzle - change the axis that gets mapped to RGB
* Normal space - save as tangent or object normal spaces
Supported Passes:
-----------------
Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled"
Development Notes for External Engines:
---------------------------------------
(read them in bake_api.c)
* For a complete implementation example look at the Cycles Bake commit (next).
Review: D421
Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge
Normal map pipeline "consulting" by Andy Davies (metalliandy)
Original design by Brecht van Lommel.
The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
|
|
|
}
|
2014-05-16 11:10:25 +09:00
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "FreestyleLineStyle", "float", "texstep")) {
|
|
|
|
FreestyleLineStyle *linestyle;
|
2014-05-16 11:10:25 +09:00
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
for (linestyle = main->linestyle.first; linestyle; linestyle = linestyle->id.next) {
|
|
|
|
linestyle->flag |= LS_TEXTURE;
|
|
|
|
linestyle->texstep = 1.0;
|
|
|
|
}
|
2014-05-16 11:10:25 +09:00
|
|
|
}
|
2014-05-23 18:30:36 +02:00
|
|
|
|
2014-06-12 22:16:43 +06:00
|
|
|
{
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
2014-11-16 13:57:58 +01:00
|
|
|
int num_layers = BLI_listbase_count(&scene->r.layers);
|
2014-06-12 22:16:43 +06:00
|
|
|
scene->r.actlay = min_ff(scene->r.actlay, num_layers - 1);
|
|
|
|
}
|
2014-05-23 18:30:36 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-07 15:54:46 +09:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 271, 1)) {
|
2014-07-07 16:52:50 +09:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "line_col[4]")) {
|
2014-07-07 15:54:46 +09:00
|
|
|
Material *mat;
|
|
|
|
|
|
|
|
for (mat = main->mat.first; mat; mat = mat->id.next) {
|
|
|
|
mat->line_col[0] = mat->line_col[1] = mat->line_col[2] = 0.0f;
|
|
|
|
mat->line_col[3] = mat->alpha;
|
|
|
|
}
|
|
|
|
}
|
2014-07-21 12:02:05 +02:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "int", "preview_start_resolution")) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
scene->r.preview_start_resolution = 64;
|
|
|
|
}
|
|
|
|
}
|
2014-07-07 15:54:46 +09:00
|
|
|
}
|
2014-07-09 19:02:07 +06:00
|
|
|
|
2014-07-14 17:36:56 -07:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 271, 2)) {
|
|
|
|
/* init up & track axis property of trackto actuators */
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
bActuator *act;
|
|
|
|
for (act = ob->actuators.first; act; act = act->next) {
|
|
|
|
if (act->type == ACT_EDIT_OBJECT) {
|
|
|
|
bEditObjectActuator *eoact = act->data;
|
|
|
|
eoact->trackflag = ob->trackflag;
|
|
|
|
/* if trackflag is pointing +-Z axis then upflag should point Y axis.
|
|
|
|
* Rest of trackflag cases, upflag should be point z axis */
|
|
|
|
if ((ob->trackflag == OB_POSZ) || (ob->trackflag == OB_NEGZ)) {
|
|
|
|
eoact->upflag = 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
eoact->upflag = 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 271, 3)) {
|
|
|
|
Brush *br;
|
|
|
|
|
|
|
|
for (br = main->brush.first; br; br = br->id.next) {
|
|
|
|
br->fill_threshold = 0.2f;
|
|
|
|
}
|
2014-10-02 07:49:11 -04:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "BevelModifierData", "int", "mat")) {
|
|
|
|
Object *ob;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Bevel) {
|
|
|
|
BevelModifierData *bmd = (BevelModifierData *)md;
|
|
|
|
bmd->mat = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-07-21 12:02:05 +02:00
|
|
|
}
|
|
|
|
|
2014-08-26 15:30:59 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 271, 6)) {
|
|
|
|
Object *ob;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_ParticleSystem) {
|
2014-08-27 09:49:31 +10:00
|
|
|
ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
|
|
|
|
if (pmd->psys && pmd->psys->clmd) {
|
2014-08-26 15:30:59 +02:00
|
|
|
pmd->psys->clmd->sim_parms->vel_damping = 1.0f;
|
2014-08-27 09:49:31 +10:00
|
|
|
}
|
2014-08-26 15:30:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-09-23 22:56:37 +06:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 272, 0)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "int", "preview_start_resolution")) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
scene->r.preview_start_resolution = 64;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-10-31 18:26:58 +01:00
|
|
|
|
2014-10-03 13:14:10 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 272, 1)) {
|
|
|
|
Brush *br;
|
|
|
|
for (br = main->brush.first; br; br = br->id.next) {
|
|
|
|
if ((br->ob_mode & OB_MODE_SCULPT) && ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK))
|
|
|
|
br->alpha = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
2014-10-02 19:04:38 +06:00
|
|
|
|
2014-10-31 18:26:58 +01:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 272, 2)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Image", "float", "gen_color")) {
|
|
|
|
Image *image;
|
|
|
|
for (image = main->image.first; image != NULL; image = image->id.next) {
|
|
|
|
image->gen_color[3] = 1.0f;
|
|
|
|
}
|
2014-10-02 19:04:38 +06:00
|
|
|
}
|
2014-10-14 11:49:58 +02:00
|
|
|
|
2014-10-31 18:26:58 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "bStretchToConstraint", "float", "bulge_min")) {
|
|
|
|
Object *ob;
|
2014-10-14 11:49:58 +02:00
|
|
|
|
2014-10-31 18:26:58 +01:00
|
|
|
/* Update Transform constraint (again :|). */
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
do_version_constraints_stretch_to_limits(&ob->constraints);
|
2014-10-14 11:49:58 +02:00
|
|
|
|
2014-10-31 18:26:58 +01:00
|
|
|
if (ob->pose) {
|
|
|
|
/* Bones constraints! */
|
|
|
|
bPoseChannel *pchan;
|
|
|
|
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
|
|
|
do_version_constraints_stretch_to_limits(&pchan->constraints);
|
|
|
|
}
|
2014-10-14 11:49:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-12-26 23:51:27 +01:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 1)) {
|
|
|
|
#define BRUSH_RAKE (1 << 7)
|
2014-12-27 00:10:53 +01:00
|
|
|
#define BRUSH_RANDOM_ROTATION (1 << 25)
|
2014-12-26 23:51:27 +01:00
|
|
|
|
|
|
|
Brush *br;
|
|
|
|
|
|
|
|
for (br = main->brush.first; br; br = br->id.next) {
|
|
|
|
if (br->flag & BRUSH_RAKE) {
|
|
|
|
br->mtex.brush_angle_mode |= MTEX_ANGLE_RAKE;
|
|
|
|
br->mask_mtex.brush_angle_mode |= MTEX_ANGLE_RAKE;
|
|
|
|
}
|
2014-12-27 00:10:53 +01:00
|
|
|
else if (br->flag & BRUSH_RANDOM_ROTATION) {
|
2014-12-26 23:51:27 +01:00
|
|
|
br->mtex.brush_angle_mode |= MTEX_ANGLE_RANDOM;
|
|
|
|
br->mask_mtex.brush_angle_mode |= MTEX_ANGLE_RANDOM;
|
|
|
|
}
|
2015-01-31 17:23:30 +11:00
|
|
|
br->mtex.random_angle = 2.0 * M_PI;
|
|
|
|
br->mask_mtex.random_angle = 2.0 * M_PI;
|
2014-12-26 23:51:27 +01:00
|
|
|
}
|
2015-04-06 10:40:12 -03:00
|
|
|
}
|
2014-12-26 23:51:27 +01:00
|
|
|
|
|
|
|
#undef BRUSH_RAKE
|
|
|
|
#undef BRUSH_RANDOM_ROTATION
|
2015-01-19 16:30:35 +11:00
|
|
|
|
|
|
|
/* Customizable Safe Areas */
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 2)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Scene", "DisplaySafeAreas", "safe_areas")) {
|
|
|
|
Scene *scene;
|
|
|
|
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
copy_v2_fl2(scene->safe_areas.title, 3.5f / 100.0f, 3.5f / 100.0f);
|
|
|
|
copy_v2_fl2(scene->safe_areas.action, 10.0f / 100.0f, 5.0f / 100.0f);
|
|
|
|
copy_v2_fl2(scene->safe_areas.title_center, 17.5f / 100.0f, 5.0f / 100.0f);
|
|
|
|
copy_v2_fl2(scene->safe_areas.action_center, 15.0f / 100.0f, 5.0f / 100.0f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-09-26 17:25:21 +02:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 3)) {
|
|
|
|
ParticleSettings *part;
|
|
|
|
for (part = main->particle.first; part; part = part->id.next) {
|
|
|
|
if (part->clumpcurve)
|
|
|
|
part->child_flag |= PART_CHILD_USE_CLUMP_CURVE;
|
|
|
|
if (part->roughcurve)
|
|
|
|
part->child_flag |= PART_CHILD_USE_ROUGH_CURVE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 6)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "bending_damping")) {
|
|
|
|
Object *ob;
|
|
|
|
ModifierData *md;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Cloth) {
|
|
|
|
ClothModifierData *clmd = (ClothModifierData *)md;
|
|
|
|
clmd->sim_parms->bending_damping = 0.5f;
|
|
|
|
}
|
|
|
|
else if (md->type == eModifierType_ParticleSystem) {
|
|
|
|
ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
|
|
|
|
if (pmd->psys->clmd) {
|
|
|
|
pmd->psys->clmd->sim_parms->bending_damping = 0.5f;
|
|
|
|
}
|
2014-09-26 17:25:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-01-12 16:03:12 +01:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "float", "clump_noise_size")) {
|
|
|
|
ParticleSettings *part;
|
|
|
|
for (part = main->particle.first; part; part = part->id.next) {
|
|
|
|
part->clump_noise_size = 1.0f;
|
|
|
|
}
|
2015-01-12 16:03:12 +01:00
|
|
|
}
|
2015-01-13 17:24:20 +01:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "int", "kink_extra_steps")) {
|
|
|
|
ParticleSettings *part;
|
|
|
|
for (part = main->particle.first; part; part = part->id.next) {
|
|
|
|
part->kink_extra_steps = 4;
|
|
|
|
}
|
2015-01-13 17:24:20 +01:00
|
|
|
}
|
2015-01-14 12:29:19 +01:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "MTex", "float", "kinkampfac")) {
|
|
|
|
ParticleSettings *part;
|
|
|
|
for (part = main->particle.first; part; part = part->id.next) {
|
|
|
|
int a;
|
|
|
|
for (a = 0; a < MAX_MTEX; a++) {
|
|
|
|
MTex *mtex = part->mtex[a];
|
|
|
|
if (mtex) {
|
|
|
|
mtex->kinkampfac = 1.0f;
|
|
|
|
}
|
2015-01-14 12:29:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-01-19 13:32:53 +01:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "HookModifierData", "char", "flag")) {
|
|
|
|
Object *ob;
|
2015-02-04 07:04:21 +11:00
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Hook) {
|
|
|
|
HookModifierData *hmd = (HookModifierData *)md;
|
|
|
|
hmd->falloff_type = eHook_Falloff_InvSquare;
|
|
|
|
}
|
2015-02-04 07:04:21 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "NodePlaneTrackDeformData", "char", "flag")) {
|
|
|
|
FOREACH_NODETREE(main, ntree, id) {
|
|
|
|
if (ntree->type == NTREE_COMPOSIT) {
|
|
|
|
bNode *node;
|
|
|
|
for (node = ntree->nodes.first; node; node = node->next) {
|
|
|
|
if (ELEM(node->type, CMP_NODE_PLANETRACKDEFORM)) {
|
|
|
|
NodePlaneTrackDeformData *data = node->storage;
|
|
|
|
data->flag = 0;
|
|
|
|
data->motion_blur_samples = 16;
|
|
|
|
data->motion_blur_shutter = 0.5f;
|
|
|
|
}
|
2015-02-04 01:16:28 +05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
FOREACH_NODETREE_END
|
2015-02-04 01:16:28 +05:00
|
|
|
}
|
2015-02-12 18:54:41 +01:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Camera", "GPUDOFSettings", "gpu_dof")) {
|
|
|
|
Camera *ca;
|
|
|
|
for (ca = main->camera.first; ca; ca = ca->id.next) {
|
|
|
|
ca->gpu_dof.fstop = 128.0f;
|
|
|
|
ca->gpu_dof.focal_length = 1.0f;
|
|
|
|
ca->gpu_dof.focus_distance = 1.0f;
|
|
|
|
ca->gpu_dof.sensor = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
2015-02-04 01:16:28 +05:00
|
|
|
}
|
2015-02-11 00:09:45 +01:00
|
|
|
|
2015-02-13 13:51:10 +05:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 8)) {
|
|
|
|
Object *ob;
|
|
|
|
for (ob = main->object.first; ob != NULL; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.last; md != NULL; md = md->prev) {
|
|
|
|
if (modifier_unique_name(&ob->modifiers, md)) {
|
|
|
|
printf("Warning: Object '%s' had several modifiers with the "
|
|
|
|
"same name, renamed one of them to '%s'.\n",
|
|
|
|
ob->id.name + 2, md->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-26 14:26:42 +01:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 273, 9)) {
|
|
|
|
bScreen *scr;
|
|
|
|
ScrArea *sa;
|
|
|
|
SpaceLink *sl;
|
|
|
|
ARegion *ar;
|
|
|
|
|
|
|
|
/* Make sure sequencer preview area limits zoom */
|
|
|
|
for (scr = main->screen.first; scr; scr = scr->id.next) {
|
|
|
|
for (sa = scr->areabase.first; sa; sa = sa->next) {
|
|
|
|
for (sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
if (sl->spacetype == SPACE_SEQ) {
|
|
|
|
for (ar = sl->regionbase.first; ar; ar = ar->next) {
|
|
|
|
if (ar->regiontype == RGN_TYPE_PREVIEW) {
|
|
|
|
ar->v2d.keepzoom |= V2D_LIMITZOOM;
|
2015-03-05 19:05:39 +01:00
|
|
|
ar->v2d.minzoom = 0.001f;
|
|
|
|
ar->v2d.maxzoom = 1000.0f;
|
2015-02-26 14:26:42 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-17 11:04:44 +01:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 274, 1)) {
|
|
|
|
/* particle systems need to be forced to redistribute for jitter mode fix */
|
|
|
|
{
|
|
|
|
Object *ob;
|
|
|
|
ParticleSystem *psys;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
for (psys = ob->particlesystem.first; psys; psys = psys->next) {
|
2015-08-26 14:27:44 +02:00
|
|
|
if ((psys->pointcache->flag & PTCACHE_BAKED) == 0) {
|
|
|
|
psys->recalc |= PSYS_RECALC_RESET;
|
|
|
|
}
|
2015-03-17 11:04:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-03-22 18:13:53 +01:00
|
|
|
|
|
|
|
/* hysteresis setted to 10% but not actived */
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "LodLevel", "int", "obhysteresis")) {
|
2015-03-23 22:51:12 +11:00
|
|
|
Object *ob;
|
2015-03-22 18:13:53 +01:00
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
LodLevel *level;
|
|
|
|
for (level = ob->lodlevels.first; level; level = level->next) {
|
|
|
|
level->obhysteresis = 10;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "GameData", "int", "scehysteresis")) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
scene->gm.scehysteresis = 10;
|
|
|
|
}
|
|
|
|
}
|
2015-03-17 11:04:44 +01:00
|
|
|
}
|
2015-03-23 18:33:50 +01:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 274, 2)) {
|
|
|
|
FOREACH_NODETREE(main, ntree, id) {
|
|
|
|
bNode *node;
|
|
|
|
bNodeSocket *sock;
|
|
|
|
|
|
|
|
for (node = ntree->nodes.first; node; node = node->next) {
|
|
|
|
if (node->type == SH_NODE_MATERIAL) {
|
|
|
|
for (sock = node->inputs.first; sock; sock = sock->next) {
|
|
|
|
if (STREQ(sock->name, "Refl")) {
|
|
|
|
BLI_strncpy(sock->name, "DiffuseIntensity", sizeof(sock->name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (node->type == SH_NODE_MATERIAL_EXT) {
|
|
|
|
for (sock = node->outputs.first; sock; sock = sock->next) {
|
|
|
|
if (STREQ(sock->name, "Refl")) {
|
|
|
|
BLI_strncpy(sock->name, "DiffuseIntensity", sizeof(sock->name));
|
|
|
|
}
|
|
|
|
else if (STREQ(sock->name, "Ray Mirror")) {
|
|
|
|
BLI_strncpy(sock->name, "Reflectivity", sizeof(sock->name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} FOREACH_NODETREE_END
|
|
|
|
}
|
2015-03-24 12:24:30 +01:00
|
|
|
|
2015-04-07 08:46:48 +10:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 274, 4)) {
|
2015-04-06 10:40:12 -03:00
|
|
|
SceneRenderView *srv;
|
|
|
|
wmWindowManager *wm;
|
|
|
|
bScreen *screen;
|
|
|
|
wmWindow *win;
|
|
|
|
Scene *scene;
|
|
|
|
Camera *cam;
|
|
|
|
Image *ima;
|
|
|
|
|
|
|
|
for (scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
Sequence *seq;
|
|
|
|
|
|
|
|
BKE_scene_add_render_view(scene, STEREO_LEFT_NAME);
|
|
|
|
srv = scene->r.views.first;
|
|
|
|
BLI_strncpy(srv->suffix, STEREO_LEFT_SUFFIX, sizeof(srv->suffix));
|
|
|
|
|
|
|
|
BKE_scene_add_render_view(scene, STEREO_RIGHT_NAME);
|
|
|
|
srv = scene->r.views.last;
|
|
|
|
BLI_strncpy(srv->suffix, STEREO_RIGHT_SUFFIX, sizeof(srv->suffix));
|
|
|
|
|
|
|
|
SEQ_BEGIN (scene->ed, seq)
|
|
|
|
{
|
|
|
|
seq->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Stereo Display 3d Format");
|
2015-04-07 16:08:46 +02:00
|
|
|
|
|
|
|
#define SEQ_USE_PROXY_CUSTOM_DIR (1 << 19)
|
|
|
|
#define SEQ_USE_PROXY_CUSTOM_FILE (1 << 21)
|
|
|
|
if (seq->strip && seq->strip->proxy && !seq->strip->proxy->storage) {
|
|
|
|
if (seq->flag & SEQ_USE_PROXY_CUSTOM_DIR)
|
|
|
|
seq->strip->proxy->storage = SEQ_STORAGE_PROXY_CUSTOM_DIR;
|
|
|
|
if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE)
|
|
|
|
seq->strip->proxy->storage = SEQ_STORAGE_PROXY_CUSTOM_FILE;
|
|
|
|
}
|
|
|
|
#undef SEQ_USE_PROXY_CUSTOM_DIR
|
|
|
|
#undef SEQ_USE_PROXY_CUSTOM_FILE
|
|
|
|
|
2015-04-06 10:40:12 -03:00
|
|
|
}
|
|
|
|
SEQ_END
|
|
|
|
}
|
|
|
|
|
|
|
|
for (screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
ScrArea *sa;
|
|
|
|
for (sa = screen->areabase.first; sa; sa = sa->next) {
|
|
|
|
SpaceLink *sl;
|
|
|
|
|
|
|
|
for (sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
switch (sl->spacetype) {
|
|
|
|
case SPACE_VIEW3D:
|
|
|
|
{
|
|
|
|
View3D *v3d = (View3D *)sl;
|
|
|
|
v3d->stereo3d_camera = STEREO_3D_ID;
|
|
|
|
v3d->stereo3d_flag |= V3D_S3D_DISPPLANE;
|
|
|
|
v3d->stereo3d_convergence_alpha = 0.15f;
|
|
|
|
v3d->stereo3d_volume_alpha = 0.05f;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SPACE_IMAGE:
|
|
|
|
{
|
|
|
|
SpaceImage *sima = (SpaceImage *) sl;
|
|
|
|
sima->iuser.flag |= IMA_SHOW_STEREO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (cam = main->camera.first; cam; cam = cam->id.next) {
|
2015-04-14 10:30:14 +10:00
|
|
|
cam->stereo.interocular_distance = 0.065f;
|
|
|
|
cam->stereo.convergence_distance = 30.0f * 0.065f;
|
2015-04-06 10:40:12 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (ima = main->image.first; ima; ima = ima->id.next) {
|
|
|
|
ima->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Image Stereo 3d Format");
|
|
|
|
|
|
|
|
if (ima->packedfile) {
|
|
|
|
ImagePackedFile *imapf = MEM_mallocN(sizeof(ImagePackedFile), "Image Packed File");
|
|
|
|
BLI_addtail(&ima->packedfiles, imapf);
|
|
|
|
|
|
|
|
imapf->packedfile = ima->packedfile;
|
|
|
|
BLI_strncpy(imapf->filepath, ima->name, FILE_MAX);
|
|
|
|
ima->packedfile = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (wm = main->wm.first; wm; wm = wm->id.next) {
|
|
|
|
for (win = wm->windows.first; win; win = win->next) {
|
|
|
|
win->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Stereo Display 3d Format");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-04-29 21:25:34 +02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 274, 6)) {
|
|
|
|
bScreen *screen;
|
|
|
|
|
2015-05-01 01:49:58 +10:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "FileSelectParams", "int", "thumbnail_size")) {
|
2015-04-29 21:25:34 +02:00
|
|
|
for (screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
ScrArea *sa;
|
|
|
|
|
|
|
|
for (sa = screen->areabase.first; sa; sa = sa->next) {
|
|
|
|
SpaceLink *sl;
|
|
|
|
|
|
|
|
for (sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
if (sl->spacetype == SPACE_FILE) {
|
|
|
|
SpaceFile *sfile = (SpaceFile *)sl;
|
|
|
|
|
|
|
|
if (sfile->params) {
|
2015-05-01 01:49:58 +10:00
|
|
|
sfile->params->thumbnail_size = 128;
|
2015-04-29 21:25:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-04 16:26:28 +05:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "short", "simplify_subsurf_render")) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene != NULL; scene = scene->id.next) {
|
|
|
|
scene->r.simplify_subsurf_render = scene->r.simplify_subsurf;
|
|
|
|
scene->r.simplify_particles_render = scene->r.simplify_particles;
|
|
|
|
}
|
|
|
|
}
|
2015-06-04 19:49:59 +10:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "DecimateModifierData", "float", "defgrp_factor")) {
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Decimate) {
|
|
|
|
DecimateModifierData *dmd = (DecimateModifierData *)md;
|
|
|
|
dmd->defgrp_factor = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-04-29 21:25:34 +02:00
|
|
|
}
|
2015-07-27 12:55:40 +02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 275, 3)) {
|
|
|
|
Brush *br;
|
|
|
|
#define BRUSH_TORUS (1 << 1)
|
|
|
|
for (br = main->brush.first; br; br = br->id.next) {
|
|
|
|
br->flag &= ~BRUSH_TORUS;
|
|
|
|
}
|
|
|
|
#undef BRUSH_TORUS
|
|
|
|
}
|
2015-09-21 23:49:58 +10:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 276, 2)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "bPoseChannel", "float", "custom_scale")) {
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
if (ob->pose) {
|
|
|
|
bPoseChannel *pchan;
|
|
|
|
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
|
|
|
pchan->custom_scale = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-23 04:54:07 +11:00
|
|
|
|
|
|
|
{
|
|
|
|
bScreen *screen;
|
|
|
|
#define RV3D_VIEW_PERSPORTHO 7
|
|
|
|
for (screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
ScrArea *sa;
|
|
|
|
for (sa = screen->areabase.first; sa; sa = sa->next) {
|
|
|
|
SpaceLink *sl;
|
|
|
|
for (sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
if (sl->spacetype == SPACE_VIEW3D) {
|
|
|
|
ARegion *ar;
|
|
|
|
ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
|
|
|
|
for (ar = lb->first; ar; ar = ar->next) {
|
|
|
|
if (ar->regiontype == RGN_TYPE_WINDOW) {
|
|
|
|
if (ar->regiondata) {
|
|
|
|
RegionView3D *rv3d = ar->regiondata;
|
|
|
|
if (rv3d->view == RV3D_VIEW_PERSPORTHO) {
|
|
|
|
rv3d->view = RV3D_VIEW_USER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#undef RV3D_VIEW_PERSPORTHO
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
Lamp *lamp;
|
|
|
|
#define LA_YF_PHOTON 5
|
|
|
|
for (lamp = main->lamp.first; lamp; lamp = lamp->id.next) {
|
|
|
|
if (lamp->type == LA_YF_PHOTON) {
|
|
|
|
lamp->type = LA_LOCAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#undef LA_YF_PHOTON
|
|
|
|
}
|
|
|
|
|
2015-10-28 02:02:31 +01:00
|
|
|
{
|
|
|
|
Object *ob;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
if (ob->body_type == OB_BODY_TYPE_CHARACTER && (ob->gameflag & OB_BOUNDS) && ob->collision_boundtype == OB_BOUND_TRIANGLE_MESH) {
|
|
|
|
ob->boundtype = ob->collision_boundtype = OB_BOUND_BOX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-21 23:49:58 +10:00
|
|
|
}
|
2015-10-27 19:00:51 +05:00
|
|
|
|
2015-12-01 23:56:48 +01:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 276, 3)) {
|
2015-10-27 19:00:51 +05:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "CurveMapping", "mblur_shutter_curve")) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene != NULL; scene = scene->id.next) {
|
|
|
|
CurveMapping *curve_mapping = &scene->r.mblur_shutter_curve;
|
|
|
|
curvemapping_set_defaults(curve_mapping, 1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
curvemapping_initialize(curve_mapping);
|
|
|
|
curvemap_reset(curve_mapping->cm,
|
|
|
|
&curve_mapping->clipr,
|
|
|
|
CURVE_PRESET_MAX,
|
|
|
|
CURVEMAP_SLOPE_POS_NEG);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-28 02:02:31 +01:00
|
|
|
|
2015-12-13 21:09:47 +13:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 276, 4)) {
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
2015-12-13 21:03:13 +13:00
|
|
|
ToolSettings *ts = scene->toolsettings;
|
|
|
|
|
|
|
|
if (ts->gp_sculpt.brush[0].size == 0) {
|
|
|
|
GP_BrushEdit_Settings *gset = &ts->gp_sculpt;
|
|
|
|
GP_EditBrush_Data *brush;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_SMOOTH];
|
|
|
|
brush->size = 25;
|
|
|
|
brush->strength = 0.3f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF | GP_EDITBRUSH_FLAG_SMOOTH_PRESSURE;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_THICKNESS];
|
|
|
|
brush->size = 25;
|
|
|
|
brush->strength = 0.5f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_GRAB];
|
|
|
|
brush->size = 50;
|
|
|
|
brush->strength = 0.3f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_PUSH];
|
|
|
|
brush->size = 25;
|
|
|
|
brush->strength = 0.3f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_TWIST];
|
|
|
|
brush->size = 50;
|
|
|
|
brush->strength = 0.3f; // XXX?
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_PINCH];
|
|
|
|
brush->size = 50;
|
|
|
|
brush->strength = 0.5f; // XXX?
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
2015-12-14 19:20:31 +01:00
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_RANDOMIZE];
|
2015-12-13 21:03:13 +13:00
|
|
|
brush->size = 25;
|
|
|
|
brush->strength = 0.5f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_CLONE];
|
|
|
|
brush->size = 50;
|
|
|
|
brush->strength = 1.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "gpencil_v3d_align")) {
|
|
|
|
#if 0 /* XXX: Cannot do this, as we get random crashes... */
|
|
|
|
if (scene->gpd) {
|
|
|
|
bGPdata *gpd = scene->gpd;
|
|
|
|
|
|
|
|
/* Copy over the settings stored in the GP datablock linked to the scene, for minimal disruption */
|
|
|
|
ts->gpencil_v3d_align = 0;
|
|
|
|
|
|
|
|
if (gpd->flag & GP_DATA_VIEWALIGN) ts->gpencil_v3d_align |= GP_PROJECT_VIEWSPACE;
|
|
|
|
if (gpd->flag & GP_DATA_DEPTH_VIEW) ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_VIEW;
|
|
|
|
if (gpd->flag & GP_DATA_DEPTH_STROKE) ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE;
|
|
|
|
|
|
|
|
if (gpd->flag & GP_DATA_DEPTH_STROKE_ENDPOINTS)
|
|
|
|
ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE_ENDPOINTS;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Default to cursor for all standard 3D views */
|
|
|
|
ts->gpencil_v3d_align = GP_PROJECT_VIEWSPACE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ts->gpencil_v3d_align = GP_PROJECT_VIEWSPACE;
|
|
|
|
ts->gpencil_v2d_align = GP_PROJECT_VIEWSPACE;
|
|
|
|
ts->gpencil_seq_align = GP_PROJECT_VIEWSPACE;
|
|
|
|
ts->gpencil_ima_align = GP_PROJECT_VIEWSPACE;
|
|
|
|
}
|
|
|
|
}
|
2015-12-13 21:09:47 +13:00
|
|
|
|
|
|
|
for (bGPdata *gpd = main->gpencil.first; gpd; gpd = gpd->id.next) {
|
|
|
|
bool enabled = false;
|
|
|
|
|
|
|
|
/* Ensure that the datablock's onionskinning toggle flag
|
|
|
|
* stays in sync with the status of the actual layers
|
|
|
|
*/
|
|
|
|
for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
|
|
|
|
if (gpl->flag & GP_LAYER_ONIONSKIN) {
|
|
|
|
enabled = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (enabled)
|
|
|
|
gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
|
|
|
|
else
|
|
|
|
gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
|
|
|
|
}
|
2015-12-18 22:44:19 +01:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Object", "unsigned char", "max_jumps")) {
|
|
|
|
for (Object *ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ob->max_jumps = 1;
|
|
|
|
}
|
|
|
|
}
|
2015-12-13 21:03:13 +13:00
|
|
|
}
|
Split id->flag in two, persistent flags and runtime tags.
This is purely internal sanitizing/cleanup, no change in behavior is expected at all.
This change was also needed because we were getting short on ID flags, and
future enhancement of 'user_one' ID behavior requires two new ones.
id->flag remains for persistent data (fakeuser only, so far!), this also allows us
100% backward & forward compatibility.
New id->tag is used for most flags. Though written in .blend files, its content
is cleared at read time.
Note that .blend file version was bumped, so that we can clear runtimeflags from
old .blends, important in case we add new persistent flags in future.
Also, behavior of tags (either status ones, or whether they need to be cleared before/after use)
has been added as comments to their declaration.
Reviewers: sergey, campbellbarton
Differential Revision: https://developer.blender.org/D1683
2015-12-27 11:53:50 +01:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 276, 5)) {
|
|
|
|
ListBase *lbarray[MAX_LIBARRAY];
|
|
|
|
int a;
|
|
|
|
|
|
|
|
/* Important to clear all non-persistent flags from older versions here, otherwise they could collide
|
|
|
|
* with any new persistent flag we may add in the future. */
|
|
|
|
a = set_listbasepointers(main, lbarray);
|
|
|
|
while (a--) {
|
|
|
|
for (ID *id = lbarray[a]->first; id; id = id->next) {
|
|
|
|
id->flag &= LIB_FAKEUSER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-15 13:00:56 -02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 276, 7)) {
|
|
|
|
Scene *scene;
|
|
|
|
for (scene = main->scene.first; scene != NULL; scene = scene->id.next) {
|
|
|
|
scene->r.bake.pass_filter = R_BAKE_PASS_FILTER_ALL;
|
|
|
|
}
|
|
|
|
}
|
2016-03-03 16:06:49 +01:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 277, 1)) {
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
ParticleEditSettings *pset = &scene->toolsettings->particle;
|
|
|
|
for (int a = 0; a < PE_TOT_BRUSH; a++) {
|
|
|
|
if (pset->brush[a].strength > 1.0f) {
|
|
|
|
pset->brush[a].strength *= 0.01f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-26 00:03:43 +01:00
|
|
|
|
|
|
|
for (bScreen *screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
|
|
|
|
for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
|
2016-03-27 13:36:12 +02:00
|
|
|
ListBase *regionbase = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
|
|
|
|
/* Bug: Was possible to add preview region to sequencer view by using AZones. */
|
2016-03-26 00:03:43 +01:00
|
|
|
if (sl->spacetype == SPACE_SEQ) {
|
|
|
|
SpaceSeq *sseq = (SpaceSeq *)sl;
|
|
|
|
if (sseq->view == SEQ_VIEW_SEQUENCE) {
|
2016-03-27 13:36:12 +02:00
|
|
|
for (ARegion *ar = regionbase->first; ar; ar = ar->next) {
|
2016-03-26 00:03:43 +01:00
|
|
|
/* remove preview region for sequencer-only view! */
|
|
|
|
if (ar->regiontype == RGN_TYPE_PREVIEW) {
|
2016-03-27 13:17:10 +02:00
|
|
|
ar->flag |= RGN_FLAG_HIDDEN;
|
|
|
|
ar->alignment = RGN_ALIGN_NONE;
|
2016-03-26 00:03:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-27 13:36:12 +02:00
|
|
|
/* Remove old deprecated region from filebrowsers */
|
|
|
|
else if (sl->spacetype == SPACE_FILE) {
|
|
|
|
for (ARegion *ar = regionbase->first; ar; ar = ar->next) {
|
|
|
|
if (ar->regiontype == RGN_TYPE_CHANNELS) {
|
|
|
|
/* Free old deprecated 'channel' region... */
|
|
|
|
BKE_area_region_free(NULL, ar);
|
|
|
|
BLI_freelinkN(regionbase, ar);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-26 00:03:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-04-15 18:10:05 +10:00
|
|
|
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
CurvePaintSettings *cps = &scene->toolsettings->curve_paint_settings;
|
|
|
|
if (cps->error_threshold == 0) {
|
|
|
|
cps->curve_type = CU_BEZIER;
|
|
|
|
cps->flag |= CURVE_PAINT_FLAG_CORNERS_DETECT;
|
|
|
|
cps->error_threshold = 8;
|
|
|
|
cps->radius_max = 1.0f;
|
|
|
|
cps->corner_angle = DEG2RADF(70.0f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-27 15:49:13 +10:00
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
Sequence *seq;
|
|
|
|
|
|
|
|
SEQ_BEGIN (scene->ed, seq)
|
|
|
|
{
|
|
|
|
if (seq->type == SEQ_TYPE_TEXT) {
|
|
|
|
TextVars *data = seq->effectdata;
|
|
|
|
if (data->color[3] == 0.0f) {
|
|
|
|
copy_v4_fl(data->color, 1.0f);
|
|
|
|
data->shadow_color[3] = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SEQ_END
|
|
|
|
}
|
|
|
|
|
2016-05-08 14:38:30 +12:00
|
|
|
/* Adding "Properties" region to DopeSheet */
|
|
|
|
for (bScreen *screen = main->screen.first; screen; screen = screen->id.next) {
|
|
|
|
for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
|
|
|
|
/* handle pushed-back space data first */
|
|
|
|
for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
|
|
|
|
if (sl->spacetype == SPACE_ACTION) {
|
|
|
|
SpaceAction *saction = (SpaceAction *)sl;
|
|
|
|
do_version_action_editor_properties_region(&saction->regionbase);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* active spacedata info must be handled too... */
|
|
|
|
if (sa->spacetype == SPACE_ACTION) {
|
|
|
|
do_version_action_editor_properties_region(&sa->regionbase);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-03 16:06:49 +01:00
|
|
|
}
|
2016-05-18 03:19:06 +12:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 277, 2)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "Bone", "float", "scaleIn")) {
|
|
|
|
for (bArmature *arm = main->armature.first; arm; arm = arm->id.next) {
|
|
|
|
do_version_bones_super_bbone(&arm->bonebase);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "bPoseChannel", "float", "scaleIn")) {
|
|
|
|
for (Object *ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
if (ob->pose) {
|
|
|
|
for (bPoseChannel *pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
|
|
|
/* see do_version_bones_super_bbone()... */
|
|
|
|
pchan->scaleIn = 1.0f;
|
|
|
|
pchan->scaleOut = 1.0f;
|
|
|
|
|
|
|
|
/* also make sure some legacy (unused for over a decade) flags are unset,
|
|
|
|
* so that we can reuse them for stuff that matters now...
|
|
|
|
* (i.e. POSE_IK_MAT, (unknown/unused x 4), POSE_HAS_IK)
|
|
|
|
*
|
|
|
|
* These seem to have been runtime flags used by the IK solver, but that stuff
|
|
|
|
* should be able to be recalculated automatically anyway, so it should be fine.
|
|
|
|
*/
|
|
|
|
pchan->flag &= ~((1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-17 14:12:29 +02:00
|
|
|
|
|
|
|
for (Camera *camera = main->camera.first; camera != NULL; camera = camera->id.next) {
|
|
|
|
if (camera->stereo.pole_merge_angle_from == 0.0f &&
|
2016-08-03 23:31:48 +02:00
|
|
|
camera->stereo.pole_merge_angle_to == 0.0f)
|
2016-05-17 14:12:29 +02:00
|
|
|
{
|
2016-07-22 04:05:38 +10:00
|
|
|
camera->stereo.pole_merge_angle_from = DEG2RADF(60.0f);
|
|
|
|
camera->stereo.pole_merge_angle_to = DEG2RADF(75.0f);
|
2016-05-17 14:12:29 +02:00
|
|
|
}
|
|
|
|
}
|
2016-06-06 21:41:17 +02:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "NormalEditModifierData", "float", "mix_limit")) {
|
|
|
|
Object *ob;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_NormalEdit) {
|
|
|
|
NormalEditModifierData *nemd = (NormalEditModifierData *)md;
|
|
|
|
nemd->mix_limit = DEG2RADF(180.0f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-13 17:45:55 +10:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "BooleanModifierData", "float", "double_threshold")) {
|
|
|
|
Object *ob;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
ModifierData *md;
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Boolean) {
|
|
|
|
BooleanModifierData *bmd = (BooleanModifierData *)md;
|
|
|
|
bmd->double_threshold = 1e-6f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-20 13:54:55 +10:00
|
|
|
|
|
|
|
for (Brush *br = main->brush.first; br; br = br->id.next) {
|
|
|
|
if (br->sculpt_tool == SCULPT_TOOL_FLATTEN) {
|
|
|
|
br->flag |= BRUSH_ACCUMULATE;
|
|
|
|
}
|
|
|
|
}
|
2016-07-30 14:46:19 +10:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "time_scale")) {
|
|
|
|
Object *ob;
|
|
|
|
ModifierData *md;
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Cloth) {
|
|
|
|
ClothModifierData *clmd = (ClothModifierData *)md;
|
|
|
|
clmd->sim_parms->time_scale = 1.0f;
|
|
|
|
}
|
|
|
|
else if (md->type == eModifierType_ParticleSystem) {
|
|
|
|
ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
|
|
|
|
if (pmd->psys->clmd) {
|
|
|
|
pmd->psys->clmd->sim_parms->time_scale = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-17 14:12:29 +02:00
|
|
|
}
|
2016-08-03 23:31:48 +02:00
|
|
|
|
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 277, 3)) {
|
|
|
|
/* ------- init of grease pencil initialization --------------- */
|
2016-08-13 01:29:17 +02:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "bGPDstroke", "bGPDpalettecolor", "*palcolor")) {
|
2016-08-03 23:31:48 +02:00
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
ToolSettings *ts = scene->toolsettings;
|
|
|
|
/* initialize use position for sculpt brushes */
|
|
|
|
ts->gp_sculpt.flag |= GP_BRUSHEDIT_FLAG_APPLY_POSITION;
|
|
|
|
/* initialize selected vertices alpha factor */
|
|
|
|
ts->gp_sculpt.alpha = 1.0f;
|
|
|
|
|
|
|
|
/* new strength sculpt brush */
|
|
|
|
if (ts->gp_sculpt.brush[0].size >= 11) {
|
|
|
|
GP_BrushEdit_Settings *gset = &ts->gp_sculpt;
|
|
|
|
GP_EditBrush_Data *brush;
|
|
|
|
|
|
|
|
brush = &gset->brush[GP_EDITBRUSH_TYPE_STRENGTH];
|
|
|
|
brush->size = 25;
|
|
|
|
brush->strength = 0.5f;
|
|
|
|
brush->flag = GP_EDITBRUSH_FLAG_USE_FALLOFF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* create a default grease pencil drawing brushes set */
|
|
|
|
if (!BLI_listbase_is_empty(&main->gpencil)) {
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
ToolSettings *ts = scene->toolsettings;
|
|
|
|
if (BLI_listbase_is_empty(&ts->gp_brushes)) {
|
2016-08-04 15:03:18 +02:00
|
|
|
BKE_gpencil_brush_init_presets(ts);
|
2016-08-03 23:31:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Convert Grease Pencil to new palettes/brushes
|
|
|
|
* Loop all strokes and create the palette and all colors
|
|
|
|
*/
|
|
|
|
for (bGPdata *gpd = main->gpencil.first; gpd; gpd = gpd->id.next) {
|
|
|
|
if (BLI_listbase_is_empty(&gpd->palettes)) {
|
|
|
|
/* create palette */
|
2016-08-04 15:03:18 +02:00
|
|
|
bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, "GP_Palette", true);
|
2016-08-03 23:31:48 +02:00
|
|
|
for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
|
|
|
|
/* create color using layer name */
|
2016-08-04 15:03:18 +02:00
|
|
|
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_addnew(palette, gpl->info, true);
|
2016-08-03 23:31:48 +02:00
|
|
|
if (palcolor != NULL) {
|
|
|
|
/* set color attributes */
|
|
|
|
copy_v4_v4(palcolor->color, gpl->color);
|
|
|
|
copy_v4_v4(palcolor->fill, gpl->fill);
|
2016-08-29 17:00:18 +12:00
|
|
|
|
|
|
|
if (gpl->flag & GP_LAYER_HIDE) palcolor->flag |= PC_COLOR_HIDE;
|
|
|
|
if (gpl->flag & GP_LAYER_LOCKED) palcolor->flag |= PC_COLOR_LOCKED;
|
|
|
|
if (gpl->flag & GP_LAYER_ONIONSKIN) palcolor->flag |= PC_COLOR_ONIONSKIN;
|
|
|
|
if (gpl->flag & GP_LAYER_VOLUMETRIC) palcolor->flag |= PC_COLOR_VOLUMETRIC;
|
|
|
|
if (gpl->flag & GP_LAYER_HQ_FILL) palcolor->flag |= PC_COLOR_HQ_FILL;
|
|
|
|
|
2016-08-03 23:31:48 +02:00
|
|
|
/* set layer opacity to 1 */
|
|
|
|
gpl->opacity = 1.0f;
|
2016-08-29 17:00:18 +12:00
|
|
|
|
2016-08-03 23:31:48 +02:00
|
|
|
/* set tint color */
|
|
|
|
ARRAY_SET_ITEMS(gpl->tintcolor, 0.0f, 0.0f, 0.0f, 0.0f);
|
2016-08-29 17:00:18 +12:00
|
|
|
|
|
|
|
/* flush relevant layer-settings to strokes */
|
2016-08-03 23:31:48 +02:00
|
|
|
for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
|
|
|
for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
|
|
|
|
/* set stroke to palette and force recalculation */
|
2016-08-18 15:45:20 +02:00
|
|
|
BLI_strncpy(gps->colorname, gpl->info, sizeof(gps->colorname));
|
2016-08-03 23:31:48 +02:00
|
|
|
gps->palcolor = NULL;
|
|
|
|
gps->flag |= GP_STROKE_RECALC_COLOR;
|
|
|
|
gps->thickness = gpl->thickness;
|
2016-08-29 17:00:18 +12:00
|
|
|
|
2016-08-03 23:31:48 +02:00
|
|
|
/* set alpha strength to 1 */
|
|
|
|
for (int i = 0; i < gps->totpoints; i++) {
|
|
|
|
gps->points[i].strength = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-08-29 17:00:18 +12:00
|
|
|
|
2016-08-03 23:31:48 +02:00
|
|
|
/* set thickness to 0 (now it is a factor to override stroke thickness) */
|
|
|
|
gpl->thickness = 0.0f;
|
|
|
|
}
|
|
|
|
/* set first color as active */
|
|
|
|
if (palette->colors.first)
|
2016-08-04 15:03:18 +02:00
|
|
|
BKE_gpencil_palettecolor_setactive(palette, palette->colors.first);
|
2016-08-03 23:31:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* ------- end of grease pencil initialization --------------- */
|
|
|
|
}
|
|
|
|
|
2016-09-02 11:37:25 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 278, 0)) {
|
2016-08-16 13:53:29 +02:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight_stab")) {
|
|
|
|
MovieClip *clip;
|
|
|
|
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
|
|
|
|
MovieTracking *tracking = &clip->tracking;
|
|
|
|
MovieTrackingObject *tracking_object;
|
|
|
|
for (tracking_object = tracking->objects.first;
|
|
|
|
tracking_object != NULL;
|
|
|
|
tracking_object = tracking_object->next)
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
{
|
2016-08-16 13:53:29 +02:00
|
|
|
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
|
|
|
|
MovieTrackingTrack *track;
|
|
|
|
for (track = tracksbase->first;
|
|
|
|
track != NULL;
|
|
|
|
track = track->next)
|
|
|
|
{
|
|
|
|
track->weight_stab = track->weight;
|
|
|
|
}
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-16 13:53:29 +02:00
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingStabilization", "int", "tot_rot_track")) {
|
|
|
|
MovieClip *clip;
|
|
|
|
for (clip = main->movieclip.first; clip != NULL; clip = clip->id.next) {
|
|
|
|
if (clip->tracking.stabilization.rot_track) {
|
|
|
|
migrate_single_rot_stabilization_track_settings(&clip->tracking.stabilization);
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
}
|
2016-08-22 17:22:06 +02:00
|
|
|
if (clip->tracking.stabilization.scale == 0.0f) {
|
|
|
|
/* ensure init.
|
|
|
|
* Was previously used for autoscale only,
|
|
|
|
* now used always (as "target scale") */
|
|
|
|
clip->tracking.stabilization.scale = 1.0f;
|
|
|
|
}
|
2016-08-22 17:29:19 +02:00
|
|
|
/* blender prefers 1-based frame counting;
|
|
|
|
* thus using frame 1 as reference typically works best */
|
|
|
|
clip->tracking.stabilization.anchor_frame = 1;
|
2016-08-22 17:22:06 +02:00
|
|
|
/* by default show the track lists expanded, to improve "discoverability" */
|
|
|
|
clip->tracking.stabilization.flag |= TRACKING_SHOW_STAB_TRACKS;
|
|
|
|
/* deprecated, not used anymore */
|
|
|
|
clip->tracking.stabilization.ok = false;
|
Rework 2D stabilizator
See this page for motivation and description of concepts:
https://github.com/Ichthyostega/blender/wiki
See this video for UI explanation and demonstration of usage
http://vimeo.com/blenderHack/stabilizerdemo
This proposal attempts to improve usability of Blender's image stabilization
feature for real-world footage esp. with moving and panning camera. It builds
upon the feature tracking to get a measurement of 2D image movement.
- Use a weighted average of movement contributions (instead of a median).
- Allow for rotation compensation and zoom (image scale) compensation.
- Allow to pick a different set of tracks for translation and for
rotation/zoom.
- Treat translation / rotation / zoom contributions systematically in a
similar way.
- Improve handling of partial tracking data with gaps and varying
start / end points.
- Have a user definable anchor frame and interpolate / extrapolate data to
avoid jumping back to "neutral" position when no tracking data is available.
- Support for travelling and panning shots by including an //intended//
position/rotation/zoom ("target position"). The idea is for these parameters
to be //animated// by the user, in order to supply an smooth, intended
camera movement. This way, we can keep the image content roughly in frame
even when moving completely away from the initial view.
A known shortcoming is that the pivot point for rotation compensation is set to
the translation compensated image center. This can produce spurious rotation on
travelling shots, which needs to be compensated manually (by animating the
target rotation parameter). There are several possible ways to address that
problem, yet all of them are considered beyond the scope of this improvement
proposal for now.
Own modifications:
- Restrict line length, it's really handy for split-view editing
- In motion tracking we prefer fully human-readable comments, meaning we
don't use doxygen with it's weird markup and comments are supposed to
start with capital and end with a full stop,
- Add explicit comparison of pointer to NULL.
Reviewers: sergey
Subscribers: kusi, kdawg, forest-house, mardy, Samoth, plasmasolutions, willolis, sebastian_k, hype, enetheru, sunboy, jta, leon_cheung
Maniphest Tasks: T49036
Differential Revision: https://developer.blender.org/D583
2016-08-16 10:32:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
FFmpeg interface improvements
This patch changes a couple of things in the video output encoding.
{F362527}
- Clearer separation between container and codec. No more "format", as this is
too ambiguous. As a result, codecs were removed from the container list.
- Added FFmpeg speed presets, so the user can choosen from the range "Very
slow" to "Ultra fast". By default no preset is used.
- Added Constant Rate Factor (CRF) mode, which allows changing the bit-rate
depending on the desired quality and the input. This generally produces the
best quality videos, at the expense of not knowing the exact bit-rate and
file size.
- Added optional maximum of non-B-frames between B-frames (`max_b_frames`).
- Presets were adjusted for these changes, and new presets added. One of the
new presets is [recommended](https://trac.ffmpeg.org/wiki/Encode/VFX#H.264)
for reviewing videos, as it allows players to scrub through it easily. Might
be nice in weeklies. This preset also requires control over the
`max_b_frames` setting.
GUI-only changes:
- Renamed "MPEG" in the output file format menu with "FFmpeg", as this is more
accurate. After all, FFmpeg is used when this option is chosen, which can
also output non-MPEG files.
- Certain parts of the GUI are disabled when not in use:
- bit rate options are not used when a constant rate factor is given.
- audio bitrate & volume are not used when no audio is exported.
Note that I did not touch `BKE_ffmpeg_preset_set()`. There are currently two
preset systems for FFmpeg (`BKE_ffmpeg_preset_set()` and the Python preset
system). Before we do more work on `BKE_ffmpeg_preset_set()`, I think it's a
good idea to determine whether we want to keep it at all.
After this patch has been accepted, I'd be happy to go through the code and
remove any then-obsolete bits, such as the handling of "XVID" as a container
format.
Reviewers: sergey, mont29, brecht
Subscribers: mpan3, Blendify, brecht, fsiddi
Tags: #bf_blender
Differential Revision: https://developer.blender.org/D2242
2016-09-21 15:01:51 +02:00
|
|
|
if (!MAIN_VERSION_ATLEAST(main, 279, 0)) {
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "ffmpeg_preset")) {
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
/* "medium" is the preset FFmpeg uses when no presets are given. */
|
|
|
|
scene->r.ffcodecdata.ffmpeg_preset = FFM_PRESET_MEDIUM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "constant_rate_factor")) {
|
|
|
|
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
|
|
|
|
/* fall back to behaviour from before we introduced CRF for old files */
|
|
|
|
scene->r.ffcodecdata.constant_rate_factor = FFM_CRF_NONE;
|
|
|
|
}
|
|
|
|
}
|
2016-09-24 21:41:16 +02:00
|
|
|
|
|
|
|
if (!DNA_struct_elem_find(fd->filesdna, "SmokeModifierData", "float", "slice_per_voxel")) {
|
|
|
|
Object *ob;
|
|
|
|
ModifierData *md;
|
|
|
|
|
|
|
|
for (ob = main->object.first; ob; ob = ob->id.next) {
|
|
|
|
for (md = ob->modifiers.first; md; md = md->next) {
|
|
|
|
if (md->type == eModifierType_Smoke) {
|
|
|
|
SmokeModifierData *smd = (SmokeModifierData *)md;
|
|
|
|
if (smd->domain) {
|
|
|
|
smd->domain->slice_per_voxel = 5.0f;
|
|
|
|
smd->domain->slice_depth = 0.5f;
|
|
|
|
smd->domain->display_thickness = 1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
FFmpeg interface improvements
This patch changes a couple of things in the video output encoding.
{F362527}
- Clearer separation between container and codec. No more "format", as this is
too ambiguous. As a result, codecs were removed from the container list.
- Added FFmpeg speed presets, so the user can choosen from the range "Very
slow" to "Ultra fast". By default no preset is used.
- Added Constant Rate Factor (CRF) mode, which allows changing the bit-rate
depending on the desired quality and the input. This generally produces the
best quality videos, at the expense of not knowing the exact bit-rate and
file size.
- Added optional maximum of non-B-frames between B-frames (`max_b_frames`).
- Presets were adjusted for these changes, and new presets added. One of the
new presets is [recommended](https://trac.ffmpeg.org/wiki/Encode/VFX#H.264)
for reviewing videos, as it allows players to scrub through it easily. Might
be nice in weeklies. This preset also requires control over the
`max_b_frames` setting.
GUI-only changes:
- Renamed "MPEG" in the output file format menu with "FFmpeg", as this is more
accurate. After all, FFmpeg is used when this option is chosen, which can
also output non-MPEG files.
- Certain parts of the GUI are disabled when not in use:
- bit rate options are not used when a constant rate factor is given.
- audio bitrate & volume are not used when no audio is exported.
Note that I did not touch `BKE_ffmpeg_preset_set()`. There are currently two
preset systems for FFmpeg (`BKE_ffmpeg_preset_set()` and the Python preset
system). Before we do more work on `BKE_ffmpeg_preset_set()`, I think it's a
good idea to determine whether we want to keep it at all.
After this patch has been accepted, I'd be happy to go through the code and
remove any then-obsolete bits, such as the handling of "XVID" as a container
format.
Reviewers: sergey, mont29, brecht
Subscribers: mpan3, Blendify, brecht, fsiddi
Tags: #bf_blender
Differential Revision: https://developer.blender.org/D2242
2016-09-21 15:01:51 +02:00
|
|
|
}
|
2014-03-06 04:33:15 +11:00
|
|
|
}
|