svn merge ^/trunk/blender -r49573:49601
authorCampbell Barton <ideasman42@gmail.com>
Mon, 6 Aug 2012 09:33:43 +0000 (09:33 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 6 Aug 2012 09:33:43 +0000 (09:33 +0000)
43 files changed:
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/intern/mask.c
source/blender/blenkernel/intern/node.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenlib/BLI_stack.h [new file with mode: 0644]
source/blender/blenlib/CMakeLists.txt
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenlib/intern/stack.c [new file with mode: 0644]
source/blender/collada/AnimationExporter.cpp
source/blender/collada/AnimationExporter.h
source/blender/collada/AnimationImporter.cpp
source/blender/collada/AnimationImporter.h
source/blender/editors/animation/anim_draw.c
source/blender/editors/include/BIF_gl.h
source/blender/editors/include/BIF_glutil.h
source/blender/editors/interface/view2d.c
source/blender/editors/mask/mask_add.c
source/blender/editors/screen/area.c
source/blender/editors/screen/glutil.c
source/blender/editors/sculpt_paint/paint_utils.c
source/blender/editors/sound/sound_ops.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/node_draw.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_node/node_relationships.c
source/blender/editors/space_node/node_view.c
source/blender/editors/space_text/text_draw.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c
source/blender/modifiers/intern/MOD_skin.c
source/blender/python/intern/bpy_interface.c
source/blender/render/extern/include/RE_render_ext.h
source/blender/render/intern/include/texture.h
source/blender/render/intern/raytrace/bvh.h
source/blender/render/intern/raytrace/rayobject_instance.cpp
source/blender/render/intern/source/imagetexture.c
source/blender/windowmanager/intern/wm_draw.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_subwindow.c
source/gameengine/Ketsji/BL_Action.cpp
source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp

index 0b9aa7e4f644c218e00644bceb98182531555cc0..61845619452840871d1c874a57f6abe985699b3f 100644 (file)
@@ -359,6 +359,7 @@ void            nodeInternalRelink(struct bNodeTree *ntree, struct bNode *node);
 
 void            nodeToView(struct bNode *node, float x, float y, float *rx, float *ry);
 void            nodeFromView(struct bNode *node, float x, float y, float *rx, float *ry);
+int             nodeAttachNodeCheck(struct bNode *node, struct bNode *parent);
 void            nodeAttachNode(struct bNode *node, struct bNode *parent);
 void            nodeDetachNode(struct bNode *node);
 
@@ -385,11 +386,13 @@ int             nodeSocketIsHidden(struct bNodeSocket *sock);
 void            nodeSocketSetType(struct bNodeSocket *sock, int type);
 
 /* Node Clipboard */
-void nodeClipboardClear(void);
-void nodeClipboardAddNode(struct bNode *node);
-void nodeClipboardAddLink(struct bNodeLink *link);
-const struct ListBase *nodeClipboardGetNodes(void);
-const struct ListBase *nodeClipboardGetLinks(void);
+void                   BKE_node_clipboard_init(struct bNodeTree *ntree);
+void                   BKE_node_clipboard_clear(void);
+void                   BKE_node_clipboard_add_node(struct bNode *node);
+void                   BKE_node_clipboard_add_link(struct bNodeLink *link);
+const struct ListBase *BKE_node_clipboard_get_nodes(void);
+const struct ListBase *BKE_node_clipboard_get_links(void);
+int                    BKE_node_clipboard_get_type(void);
 
 /* ************** NODE TYPE ACCESS *************** */
 
index 8bb3a0fd30671cf671ed0c190c6ac0938c78e3f9..01aa9fa9fa9fe05344c17775202cae28d84d1fb2 100644 (file)
@@ -1287,12 +1287,13 @@ MaskSplinePointUW *BKE_mask_point_sort_uw(MaskSplinePoint *point, MaskSplinePoin
 void BKE_mask_point_add_uw(MaskSplinePoint *point, float u, float w)
 {
        if (!point->uw)
-               point->uw = MEM_callocN(sizeof(*point->uw), "mask point uw");
+               point->uw = MEM_mallocN(sizeof(*point->uw), "mask point uw");
        else
                point->uw = MEM_reallocN(point->uw, (point->tot_uw + 1) * sizeof(*point->uw));
 
        point->uw[point->tot_uw].u = u;
        point->uw[point->tot_uw].w = w;
+       point->uw[point->tot_uw].flag = 0;
 
        point->tot_uw++;
 
index afe0b9ec81f0f75c6297f5a80dfc60625456a3dd..8f3c76c33571b4893ed23f7d0f64069764af090a 100644 (file)
@@ -592,9 +592,25 @@ void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
        }
 }
 
+int nodeAttachNodeCheck(bNode *node, bNode *parent)
+{
+       bNode *parent_recurse;
+       for (parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
+               if (parent_recurse == parent) {
+                       return TRUE;
+               }
+       }
+
+       return FALSE;
+}
+
 void nodeAttachNode(bNode *node, bNode *parent)
 {
        float locx, locy;
+
+       BLI_assert(parent->type == NODE_FRAME);
+       BLI_assert(nodeAttachNodeCheck(parent, node) == FALSE);
+
        nodeToView(node, 0.0f, 0.0f, &locx, &locy);
        
        node->parent = parent;
@@ -607,6 +623,9 @@ void nodeDetachNode(struct bNode *node)
        float locx, locy;
        
        if (node->parent) {
+
+               BLI_assert(node->parent->type == NODE_FRAME);
+
                /* transform to view space */
                nodeToView(node, 0.0f, 0.0f, &locx, &locy);
                node->locx = locx;
@@ -1409,11 +1428,17 @@ void nodeSocketSetType(bNodeSocket *sock, int type)
 typedef struct bNodeClipboard {
        ListBase nodes;
        ListBase links;
+       int type;
 } bNodeClipboard;
 
 bNodeClipboard node_clipboard;
 
-void nodeClipboardClear(void)
+void BKE_node_clipboard_init(struct bNodeTree *ntree)
+{
+       node_clipboard.type = ntree->type;
+}
+
+void BKE_node_clipboard_clear(void)
 {
        bNode *node, *node_next;
        bNodeLink *link, *link_next;
@@ -1431,26 +1456,31 @@ void nodeClipboardClear(void)
        node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
 }
 
-void nodeClipboardAddNode(bNode *node)
+void BKE_node_clipboard_add_node(bNode *node)
 {
        BLI_addtail(&node_clipboard.nodes, node);
 }
 
-void nodeClipboardAddLink(bNodeLink *link)
+void BKE_node_clipboard_add_link(bNodeLink *link)
 {
        BLI_addtail(&node_clipboard.links, link);
 }
 
-const ListBase *nodeClipboardGetNodes(void)
+const ListBase *BKE_node_clipboard_get_nodes(void)
 {
        return &node_clipboard.nodes;
 }
 
-const ListBase *nodeClipboardGetLinks(void)
+const ListBase *BKE_node_clipboard_get_links(void)
 {
        return &node_clipboard.links;
 }
 
+int BKE_node_clipboard_get_type(void)
+{
+       return node_clipboard.type;
+}
+
 /* ************** dependency stuff *********** */
 
 /* node is guaranteed to be not checked before */
index 3b077dd22ef7e21c97937b26b5cd091b3d6784c8..674e848937f1eaf6dd4699edce93f777b290d297 100644 (file)
@@ -3918,7 +3918,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 
        AUD_SoundInfo info;
 
-       sound = sound_new_file(CTX_data_main(C), seq_load->path); /* handles relative paths */
+       sound = sound_new_file(bmain, seq_load->path); /* handles relative paths */
 
        if (sound == NULL || sound->playback_handle == NULL) {
                //if (op)
diff --git a/source/blender/blenlib/BLI_stack.h b/source/blender/blenlib/BLI_stack.h
new file mode 100644 (file)
index 0000000..9151e6a
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ * ***** 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): Nicholas Bishop
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+#ifndef __BLI_STACK_H__
+#define __BLI_STACK_H__
+
+/** \file BLI_stack.h
+ *  \ingroup bli
+ */
+
+typedef struct BLI_Stack BLI_Stack;
+
+/* Create a new homogeneous stack with elements of 'elem_size' bytes */
+BLI_Stack *BLI_stack_new(int elem_size, const char *description);
+
+/* Free the stack's data and the stack itself */
+void BLI_stack_free(BLI_Stack *stack);
+
+/* Copies the source value onto the stack (note that it copies
+ * elem_size bytes from 'src', the pointer itself is not stored) */
+void BLI_stack_push(BLI_Stack *stack, void *src);
+
+/* Retrieves and removes the top element from the stack. The value is
+ * copies to 'dst', which must be at least elem_size bytes.
+ *
+ * Does not reduce amount of allocated memory.
+ *
+ * If stack is empty, 'dst' will not be modified. */
+void BLI_stack_pop(BLI_Stack *stack, void *dst);
+
+/* Returns TRUE if the stack is empty, FALSE otherwise */
+int BLI_stack_empty(const BLI_Stack *stack);
+
+#endif
index ac7681e3be702f7ec22b2b3f16b8c2d9a7b91a73..0175076fab8068ce99f379e8e709781c062249bb 100644 (file)
@@ -81,6 +81,7 @@ set(SRC
        intern/rct.c
        intern/scanfill.c
        intern/smallhash.c
+       intern/stack.c
        intern/storage.c
        intern/string.c
        intern/string_cursor_utf8.c
@@ -135,6 +136,7 @@ set(SRC
        BLI_rect.h
        BLI_scanfill.h
        BLI_smallhash.h
+       BLI_stack.h
        BLI_string.h
        BLI_string_cursor_utf8.h
        BLI_string_utf8.h
index f3b047130f2ba5df292dcd7bdb28696a89c9dfda..5d3a658b206089d2b11ea24be62c3fc2033d5456 100644 (file)
@@ -430,7 +430,7 @@ int isect_seg_seg_v2(const float v1[2], const float v2[2], const float v3[2], co
 {
 #define CCW(A, B, C) ((C[1] - A[1]) * (B[0] - A[0]) > (B[1]-A[1]) * (C[0]-A[0]))
 
-   return CCW(v1, v3, v4) != CCW(v2, v3, v4) && CCW(v1, v2, v3) != CCW(v1, v2, v4);
+       return CCW(v1, v3, v4) != CCW(v2, v3, v4) && CCW(v1, v2, v3) != CCW(v1, v2, v4);
 
 #undef CCW
 }
index a2da9f5f79143a9ca921763ba03b529ffa4a4143..69f837c7652212b1e96f31fdc7c3e753ab8d28f7 100644 (file)
@@ -1660,12 +1660,12 @@ void quat_apply_track(float quat[4], short axis, short upflag)
 {
        /* rotations are hard coded to match vec_to_quat */
        const float quat_track[][4] = {
-               {0.70710676908493, 0.0, -0.70710676908493, 0.0}, /* pos-y90 */
+               {M_SQRT1_2, 0.0, -M_SQRT1_2, 0.0}, /* pos-y90 */
                {0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
-               {0.70710676908493, 0.0, 0.0, 0.70710676908493}, /* pos-z90 */
-               {0.70710676908493, 0.0, 0.70710676908493, 0.0}, /* neg-y90 */
+               {M_SQRT1_2, 0.0, 0.0, M_SQRT1_2}, /* pos-z90 */
+               {M_SQRT1_2, 0.0, M_SQRT1_2, 0.0}, /* neg-y90 */
                {0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
-               {-3.0908619663705394e-08, 0.70710676908493, 0.70710676908493, 3.0908619663705394e-08} /* no rotation */
+               {-3.0908619663705394e-08, M_SQRT1_2, M_SQRT1_2, 3.0908619663705394e-08} /* no rotation */
        };
 
        assert(axis >= 0 && axis <= 5);
@@ -1680,8 +1680,8 @@ void quat_apply_track(float quat[4], short axis, short upflag)
         * up axis is used X->Y, Y->X, Z->X, if this first up axis isn used then rotate 90d
         * the strange bit shift below just find the low axis {X:Y, Y:X, Z:X} */
        if (upflag != (2 - axis) >> 1) {
-               float q[4] = {0.70710676908493, 0.0, 0.0, 0.0}; /* assign 90d rotation axis */
-               q[axis + 1] = ((axis == 1)) ? 0.70710676908493 : -0.70710676908493; /* flip non Y axis */
+               float q[4] = {M_SQRT1_2, 0.0, 0.0, 0.0}; /* assign 90d rotation axis */
+               q[axis + 1] = ((axis == 1)) ? M_SQRT1_2 : -M_SQRT1_2; /* flip non Y axis */
                mul_qt_qtqt(quat, quat, q);
        }
 }
diff --git a/source/blender/blenlib/intern/stack.c b/source/blender/blenlib/intern/stack.c
new file mode 100644 (file)
index 0000000..1d5bdbf
--- /dev/null
@@ -0,0 +1,110 @@
+/*
+ * ***** 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): Nicholas Bishop
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+/** \file blender/blenlib/intern/stack.c
+ *  \ingroup bli
+ */
+
+#include <string.h>
+#include <stdlib.h>  /* abort() */
+
+#include "BLI_stack.h"  /* own include */
+
+#include "BLI_utildefines.h"
+#include "MEM_guardedalloc.h"
+
+typedef struct BLI_Stack {
+       void *data;
+
+       int totelem;
+       int maxelem;
+
+       int elem_size;
+} BLI_Stack;
+
+BLI_Stack *BLI_stack_new(int elem_size, const char *description)
+{
+       BLI_Stack *stack = MEM_callocN(sizeof(*stack), description);
+
+       stack->elem_size = elem_size;
+
+       return stack;
+}
+
+void BLI_stack_free(BLI_Stack *stack)
+{
+       if (stack) {
+               if (stack->data)
+                       MEM_freeN(stack->data);
+               MEM_freeN(stack);
+       }
+}
+
+/* Gets the last element in the stack */
+#define STACK_LAST_ELEM(stack__) \
+       (((char *)(stack__)->data) + \
+        ((stack__)->elem_size * ((stack__)->totelem - 1)))
+
+void BLI_stack_push(BLI_Stack *stack, void *src)
+{
+       /* Ensure stack is large enough */
+       if (stack->totelem == stack->maxelem) {
+               if (stack->maxelem == 0) {
+                       /* Initialize stack with space for a small hardcoded
+                        * number of elements */
+                       stack->maxelem = 32;
+                       stack->data = MEM_mallocN((stack->elem_size *
+                                                  stack->maxelem), AT);
+               }
+               else {
+                       /* Double stack size */
+                       int maxelem = stack->maxelem + stack->maxelem;
+                       /* Check for overflow */
+                       BLI_assert(maxelem > stack->maxelem);
+                       stack->data = MEM_reallocN(stack->data,
+                                                  (stack->elem_size *
+                                                   maxelem));
+                       stack->maxelem = maxelem;
+               }
+       }
+
+       BLI_assert(stack->totelem < stack->maxelem);
+
+       /* Copy source to end of stack */
+       stack->totelem++;
+       memcpy(STACK_LAST_ELEM(stack), src, stack->elem_size);
+}
+
+void BLI_stack_pop(BLI_Stack *stack, void *dst)
+{
+       BLI_assert(stack->totelem > 0);
+       if (stack->totelem > 0) {
+               memcpy(dst, STACK_LAST_ELEM(stack), stack->elem_size);
+               stack->totelem--;
+       }
+}
+
+int BLI_stack_empty(const BLI_Stack *stack)
+{
+       return stack->totelem == 0;
+}
index 57829f777c583885f83030d6b250f318c06363f8..0e8ead61437d667323e3f2dc95559378245cb068 100644 (file)
@@ -106,7 +106,8 @@ void AnimationExporter::operator()(Object *ob)
 
                        if ((!strcmp(transformName, "lens")) ||
                            (!strcmp(transformName, "ortho_scale")) ||
-                           (!strcmp(transformName, "clip_end")) || (!strcmp(transformName, "clip_start")))
+                           (!strcmp(transformName, "clip_end")) || 
+                               (!strcmp(transformName, "clip_start")))
                        {
                                dae_animation(ob, fcu, transformName, true);
                        }
@@ -203,8 +204,10 @@ void AnimationExporter::dae_animation(Object *ob, FCurve *fcu, char *transformNa
        }
 
        //axis names for colors
-       else if (!strcmp(transformName, "color") || !strcmp(transformName, "specular_color") || !strcmp(transformName, "diffuse_color") ||
-                (!strcmp(transformName, "alpha")))
+       else if (!strcmp(transformName, "color") ||
+                        !strcmp(transformName, "specular_color") ||
+                        !strcmp(transformName, "diffuse_color") ||
+                !strcmp(transformName, "alpha"))
        {
                const char *axis_names[] = {"R", "G", "B"};
                if (fcu->array_index < 3)
@@ -212,8 +215,10 @@ void AnimationExporter::dae_animation(Object *ob, FCurve *fcu, char *transformNa
        }
 
        //axis names for transforms
-       else if ((!strcmp(transformName, "location") || !strcmp(transformName, "scale")) ||
-                (!strcmp(transformName, "rotation_euler")) || (!strcmp(transformName, "rotation_quaternion")))
+       else if (!strcmp(transformName, "location") ||
+                        !strcmp(transformName, "scale") ||
+                !strcmp(transformName, "rotation_euler") ||
+                        !strcmp(transformName, "rotation_quaternion"))
        {
                const char *axis_names[] = {"X", "Y", "Z"};
                if (fcu->array_index < 3)
@@ -260,9 +265,13 @@ void AnimationExporter::dae_animation(Object *ob, FCurve *fcu, char *transformNa
                MEM_freeN(eul);
                MEM_freeN(eul_axis);
        }
+       else if(!strcmp(transformName, "lens") && (ob->type == OB_CAMERA)) {
+               output_id = create_lens_source_from_fcurve((Camera *) ob->data, COLLADASW::InputSemantic::OUTPUT, fcu, anim_id);
+       }
        else {
                output_id = create_source_from_fcurve(COLLADASW::InputSemantic::OUTPUT, fcu, anim_id, axis_name);
        }
+
        // create interpolations source
        std::string interpolation_id = create_interpolation_source(fcu, anim_id, axis_name, &has_tangents);
 
@@ -553,7 +562,7 @@ void AnimationExporter::add_source_parameters(COLLADASW::SourceBase::ParameterNa
        }
 }
 
-void AnimationExporter::get_source_values(BezTriple *bezt, COLLADASW::InputSemantic::Semantics semantic, bool rotation, float *values, int *length)
+void AnimationExporter::get_source_values(BezTriple *bezt, COLLADASW::InputSemantic::Semantics semantic, bool is_rotation, float *values, int *length)
 {
        switch (semantic) {
                case COLLADASW::InputSemantic::INPUT:
@@ -562,7 +571,7 @@ void AnimationExporter::get_source_values(BezTriple *bezt, COLLADASW::InputSeman
                        break;
                case COLLADASW::InputSemantic::OUTPUT:
                        *length = 1;
-                       if (rotation) {
+                       if (is_rotation) {
                                values[0] = RAD2DEGF(bezt->vec[1][1]);
                        }
                        else {
@@ -578,7 +587,7 @@ void AnimationExporter::get_source_values(BezTriple *bezt, COLLADASW::InputSeman
                                values[0] = 0;  
                                values[1] = 0;  
                        }
-                       else if (rotation) {
+                       else if (is_rotation) {
                                values[1] = RAD2DEGF(bezt->vec[0][1]);
                        }
                        else {
@@ -594,7 +603,7 @@ void AnimationExporter::get_source_values(BezTriple *bezt, COLLADASW::InputSeman
                                values[0] = 0;  
                                values[1] = 0;  
                        }
-                       else if (rotation) {
+                       else if (is_rotation) {
                                values[1] = RAD2DEGF(bezt->vec[2][1]);
                        }
                        else {
@@ -654,6 +663,44 @@ std::string AnimationExporter::create_source_from_fcurve(COLLADASW::InputSemanti
        return source_id;
 }
 
+/*
+ * Similar to create_source_from_fcurve, but adds conversion of lens
+ * animation data from focal length to FOV.
+ */
+std::string AnimationExporter::create_lens_source_from_fcurve(Camera *cam, COLLADASW::InputSemantic::Semantics semantic, FCurve *fcu, const std::string& anim_id)
+{
+       std::string source_id = anim_id + get_semantic_suffix(semantic);
+
+       COLLADASW::FloatSourceF source(mSW);
+       source.setId(source_id);
+       source.setArrayId(source_id + ARRAY_ID_SUFFIX);
+       source.setAccessorCount(fcu->totvert);
+
+       source.setAccessorStride(1);
+
+       COLLADASW::SourceBase::ParameterNameList &param = source.getParameterNameList();
+       add_source_parameters(param, semantic, false, "", false);
+
+       source.prepareToAppendValues();
+
+       for (unsigned int i = 0; i < fcu->totvert; i++) {
+               float values[3]; // be careful!
+               int length = 0;
+               get_source_values(&fcu->bezt[i], semantic, false, values, &length);
+               for (int j = 0; j < length; j++)
+               {
+                       float val = RAD2DEGF(focallength_to_fov(values[j], cam->sensor_x));
+                       source.appendValues(val);
+               }
+       }
+
+       source.finish();
+
+       return source_id;
+}
+
+
+
 //Currently called only to get OUTPUT source values ( if rotation and hence the axis is also specified )
 std::string AnimationExporter::create_source_from_array(COLLADASW::InputSemantic::Semantics semantic, float *v, int tot, bool is_rot, const std::string& anim_id, const char *axis_name)
 {
index 1313687db28e393c82f85f466f3ac740747bdd8c..0a7832e9d64a209bc2d548452f99ed33a0c432eb 100644 (file)
@@ -133,6 +133,8 @@ protected:
 
        std::string create_source_from_fcurve(COLLADASW::InputSemantic::Semantics semantic, FCurve *fcu, const std::string& anim_id, const char *axis_name);
 
+       std::string create_lens_source_from_fcurve(Camera *cam, COLLADASW::InputSemantic::Semantics semantic, FCurve *fcu, const std::string& anim_id);
+
        std::string create_source_from_array(COLLADASW::InputSemantic::Semantics semantic, float *v, int tot, bool is_rot, const std::string& anim_id, const char *axis_name);
 
        std::string create_source_from_vector(COLLADASW::InputSemantic::Semantics semantic, std::vector<float> &fra, bool is_rot, const std::string& anim_id, const char *axis_name);
index af6d70ecca0858be51f369bd1a5fc6dd1576f89b..a237222774db339027c1563fa332ca10ae3ac924 100644 (file)
@@ -652,6 +652,51 @@ void AnimationImporter:: Assign_float_animations(const COLLADAFW::UniqueId& list
        
 }
 
+/*
+ * Lens animations must be stored in COLLADA by using FOV,
+ * while blender internally uses focal length.
+ * The imported animation curves must be converted appropriately.
+ */
+void AnimationImporter::Assign_lens_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const double aspect, Camera *cam, const char *anim_type, int fov_type)
+{
+       char rna_path[100];
+       if (animlist_map.find(listid) == animlist_map.end()) {
+               return;
+       }
+       else {
+               //anim_type has animations
+               const COLLADAFW::AnimationList *animlist = animlist_map[listid];
+               const COLLADAFW::AnimationList::AnimationBindings& bindings = animlist->getAnimationBindings();
+               //all the curves belonging to the current binding
+               std::vector<FCurve *> animcurves;
+               for (unsigned int j = 0; j < bindings.getCount(); j++) {
+                       animcurves = curve_map[bindings[j].animation];
+
+                       BLI_strncpy(rna_path, anim_type, sizeof(rna_path));
+
+                       modify_fcurve(&animcurves, rna_path, 0);
+                       std::vector<FCurve *>::iterator iter;
+                       //Add the curves of the current animation to the object
+                       for (iter = animcurves.begin(); iter != animcurves.end(); iter++) {
+                               FCurve *fcu = *iter;
+                               
+                               for (unsigned int i = 0; i < fcu->totvert; i++) {
+
+                                       double input_fov = fcu->bezt[i].vec[1][1];
+                                       double xfov = (fov_type == CAMERA_YFOV) ? aspect * input_fov : input_fov;
+
+                                       // fov is in degrees, cam->lens is in millimiters
+                                       double fov = fov_to_focallength(DEG2RADF(input_fov), cam->sensor_x);
+
+                                       fcu->bezt[i].vec[1][1] = fov;
+                               }
+
+                               BLI_addtail(AnimCurves, fcu);
+                       }
+               }
+       }
+}
+
 void AnimationImporter::apply_matrix_curves(Object *ob, std::vector<FCurve *>& animcurves, COLLADAFW::Node *root, COLLADAFW::Node *node,
                                             COLLADAFW::Transformation *tm)
 {
@@ -796,6 +841,39 @@ void AnimationImporter::apply_matrix_curves(Object *ob, std::vector<FCurve *>& a
 
 }
 
+/*
+ * This function returns the aspet ration from the Collada camera.
+ *
+ * Note:COLLADA allows to specify either XFov, or YFov alone. 
+ * In tghat case the aspect ratio can be determined from 
+ * the viewport aspect ratio (which is 1:1 ?)
+ * XXX: check this: its probably wrong!
+ * If both values are specified, then the aspect ration is simply xfov/yfov
+ * and if aspect ratio is efined, then .. well then its that one.
+ */
+static const double get_aspect_ratio(const COLLADAFW::Camera *camera)
+{
+       double aspect =  camera->getAspectRatio().getValue();
+
+       if(aspect == 0)
+       {
+               const double yfov   =  camera->getYFov().getValue();
+
+               if(yfov == 0)
+                       aspect=1; // assume yfov and xfov are equal
+               else
+               {
+                       const double xfov   =  camera->getXFov().getValue();
+                       if (xfov==0)
+                               aspect = 1;
+                       else
+                               aspect = xfov / yfov;
+               }
+       }
+       return aspect;
+}
+
+
 void AnimationImporter::translate_Animations(COLLADAFW::Node *node,
                                              std::map<COLLADAFW::UniqueId, COLLADAFW::Node *>& root_map,
                                              std::multimap<COLLADAFW::UniqueId, Object *>& object_map,
@@ -924,10 +1002,11 @@ void AnimationImporter::translate_Animations(COLLADAFW::Node *node,
        }
 
        if (animType->camera != 0) {
-               Camera *camera  = (Camera *) ob->data;
-
-               if (!camera->adt || !camera->adt->action) act = verify_adt_action((ID *)&camera->id, 1);
-               else act = camera->adt->action;
+               Camera *cam  = (Camera *) ob->data;
+               if (!cam->adt || !cam->adt->action)
+                       act = verify_adt_action((ID *)&cam->id, 1);
+               else
+                       act = cam->adt->action;
 
                ListBase *AnimCurves = &(act->curves);
                const COLLADAFW::InstanceCameraPointerArray& nodeCameras = node->getInstanceCameras();
@@ -938,13 +1017,15 @@ void AnimationImporter::translate_Animations(COLLADAFW::Node *node,
                        if ((animType->camera & CAMERA_XFOV) != 0) {
                                const COLLADAFW::AnimatableFloat *xfov =  &(camera->getXFov());
                                const COLLADAFW::UniqueId& listid = xfov->getAnimationList();
-                               Assign_float_animations(listid, AnimCurves, "lens");
+                               double aspect = get_aspect_ratio(camera); 
+                               Assign_lens_animations(listid, AnimCurves, aspect, cam, "lens", CAMERA_XFOV);
                        }
 
                        else if ((animType->camera & CAMERA_YFOV) != 0) {
                                const COLLADAFW::AnimatableFloat *yfov =  &(camera->getYFov());
                                const COLLADAFW::UniqueId& listid = yfov->getAnimationList();
-                               Assign_float_animations(listid, AnimCurves, "lens");
+                               double aspect = get_aspect_ratio(camera); 
+                               Assign_lens_animations(listid, AnimCurves, aspect, cam, "lens", CAMERA_YFOV);
                        }
 
                        else if ((animType->camera & CAMERA_XMAG) != 0) {
index 32af2b5b78b2472daad6b3ab188fc01573131c22..db61692484b3b39a9a1dfcb3a161d61c45b69072 100644 (file)
@@ -165,6 +165,7 @@ public:
 
        void Assign_color_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
        void Assign_float_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
+       void Assign_lens_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const double aspect, Camera *cam, const char *anim_type, int fov_type);
 
        int setAnimType ( const COLLADAFW::Animatable * prop, int type, int addition);
        
index 0d48bf19c9e035475dc5169a99989f6e48ed5e8b..9c9d7f8e34acca54ce606ae6f65ebb107dae317c 100644 (file)
@@ -100,7 +100,7 @@ void ANIM_timecode_string_from_frame(char *str, Scene *scene, int power, short t
                }
                else {
                        /* seconds (with pixel offset rounding) */
-                       seconds = (int)floor(cfra + 0.375f);
+                       seconds = (int)floor(cfra + GLA_PIXEL_OFS);
                }
                
                switch (U.timecode_style) {
@@ -150,7 +150,7 @@ void ANIM_timecode_string_from_frame(char *str, Scene *scene, int power, short t
                                /* only show the original seconds display */
                                /* round to whole numbers if power is >= 1 (i.e. scale is coarse) */
                                if (power <= 0) sprintf(str, "%.*f", 1 - power, raw_seconds);
-                               else sprintf(str, "%d", (int)floor(raw_seconds + 0.375f));
+                               else sprintf(str, "%d", (int)floor(raw_seconds + GLA_PIXEL_OFS));
                        }
                        break;
                        
@@ -166,7 +166,7 @@ void ANIM_timecode_string_from_frame(char *str, Scene *scene, int power, short t
        else {
                /* round to whole numbers if power is >= 1 (i.e. scale is coarse) */
                if (power <= 0) sprintf(str, "%.*f", 1 - power, cfra);
-               else sprintf(str, "%d", (int)floor(cfra + 0.375f));
+               else sprintf(str, "%d", (int)floor(cfra + GLA_PIXEL_OFS));
        }
 } 
 
index a5e5d7ce2e078d2e472868495ae214e6046015f4..479e0b65177a5a00857d8ac198798638d8e4ae53 100644 (file)
@@ -50,5 +50,7 @@
 #define glMultMatrixf(x)  glMultMatrixf( (float *)(x))
 #define glLoadMatrixf(x)  glLoadMatrixf( (float *)(x))
 
+#define GLA_PIXEL_OFS 0.375f
+
 #endif /* #ifdef __BIF_GL_H__ */
 
index b939ae47ead81d8cdb19feab1d9dadfd203e7c2f..577113927d15e9cac6eed7a5e33607922512e5dc 100644 (file)
@@ -116,8 +116,8 @@ void glaRasterPosSafe2f(float x, float y, float known_good_x, float known_good_y
  *
  * \attention This routine makes many assumptions: the rect data
  * is expected to be in RGBA unsigned byte format, the coordinate
- * (0.375, 0.375) is assumed to be within the view frustum, and the
- * modelview and projection matrices are assumed to define a
+ * (GLA_PIXEL_OFS, GLA_PIXEL_OFS) is assumed to be within the view frustum,
+ * and the modelview and projection matrices are assumed to define a
  * 1-to-1 mapping to screen space.
  * \attention Furthermore, in the case of zoomed or unpixel aligned
  * images extending outside the view frustum, but still within the
index a693e9eb627cc9a3bef27588fe717b7475278e20..8ae08c08693c125984ce0b736b9541e312d2e99b 100644 (file)
@@ -980,7 +980,7 @@ void UI_view2d_view_ortho(View2D *v2d)
        rctf curmasked;
        float xofs, yofs;
        
-       /* pixel offsets (-0.375f) are needed to get 1:1 correspondence with pixels for smooth UI drawing, 
+       /* pixel offsets (-GLA_PIXEL_OFS) are needed to get 1:1 correspondence with pixels for smooth UI drawing,
         * but only applied where requested
         */
        /* XXX brecht: instead of zero at least use a tiny offset, otherwise
@@ -1019,12 +1019,12 @@ void UI_view2d_view_orthoSpecial(ARegion *ar, View2D *v2d, short xaxis)
        rctf curmasked;
        float xofs, yofs;
        
-       /* pixel offsets (-0.375f) are needed to get 1:1 correspondence with pixels for smooth UI drawing, 
+       /* pixel offsets (-GLA_PIXEL_OFS) are needed to get 1:1 correspondence with pixels for smooth UI drawing,
         * but only applied where requested
         */
        /* XXX temp (ton) */
-       xofs = 0.0f; // (v2d->flag & V2D_PIXELOFS_X) ? 0.375f : 0.0f;
-       yofs = 0.0f; // (v2d->flag & V2D_PIXELOFS_Y) ? 0.375f : 0.0f;
+       xofs = 0.0f; // (v2d->flag & V2D_PIXELOFS_X) ? GLA_PIXEL_OFS : 0.0f;
+       yofs = 0.0f; // (v2d->flag & V2D_PIXELOFS_Y) ? GLA_PIXEL_OFS : 0.0f;
        
        /* apply mask-based adjustments to cur rect (due to scrollers), to eliminate scaling artifacts */
        view2d_map_cur_using_mask(v2d, &curmasked);
index 856db013872ea6eae347ae39eeb6b01585d134c7..e20a7b51d13020b2c60878cb1497716ae9df7f3f 100644 (file)
@@ -321,6 +321,7 @@ static void finSelectedSplinePoint(MaskLayer *masklay, MaskSpline **spline, Mask
        *point = NULL;
 
        if (check_active) {
+               /* TODO, having an active point but no active spline is possible, why? */
                if (masklay->act_spline && masklay->act_point && MASKPOINT_ISSEL_ANY(masklay->act_point)) {
                        *spline = masklay->act_spline;
                        *point = masklay->act_point;
@@ -562,7 +563,8 @@ static int add_vertex_exec(bContext *C, wmOperator *op)
 
        RNA_float_get_array(op->ptr, "location", co);
 
-       if (masklay && masklay->act_point && MASKPOINT_ISSEL_ANY(masklay->act_point)) {
+       /* TODO, having an active point but no active spline is possible, why? */
+       if (masklay && masklay->act_spline && masklay->act_point && MASKPOINT_ISSEL_ANY(masklay->act_point)) {
 
                /* cheap trick - double click for cyclic */
                MaskSpline *spline = masklay->act_spline;
index 47a086a2779d681bec060bba563992ce721e06eb..b4f1f4b3022eaa2f058afd05b57ddef2be7cd122 100644 (file)
@@ -107,7 +107,7 @@ void ED_region_pixelspace(ARegion *ar)
        int width = ar->winrct.xmax - ar->winrct.xmin + 1;
        int height = ar->winrct.ymax - ar->winrct.ymin + 1;
        
-       wmOrtho2(-0.375f, (float)width - 0.375f, -0.375f, (float)height - 0.375f);
+       wmOrtho2(-GLA_PIXEL_OFS, (float)width - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, (float)height - GLA_PIXEL_OFS);
        glLoadIdentity();
 }
 
index 5296c8615ab6bb7be605b23cb88233064aa50d8e..a534124d2c01e216c3e437116ad30b9d7bad5462 100644 (file)
@@ -674,7 +674,7 @@ void glaDefine2DArea(rcti *screen_rect)
        glViewport(screen_rect->xmin, screen_rect->ymin, sc_w, sc_h);
        glScissor(screen_rect->xmin, screen_rect->ymin, sc_w, sc_h);
 
-       /* The 0.375 magic number is to shift the matrix so that
+       /* The GLA_PIXEL_OFS magic number is to shift the matrix so that
         * both raster and vertex integer coordinates fall at pixel
         * centers properly. For a longer discussion see the OpenGL
         * Programming Guide, Appendix H, Correctness Tips.
@@ -683,7 +683,7 @@ void glaDefine2DArea(rcti *screen_rect)
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0.0, sc_w, 0.0, sc_h, -1, 1);
-       glTranslatef(0.375, 0.375, 0.0);
+       glTranslatef(GLA_PIXEL_OFS, GLA_PIXEL_OFS, 0.0);
 
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
index 3f9e0051d2e0cfa171efef200381cc824f0596be..99bc192042c03b06b8202bdc121578e61014368f 100644 (file)
@@ -13,7 +13,7 @@
  *
  * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
@@ -177,15 +177,10 @@ float paint_calc_object_space_radius(ViewContext *vc, const float center[3],
 
 float paint_get_tex_pixel(Brush *br, float u, float v)
 {
-       TexResult texres;
-       float co[3];
+       TexResult texres = {0};
+       float co[3] = {u, v, 0.0f};
        int hasrgb;
 
-       co[0] = u;
-       co[1] = v;
-       co[2] = 0;
-
-       memset(&texres, 0, sizeof(TexResult));
        hasrgb = multitex_ext(br->mtex.tex, co, NULL, NULL, 0, &texres);
 
        if (hasrgb & TEX_RGB)
index 53ca256be0cc77929c063b680f4c2ef24efb53eb..aaa1328f9f6afae19ac1ed5cb3a42d8b0e90ba2c 100644 (file)
@@ -701,7 +701,7 @@ static int sound_pack_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
 
        sound->packedfile = newPackedFile(op->reports, sound->name, ID_BLEND_PATH(bmain, &sound->id));
-       sound_load(CTX_data_main(C), sound);
+       sound_load(bmain, sound);
 
        return OPERATOR_FINISHED;
 }
@@ -725,6 +725,7 @@ static void SOUND_OT_pack(wmOperatorType *ot)
 
 static int sound_unpack_exec(bContext *C, wmOperator *op)
 {
+       Main *bmain = CTX_data_main(C);
        int method = RNA_enum_get(op->ptr, "method");
        bSound *sound = NULL;
 
@@ -732,7 +733,7 @@ static int sound_unpack_exec(bContext *C, wmOperator *op)
        if (RNA_struct_property_is_set(op->ptr, "id")) {
                char sndname[MAX_ID_NAME - 2];
                RNA_string_get(op->ptr, "id", sndname);
-               sound = BLI_findstring(&CTX_data_main(C)->sound, sndname, offsetof(ID, name) + 2);
+               sound = BLI_findstring(&bmain->sound, sndname, offsetof(ID, name) + 2);
        }
 
        if (!sound || !sound->packedfile)
@@ -741,7 +742,7 @@ static int sound_unpack_exec(bContext *C, wmOperator *op)
        if (G.fileflags & G_AUTOPACK)
                BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save");
 
-       unpackSound(CTX_data_main(C), op->reports, sound, method);
+       unpackSound(bmain, op->reports, sound, method);
 
        return OPERATOR_FINISHED;
 }
index 8c40eaa4836a988b4d2595398c0dc4c30b96b1f3..54c7d0b21003917c79a1d8c8c13a672cd92401ca 100644 (file)
@@ -997,9 +997,7 @@ static void node_draw_frame(const bContext *C, ARegion *ar, SpaceNode *snode, bN
        float alpha;
        
        /* skip if out of view */
-       if (node->totr.xmax < ar->v2d.cur.xmin || node->totr.xmin > ar->v2d.cur.xmax ||
-           node->totr.ymax < ar->v2d.cur.ymin || node->totr.ymin > ar->v2d.cur.ymax) {
-               
+       if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == FALSE) {
                uiEndBlock(C, node->block);
                node->block = NULL;
                return;
@@ -3043,7 +3041,7 @@ void draw_nodespace_back_pix(const bContext *C, ARegion *ar, SpaceNode *snode)
                        
                        glaDefine2DArea(&ar->winrct);
                        /* ortho at pixel level curarea */
-                       wmOrtho2(-0.375, ar->winx - 0.375, -0.375, ar->winy - 0.375);
+                       wmOrtho2(-GLA_PIXEL_OFS, ar->winx - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, ar->winy - GLA_PIXEL_OFS);
                        
                        x = (ar->winx - snode->zoom * ibuf->x) / 2 + snode->xof;
                        y = (ar->winy - snode->zoom * ibuf->y) / 2 + snode->yof;
index f1ba81acf903b7768673e8e3a228521f67625d4b..71e7e53eb4f1af86aef2c68f3faa4e813ec72996 100644 (file)
@@ -681,9 +681,7 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN
                nodeShaderSynchronizeID(node, 0);
        
        /* skip if out of view */
-       if (node->totr.xmax < ar->v2d.cur.xmin || node->totr.xmin > ar->v2d.cur.xmax ||
-           node->totr.ymax < ar->v2d.cur.ymin || node->totr.ymin > ar->v2d.cur.ymax)
-       {
+       if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == FALSE) {
                uiEndBlock(C, node->block);
                node->block = NULL;
                return;
index 85ad590f772a076578a33d1ea1650a689c562bcb..68806a802acc4c9adb3544c31ebcf1d4c074461b 100644 (file)
 #include "BKE_image.h"
 #include "BKE_library.h"
 #include "BKE_main.h"
-#include "BKE_node.h"
 #include "BKE_material.h"
+#include "BKE_node.h"
 #include "BKE_paint.h"
+#include "BKE_report.h"
 #include "BKE_scene.h"
 #include "BKE_texture.h"
 
@@ -762,7 +763,7 @@ static void edit_node_properties_get(wmOperator *op, bNodeTree *ntree, bNode **r
 /* ************************** Node generic ************** */
 
 /* is rct in visible part of node? */
-static bNode *visible_node(SpaceNode *snode, rctf *rct)
+static bNode *visible_node(SpaceNode *snode, const rctf *rct)
 {
        bNode *node;
        
@@ -1917,7 +1918,8 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op))
        ED_preview_kill_jobs(C);
 
        /* clear current clipboard */
-       nodeClipboardClear();
+       BKE_node_clipboard_clear();
+       BKE_node_clipboard_init(ntree);
 
        /* get group node offset */
        if (gnode)
@@ -1926,7 +1928,7 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op))
        for (node = ntree->nodes.first; node; node = node->next) {
                if (node->flag & SELECT) {
                        new_node = nodeCopyNode(NULL, node);
-                       nodeClipboardAddNode(new_node);
+                       BKE_node_clipboard_add_node(new_node);
                }
        }
 
@@ -1968,7 +1970,7 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op))
                        newlink->fromnode = link->fromnode->new_node;
                        newlink->fromsock = link->fromsock->new_sock;
 
-                       nodeClipboardAddLink(newlink);
+                       BKE_node_clipboard_add_link(newlink);
                }
        }
 
@@ -1992,7 +1994,7 @@ void NODE_OT_clipboard_copy(wmOperatorType *ot)
 
 /* ****************** Paste from clipboard ******************* */
 
-static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
+static int node_clipboard_paste_exec(bContext *C, wmOperator *op)
 {
        SpaceNode *snode = CTX_wm_space_node(C);
        bNodeTree *ntree = snode->edittree;
@@ -2003,6 +2005,11 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
        int num_nodes;
        float centerx, centery;
 
+       if (BKE_node_clipboard_get_type() != ntree->type) {
+               BKE_report(op->reports, RPT_ERROR, "Clipboard nodes are an incompatible type");
+               return OPERATOR_CANCELLED;
+       }
+
        ED_preview_kill_jobs(C);
 
        /* deselect old nodes */
@@ -2015,7 +2022,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
        /* calculate "barycenter" for placing on mouse cursor */
        num_nodes = 0;
        centerx = centery = 0.0f;
-       for (node = nodeClipboardGetNodes()->first; node; node = node->next) {
+       for (node = BKE_node_clipboard_get_nodes()->first; node; node = node->next) {
                ++num_nodes;
                centerx += 0.5f * (node->totr.xmin + node->totr.xmax);
                centery += 0.5f * (node->totr.ymin + node->totr.ymax);
@@ -2024,7 +2031,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
        centery /= num_nodes;
 
        /* copy nodes from clipboard */
-       for (node = nodeClipboardGetNodes()->first; node; node = node->next) {
+       for (node = BKE_node_clipboard_get_nodes()->first; node; node = node->next) {
                bNode *new_node = nodeCopyNode(ntree, node);
 
                /* pasted nodes are selected */
@@ -2032,7 +2039,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
        }
        
        /* reparent copied nodes */
-       for (node = nodeClipboardGetNodes()->first; node; node = node->next) {
+       for (node = BKE_node_clipboard_get_nodes()->first; node; node = node->next) {
                bNode *new_node = node->new_node;
                if (new_node->parent)
                        new_node->parent = new_node->parent->new_node;
@@ -2045,7 +2052,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *UNUSED(op))
                }
        }
 
-       for (link = nodeClipboardGetLinks()->first; link; link = link->next) {
+       for (link = BKE_node_clipboard_get_links()->first; link; link = link->next) {
                nodeAddLink(ntree, link->fromnode->new_node, link->fromsock->new_sock,
                            link->tonode->new_node, link->tosock->new_sock);
        }
index 5c59555a0ed1da4d085f6c46d0ad580a61c6d29a..d82118facd1404bb99aa00d804255061ae5fe13d 100644 (file)
@@ -1147,17 +1147,26 @@ static int node_attach_exec(bContext *C, wmOperator *UNUSED(op))
                for (node = ntree->nodes.last; node; node = node->prev) {
                        if (node->flag & NODE_SELECT) {
                                if (node->parent == NULL) {
-                                       /* attach all unparented nodes */
-                                       nodeAttachNode(node, frame);
+                                       /* disallow moving a parent into its child */
+                                       if (nodeAttachNodeCheck(frame, node) == FALSE) {
+                                               /* attach all unparented nodes */
+                                               nodeAttachNode(node, frame);
+                                       }
                                }
                                else {
                                        /* attach nodes which share parent with the frame */
-                                       for (parent = frame->parent; parent; parent = parent->parent)
-                                               if (parent == node->parent)
+                                       for (parent = frame->parent; parent; parent = parent->parent) {
+                                               if (parent == node->parent) {
                                                        break;
+                                               }
+                                       }
+
                                        if (parent) {
-                                               nodeDetachNode(node);
-                                               nodeAttachNode(node, frame);
+                                               /* disallow moving a parent into its child */
+                                               if (nodeAttachNodeCheck(frame, node) == FALSE) {
+                                                       nodeDetachNode(node);
+                                                       nodeAttachNode(node, frame);
+                                               }
                                        }
                                }
                        }
index 0c3a5372e6d51fa4f2eac33c0bc34b42330b5d08..248998a3a56b94dff3e50aafb65805b99b84cb1e 100644 (file)
 
 #include "UI_view2d.h"
 
+#include "MEM_guardedalloc.h"
+
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
-#include "MEM_guardedalloc.h"
-
 #include "node_intern.h"  /* own include */
 
 
index 8be5b644afb82f26b834c9f10ccb45fa1b289df3..6240d17457579230cef4d804be57ea2fcfe31f54 100644 (file)
@@ -50,7 +50,6 @@
 #include "BKE_suggestions.h"
 #include "BKE_text.h"
 
-
 #include "BIF_gl.h"
 
 #include "ED_datafiles.h"
@@ -1854,7 +1853,7 @@ void draw_text_main(SpaceText *st, ARegion *ar)
        /* draw other stuff */
        draw_brackets(st, ar);
        draw_markers(st, ar);
-       glTranslatef(0.375f, 0.375f, 0.0f); /* XXX scroll requires exact pixel space */
+       glTranslatef(GLA_PIXEL_OFS, GLA_PIXEL_OFS, 0.0f); /* XXX scroll requires exact pixel space */
        draw_textscroll(st, &scroll, &back);
        draw_documentation(st, ar);
        draw_suggestion_list(st, ar);
index 3ab5bf7bbfb226a3504208c2cce3449bc9b0f16a..1585fb1ad6b07f8926ba62c84959b5fc1b9a375e 100644 (file)
@@ -666,7 +666,7 @@ int initTransInfo(struct bContext *C, TransInfo *t, struct wmOperator *op, struc
 void postTrans (struct bContext *C, TransInfo *t);
 void resetTransRestrictions(TransInfo *t);
 
-void drawLine(TransInfo *t, float *center, float *dir, char axis, short options);
+void drawLine(TransInfo *t, const float center[3], const float dir[3], char axis, short options);
 
 void drawNonPropEdge(const struct bContext *C, TransInfo *t);
 
index 00cde33e79941ac9b5617b95d62c1543017b48be..0fdd873624853b811575cb71e675a47a093ad2a4 100644 (file)
@@ -2189,12 +2189,13 @@ cleanup:
 void flushTransNodes(TransInfo *t)
 {
        int a;
-       TransData2D *td;
+       TransData *td;
+       TransData2D *td2d;
 
        /* flush to 2d vector from internally used 3d vector */
-       for (a = 0, td = t->data2d; a < t->total; a++, td++) {
-               td->loc2d[0] = td->loc[0];
-               td->loc2d[1] = td->loc[1];
+       for (a = 0, td = t->data, td2d = t->data2d; a < t->total; a++, td++, td2d++) {
+               bNode *node = td->extra;
+               add_v2_v2v2(&node->locx, td2d->loc, td2d->ih1);
        }
        
        /* handle intersection with noodles */
@@ -5525,24 +5526,22 @@ static void createTransObject(bContext *C, TransInfo *t)
 
 /* transcribe given node into TransData2D for Transforming */
 static void NodeToTransData(TransData *td, TransData2D *td2d, bNode *node)
-// static void NodeToTransData(bContext *C, TransInfo *t, TransData2D *td, bNode *node)
 {
-       td2d->loc[0] = node->locx; /* hold original location */
-       td2d->loc[1] = node->locy;
+       /* hold original location */
+       float locxy[2] = {(node->totr.xmax + node->totr.xmin) / 2.0f,
+                         (node->totr.ymax + node->totr.ymin) / 2.0f};
+
+       copy_v2_v2(td2d->loc, locxy);
        td2d->loc[2] = 0.0f;
-       td2d->loc2d = &node->locx; /* current location */
+       td2d->loc2d = td2d->loc; /* current location */
 
        td->flag = 0;
-       /* exclude nodes whose parent is also transformed */
-       if (node->parent && (node->parent->flag & NODE_TRANSFORM)) {
-               td->flag |= TD_SKIP;
-       }
 
        td->loc = td2d->loc;
        copy_v3_v3(td->iloc, td->loc);
        /* use node center instead of origin (top-left corner) */
-       td->center[0] = node->locx + 0.5f * (node->totr.xmax - node->totr.xmin);
-       td->center[1] = node->locy - 0.5f * (node->totr.ymax - node->totr.ymin);        /* node height is used negative */
+       td->center[0] = locxy[0];
+       td->center[1] = locxy[1];
        td->center[2] = 0.0f;
 
        memset(td->axismtx, 0, sizeof(td->axismtx));
@@ -5556,37 +5555,53 @@ static void NodeToTransData(TransData *td, TransData2D *td2d, bNode *node)
        unit_m3(td->mtx);
        unit_m3(td->smtx);
 
+       sub_v2_v2v2(td2d->ih1, &node->locx, locxy);
+
        td->extra = node;
 }
 
-static void createTransNodeData(bContext *C, TransInfo *t)
+static int is_node_parent_select(bNode *node)
+{
+       while ((node = node->parent)) {
+               if (node->flag & NODE_TRANSFORM) {
+                       return TRUE;
+               }
+       }
+       return FALSE;
+}
+
+static void createTransNodeData(bContext *UNUSED(C), TransInfo *t)
 {
        TransData *td;
        TransData2D *td2d;
        SpaceNode *snode = t->sa->spacedata.first;
        bNode *node;
 
+       t->total = 0;
+
        if (!snode->edittree) {
-               t->total = 0;
                return;
        }
 
        /* set transform flags on nodes */
        for (node = snode->edittree->nodes.first; node; node = node->next) {
-               if ((node->flag & NODE_SELECT) || (node->parent && (node->parent->flag & NODE_TRANSFORM)))
+               if (node->flag & NODE_SELECT && is_node_parent_select(node) == FALSE) {
                        node->flag |= NODE_TRANSFORM;
-               else
+                       t->total++;
+               }
+               else {
                        node->flag &= ~NODE_TRANSFORM;
+               }
        }
 
-       t->total = CTX_DATA_COUNT(C, selected_nodes);
-
        td = t->data = MEM_callocN(t->total * sizeof(TransData), "TransNode TransData");
        td2d = t->data2d = MEM_callocN(t->total * sizeof(TransData2D), "TransNode TransData2D");
 
-       CTX_DATA_BEGIN(C, bNode *, selnode, selected_nodes)
-       NodeToTransData(td++, td2d++, selnode);
-       CTX_DATA_END
+       for (node = snode->edittree->nodes.first; node; node = node->next) {
+               if (node->flag & NODE_TRANSFORM) {
+                       NodeToTransData(td++, td2d++, node);
+               }
+       }
 }
 
 /* *** CLIP EDITOR *** */
index 43de0f2b35f2098e698da1ed8414b386b9389dcd..8e73fb8b8cbca033619fd9dfa266adc696f43a4a 100644 (file)
@@ -923,7 +923,7 @@ void recalcData(TransInfo *t)
        }
 }
 
-void drawLine(TransInfo *t, float *center, float *dir, char axis, short options)
+void drawLine(TransInfo *t, const float center[3], const float dir[3], char axis, short options)
 {
        float v1[3], v2[3], v3[3];
        unsigned char col[3], col2[3];
@@ -1017,15 +1017,10 @@ int initTransInfo(bContext *C, TransInfo *t, wmOperator *op, wmEvent *event)
        t->total            = 0;
        
        t->val = 0.0f;
-       
-       t->vec[0]           =
-           t->vec[1]       =
-               t->vec[2]       = 0.0f;
 
-       t->center[0]        =
-           t->center[1]    =
-               t->center[2]    = 0.0f;
-       
+       zero_v3(t->vec);
+       zero_v3(t->center);
+
        unit_m3(t->mat);
        
        /* if there's an event, we're modal */
index 0eacfd392b9e39933aa0d1471cc03916eef9a103..222f13185ea06cb8c1f72afa5b2854c48563d24d 100644 (file)
@@ -69,6 +69,7 @@
 #include "BLI_heap.h"
 #include "BLI_listbase.h"
 #include "BLI_math.h"
+#include "BLI_stack.h"
 #include "BLI_string.h"
 
 #include "BKE_cdderivedmesh.h"
@@ -634,71 +635,107 @@ static void calc_edge_mat(float mat[3][3], const float a[3], const float b[3])
        }
 }
 
-static void build_emats_rec(int *visited_e, EMat *emat,
-                            const MeshElemMap *emap, const MEdge *medge,
-                            const MVertSkin *vs, const MVert *mvert,
-                            int parent_v, float parent_mat[3][3])
+typedef struct {
+       float mat[3][3];
+       int parent_v;
+       int e;
+} EdgeStackElem;
+
+static void build_emats_stack(BLI_Stack *stack, int *visited_e, EMat *emat,
+                                                         const MeshElemMap *emap, const MEdge *medge,
+                                                         const MVertSkin *vs, const MVert *mvert)
 {
+       EdgeStackElem stack_elem;
        float axis[3], angle;
-       int i, e, v, parent_is_branch;
+       int i, e, v, parent_v, parent_is_branch;
 
-       parent_is_branch = ((emap[parent_v].count > 2) ||
-                           (vs[parent_v].flag & MVERT_SKIN_ROOT));
+       BLI_stack_pop(stack, &stack_elem);
+       parent_v = stack_elem.parent_v;
+       e = stack_elem.e;
 
-       for (i = 0; i < emap[parent_v].count; i++) {
-               e = emap[parent_v].indices[i];
+       /* Skip if edge already visited */
+       if (visited_e[e])
+               return;
 
-               /* Ignore edge if already visited */
-               if (visited_e[e]) continue;
-               visited_e[e] = 1;
+       /* Mark edge as visited */
+       visited_e[e] = TRUE;
+       
+       /* Process edge */
 
-               v = BKE_mesh_edge_other_vert(&medge[e], parent_v);
-               emat[e].origin = parent_v;
+       parent_is_branch = ((emap[parent_v].count > 2) ||
+                           (vs[parent_v].flag & MVERT_SKIN_ROOT));
 
-               /* If parent is a branch node, start a new edge chain */
-               if (parent_is_branch) {
-                       calc_edge_mat(emat[e].mat, mvert[parent_v].co,
-                                     mvert[v].co);
-               }
-               else {
-                       /* Build edge matrix guided by parent matrix */
-                       sub_v3_v3v3(emat[e].mat[0], mvert[v].co, mvert[parent_v].co);
-                       normalize_v3(emat[e].mat[0]);
-                       angle = angle_normalized_v3v3(parent_mat[0], emat[e].mat[0]);
-                       cross_v3_v3v3(axis, parent_mat[0], emat[e].mat[0]);
-                       normalize_v3(axis);
-                       rotate_normalized_v3_v3v3fl(emat[e].mat[1], parent_mat[1], axis, angle);
-                       rotate_normalized_v3_v3v3fl(emat[e].mat[2], parent_mat[2], axis, angle);
-               }
+       v = BKE_mesh_edge_other_vert(&medge[e], parent_v);
+       emat[e].origin = parent_v;
+
+       /* If parent is a branch node, start a new edge chain */
+       if (parent_is_branch) {
+               calc_edge_mat(emat[e].mat, mvert[parent_v].co,
+                                         mvert[v].co);
+       }
+       else {
+               /* Build edge matrix guided by parent matrix */
+               sub_v3_v3v3(emat[e].mat[0], mvert[v].co, mvert[parent_v].co);
+               normalize_v3(emat[e].mat[0]);
+               angle = angle_normalized_v3v3(stack_elem.mat[0], emat[e].mat[0]);
+               cross_v3_v3v3(axis, stack_elem.mat[0], emat[e].mat[0]);
+               normalize_v3(axis);
+               rotate_normalized_v3_v3v3fl(emat[e].mat[1], stack_elem.mat[1], axis, angle);
+               rotate_normalized_v3_v3v3fl(emat[e].mat[2], stack_elem.mat[2], axis, angle);
+       }
 
-               build_emats_rec(visited_e, emat, emap, medge,
-                               vs, mvert, v, emat[e].mat);
+       /* Add neighbors to stack */
+       for (i = 0; i < emap[v].count; i++) {
+               /* Add neighbors to stack */
+               memcpy(stack_elem.mat, emat[e].mat, sizeof(float) * 3 * 3);
+               stack_elem.e = emap[v].indices[i];
+               stack_elem.parent_v = v;
+               BLI_stack_push(stack, &stack_elem);
        }
 }
 
-static EMat *build_edge_mats(MVertSkin *vs, MVert *mvert, int totvert,
-                             MEdge *medge, MeshElemMap *emap, int totedge)
+static EMat *build_edge_mats(const MVertSkin *vs,
+                                                        const MVert *mvert,
+                                                        int totvert,
+                             const MEdge *medge,
+                                                        const MeshElemMap *emap,
+                                                        int totedge)
 {
+       BLI_Stack *stack;
        EMat *emat;
-       float mat[3][3];
-       int *visited_e, v;
+       EdgeStackElem stack_elem;
+       int *visited_e, i, v;
+
+       stack = BLI_stack_new(sizeof(stack_elem), "build_edge_mats.stack");
 
        visited_e = MEM_callocN(sizeof(int) * totedge, "build_edge_mats.visited_e");
        emat = MEM_callocN(sizeof(EMat) * totedge, "build_edge_mats.emat");
 
-       /* Build edge matrices recursively from the root nodes */
+       /* Edge matrices are built from the root nodes, add all roots with
+        * children to the stack */
        for (v = 0; v < totvert; v++) {
                if (vs[v].flag & MVERT_SKIN_ROOT) {
                        if (emap[v].count >= 1) {
                                const MEdge *e = &medge[emap[v].indices[0]];
-                               calc_edge_mat(mat, mvert[v].co,
+                               calc_edge_mat(stack_elem.mat, mvert[v].co,
                                              mvert[BKE_mesh_edge_other_vert(e, v)].co);
-                               build_emats_rec(visited_e, emat, emap, medge, vs, mvert, v, mat);
+                               stack_elem.parent_v = v;
+
+                               /* Add adjacent edges to stack */
+                               for (i = 0; i < emap[v].count; i++) {
+                                       stack_elem.e = emap[v].indices[i];
+                                       BLI_stack_push(stack, &stack_elem);
+                               }
                        }
                }
        }
 
+       while (!BLI_stack_empty(stack)) {
+               build_emats_stack(stack, visited_e, emat, emap, medge, vs, mvert);
+       }
+
        MEM_freeN(visited_e);
+       BLI_stack_free(stack);
 
        return emat;
 }
index 93f49fd72c9f65396b02cc2354312590d831e76f..aa9d81389da24d3b4c2c26a742eb110cd8c00b87 100644 (file)
@@ -639,7 +639,7 @@ void BPY_modules_load_user(bContext *C)
 
        bpy_context_set(C, &gilstate);
 
-       for (text = CTX_data_main(C)->text.first; text; text = text->id.next) {
+       for (text = bmain->text.first; text; text = text->id.next) {
                if (text->flags & TXT_ISSCRIPT && BLI_testextensie(text->id.name + 2, ".py")) {
                        if (!(G.f & G_SCRIPT_AUTOEXEC)) {
                                printf("scripts disabled for \"%s\", skipping '%s'\n", bmain->name, text->id.name + 2);
index 9d7393f94148f2f8a2d8e840a7b2e91452738d5f..604cd940fabaed8c612cadc1c29cd6140083a493 100644 (file)
@@ -58,7 +58,7 @@ void texture_rgb_blend(float in[3], const float tex[3], const float out[3], floa
 float texture_value_blend(float tex, float out, float fact, float facg, int blendtype);
 
 /* node_composite.c */
-void ibuf_sample(struct ImBuf *ibuf, float fx, float fy, float dx, float dy, float *result);
+void ibuf_sample(struct ImBuf *ibuf, float fx, float fy, float dx, float dy, float result[4]);
 void antialias_tagbuf(int xsize, int ysize, char *rectmove);
 
 /* dynamicpaint.c */
index 1c8a25524826a8155e59d489cc2a6cbd9662ddc6..e8f171fe38321abcfcc9d8f9b47a6ef5557db362 100644 (file)
@@ -78,7 +78,7 @@ void render_realtime_texture(struct ShadeInput *shi, struct Image *ima);
 
 int imagewraposa(struct Tex *tex, struct Image *ima, struct ImBuf *ibuf, const float texvec[3], const float dxt[3], const float dyt[3], struct TexResult *texres);
 int imagewrap(struct Tex *tex, struct Image *ima, struct ImBuf *ibuf, const float texvec[3], struct TexResult *texres);
-void image_sample(struct Image *ima, float fx, float fy, float dx, float dy, float *result);
+void image_sample(struct Image *ima, float fx, float fy, float dx, float dy, float result[4]);
 
 #endif /* __TEXTURE_H__ */
 
index a0d730c5b8af9869619fa31addd3d300762ab862..103c04a590fdce30897fa933175fbdd30275c977 100644 (file)
@@ -133,7 +133,7 @@ static void bvh_bb(Tree *obj, float *min, float *max)
 template<class Tree>
 static float bvh_cost(Tree *obj)
 {
-       assert(obj->cost >= 0.0);
+       assert(obj->cost >= 0.0f);
        return obj->cost;
 }
 
index bfbc1c641334d0c392665ce1e14a9c498db8d9fd..c3e761ae06971e2df98fd6cc58371a7e2956df55 100644 (file)
@@ -118,7 +118,7 @@ static int  RE_rayobject_instance_intersect(RayObject *o, Isect *isec)
        for (i = 0; i < 3; i++) {
                isec->idot_axis[i]        = 1.0f / isec->dir[i];
 
-               isec->bv_index[2 * i]     = isec->idot_axis[i] < 0.0 ? 1 : 0;
+               isec->bv_index[2 * i]     = isec->idot_axis[i] < 0.0f ? 1 : 0;
                isec->bv_index[2 * i + 1] = 1 - isec->bv_index[2 * i];
 
                isec->bv_index[2 * i]     = i + 3 * isec->bv_index[2 * i];
@@ -161,7 +161,7 @@ static int  RE_rayobject_instance_intersect(RayObject *o, Isect *isec)
 
        // restore bv_index
        for (i = 0; i < 3; i++) {
-               isec->bv_index[2 * i]     = isec->idot_axis[i] < 0.0 ? 1 : 0;
+               isec->bv_index[2 * i]     = isec->idot_axis[i] < 0.0f ? 1 : 0;
                isec->bv_index[2 * i + 1] = 1 - isec->bv_index[2 * i];
 
                isec->bv_index[2 * i]     = i + 3 * isec->bv_index[2 * i];
index c4c89bd06a6a28f74847bc5ba521270eec320612..0a90a55b3bc896dae440f8206a54258234378e8f 100644 (file)
@@ -1779,11 +1779,8 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
        }
 
        /* de-premul, this is being premulled in shade_input_do_shade() */
-       if (texres->ta!=1.0f && texres->ta>1e-4f) {
-               fx= 1.0f/texres->ta;
-               texres->tr*= fx;
-               texres->tg*= fx;
-               texres->tb*= fx;
+       if (texres->ta != 1.0f && texres->ta > 1e-4f) {
+               mul_v3_fl(&texres->tr, 1.0f / texres->ta);
        }
 
        BRICONTRGB;
@@ -1791,25 +1788,22 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
        return retval;
 }
 
-void image_sample(Image *ima, float fx, float fy, float dx, float dy, float *result)
+void image_sample(Image *ima, float fx, float fy, float dx, float dy, float result[4])
 {
        TexResult texres;
        ImBuf *ibuf= BKE_image_get_ibuf(ima, NULL);
        
-       if (ibuf==NULL) {
-               result[0]= result[1]= result[2]= result[3]= 0.0f;
+       if (UNLIKELY(ibuf == NULL)) {
+               zero_v4(result);
                return;
        }
        
        if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
                ibuf->rect+= (ibuf->x*ibuf->y);
 
-       texres.talpha= 1; /* boxsample expects to be initialized */
-       boxsample(ibuf, fx, fy, fx+dx, fy+dy, &texres, 0, 1);
-       result[0]= texres.tr;
-       result[1]= texres.tg;
-       result[2]= texres.tb;
-       result[3]= texres.ta;
+       texres.talpha = TRUE; /* boxsample expects to be initialized */
+       boxsample(ibuf, fx, fy, fx + dx, fy + dy, &texres, 0, 1);
+       copy_v4_v4(result, &texres.tr);
        
        if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
                ibuf->rect-= (ibuf->x*ibuf->y);
@@ -1817,15 +1811,11 @@ void image_sample(Image *ima, float fx, float fy, float dx, float dy, float *res
        ima->flag|= IMA_USED_FOR_RENDER;
 }
 
-void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float *result)
+void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float result[4])
 {
-       TexResult texres;
+       TexResult texres = {0};
        afdata_t AFD;
-       
-       if (ibuf==NULL) {
-               return;
-       }
-       
+
        AFD.dxt[0] = dx; AFD.dxt[1] = dx;
        AFD.dyt[0] = dy; AFD.dyt[1] = dy;
        //copy_v2_v2(AFD.dxt, dx);
@@ -1833,13 +1823,8 @@ void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float *res
        
        AFD.intpol = 1;
        AFD.extflag = TXC_EXTD;
-       
-       memset(&texres, 0, sizeof(texres));
+
        ewa_eval(&texres, ibuf, fx, fy, &AFD);
        
-       
-       result[0]= texres.tr;
-       result[1]= texres.tg;
-       result[2]= texres.tb;
-       result[3]= texres.ta;
+       copy_v4_v4(result, &texres.tr);
 }
index 8652870e2804851c20fb5192461b0b529c984be8..66bb321e832ec44a5e77dd65a4e18878a84cd309 100644 (file)
 #include "BLI_utildefines.h"
 #include "BLI_math_base.h"
 
+#include "BIF_gl.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
 
-
 #include "GHOST_C-api.h"
 
 #include "ED_screen.h"
@@ -505,8 +506,8 @@ static void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple)
                        /* wmOrtho for the screen has this same offset */
                        ratiox = sizex;
                        ratioy = sizey;
-                       halfx = 0.375f;
-                       halfy = 0.375f;
+                       halfx = GLA_PIXEL_OFS;
+                       halfy = GLA_PIXEL_OFS;
 
                        /* texture rectangle has unnormalized coordinates */
                        if (triple->target == GL_TEXTURE_2D) {
index f6b6c70dbf21702030a5940f37487f2aeff83c30..c1bc8912425be3c2e4f9ac2908b57068cd0158c8 100644 (file)
@@ -58,6 +58,7 @@
 #include "BKE_library.h"
 #include "BKE_main.h"
 #include "BKE_mball.h"
+#include "BKE_node.h"
 #include "BKE_report.h"
 
 #include "BKE_packedFile.h"
@@ -335,10 +336,10 @@ static void free_openrecent(void)
 /* bad stuff*/
 
 // XXX copy/paste buffer stuff...
-extern void free_anim_copybuf(void); 
-extern void free_anim_drivers_copybuf(void); 
-extern void free_fmodifiers_copybuf(void); 
-extern void free_posebuf(void); 
+extern void free_anim_copybuf(void);
+extern void free_anim_drivers_copybuf(void);
+extern void free_fmodifiers_copybuf(void);
+extern void free_posebuf(void);
 
 #if WIN32
 /* Read console events until there is a key event.  Also returns on any error. */
@@ -421,6 +422,7 @@ void WM_exit_ext(bContext *C, const short do_python)
        free_anim_drivers_copybuf();
        free_fmodifiers_copybuf();
        free_posebuf();
+       BKE_node_clipboard_clear();
 
        BLF_exit();
 
index 0b9dc441227376f182b78dbc179be765d69ef438..529910d220ee58e78e6e5165d196f369b9f43a13 100644 (file)
@@ -141,7 +141,7 @@ void wm_subwindow_getmatrix(wmWindow *win, int swinid, float mat[][4])
                        int width, height;
 
                        wm_subwindow_getsize(win, swin->swinid, &width, &height);
-                       orthographic_m4(mat, -0.375f, (float)width - 0.375f, -0.375f, (float)height - 0.375f, -100, 100);
+                       orthographic_m4(mat, -GLA_PIXEL_OFS, (float)width - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, (float)height - GLA_PIXEL_OFS, -100, 100);
                }
                else
                        glGetFloatv(GL_PROJECTION_MATRIX, (float *)mat);
@@ -175,7 +175,7 @@ int wm_subwindow_open(wmWindow *win, rcti *winrct)
        
        /* extra service */
        wm_subwindow_getsize(win, swin->swinid, &width, &height);
-       wmOrtho2(-0.375f, (float)width - 0.375f, -0.375f, (float)height - 0.375f);
+       wmOrtho2(-GLA_PIXEL_OFS, (float)width - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, (float)height - GLA_PIXEL_OFS);
        glLoadIdentity();
 
        return swin->swinid;
@@ -229,7 +229,7 @@ void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
                /* extra service */
                wmSubWindowSet(win, swinid);
                wm_subwindow_getsize(win, swinid, &width, &height);
-               wmOrtho2(-0.375f, (float)width - 0.375f, -0.375f, (float)height - 0.375f);
+               wmOrtho2(-GLA_PIXEL_OFS, (float)width - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, (float)height - GLA_PIXEL_OFS);
        }
        else {
                printf("%s: Internal error, bad winid: %d\n", __func__, swinid);
@@ -268,7 +268,7 @@ void wmSubWindowScissorSet(wmWindow *win, int swinid, rcti *srct)
        else
                glScissor(_curswin->winrct.xmin, _curswin->winrct.ymin, width, height);
        
-       wmOrtho2(-0.375f, (float)width - 0.375f, -0.375f, (float)height - 0.375f);
+       wmOrtho2(-GLA_PIXEL_OFS, (float)width - GLA_PIXEL_OFS, -GLA_PIXEL_OFS, (float)height - GLA_PIXEL_OFS);
        glLoadIdentity();
 
        glFlush();
index fbeb34b70b4969292982faafa253fd8181d89c50..a21c3965be938ec4e58a9f8d0c7c70edffa3329f 100644 (file)
@@ -206,7 +206,7 @@ bool BL_Action::Play(const char* name,
        }
 
        // Now that we have an action, we have something we can play
-       m_starttime = KX_GetActiveEngine()->GetFrameTime();
+       m_starttime = -1.f; // We get the start time on our first update
        m_startframe = m_localtime = start;
        m_endframe = end;
        m_blendin = blendin;
@@ -338,6 +338,11 @@ void BL_Action::Update(float curtime)
 
        curtime -= KX_KetsjiEngine::GetSuspendedDelta();
 
+       // Grab the start time here so we don't end up with a negative m_localtime when
+       // suspending and resuming scenes.
+       if (m_starttime < 0)
+               m_starttime = curtime;
+
        if (m_calc_localtime)
                SetLocalTime(curtime);
        else
index 79898cdc0d4f20e242fca1070cb7501677de4085..5d28bf47401e52bf5de5055e2b0e990fec5e766e 100644 (file)
@@ -451,6 +451,11 @@ bool       CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
                } else
                {
                        m_dynamicsWorld->removeCollisionObject(ctrl->GetCollisionObject());
+
+                       if (ctrl->GetCharacterController())
+                       {
+                               m_dynamicsWorld->removeAction(ctrl->GetCharacterController());
+                       }
                }
        }
        if (ctrl->m_registerCount != 0)