Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
deb6f733a6aed0c578e1ee01e4d0d41563574bc7
blender/source/blender/blenloader/intern/versioning_260.c
Campbell Barton deb6f733a6 Move do-versions functions for 2.70
2014-03-06 04:40:49 +11:00

2710 lines
78 KiB
C
Raw Blame History

/*
* ***** 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_260.c
* \ingroup blenloader
*/
#include "zlib.h"
#include "BLI_utildefines.h"
/* allow readfile to use deprecated functionality */
#define DNA_DEPRECATED_ALLOW
#include "DNA_anim_types.h"
#include "DNA_actuator_types.h"
#include "DNA_brush_types.h"
#include "DNA_camera_types.h"
#include "DNA_cloth_types.h"
#include "DNA_constraint_types.h"
#include "DNA_genfile.h"
#include "DNA_key_types.h"
#include "DNA_linestyle_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_fluidsim.h" // NT
#include "DNA_object_types.h"
#include "DNA_property_types.h"
#include "DNA_text_types.h"
#include "DNA_view3d_types.h"
#include "DNA_screen_types.h"
#include "DNA_sensor_types.h"
#include "DNA_sdna_types.h"
#include "DNA_smoke_types.h"
#include "DNA_space_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_math.h"
#include "BLF_translation.h"
#include "BKE_anim.h"
#include "BKE_image.h"
#include "BKE_main.h" // for Main
#include "BKE_mesh.h" // for ME_ defines (patching)
#include "BKE_modifier.h"
#include "BKE_particle.h"
#include "BKE_pointcache.h"
#include "BKE_property.h" // for BKE_bproperty_object_get
#include "BKE_scene.h"
#include "BKE_screen.h"
#include "BKE_sequencer.h"
#include "BKE_text.h" // for txt_extended_ascii_as_utf8
#include "BKE_texture.h"
#include "BKE_tracking.h"
#include "BKE_writeffmpeg.h"
#include "IMB_imbuf.h" // for proxy / timecode versioning stuff
#include "NOD_texture.h"
#include "BLO_readfile.h"
#include "readfile.h"
static void do_versions_nodetree_image_default_alpha_output(bNodeTree *ntree)
{
bNode *node;
bNodeSocket *sock;
for (node = ntree->nodes.first; node; node = node->next) {
if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
/* default Image output value should have 0 alpha */
sock = node->outputs.first;
((bNodeSocketValueRGBA *)(sock->default_value))->value[3] = 0.0f;
}
}
}
static void do_versions_nodetree_convert_angle(bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_ROTATE) {
/* Convert degrees to radians. */
bNodeSocket *sock = ((bNodeSocket *)node->inputs.first)->next;
((bNodeSocketValueFloat *)sock->default_value)->value =
DEG2RADF(((bNodeSocketValueFloat *)sock->default_value)->value);
}
else if (node->type == CMP_NODE_DBLUR) {
/* Convert degrees to radians. */
NodeDBlurData *ndbd = node->storage;
ndbd->angle = DEG2RADF(ndbd->angle);
ndbd->spin = DEG2RADF(ndbd->spin);
}
else if (node->type == CMP_NODE_DEFOCUS) {
/* Convert degrees to radians. */
NodeDefocus *nqd = node->storage;
/* XXX DNA char to float conversion seems to map the char value into the [0.0f, 1.0f] range... */
nqd->rotation = DEG2RADF(nqd->rotation * 255.0f);
}
else if (node->type == CMP_NODE_CHROMA_MATTE) {
/* Convert degrees to radians. */
NodeChroma *ndc = node->storage;
ndc->t1 = DEG2RADF(ndc->t1);
ndc->t2 = DEG2RADF(ndc->t2);
}
else if (node->type == CMP_NODE_GLARE) {
/* Convert degrees to radians. */
NodeGlare *ndg = node->storage;
/* XXX DNA char to float conversion seems to map the char value into the [0.0f, 1.0f] range... */
ndg->angle_ofs = DEG2RADF(ndg->angle_ofs * 255.0f);
}
/* XXX TexMapping struct is used by other nodes too (at least node_composite_mapValue),
* but not the rot part...
*/
else if (node->type == SH_NODE_MAPPING) {
/* Convert degrees to radians. */
TexMapping *tmap = node->storage;
tmap->rot[0] = DEG2RADF(tmap->rot[0]);
tmap->rot[1] = DEG2RADF(tmap->rot[1]);
tmap->rot[2] = DEG2RADF(tmap->rot[2]);
}
}
}
static void do_versions_image_settings_2_60(Scene *sce)
{
/* note: rd->subimtype is moved into individual settings now and no longer
* exists */
RenderData *rd = &sce->r;
ImageFormatData *imf = &sce->r.im_format;
/* we know no data loss happens here, the old values were in char range */
imf->imtype = (char)rd->imtype;
imf->planes = (char)rd->planes;
imf->compress = (char)rd->quality;
imf->quality = (char)rd->quality;
/* default, was stored in multiple places, may override later */
imf->depth = R_IMF_CHAN_DEPTH_8;
/* openexr */
imf->exr_codec = rd->quality & 7; /* strange but true! 0-4 are valid values, OPENEXR_COMPRESS */
switch (imf->imtype) {
case R_IMF_IMTYPE_OPENEXR:
imf->depth = (rd->subimtype & R_OPENEXR_HALF) ? R_IMF_CHAN_DEPTH_16 : R_IMF_CHAN_DEPTH_32;
if (rd->subimtype & R_PREVIEW_JPG) {
imf->flag |= R_IMF_FLAG_PREVIEW_JPG;
}
if (rd->subimtype & R_OPENEXR_ZBUF) {
imf->flag |= R_IMF_FLAG_ZBUF;
}
break;
case R_IMF_IMTYPE_TIFF:
if (rd->subimtype & R_TIFF_16BIT) {
imf->depth = R_IMF_CHAN_DEPTH_16;
}
break;
case R_IMF_IMTYPE_JP2:
if (rd->subimtype & R_JPEG2K_16BIT) {
imf->depth = R_IMF_CHAN_DEPTH_16;
}
else if (rd->subimtype & R_JPEG2K_12BIT) {
imf->depth = R_IMF_CHAN_DEPTH_12;
}
if (rd->subimtype & R_JPEG2K_YCC) {
imf->jp2_flag |= R_IMF_JP2_FLAG_YCC;
}
if (rd->subimtype & R_JPEG2K_CINE_PRESET) {
imf->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
}
if (rd->subimtype & R_JPEG2K_CINE_48FPS) {
imf->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
}
break;
case R_IMF_IMTYPE_CINEON:
case R_IMF_IMTYPE_DPX:
if (rd->subimtype & R_CINEON_LOG) {
imf->cineon_flag |= R_IMF_CINEON_FLAG_LOG;
}
break;
}
}
/* socket use flags were only temporary before */
static void do_versions_nodetree_socket_use_flags_2_62(bNodeTree *ntree)
{
bNode *node;
bNodeSocket *sock;
bNodeLink *link;
for (node = ntree->nodes.first; node; node = node->next) {
for (sock = node->inputs.first; sock; sock = sock->next)
sock->flag &= ~SOCK_IN_USE;
for (sock = node->outputs.first; sock; sock = sock->next)
sock->flag &= ~SOCK_IN_USE;
}
for (sock = ntree->inputs.first; sock; sock = sock->next)
sock->flag &= ~SOCK_IN_USE;
for (sock = ntree->outputs.first; sock; sock = sock->next)
sock->flag &= ~SOCK_IN_USE;
for (link = ntree->links.first; link; link = link->next) {
link->fromsock->flag |= SOCK_IN_USE;
link->tosock->flag |= SOCK_IN_USE;
}
}
static void do_versions_nodetree_multi_file_output_format_2_62_1(Scene *sce, bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_OUTPUT_FILE) {
/* previous CMP_NODE_OUTPUT_FILE nodes get converted to multi-file outputs */
NodeImageFile *old_data = node->storage;
NodeImageMultiFile *nimf = MEM_callocN(sizeof(NodeImageMultiFile), "node image multi file");
bNodeSocket *old_image = BLI_findlink(&node->inputs, 0);
bNodeSocket *old_z = BLI_findlink(&node->inputs, 1);
bNodeSocket *sock;
char filename[FILE_MAXFILE];
/* ugly, need to remove the old inputs list to avoid bad pointer checks when adding new sockets.
* sock->storage is expected to contain path info in ntreeCompositOutputFileAddSocket.
*/
BLI_listbase_clear(&node->inputs);
node->storage = nimf;
/* looks like storage data can be messed up somehow, stupid check here */
if (old_data) {
char basepath[FILE_MAXDIR];
/* split off filename from the old path, to be used as socket sub-path */
BLI_split_dirfile(old_data->name, basepath, filename, sizeof(basepath), sizeof(filename));
BLI_strncpy(nimf->base_path, basepath, sizeof(nimf->base_path));
nimf->format = old_data->im_format;
}
else {
BLI_strncpy(filename, old_image->name, sizeof(filename));
}
/* if z buffer is saved, change the image type to multilayer exr.
* XXX this is slightly messy, Z buffer was ignored before for anything but EXR and IRIS ...
* i'm just assuming here that IRIZ means IRIS with z buffer ...
*/
if (old_data && ELEM(old_data->im_format.imtype, R_IMF_IMTYPE_IRIZ, R_IMF_IMTYPE_OPENEXR)) {
char sockpath[FILE_MAX];
nimf->format.imtype = R_IMF_IMTYPE_MULTILAYER;
BLI_snprintf(sockpath, sizeof(sockpath), "%s_Image", filename);
sock = ntreeCompositOutputFileAddSocket(ntree, node, sockpath, &nimf->format);
/* XXX later do_versions copies path from socket name, need to set this explicitely */
BLI_strncpy(sock->name, sockpath, sizeof(sock->name));
if (old_image->link) {
old_image->link->tosock = sock;
sock->link = old_image->link;
}
BLI_snprintf(sockpath, sizeof(sockpath), "%s_Z", filename);
sock = ntreeCompositOutputFileAddSocket(ntree, node, sockpath, &nimf->format);
/* XXX later do_versions copies path from socket name, need to set this explicitely */
BLI_strncpy(sock->name, sockpath, sizeof(sock->name));
if (old_z->link) {
old_z->link->tosock = sock;
sock->link = old_z->link;
}
}
else {
sock = ntreeCompositOutputFileAddSocket(ntree, node, filename, &nimf->format);
/* XXX later do_versions copies path from socket name, need to set this explicitely */
BLI_strncpy(sock->name, filename, sizeof(sock->name));
if (old_image->link) {
old_image->link->tosock = sock;
sock->link = old_image->link;
}
}
nodeRemoveSocket(ntree, node, old_image);
nodeRemoveSocket(ntree, node, old_z);
if (old_data)
MEM_freeN(old_data);
}
else if (node->type == CMP_NODE_OUTPUT_MULTI_FILE__DEPRECATED) {
NodeImageMultiFile *nimf = node->storage;
bNodeSocket *sock;
/* CMP_NODE_OUTPUT_MULTI_FILE has been redeclared as CMP_NODE_OUTPUT_FILE */
node->type = CMP_NODE_OUTPUT_FILE;
/* initialize the node-wide image format from render data, if available */
if (sce)
nimf->format = sce->r.im_format;
/* transfer render format toggle to node format toggle */
for (sock = node->inputs.first; sock; sock = sock->next) {
NodeImageMultiFileSocket *simf = sock->storage;
simf->use_node_format = simf->use_render_format;
}
/* we do have preview now */
node->flag |= NODE_PREVIEW;
}
}
}
/* blue and red are swapped pre 2.62.1, be sane (red == red) now! */
static void do_versions_mesh_mloopcol_swap_2_62_1(Mesh *me)
{
CustomDataLayer *layer;
MLoopCol *mloopcol;
int a;
int i;
for (a = 0; a < me->ldata.totlayer; a++) {
layer = &me->ldata.layers[a];
if (layer->type == CD_MLOOPCOL) {
mloopcol = (MLoopCol *)layer->data;
for (i = 0; i < me->totloop; i++, mloopcol++) {
SWAP(char, mloopcol->r, mloopcol->b);
}
}
}
}
static void do_versions_nodetree_multi_file_output_path_2_63_1(bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_OUTPUT_FILE) {
bNodeSocket *sock;
for (sock = node->inputs.first; sock; sock = sock->next) {
NodeImageMultiFileSocket *input = sock->storage;
/* input file path is stored in dedicated struct now instead socket name */
BLI_strncpy(input->path, sock->name, sizeof(input->path));
}
}
}
}
static void do_versions_nodetree_file_output_layers_2_64_5(bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_OUTPUT_FILE) {
bNodeSocket *sock;
for (sock = node->inputs.first; sock; sock = sock->next) {
NodeImageMultiFileSocket *input = sock->storage;
/* multilayer names are stored as separate strings now,
* used the path string before, so copy it over.
*/
BLI_strncpy(input->layer, input->path, sizeof(input->layer));
/* paths/layer names also have to be unique now, initial check */
ntreeCompositOutputFileUniquePath(&node->inputs, sock, input->path, '_');
ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, input->layer, '_');
}
}
}
}
static void do_versions_nodetree_image_layer_2_64_5(bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_IMAGE) {
bNodeSocket *sock;
for (sock = node->outputs.first; sock; sock = sock->next) {
NodeImageLayer *output = MEM_callocN(sizeof(NodeImageLayer), "node image layer");
/* take pass index both from current storage ptr (actually an int) */
output->pass_index = GET_INT_FROM_POINTER(sock->storage);
/* replace socket data pointer */
sock->storage = output;
}
}
}
}
static void do_versions_nodetree_frame_2_64_6(bNodeTree *ntree)
{
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == NODE_FRAME) {
/* initialize frame node storage data */
if (node->storage == NULL) {
NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
node->storage = data;
/* copy current flags */
data->flag = node->custom1;
data->label_size = 20;
}
}
/* initialize custom node color */
node->color[0] = node->color[1] = node->color[2] = 0.608f; /* default theme color */
}
}
static void do_version_logic_264(ListBase *regionbase)
{
ARegion *ar;
/* view settings for logic changed */
for (ar = regionbase->first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_WINDOW) {
if (ar->v2d.keeptot == 0) {
ar->v2d.maxzoom = 1.5f;
ar->v2d.keepzoom = V2D_KEEPZOOM | V2D_LIMITZOOM | V2D_KEEPASPECT;
ar->v2d.keeptot = V2D_KEEPTOT_BOUNDS;
ar->v2d.align = V2D_ALIGN_NO_POS_Y | V2D_ALIGN_NO_NEG_X;
ar->v2d.keepofs = V2D_KEEPOFS_Y;
}
}
}
}
static void do_versions_affine_tracker_track(MovieTrackingTrack *track)
{
int i;
for (i = 0; i < track->markersnr; i++) {
MovieTrackingMarker *marker = &track->markers[i];
if (is_zero_v2(marker->pattern_corners[0]) && is_zero_v2(marker->pattern_corners[1]) &&
is_zero_v2(marker->pattern_corners[2]) && is_zero_v2(marker->pattern_corners[3]))
{
marker->pattern_corners[0][0] = track->pat_min[0];
marker->pattern_corners[0][1] = track->pat_min[1];
marker->pattern_corners[1][0] = track->pat_max[0];
marker->pattern_corners[1][1] = track->pat_min[1];
marker->pattern_corners[2][0] = track->pat_max[0];
marker->pattern_corners[2][1] = track->pat_max[1];
marker->pattern_corners[3][0] = track->pat_min[0];
marker->pattern_corners[3][1] = track->pat_max[1];
}
if (is_zero_v2(marker->search_min) && is_zero_v2(marker->search_max)) {
copy_v2_v2(marker->search_min, track->search_min);
copy_v2_v2(marker->search_max, track->search_max);
}
}
}
static const char *node_get_static_idname(int type, int treetype)
{
/* use static type info header to map static int type to identifier string */
#define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
case ID: return #Category #StructName;
/* XXX hack, group types share a single static integer identifier, but are registered as separate types */
if (type == NODE_GROUP) {
switch (treetype) {
case NTREE_COMPOSIT: return "CompositorNodeGroup";
case NTREE_SHADER: return "ShaderNodeGroup";
case NTREE_TEXTURE: return "TextureNodeGroup";
}
}
else {
switch (type) {
#include "NOD_static_types.h"
}
}
return "";
}
static const char *node_socket_get_static_idname(bNodeSocket *sock)
{
switch (sock->type) {
case SOCK_FLOAT:
{
bNodeSocketValueFloat *dval = sock->default_value;
return nodeStaticSocketType(SOCK_FLOAT, dval->subtype);
}
case SOCK_INT:
{
bNodeSocketValueInt *dval = sock->default_value;
return nodeStaticSocketType(SOCK_INT, dval->subtype);
}
case SOCK_BOOLEAN:
{
return nodeStaticSocketType(SOCK_BOOLEAN, PROP_NONE);
}
case SOCK_VECTOR:
{
bNodeSocketValueVector *dval = sock->default_value;
return nodeStaticSocketType(SOCK_VECTOR, dval->subtype);
}
case SOCK_RGBA:
{
return nodeStaticSocketType(SOCK_RGBA, PROP_NONE);
}
case SOCK_STRING:
{
bNodeSocketValueString *dval = sock->default_value;
return nodeStaticSocketType(SOCK_STRING, dval->subtype);
}
case SOCK_SHADER:
{
return nodeStaticSocketType(SOCK_SHADER, PROP_NONE);
}
}
return "";
}
static void do_versions_nodetree_customnodes(bNodeTree *ntree, int UNUSED(is_group))
{
/* initialize node tree type idname */
{
bNode *node;
bNodeSocket *sock;
ntree->typeinfo = NULL;
/* tree type idname */
switch (ntree->type) {
case NTREE_COMPOSIT:
strcpy(ntree->idname, "CompositorNodeTree");
break;
case NTREE_SHADER:
strcpy(ntree->idname, "ShaderNodeTree");
break;
case NTREE_TEXTURE:
strcpy(ntree->idname, "TextureNodeTree");
break;
}
/* node type idname */
for (node = ntree->nodes.first; node; node = node->next) {
BLI_strncpy(node->idname, node_get_static_idname(node->type, ntree->type), sizeof(node->idname));
/* existing old nodes have been initialized already */
node->flag |= NODE_INIT;
/* sockets idname */
for (sock = node->inputs.first; sock; sock = sock->next)
BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
for (sock = node->outputs.first; sock; sock = sock->next)
BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
}
/* tree sockets idname */
for (sock = ntree->inputs.first; sock; sock = sock->next)
BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
for (sock = ntree->outputs.first; sock; sock = sock->next)
BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
}
/* initialize socket in_out values */
{
bNode *node;
bNodeSocket *sock;
for (node = ntree->nodes.first; node; node = node->next) {
for (sock = node->inputs.first; sock; sock = sock->next)
sock->in_out = SOCK_IN;
for (sock = node->outputs.first; sock; sock = sock->next)
sock->in_out = SOCK_OUT;
}
for (sock = ntree->inputs.first; sock; sock = sock->next)
sock->in_out = SOCK_IN;
for (sock = ntree->outputs.first; sock; sock = sock->next)
sock->in_out = SOCK_OUT;
}
/* initialize socket identifier strings */
{
bNode *node;
bNodeSocket *sock;
for (node = ntree->nodes.first; node; node = node->next) {
for (sock = node->inputs.first; sock; sock = sock->next) {
BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
BLI_uniquename(&node->inputs, sock, "socket", '.',
offsetof(bNodeSocket, identifier), sizeof(sock->identifier));
}
for (sock = node->outputs.first; sock; sock = sock->next) {
BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
BLI_uniquename(&node->outputs, sock, "socket", '.',
offsetof(bNodeSocket, identifier), sizeof(sock->identifier));
}
}
for (sock = ntree->inputs.first; sock; sock = sock->next) {
BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
BLI_uniquename(&ntree->inputs, sock, "socket", '.',
offsetof(bNodeSocket, identifier), sizeof(sock->identifier));
}
for (sock = ntree->outputs.first; sock; sock = sock->next) {
BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
BLI_uniquename(&ntree->outputs, sock, "socket", '.',
offsetof(bNodeSocket, identifier), sizeof(sock->identifier));
}
}
}
void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *main)
{
if (main->versionfile < 260) {
{
/* set default alpha value of Image outputs in image and render layer nodes to 0 */
Scene *sce;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next) {
/* there are files with invalid audio_channels value, the real cause
* is unknown, but we fix it here anyway to avoid crashes */
if (sce->r.ffcodecdata.audio_channels == 0)
sce->r.ffcodecdata.audio_channels = 2;
if (sce->nodetree)
do_versions_nodetree_image_default_alpha_output(sce->nodetree);
}
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
do_versions_nodetree_image_default_alpha_output(ntree);
}
{
/* support old particle dupliobject rotation settings */
ParticleSettings *part;
for (part = main->particle.first; part; part = part->id.next) {
if (ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
part->draw |= PART_DRAW_ROTATE_OB;
if (part->rotmode == 0)
part->rotmode = PART_ROT_VEL;
}
}
}
}
if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 1)) {
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
ob->collision_boundtype = ob->boundtype;
}
{
Camera *cam;
for (cam = main->camera.first; cam; cam = cam->id.next) {
if (cam->sensor_x < 0.01f)
cam->sensor_x = DEFAULT_SENSOR_WIDTH;
if (cam->sensor_y < 0.01f)
cam->sensor_y = DEFAULT_SENSOR_HEIGHT;
}
}
}
if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 2)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_SHADER) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == SH_NODE_MAPPING) {
TexMapping *tex_mapping;
tex_mapping = node->storage;
tex_mapping->projx = PROJ_X;
tex_mapping->projy = PROJ_Y;
tex_mapping->projz = PROJ_Z;
}
}
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 4)) {
{
/* Convert node angles to radians! */
Scene *sce;
Material *mat;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next) {
if (sce->nodetree)
do_versions_nodetree_convert_angle(sce->nodetree);
}
for (mat = main->mat.first; mat; mat = mat->id.next) {
if (mat->nodetree)
do_versions_nodetree_convert_angle(mat->nodetree);
}
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
do_versions_nodetree_convert_angle(ntree);
}
{
/* Tomato compatibility code. */
bScreen *sc;
MovieClip *clip;
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) {
if (sl->spacetype == SPACE_VIEW3D) {
View3D *v3d = (View3D *)sl;
if (v3d->bundle_size == 0.0f) {
v3d->bundle_size = 0.2f;
v3d->flag2 |= V3D_SHOW_RECONSTRUCTION;
}
if (v3d->bundle_drawtype == 0)
v3d->bundle_drawtype = OB_PLAINAXES;
}
else if (sl->spacetype == SPACE_CLIP) {
SpaceClip *sclip = (SpaceClip *)sl;
if (sclip->scopes.track_preview_height == 0)
sclip->scopes.track_preview_height = 120;
}
}
}
}
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTrackingTrack *track;
if (clip->aspx < 1.0f) {
clip->aspx = 1.0f;
clip->aspy = 1.0f;
}
clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN |
IMB_TC_FREE_RUN |
IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN;
if (clip->proxy.build_size_flag == 0)
clip->proxy.build_size_flag = IMB_PROXY_25;
if (clip->proxy.quality == 0)
clip->proxy.quality = 90;
if (clip->tracking.camera.pixel_aspect < 0.01f)
clip->tracking.camera.pixel_aspect = 1.0f;
track = clip->tracking.tracks.first;
while (track) {
if (track->minimum_correlation == 0.0f)
track->minimum_correlation = 0.75f;
track = track->next;
}
}
}
}
if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 6)) {
Scene *sce;
MovieClip *clip;
bScreen *sc;
for (sce = main->scene.first; sce; sce = sce->id.next) {
do_versions_image_settings_2_60(sce);
}
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTrackingSettings *settings = &clip->tracking.settings;
if (settings->default_pattern_size == 0.0f) {
settings->default_motion_model = TRACK_MOTION_MODEL_TRANSLATION;
settings->default_minimum_correlation = 0.75;
settings->default_pattern_size = 11;
settings->default_search_size = 51;
}
}
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) {
if (sl->spacetype == SPACE_VIEW3D) {
View3D *v3d = (View3D *)sl;
v3d->flag2 &= ~V3D_RENDER_SHADOW;
}
}
}
}
{
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
/* convert delta addition into delta scale */
int i;
for (i = 0; i < 3; i++) {
if ( (ob->dsize[i] == 0.0f) || /* simple case, user never touched dsize */
(ob->size[i] == 0.0f)) /* cant scale the dsize to give a non zero result,
so fallback to 1.0f */
{
ob->dscale[i] = 1.0f;
}
else {
ob->dscale[i] = (ob->size[i] + ob->dsize[i]) / ob->size[i];
}
}
}
}
}
/* sigh, this dscale vs dsize version patching was not done right, fix for fix,
* this intentionally checks an exact subversion, also note this was never in a release,
* at some point this could be removed. */
else if (main->versionfile == 260 && main->subversionfile == 6) {
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
if (is_zero_v3(ob->dscale)) {
fill_vn_fl(ob->dscale, 3, 1.0f);
}
}
}
if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 8)) {
Brush *brush;
for (brush = main->brush.first; brush; brush = brush->id.next) {
if (brush->sculpt_tool == SCULPT_TOOL_ROTATE)
brush->alpha = 1.0f;
}
}
if (main->versionfile < 261 || (main->versionfile == 261 && main->subversionfile < 1)) {
{
/* update use flags for node sockets (was only temporary before) */
Scene *sce;
Material *mat;
Tex *tex;
Lamp *lamp;
World *world;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next) {
if (sce->nodetree)
do_versions_nodetree_socket_use_flags_2_62(sce->nodetree);
}
for (mat = main->mat.first; mat; mat = mat->id.next) {
if (mat->nodetree)
do_versions_nodetree_socket_use_flags_2_62(mat->nodetree);
}
for (tex = main->tex.first; tex; tex = tex->id.next) {
if (tex->nodetree)
do_versions_nodetree_socket_use_flags_2_62(tex->nodetree);
}
for (lamp = main->lamp.first; lamp; lamp = lamp->id.next) {
if (lamp->nodetree)
do_versions_nodetree_socket_use_flags_2_62(lamp->nodetree);
}
for (world = main->world.first; world; world = world->id.next) {
if (world->nodetree)
do_versions_nodetree_socket_use_flags_2_62(world->nodetree);
}
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) {
do_versions_nodetree_socket_use_flags_2_62(ntree);
}
}
{
/* Initialize BGE exit key to esc key */
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
if (!scene->gm.exitkey)
scene->gm.exitkey = 218; // Blender key code for ESC
}
}
{
MovieClip *clip;
Object *ob;
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = tracking->objects.first;
clip->proxy.build_tc_flag |= IMB_TC_RECORD_RUN_NO_GAPS;
if (!tracking->settings.object_distance)
tracking->settings.object_distance = 1.0f;
if (BLI_listbase_is_empty(&tracking->objects))
BKE_tracking_object_add(tracking, "Camera");
while (tracking_object) {
if (!tracking_object->scale)
tracking_object->scale = 1.0f;
tracking_object = tracking_object->next;
}
}
for (ob = main->object.first; ob; ob = ob->id.next) {
bConstraint *con;
for (con = ob->constraints.first; con; con = con->next) {
if (con->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
bObjectSolverConstraint *data = (bObjectSolverConstraint *)con->data;
if (data->invmat[3][3] == 0.0f)
unit_m4(data->invmat);
}
}
}
}
{
/* Warn the user if he is using ["Text"] properties for Font objects */
Object *ob;
bProperty *prop;
for (ob = main->object.first; ob; ob = ob->id.next) {
if (ob->type == OB_FONT) {
prop = BKE_bproperty_object_get(ob, "Text");
if (prop) {
blo_reportf_wrap(fd->reports, RPT_WARNING,
TIP_("Game property name conflict in object '%s': text objects reserve the "
"['Text'] game property to change their content through logic bricks"),
ob->id.name + 2);
}
}
}
}
}
if (main->versionfile < 261 || (main->versionfile == 261 && main->subversionfile < 2)) {
{
/* convert Camera Actuator values to defines */
Object *ob;
bActuator *act;
for (ob = main->object.first; ob; ob = ob->id.next) {
for (act = ob->actuators.first; act; act = act->next) {
if (act->type == ACT_CAMERA) {
bCameraActuator *ba = act->data;
if (ba->axis == (float) 'x') ba->axis = OB_POSX;
else if (ba->axis == (float)'y') ba->axis = OB_POSY;
/* don't do an if/else to avoid imediate subversion bump*/
// ba->axis=((ba->axis == (float)'x') ? OB_POSX_X : OB_POSY);
}
}
}
}
{
/* convert deprecated sculpt_paint_unified_* fields to
* UnifiedPaintSettings */
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
ToolSettings *ts = scene->toolsettings;
UnifiedPaintSettings *ups = &ts->unified_paint_settings;
ups->size = ts->sculpt_paint_unified_size;
ups->unprojected_radius = ts->sculpt_paint_unified_unprojected_radius;
ups->alpha = ts->sculpt_paint_unified_alpha;
ups->flag = ts->sculpt_paint_settings;
}
}
}
if (main->versionfile < 261 || (main->versionfile == 261 && main->subversionfile < 3)) {
{
/* convert extended ascii to utf-8 for text editor */
Text *text;
for (text = main->text.first; text; text = text->id.next)
if (!(text->flags & TXT_ISEXT)) {
TextLine *tl;
for (tl = text->lines.first; tl; tl = tl->next) {
int added = txt_extended_ascii_as_utf8(&tl->line);
tl->len += added;
/* reset cursor position if line was changed */
if (added && tl == text->curl)
text->curc = 0;
}
}
}
{
/* set new dynamic paint values */
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_DynamicPaint) {
DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
if (pmd->canvas) {
DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
for (; surface; surface = surface->next) {
surface->color_dry_threshold = 1.0f;
surface->influence_scale = 1.0f;
surface->radius_scale = 1.0f;
surface->flags |= MOD_DPAINT_USE_DRYING;
}
}
}
}
}
}
}
if (main->versionfile < 262) {
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_Cloth) {
ClothModifierData *clmd = (ClothModifierData *) md;
if (clmd->sim_parms)
clmd->sim_parms->vel_damping = 1.0f;
}
}
}
}
if (main->versionfile < 263) {
/* set fluidsim rate. the version patch for this in 2.62 was wrong, so
* try to correct it, if rate is 0.0 that's likely not intentional */
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_Fluidsim) {
FluidsimModifierData *fmd = (FluidsimModifierData *)md;
if (fmd->fss->animRate == 0.0f)
fmd->fss->animRate = 1.0f;
}
}
}
}
if (main->versionfile < 262 || (main->versionfile == 262 && main->subversionfile < 1)) {
/* update use flags for node sockets (was only temporary before) */
Scene *sce;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next) {
if (sce->nodetree)
do_versions_nodetree_multi_file_output_format_2_62_1(sce, sce->nodetree);
}
/* XXX can't associate with scene for group nodes, image format will stay uninitialized */
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
do_versions_nodetree_multi_file_output_format_2_62_1(NULL, ntree);
}
/* only swap for pre-release bmesh merge which had MLoopCol red/blue swap */
if (main->versionfile == 262 && main->subversionfile == 1) {
{
Mesh *me;
for (me = main->mesh.first; me; me = me->id.next) {
do_versions_mesh_mloopcol_swap_2_62_1(me);
}
}
}
if (main->versionfile < 262 || (main->versionfile == 262 && main->subversionfile < 2)) {
/* Set new idname of keyingsets from their now "label-only" name. */
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
KeyingSet *ks;
for (ks = scene->keyingsets.first; ks; ks = ks->next) {
if (!ks->idname[0])
BLI_strncpy(ks->idname, ks->name, sizeof(ks->idname));
}
}
}
if (main->versionfile < 262 || (main->versionfile == 262 && main->subversionfile < 3)) {
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_Lattice) {
LatticeModifierData *lmd = (LatticeModifierData *)md;
lmd->strength = 1.0f;
}
}
}
}
if (main->versionfile < 262 || (main->versionfile == 262 && main->subversionfile < 4)) {
/* Read Viscosity presets from older files */
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_Fluidsim) {
FluidsimModifierData *fmd = (FluidsimModifierData *)md;
if (fmd->fss->viscosityMode == 3) {
fmd->fss->viscosityValue = 5.0;
fmd->fss->viscosityExponent = 5;
}
else if (fmd->fss->viscosityMode == 4) {
fmd->fss->viscosityValue = 2.0;
fmd->fss->viscosityExponent = 3;
}
}
}
}
}
if (main->versionfile < 263) {
/* Default for old files is to save particle rotations to pointcache */
ParticleSettings *part;
for (part = main->particle.first; part; part = part->id.next) {
part->flag |= PART_ROTATIONS;
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 1)) {
/* file output node paths are now stored in the file info struct instead socket name */
Scene *sce;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next)
if (sce->nodetree)
do_versions_nodetree_multi_file_output_path_2_63_1(sce->nodetree);
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
do_versions_nodetree_multi_file_output_path_2_63_1(ntree);
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 3)) {
Scene *scene;
Brush *brush;
/* For weight paint, each brush now gets its own weight;
* unified paint settings also have weight. Update unified
* paint settings and brushes with a default weight value. */
for (scene = main->scene.first; scene; scene = scene->id.next) {
ToolSettings *ts = scene->toolsettings;
if (ts) {
ts->unified_paint_settings.weight = ts->vgroup_weight;
ts->unified_paint_settings.flag |= UNIFIED_PAINT_WEIGHT;
}
}
for (brush = main->brush.first; brush; brush = brush->id.next) {
brush->weight = 0.5;
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 2)) {
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) {
if (sl->spacetype == SPACE_CLIP) {
SpaceClip *sclip = (SpaceClip *)sl;
ARegion *ar;
int hide = FALSE;
for (ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_PREVIEW) {
if (ar->alignment != RGN_ALIGN_NONE) {
ar->flag |= RGN_FLAG_HIDDEN;
ar->v2d.flag &= ~V2D_IS_INITIALISED;
ar->alignment = RGN_ALIGN_NONE;
hide = TRUE;
}
}
}
if (hide) {
sclip->view = SC_VIEW_CLIP;
}
}
}
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 4)) {
Lamp *la;
Camera *cam;
Curve *cu;
for (la = main->lamp.first; la; la = la->id.next) {
if (la->shadow_frustum_size == 0.0f)
la->shadow_frustum_size = 10.0f;
}
for (cam = main->camera.first; cam; cam = cam->id.next) {
if (cam->flag & CAM_PANORAMA) {
cam->type = CAM_PANO;
cam->flag &= ~CAM_PANORAMA;
}
}
for (cu = main->curve.first; cu; cu = cu->id.next) {
if (cu->bevfac2 == 0.0f) {
cu->bevfac1 = 0.0f;
cu->bevfac2 = 1.0f;
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 5)) {
{
/* file output node paths are now stored in the file info struct instead socket name */
Scene *sce;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next) {
if (sce->nodetree) {
do_versions_nodetree_file_output_layers_2_64_5(sce->nodetree);
do_versions_nodetree_image_layer_2_64_5(sce->nodetree);
}
}
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) {
do_versions_nodetree_file_output_layers_2_64_5(ntree);
do_versions_nodetree_image_layer_2_64_5(ntree);
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 6)) {
/* update use flags for node sockets (was only temporary before) */
Scene *sce;
Material *mat;
Tex *tex;
Lamp *lamp;
World *world;
bNodeTree *ntree;
for (sce = main->scene.first; sce; sce = sce->id.next)
if (sce->nodetree)
do_versions_nodetree_frame_2_64_6(sce->nodetree);
for (mat = main->mat.first; mat; mat = mat->id.next)
if (mat->nodetree)
do_versions_nodetree_frame_2_64_6(mat->nodetree);
for (tex = main->tex.first; tex; tex = tex->id.next)
if (tex->nodetree)
do_versions_nodetree_frame_2_64_6(tex->nodetree);
for (lamp = main->lamp.first; lamp; lamp = lamp->id.next)
if (lamp->nodetree)
do_versions_nodetree_frame_2_64_6(lamp->nodetree);
for (world = main->world.first; world; world = world->id.next)
if (world->nodetree)
do_versions_nodetree_frame_2_64_6(world->nodetree);
for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
do_versions_nodetree_frame_2_64_6(ntree);
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 7)) {
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_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
int maxres = max_iii(smd->domain->res[0], smd->domain->res[1], smd->domain->res[2]);
smd->domain->scale = smd->domain->dx * maxres;
smd->domain->dx = 1.0f / smd->domain->scale;
}
}
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 8)) {
/* set new deactivation values for game settings */
Scene *sce;
for (sce = main->scene.first; sce; sce = sce->id.next) {
/* Game Settings */
sce->gm.lineardeactthreshold = 0.8f;
sce->gm.angulardeactthreshold = 1.0f;
sce->gm.deactivationtime = 2.0f;
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 9)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_SHADER) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (ELEM(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_ENVIRONMENT)) {
NodeTexImage *tex = node->storage;
tex->iuser.frames = 1;
tex->iuser.sfra = 1;
tex->iuser.fie_ima = 2;
tex->iuser.ok = 1;
}
}
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 10)) {
{
Scene *scene;
// composite redesign
for (scene = main->scene.first; scene; scene = scene->id.next) {
if (scene->nodetree) {
if (scene->nodetree->chunksize == 0) {
scene->nodetree->chunksize = 256;
}
}
}
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_DEFOCUS) {
NodeDefocus *data = node->storage;
if (data->maxblur == 0.0f) {
data->maxblur = 16.0f;
}
}
}
}
} FOREACH_NODETREE_END
}
{
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) {
if (sl->spacetype == SPACE_CLIP) {
SpaceClip *sclip = (SpaceClip *)sl;
if (sclip->around == 0) {
sclip->around = V3D_CENTROID;
}
}
}
}
}
}
{
MovieClip *clip;
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
clip->start_frame = 1;
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 11)) {
MovieClip *clip;
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTrackingTrack *track;
track = clip->tracking.tracks.first;
while (track) {
do_versions_affine_tracker_track(track);
track = track->next;
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 12)) {
Material *ma;
for (ma = main->mat.first; ma; ma = ma->id.next)
if (ma->strand_widthfade == 2.0f)
ma->strand_widthfade = 0.0f;
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 13)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_DILATEERODE) {
if (node->storage == NULL) {
NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), __func__);
data->falloff = PROP_SMOOTH;
node->storage = data;
}
}
}
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 14)) {
ParticleSettings *part;
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_KEYING) {
NodeKeyingData *data = node->storage;
if (data->despill_balance == 0.0f) {
data->despill_balance = 0.5f;
}
}
}
}
} FOREACH_NODETREE_END
/* keep compatibility for dupliobject particle size */
for (part = main->particle.first; part; part = part->id.next)
if (ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR))
if ((part->draw & PART_DRAW_ROTATE_OB) == 0)
part->draw |= PART_DRAW_NO_SCALE_OB;
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 17)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_MASK) {
if (node->storage == NULL) {
NodeMask *data = MEM_callocN(sizeof(NodeMask), __func__);
/* move settings into own struct */
data->size_x = (int)node->custom3;
data->size_y = (int)node->custom4;
node->custom3 = 0.5f; /* default shutter */
node->storage = data;
}
}
}
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 18)) {
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
if (scene->ed) {
Sequence *seq;
SEQ_BEGIN (scene->ed, seq)
{
Strip *strip = seq->strip;
if (strip && strip->color_balance) {
SequenceModifierData *smd;
ColorBalanceModifierData *cbmd;
smd = BKE_sequence_modifier_new(seq, NULL, seqModifierType_ColorBalance);
cbmd = (ColorBalanceModifierData *) smd;
cbmd->color_balance = *strip->color_balance;
/* multiplication with color balance used is handled differently,
* so we need to move multiplication to modifier so files would be
* compatible
*/
cbmd->color_multiply = seq->mul;
seq->mul = 1.0f;
MEM_freeN(strip->color_balance);
strip->color_balance = NULL;
}
}
SEQ_END
}
}
}
/* color management pipeline changes compatibility code */
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 19)) {
Scene *scene;
Image *ima;
int colormanagement_disabled = FALSE;
/* make scenes which are not using color management have got None as display device,
* so they wouldn't perform linear-to-sRGB conversion on display
*/
for (scene = main->scene.first; scene; scene = scene->id.next) {
if ((scene->r.color_mgt_flag & R_COLOR_MANAGEMENT) == 0) {
ColorManagedDisplaySettings *display_settings = &scene->display_settings;
if (display_settings->display_device[0] == 0) {
BKE_scene_disable_color_management(scene);
}
colormanagement_disabled = TRUE;
}
}
for (ima = main->image.first; ima; ima = ima->id.next) {
if (ima->source == IMA_SRC_VIEWER) {
ima->flag |= IMA_VIEW_AS_RENDER;
}
else if (colormanagement_disabled) {
/* if colormanagement not used, set image's color space to raw, so no sRGB->linear conversion
* would happen on display and render
* there's no clear way to check whether color management is enabled or not in render engine
* so set all images to raw if there's at least one scene with color management disabled
* this would still behave incorrect in cases when color management was used for only some
* of scenes, but such a setup is crazy anyway and think it's fair enough to break compatibility
* in that cases
*/
BLI_strncpy(ima->colorspace_settings.name, "Raw", sizeof(ima->colorspace_settings.name));
}
}
}
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 20)) {
Key *key;
for (key = main->key.first; key; key = key->id.next) {
blo_do_versions_key_uidgen(key);
}
}
/* remove texco */
if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 21)) {
Material *ma;
for (ma = main->mat.first; ma; ma = ma->id.next) {
int a;
for (a = 0; a < MAX_MTEX; a++) {
if (ma->mtex[a]) {
if (ma->mtex[a]->texco == TEXCO_STICKY_) {
ma->mtex[a]->texco = TEXCO_UV;
}
}
}
}
{
Mesh *me;
for (me = main->mesh.first; me; me = me->id.next) {
CustomData_update_typemap(&me->vdata);
CustomData_free_layers(&me->vdata, CD_MSTICKY, me->totvert);
}
}
}
/* correction for files saved in blender version when BKE_pose_copy_data
* didn't copy animation visualization, which lead to deadlocks on motion
* path calculation for proxied armatures, see [#32742]
*/
if (main->versionfile < 264) {
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
if (ob->pose) {
if (ob->pose->avs.path_step == 0) {
animviz_settings_init(&ob->pose->avs);
}
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 1)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_SHADER) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next)
if (node->type == SH_NODE_TEX_COORD)
node->flag |= NODE_OPTIONS;
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 2)) {
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;
tracking_object = tracking_object->next)
{
if (tracking_object->keyframe1 == 0 && tracking_object->keyframe2 == 0) {
tracking_object->keyframe1 = tracking->settings.keyframe1;
tracking_object->keyframe2 = tracking->settings.keyframe2;
}
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 3)) {
/* smoke branch */
{
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_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
/* keep branch saves if possible */
if (!smd->domain->flame_max_temp) {
smd->domain->burning_rate = 0.75f;
smd->domain->flame_smoke = 1.0f;
smd->domain->flame_vorticity = 0.5f;
smd->domain->flame_ignition = 1.25f;
smd->domain->flame_max_temp = 1.75f;
smd->domain->adapt_threshold = 0.02f;
smd->domain->adapt_margin = 4;
smd->domain->flame_smoke_color[0] = 0.7f;
smd->domain->flame_smoke_color[1] = 0.7f;
smd->domain->flame_smoke_color[2] = 0.7f;
}
}
else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
if (!smd->flow->texture_size) {
smd->flow->fuel_amount = 1.0;
smd->flow->surface_distance = 1.5;
smd->flow->color[0] = 0.7f;
smd->flow->color[1] = 0.7f;
smd->flow->color[2] = 0.7f;
smd->flow->texture_size = 1.0f;
}
}
}
}
}
}
/* render border for viewport */
{
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) {
if (sl->spacetype == SPACE_VIEW3D) {
View3D *v3d = (View3D *)sl;
if (v3d->render_border.xmin == 0.0f && v3d->render_border.ymin == 0.0f &&
v3d->render_border.xmax == 0.0f && v3d->render_border.ymax == 0.0f)
{
v3d->render_border.xmax = 1.0f;
v3d->render_border.ymax = 1.0f;
}
}
}
}
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 5)) {
/* set a unwrapping margin and ABF by default */
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
if (scene->toolsettings->uvcalc_margin == 0.0f) {
scene->toolsettings->uvcalc_margin = 0.001f;
scene->toolsettings->unwrapper = 0;
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 6)) {
/* Fix for bug #32982, internal_links list could get corrupted from r51630 onward.
* Simply remove bad internal_links lists to avoid NULL pointers.
*/
FOREACH_NODETREE(main, ntree, id) {
bNode *node;
bNodeLink *link, *nextlink;
for (node = ntree->nodes.first; node; node = node->next) {
for (link = node->internal_links.first; link; link = nextlink) {
nextlink = link->next;
if (!link->fromnode || !link->fromsock || !link->tonode || !link->tosock) {
BLI_remlink(&node->internal_links, link);
}
}
}
} FOREACH_NODETREE_END
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 6)) {
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;
if ( sa->spacetype == SPACE_LOGIC)
do_version_logic_264(&sa->regionbase);
for (sl = sa->spacedata.first; sl; sl = sl->next) {
if (sl->spacetype == SPACE_LOGIC)
do_version_logic_264(&sl->regionbase);
}
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 7)) {
/* convert tiles size from resolution and number of tiles */
{
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
if (scene->r.tilex == 0 || scene->r.tiley == 1) {
if (scene->r.xparts && scene->r.yparts) {
/* scene could be set for panoramic rendering, so clamp with the
* lowest possible tile size value
*/
scene->r.tilex = max_ii(scene->r.xsch * scene->r.size / scene->r.xparts / 100, 8);
scene->r.tiley = max_ii(scene->r.ysch * scene->r.size / scene->r.yparts / 100, 8);
}
else {
/* happens when mixing using current trunk and previous release */
scene->r.tilex = scene->r.tiley = 64;
}
}
}
}
/* collision masks */
{
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
if (ob->col_group == 0) {
ob->col_group = 0x01;
ob->col_mask = 0xff;
}
}
}
}
if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 7)) {
MovieClip *clip;
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTrackingTrack *track;
MovieTrackingObject *object;
for (track = clip->tracking.tracks.first; track; track = track->next) {
do_versions_affine_tracker_track(track);
}
for (object = clip->tracking.objects.first; object; object = object->next) {
for (track = object->tracks.first; track; track = track->next) {
do_versions_affine_tracker_track(track);
}
}
}
}
if (main->versionfile < 265) {
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
if (ob->step_height == 0.0f) {
ob->step_height = 0.15f;
ob->jump_speed = 10.0f;
ob->fall_speed = 55.0f;
}
}
}
if (main->versionfile < 265 || (main->versionfile == 265 && main->subversionfile < 3)) {
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) {
switch (sl->spacetype) {
case SPACE_VIEW3D:
{
View3D *v3d = (View3D *)sl;
v3d->flag2 |= V3D_SHOW_GPENCIL;
break;
}
case SPACE_SEQ:
{
SpaceSeq *sseq = (SpaceSeq *)sl;
sseq->flag |= SEQ_SHOW_GPENCIL;
break;
}
case SPACE_IMAGE:
{
SpaceImage *sima = (SpaceImage *)sl;
sima->flag |= SI_SHOW_GPENCIL;
break;
}
case SPACE_NODE:
{
SpaceNode *snode = (SpaceNode *)sl;
snode->flag |= SNODE_SHOW_GPENCIL;
break;
}
case SPACE_CLIP:
{
SpaceClip *sclip = (SpaceClip *)sl;
sclip->flag |= SC_SHOW_GPENCIL;
break;
}
}
}
}
}
}
if (main->versionfile < 265 || (main->versionfile == 265 && main->subversionfile < 5)) {
Scene *scene;
Image *image;
Tex *tex;
for (scene = main->scene.first; scene; scene = scene->id.next) {
Sequence *seq;
bool set_premul = false;
SEQ_BEGIN (scene->ed, seq)
{
if (seq->flag & SEQ_MAKE_PREMUL) {
seq->alpha_mode = SEQ_ALPHA_STRAIGHT;
}
else {
BKE_sequence_alpha_mode_from_extension(seq);
}
}
SEQ_END
if (scene->r.bake_samples == 0)
scene->r.bake_samples = 256;
if (scene->world) {
World *world = blo_do_versions_newlibadr(fd, scene->id.lib, scene->world);
if (world && is_zero_v3(&world->horr)) {
if ((world->skytype & WO_SKYBLEND) == 0 || is_zero_v3(&world->zenr)) {
set_premul = true;
}
}
}
else
set_premul = true;
if (set_premul) {
printf("2.66 versioning fix: replacing black sky with premultiplied alpha for scene %s\n",
scene->id.name + 2);
scene->r.alphamode = R_ALPHAPREMUL;
}
}
for (image = main->image.first; image; image = image->id.next) {
if (image->flag & IMA_DO_PREMUL) {
image->alpha_mode = IMA_ALPHA_STRAIGHT;
}
else {
BKE_image_alpha_mode_from_extension(image);
}
}
for (tex = main->tex.first; tex; tex = tex->id.next) {
if (tex->type == TEX_IMAGE && (tex->imaflag & TEX_USEALPHA) == 0) {
image = blo_do_versions_newlibadr(fd, tex->id.lib, tex->ima);
if (image && (image->flag & IMA_DO_PREMUL) == 0)
image->flag |= IMA_IGNORE_ALPHA;
}
}
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_IMAGE) {
Image *image = blo_do_versions_newlibadr(fd, ntree->id.lib, node->id);
if (image) {
if ((image->flag & IMA_DO_PREMUL) == 0 && image->alpha_mode == IMA_ALPHA_STRAIGHT)
node->custom1 |= CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT;
}
}
}
}
} FOREACH_NODETREE_END
}
else if (main->versionfile < 266 || (main->versionfile == 266 && main->subversionfile < 1)) {
/* texture use alpha was removed for 2.66 but added back again for 2.66a,
* for compatibility all textures assumed it to be enabled */
Tex *tex;
for (tex = main->tex.first; tex; tex = tex->id.next)
if (tex->type == TEX_IMAGE)
tex->imaflag |= TEX_USEALPHA;
}
if (main->versionfile < 265 || (main->versionfile == 265 && main->subversionfile < 7)) {
Curve *cu;
for (cu = main->curve.first; cu; cu = cu->id.next) {
if (cu->flag & (CU_FRONT | CU_BACK)) {
if ( cu->ext1 != 0.0f || cu->ext2 != 0.0f) {
Nurb *nu;
for (nu = cu->nurb.first; nu; nu = nu->next) {
int a;
if (nu->bezt) {
BezTriple *bezt = nu->bezt;
a = nu->pntsu;
while (a--) {
bezt->radius = 1.0f;
bezt++;
}
}
else if (nu->bp) {
BPoint *bp = nu->bp;
a = nu->pntsu * nu->pntsv;
while (a--) {
bp->radius = 1.0f;
bp++;
}
}
}
}
}
}
}
if (MAIN_VERSION_OLDER(main, 265, 9)) {
Mesh *me;
for (me = main->mesh.first; me; me = me->id.next) {
BKE_mesh_do_versions_cd_flag_init(me);
}
}
if (MAIN_VERSION_OLDER(main, 265, 10)) {
Brush *br;
for (br = main->brush.first; br; br = br->id.next) {
if (br->ob_mode & OB_MODE_TEXTURE_PAINT) {
br->mtex.brush_map_mode = MTEX_MAP_MODE_TILED;
}
}
}
// add storage for compositor translate nodes when not existing
if (MAIN_VERSION_OLDER(main, 265, 11)) {
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_TRANSLATE && node->storage == NULL) {
node->storage = MEM_callocN(sizeof(NodeTranslateData), "node translate data");
}
}
}
} FOREACH_NODETREE_END
}
if (MAIN_VERSION_OLDER(main, 266, 2)) {
FOREACH_NODETREE(main, ntree, id) {
do_versions_nodetree_customnodes(ntree, ((ID *)ntree == id));
} FOREACH_NODETREE_END
}
if (MAIN_VERSION_OLDER(main, 266, 2)) {
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) {
if (sl->spacetype == SPACE_NODE) {
SpaceNode *snode = (SpaceNode *)sl;
/* reset pointers to force tree path update from context */
snode->nodetree = NULL;
snode->edittree = NULL;
snode->id = NULL;
snode->from = NULL;
/* convert deprecated treetype setting to tree_idname */
switch (snode->treetype) {
case NTREE_COMPOSIT:
strcpy(snode->tree_idname, "CompositorNodeTree");
break;
case NTREE_SHADER:
strcpy(snode->tree_idname, "ShaderNodeTree");
break;
case NTREE_TEXTURE:
strcpy(snode->tree_idname, "TextureNodeTree");
break;
}
}
}
}
}
}
/* Set flag for delayed do_versions in lib_verify_nodetree. It needs valid typeinfo pointers ... */
{
FOREACH_NODETREE(main, ntree, id) {
/* XXX This should be kept without version check for now!
* As long as USE_NODE_COMPAT_CUSTOMNODES is active, files will write links
* to tree interface sockets for forward compatibility. These links need to be removed again
* on file load in new versions.
* Once forward compatibility is not required any longer, make a subversion bump
* and only execute this for older versions.
*/
ntree->flag |= NTREE_DO_VERSIONS_CUSTOMNODES_GROUP;
/* Only add interface nodes once.
* In old Blender versions they will be removed automatically due to undefined type */
if (MAIN_VERSION_OLDER(main, 266, 2))
ntree->flag |= NTREE_DO_VERSIONS_CUSTOMNODES_GROUP_CREATE_INTERFACE;
}
FOREACH_NODETREE_END
}
if (MAIN_VERSION_OLDER(main, 266, 3)) {
{
/* Fix for a very old issue:
* Node names were nominally made unique in r24478 (2.50.8), but the do_versions check
* to update existing node names only applied to main->nodetree (i.e. group nodes).
* Uniqueness is now required for proper preview mapping,
* so do this now to ensure old files don't break.
*/
bNode *node;
FOREACH_NODETREE(main, ntree, id) {
if (id == &ntree->id)
continue; /* already fixed for node groups */
for (node = ntree->nodes.first; node; node = node->next)
nodeUniqueName(ntree, node);
}
FOREACH_NODETREE_END
}
}
if (!MAIN_VERSION_ATLEAST(main, 266, 4)) {
Brush *brush;
for (brush = main->brush.first; brush; brush = brush->id.next) {
default_mtex(&brush->mask_mtex);
if (brush->ob_mode & OB_MODE_TEXTURE_PAINT) {
brush->spacing /= 2;
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 266, 6)) {
Brush *brush;
#define BRUSH_TEXTURE_OVERLAY (1 << 21)
for (brush = main->brush.first; brush; brush = brush->id.next) {
brush->overlay_flags = 0;
if (brush->flag & BRUSH_TEXTURE_OVERLAY)
brush->overlay_flags |= (BRUSH_OVERLAY_PRIMARY | BRUSH_OVERLAY_CURSOR);
}
#undef BRUSH_TEXTURE_OVERLAY
}
if (main->versionfile < 267) {
//if (!DNA_struct_elem_find(fd->filesdna, "Brush", "int", "stencil_pos")) {
Brush *brush;
for (brush = main->brush.first; brush; brush = brush->id.next) {
if (brush->stencil_dimension[0] == 0) {
brush->stencil_dimension[0] = 256;
brush->stencil_dimension[1] = 256;
brush->stencil_pos[0] = 256;
brush->stencil_pos[1] = 256;
}
if (brush->mask_stencil_dimension[0] == 0) {
brush->mask_stencil_dimension[0] = 256;
brush->mask_stencil_dimension[1] = 256;
brush->mask_stencil_pos[0] = 256;
brush->mask_stencil_pos[1] = 256;
}
}
/* TIP: to initialize new variables added, use the new function
* DNA_struct_elem_find(fd->filesdna, "structname", "typename", "varname")
* example:
* if (!DNA_struct_elem_find(fd->filesdna, "UserDef", "short", "image_gpubuffer_limit"))
* user->image_gpubuffer_limit = 10;
*/
}
/* default values in Freestyle settings */
if (main->versionfile < 267) {
Scene *sce;
SceneRenderLayer *srl;
FreestyleLineStyle *linestyle;
for (sce = main->scene.first; sce; sce = sce->id.next) {
if (sce->r.line_thickness_mode == 0) {
sce->r.line_thickness_mode = R_LINE_THICKNESS_ABSOLUTE;
sce->r.unit_line_thickness = 1.0f;
}
for (srl = sce->r.layers.first; srl; srl = srl->next) {
if (srl->freestyleConfig.mode == 0)
srl->freestyleConfig.mode = FREESTYLE_CONTROL_EDITOR_MODE;
if (srl->freestyleConfig.raycasting_algorithm == FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE ||
srl->freestyleConfig.raycasting_algorithm == FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL)
{
srl->freestyleConfig.raycasting_algorithm = 0; /* deprecated */
srl->freestyleConfig.flags |= FREESTYLE_CULLING;
}
}
/* not freestyle */
{
MeshStatVis *statvis = &sce->toolsettings->statvis;
if (statvis->thickness_samples == 0) {
statvis->overhang_axis = OB_NEGZ;
statvis->overhang_min = 0;
statvis->overhang_max = DEG2RADF(45.0f);
statvis->thickness_max = 0.1f;
statvis->thickness_samples = 1;
statvis->distort_min = DEG2RADF(5.0f);
statvis->distort_max = DEG2RADF(45.0f);
statvis->sharp_min = DEG2RADF(90.0f);
statvis->sharp_max = DEG2RADF(180.0f);
}
}
}
for (linestyle = main->linestyle.first; linestyle; linestyle = linestyle->id.next) {
#if 1
/* disable the Misc panel for now */
if (linestyle->panel == LS_PANEL_MISC) {
linestyle->panel = LS_PANEL_STROKES;
}
#endif
if (linestyle->thickness_position == 0) {
linestyle->thickness_position = LS_THICKNESS_CENTER;
linestyle->thickness_ratio = 0.5f;
}
if (linestyle->chaining == 0)
linestyle->chaining = LS_CHAINING_PLAIN;
if (linestyle->rounds == 0)
linestyle->rounds = 3;
}
}
if (main->versionfile < 267) {
/* Initialize the active_viewer_key for compositing */
bScreen *screen;
Scene *scene;
bNodeInstanceKey active_viewer_key = {0};
/* simply pick the first node space and use that for the active viewer key */
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_NODE) {
SpaceNode *snode = (SpaceNode *)sl;
bNodeTreePath *path = snode->treepath.last;
if (!path)
continue;
active_viewer_key = path->parent_key;
break;
}
}
if (active_viewer_key.value != 0)
break;
}
if (active_viewer_key.value != 0)
break;
}
for (scene = main->scene.first; scene; scene = scene->id.next) {
/* NB: scene->nodetree is a local ID block, has been direct_link'ed */
if (scene->nodetree)
scene->nodetree->active_viewer_key = active_viewer_key;
}
}
if (MAIN_VERSION_OLDER(main, 267, 1)) {
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_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
if (smd->domain->flags & MOD_SMOKE_HIGH_SMOOTH) {
smd->domain->highres_sampling = SM_HRES_LINEAR;
}
else {
smd->domain->highres_sampling = SM_HRES_NEAREST;
}
}
}
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 268, 1)) {
Brush *brush;
for (brush = main->brush.first; brush; brush = brush->id.next) {
brush->spacing = MAX2(1, brush->spacing);
}
}
if (!MAIN_VERSION_ATLEAST(main, 268, 2)) {
Brush *brush;
#define BRUSH_FIXED (1 << 6)
for (brush = main->brush.first; brush; brush = brush->id.next) {
brush->flag &= ~BRUSH_FIXED;
if (brush->cursor_overlay_alpha < 2)
brush->cursor_overlay_alpha = 33;
if (brush->texture_overlay_alpha < 2)
brush->texture_overlay_alpha = 33;
if (brush->mask_overlay_alpha < 2)
brush->mask_overlay_alpha = 33;
}
#undef BRUSH_FIXED
}
if (!MAIN_VERSION_ATLEAST(main, 268, 4)) {
bScreen *sc;
Object *ob;
for (ob = main->object.first; ob; ob = ob->id.next) {
bConstraint *con;
for (con = ob->constraints.first; con; con = con->next) {
if (con->type == CONSTRAINT_TYPE_SHRINKWRAP) {
bShrinkwrapConstraint *data = (bShrinkwrapConstraint *)con->data;
if (data->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS) data->projAxis = OB_POSX;
else if (data->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS) data->projAxis = OB_POSY;
else data->projAxis = OB_POSZ;
data->projAxisSpace = CONSTRAINT_SPACE_LOCAL;
}
}
}
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_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
if (!smd->flow->particle_size) {
smd->flow->particle_size = 1.0f;
}
}
}
}
}
/*
* FIX some files have a zoom level of 0, and was checked during the drawing of the node space
*
* We moved this check to the do versions to be sure the value makes any sense.
*/
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) {
if (sl->spacetype == SPACE_NODE) {
SpaceNode *snode = (SpaceNode *)sl;
if (snode->zoom < 0.02f) {
snode->zoom = 1.0;
}
}
}
}
}
for (ob = main->object.first; ob; ob = ob->id.next) {
bSensor *sens;
bTouchSensor *ts;
bCollisionSensor *cs;
Material *ma;
for (sens = ob->sensors.first; sens; sens = sens->next) {
if (sens->type == SENS_TOUCH) {
ts = sens->data;
cs = MEM_callocN(sizeof(bCollisionSensor), "touch -> collision sensor do_version");
if (ts->ma) {
ma = blo_do_versions_newlibadr(fd, ob->id.lib, ts->ma);
BLI_strncpy(cs->materialName, ma->id.name + 2, sizeof(cs->materialName));
}
cs->mode = SENS_COLLISION_MATERIAL;
MEM_freeN(ts);
sens->data = cs;
sens->type = sens->otype = SENS_COLLISION;
}
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 268, 5)) {
bScreen *sc;
ScrArea *sa;
/* add missing (+) expander in node editor */
for (sc = main->screen.first; sc; sc = sc->id.next) {
for (sa = sc->areabase.first; sa; sa = sa->next) {
ARegion *ar, *arnew;
if (sa->spacetype == SPACE_NODE) {
ar = BKE_area_find_region_type(sa, RGN_TYPE_TOOLS);
if (ar)
continue;
/* add subdiv level; after header */
ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
/* is error! */
if (ar == NULL)
continue;
arnew = MEM_callocN(sizeof(ARegion), "node tools");
BLI_insertlinkafter(&sa->regionbase, ar, arnew);
arnew->regiontype = RGN_TYPE_TOOLS;
arnew->alignment = RGN_ALIGN_LEFT;
arnew->flag = RGN_FLAG_HIDDEN;
}
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 1)) {
/* Removal of Cycles SSS Compatible falloff */
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_SHADER) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == SH_NODE_SUBSURFACE_SCATTERING) {
if (node->custom1 == SHD_SUBSURFACE_COMPATIBLE) {
node->custom1 = SHD_SUBSURFACE_CUBIC;
}
}
}
}
} FOREACH_NODETREE_END
}
if (!MAIN_VERSION_ATLEAST(main, 269, 2)) {
/* Initialize CDL settings for Color Balance nodes */
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_COLORBALANCE) {
NodeColorBalance *n = node->storage;
if (node->custom1 == 0) {
/* LGG mode stays the same, just init CDL settings */
ntreeCompositColorBalanceSyncFromLGG(ntree, node);
}
else if (node->custom1 == 1) {
/* CDL previously used same variables as LGG, copy them over
* and then sync LGG for comparable results in both modes.
*/
copy_v3_v3(n->offset, n->lift);
copy_v3_v3(n->power, n->gamma);
copy_v3_v3(n->slope, n->gain);
ntreeCompositColorBalanceSyncFromCDL(ntree, node);
}
}
}
}
} FOREACH_NODETREE_END
}
if (!MAIN_VERSION_ATLEAST(main, 269, 3)) {
bScreen *sc;
ScrArea *sa;
SpaceLink *sl;
Scene *scene;
/* Update files using invalid (outdated) outlinevis Outliner values. */
for (sc = main->screen.first; sc; sc = sc->id.next) {
for (sa = sc->areabase.first; sa; sa = sa->next) {
for (sl = sa->spacedata.first; sl; sl = sl->next) {
if (sl->spacetype == SPACE_OUTLINER) {
SpaceOops *so = (SpaceOops *)sl;
if (!ELEM11(so->outlinevis, SO_ALL_SCENES, SO_CUR_SCENE, SO_VISIBLE, SO_SELECTED, SO_ACTIVE,
SO_SAME_TYPE, SO_GROUPS, SO_LIBRARIES, SO_SEQUENCE, SO_DATABLOCKS,
SO_USERDEF))
{
so->outlinevis = SO_ALL_SCENES;
}
}
}
}
}
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight")) {
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;
tracking_object = tracking_object->next)
{
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
MovieTrackingTrack *track;
for (track = tracksbase->first;
track;
track = track->next)
{
track->weight = 1.0f;
}
}
}
}
if (!DNA_struct_elem_find(fd->filesdna, "TriangulateModifierData", "int", "quad_method")) {
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_Triangulate) {
TriangulateModifierData *tmd = (TriangulateModifierData *)md;
if ((tmd->flag & MOD_TRIANGULATE_BEAUTY)) {
tmd->quad_method = MOD_TRIANGULATE_QUAD_BEAUTY;
tmd->ngon_method = MOD_TRIANGULATE_NGON_BEAUTY;
}
else {
tmd->quad_method = MOD_TRIANGULATE_QUAD_FIXED;
tmd->ngon_method = MOD_TRIANGULATE_NGON_EARCLIP;
}
}
}
}
}
for (scene = main->scene.first; scene; scene = scene->id.next) {
/* this can now be turned off */
ToolSettings *ts = scene->toolsettings;
if (ts->sculpt)
ts->sculpt->flags |= SCULPT_DYNTOPO_SUBDIVIDE;
/* single texture mode removed from game engine */
if (scene->gm.matmode == GAME_MAT_TEXFACE)
scene->gm.matmode = GAME_MAT_MULTITEX;
/* 'Increment' mode disabled for nodes, use true grid snapping instead */
if (scene->toolsettings->snap_node_mode == SCE_SNAP_MODE_INCREMENT)
scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_GRID;
#ifdef WITH_FFMPEG
/* Update for removed "sound-only" option in FFMPEG export settings. */
if (scene->r.ffcodecdata.type >= FFMPEG_INVALID) {
scene->r.ffcodecdata.type = FFMPEG_AVI;
}
#endif
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 4)) {
/* Internal degrees to radians conversions... */
{
Scene *scene;
Object *ob;
Lamp *lamp;
for (lamp = main->lamp.first; lamp; lamp = lamp->id.next)
lamp->spotsize = DEG2RADF(lamp->spotsize);
for (ob = main->object.first; ob; ob = ob->id.next) {
ModifierData *md;
bSensor *bs;
bActuator *ba;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_EdgeSplit) {
EdgeSplitModifierData *emd = (EdgeSplitModifierData *)md;
emd->split_angle = DEG2RADF(emd->split_angle);
}
else if (md->type == eModifierType_Bevel) {
BevelModifierData *bmd = (BevelModifierData *)md;
bmd->bevel_angle = DEG2RADF(bmd->bevel_angle);
}
}
for (bs = ob->sensors.first; bs; bs = bs->next) {
if (bs->type == SENS_RADAR) {
bRadarSensor *brs = bs->data;
brs->angle = DEG2RADF(brs->angle);
}
}
for (ba = ob->actuators.first; ba; ba = ba->next) {
if (ba->type == ACT_CONSTRAINT) {
bConstraintActuator *bca = ba->data;
if (bca->type == ACT_CONST_TYPE_ORI) {
bca->minloc[0] = DEG2RADF(bca->minloc[0]);
bca->maxloc[0] = DEG2RADF(bca->maxloc[0]);
}
}
else if (ba->type == ACT_SOUND) {
bSoundActuator *bsa = ba->data;
bsa->sound3D.cone_outer_angle = DEG2RADF(bsa->sound3D.cone_outer_angle);
bsa->sound3D.cone_inner_angle = DEG2RADF(bsa->sound3D.cone_inner_angle);
}
}
}
for (scene = main->scene.first; scene; scene = scene->id.next) {
Sequence *seq;
SEQ_BEGIN (scene->ed, seq)
{
if (seq->type == SEQ_TYPE_WIPE) {
WipeVars *wv = seq->effectdata;
wv->angle = DEG2RADF(wv->angle);
}
}
SEQ_END
}
FOREACH_NODETREE(main, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
bNode *node;
for (node = ntree->nodes.first; node; node = node->next) {
if (node->type == CMP_NODE_BOKEHIMAGE) {
NodeBokehImage *n = node->storage;
n->angle = DEG2RADF(n->angle);
}
if (node->type == CMP_NODE_MASK_BOX) {
NodeBoxMask *n = node->storage;
n->rotation = DEG2RADF(n->rotation);
}
if (node->type == CMP_NODE_MASK_ELLIPSE) {
NodeEllipseMask *n = node->storage;
n->rotation = DEG2RADF(n->rotation);
}
}
}
} FOREACH_NODETREE_END
}
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingPlaneTrack", "float", "image_opacity")) {
MovieClip *clip;
for (clip = main->movieclip.first; clip; clip = clip->id.next) {
MovieTrackingPlaneTrack *plane_track;
for (plane_track = clip->tracking.plane_tracks.first;
plane_track;
plane_track = plane_track->next)
{
plane_track->image_opacity = 1.0f;
}
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 7)) {
Scene *scene;
for (scene = main->scene.first; scene; scene = scene->id.next) {
Sculpt *sd = scene->toolsettings->sculpt;
if (sd) {
int symmetry_flags = sd->flags & 7;
if (symmetry_flags & SCULPT_SYMM_X)
sd->paint.symmetry_flags |= PAINT_SYMM_X;
if (symmetry_flags & SCULPT_SYMM_Y)
sd->paint.symmetry_flags |= PAINT_SYMM_Y;
if (symmetry_flags & SCULPT_SYMM_Z)
sd->paint.symmetry_flags |= PAINT_SYMM_Z;
if (symmetry_flags & SCULPT_SYMMETRY_FEATHER)
sd->paint.symmetry_flags |= PAINT_SYMMETRY_FEATHER;
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 8)) {
Curve *cu;
for (cu = main->curve.first; cu; cu = cu->id.next) {
if (cu->str) {
cu->len_wchar = BLI_strlen_utf8(cu->str);
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 9)) {
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_Build) {
BuildModifierData *bmd = (BuildModifierData *)md;
if (bmd->randomize) {
bmd->flag |= MOD_BUILD_FLAG_RANDOMIZE;
}
}
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 269, 11)) {
bScreen *sc;
for (sc = main->screen.first; sc; sc = sc->id.next) {
ScrArea *sa;
for (sa = sc->areabase.first; sa; sa = sa->next) {
SpaceLink *space_link;
for (space_link = sa->spacedata.first; space_link; space_link = space_link->next) {
if (space_link->spacetype == SPACE_IMAGE) {
ARegion *ar;
ListBase *lb;
if (space_link == sa->spacedata.first) {
lb = &sa->regionbase;
}
else {
lb = &space_link->regionbase;
}
for (ar = lb->first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_PREVIEW) {
ar->regiontype = RGN_TYPE_TOOLS;
ar->alignment = RGN_ALIGN_LEFT;
}
else if (ar->regiontype == RGN_TYPE_UI) {
ar->alignment = RGN_ALIGN_RIGHT;
}
}
}
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink