Partial revert '#if 0' cleanup
authorCampbell Barton <ideasman42@gmail.com>
Thu, 18 Oct 2018 22:07:40 +0000 (09:07 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 18 Oct 2018 22:18:22 +0000 (09:18 +1100)
Partially revert 41216d5ad4c722e2ad9f15c968af454fc7566d5e

Some of this code had comments to be left as is for readability,
or comment the code should be kept.
Other functions were only for debugging.

12 files changed:
source/blender/blenkernel/intern/mask_rasterize.c
source/blender/blenkernel/intern/mesh_evaluate.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/particle_child.c
source/blender/blenkernel/intern/pbvh_bmesh.c
source/blender/blenkernel/intern/seqmodifier.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/text.c
source/blender/blenlib/intern/BLI_heap.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_interp.c

index fc1412c1baab1f49956d62fae4160f5cabe64eba..ecdd30edc36595a7e228242f9a7a369878245a3b 100644 (file)
@@ -1200,6 +1200,17 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mas
 /* functions that run inside the sampling thread (keep fast!)            */
 /* --------------------------------------------------------------------- */
 
+/* 2D ray test */
+#if 0
+static float maskrasterize_layer_z_depth_tri(const float pt[2],
+                                             const float v1[3], const float v2[3], const float v3[3])
+{
+       float w[3];
+       barycentric_weights_v2(v1, v2, v3, pt, w);
+       return (v1[2] * w[0]) + (v2[2] * w[1]) + (v3[2] * w[2]);
+}
+#endif
+
 static float maskrasterize_layer_z_depth_quad(const float pt[2],
                                               const float v1[3], const float v2[3], const float v3[3], const float v4[3])
 {
@@ -1214,10 +1225,24 @@ static float maskrasterize_layer_isect(unsigned int *face, float (*cos)[3], cons
        /* we always cast from same place only need xy */
        if (face[3] == TRI_VERT) {
                /* --- tri --- */
+
+#if 0
+               /* not essential but avoids unneeded extra lookups */
+               if ((cos[0][2] < dist_orig) ||
+                   (cos[1][2] < dist_orig) ||
+                   (cos[2][2] < dist_orig))
+               {
+                       if (isect_point_tri_v2_cw(xy, cos[face[0]], cos[face[1]], cos[face[2]])) {
+                               /* we know all tris are close for now */
+                               return maskrasterize_layer_z_depth_tri(xy, cos[face[0]], cos[face[1]], cos[face[2]]);
+                       }
+               }
+#else
                /* we know all tris are close for now */
                if (isect_point_tri_v2_cw(xy, cos[face[0]], cos[face[1]], cos[face[2]])) {
                        return 0.0f;
                }
+#endif
        }
        else {
                /* --- quad --- */
index e40336cd4bd959d500e9a9a4b330ebe26ec5f74f..fd117734aaf00f8de452cca00684fd4c0b9ecd0c 100644 (file)
@@ -982,6 +982,10 @@ static void split_loop_nor_single_do(LoopSplitTaskDataCommon *common_data, LoopS
        const MLoop *ml_curr = data->ml_curr;
        const MLoop *ml_prev = data->ml_prev;
        const int ml_curr_index = data->ml_curr_index;
+#if 0  /* Not needed for 'single' loop. */
+       const int ml_prev_index = data->ml_prev_index;
+       const int *e2l_prev = data->e2l_prev;
+#endif
        const int mp_index = data->mp_index;
 
        /* Simple case (both edges around that vertex are sharp in current polygon),
@@ -1032,6 +1036,9 @@ static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data, LoopSpli
        const float (*polynors)[3] = common_data->polynors;
 
        MLoopNorSpace *lnor_space = data->lnor_space;
+#if 0  /* Not needed for 'fan' loops. */
+       float (*lnor)[3] = data->lnor;
+#endif
        const MLoop *ml_curr = data->ml_curr;
        const MLoop *ml_prev = data->ml_prev;
        const int ml_curr_index = data->ml_curr_index;
@@ -1416,6 +1423,10 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
                                        data->ml_curr = ml_curr;
                                        data->ml_prev = ml_prev;
                                        data->ml_curr_index = ml_curr_index;
+#if 0  /* Not needed for 'single' loop. */
+                                       data->ml_prev_index = ml_prev_index;
+                                       data->e2l_prev = NULL;  /* Tag as 'single' task. */
+#endif
                                        data->mp_index = mp_index;
                                        if (lnors_spacearr) {
                                                data->lnor_space = BKE_lnor_space_create(lnors_spacearr);
@@ -1430,6 +1441,9 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
                                 * All this due/thanks to link between normals and loop ordering (i.e. winding).
                                 */
                                else {
+#if 0  /* Not needed for 'fan' loops. */
+                                       data->lnor = lnors;
+#endif
                                        data->ml_curr = ml_curr;
                                        data->ml_prev = ml_prev;
                                        data->ml_curr_index = ml_curr_index;
index 8f5354a501c10f929f42516fd55783ae038759eb..2aa3b3f79a3ea87a8b95363938a113a5f7ffe99c 100644 (file)
@@ -2373,6 +2373,19 @@ int mdisp_rot_face_to_crn(struct MVert *UNUSED(mvert), struct MPoly *mpoly, stru
                 * the barycentric coordinates and finally find the closest vertex
                 * should work reliably for convex cases only but better than nothing */
 
+#if 0
+               int minS, i;
+               float mindist = FLT_MAX;
+
+               for (i = 0; i < mpoly->totloop; i++) {
+                       float len = len_v3v3(NULL, mvert[mloop[mpoly->loopstart + i].v].co);
+                       if (len < mindist) {
+                               mindist = len;
+                               minS = i;
+                       }
+               }
+               S = minS;
+#endif
                /* temp not implemented yet and also not working properly in current master.
                 * (was worked around by subdividing once) */
                S = 0;
index 339c8533e516505f92636fcd54a15d48870d72c2..0cba5f5a2fca723ffeb433fd2bbe9584aa4cc76c 100644 (file)
@@ -299,6 +299,8 @@ void psys_apply_child_modifiers(ParticleThreadContext *ctx, struct ListBase *mod
        int totkeys, k;
        float max_length;
 
+       /* TODO for the future: use true particle modifiers that work on the whole curve */
+
        (void)modifiers;
        (void)mod;
 
index b58a35e98419411ef1fb8653886d4f3ffdd01110..e32a5d0681e0419da1e0b425b817b5edd1ce6ce8 100644 (file)
@@ -413,6 +413,45 @@ static bool pbvh_bmesh_node_limit_ensure(PBVH *bvh, int node_index)
 
 /**********************************************************************/
 
+#if 0
+static int pbvh_bmesh_node_offset_from_elem(PBVH *bvh, BMElem *ele)
+{
+       switch (ele->head.htype) {
+               case BM_VERT:
+                       return bvh->cd_vert_node_offset;
+               default:
+                       BLI_assert(ele->head.htype == BM_FACE);
+                       return bvh->cd_face_node_offset;
+       }
+
+}
+
+static int pbvh_bmesh_node_index_from_elem(PBVH *bvh, void *key)
+{
+       const int cd_node_offset = pbvh_bmesh_node_offset_from_elem(bvh, key);
+       const int node_index = BM_ELEM_CD_GET_INT((BMElem *)key, cd_node_offset);
+
+       BLI_assert(node_index != DYNTOPO_NODE_NONE);
+       BLI_assert(node_index < bvh->totnode);
+       (void)bvh;
+
+       return node_index;
+}
+
+static PBVHNode *pbvh_bmesh_node_from_elem(PBVH *bvh, void *key)
+{
+       return &bvh->nodes[pbvh_bmesh_node_index_from_elem(bvh, key)];
+}
+
+/* typecheck */
+#define pbvh_bmesh_node_index_from_elem(bvh, key) ( \
+       CHECK_TYPE_ANY(key, BMFace *, BMVert *), \
+       pbvh_bmesh_node_index_from_elem(bvh, key))
+#define pbvh_bmesh_node_from_elem(bvh, key) ( \
+       CHECK_TYPE_ANY(key, BMFace *, BMVert *), \
+       pbvh_bmesh_node_from_elem(bvh, key))
+#endif
+
 BLI_INLINE int pbvh_bmesh_node_index_from_vert(PBVH *bvh, const BMVert *key)
 {
        const int node_index = BM_ELEM_CD_GET_INT((const BMElem *)key, bvh->cd_vert_node_offset);
@@ -496,6 +535,25 @@ static BMFace *pbvh_bmesh_face_create(
        return f;
 }
 
+/* Return the number of faces in 'node' that use vertex 'v' */
+#if 0
+static int pbvh_bmesh_node_vert_use_count(PBVH *bvh, PBVHNode *node, BMVert *v)
+{
+       BMFace *f;
+       int count = 0;
+
+       BM_FACES_OF_VERT_ITER_BEGIN(f, v) {
+               PBVHNode *f_node = pbvh_bmesh_node_from_face(bvh, f);
+               if (f_node == node) {
+                       count++;
+               }
+       }
+       BM_FACES_OF_VERT_ITER_END;
+
+       return count;
+}
+#endif
+
 #define pbvh_bmesh_node_vert_use_count_is_equal(bvh, node, v, n) \
        (pbvh_bmesh_node_vert_use_count_at_most(bvh, node, v, (n) + 1) == n)
 
@@ -1197,7 +1255,12 @@ static bool pbvh_bmesh_subdivide_long_edges(
 
                /* At the moment edges never get shorter (subdiv will make new edges)
                 * unlike collapse where edges can become longer. */
+#if 0
+               if (len_squared_v3v3(v1->co, v2->co) <= eq_ctx->q->limit_len_squared)
+                       continue;
+#else
                BLI_assert(len_squared_v3v3(v1->co, v2->co) > eq_ctx->q->limit_len_squared);
+#endif
 
                /* Check that the edge's vertices are still in the PBVH. It's
                 * possible that an edge collapse has deleted adjacent faces
@@ -1273,12 +1336,25 @@ static void pbvh_bmesh_collapse_edge(
                /* Get vertices, replace use of v_del with v_conn */
                // BM_iter_as_array(NULL, BM_VERTS_OF_FACE, f, (void **)v_tri, 3);
                BMFace *f = l->f;
+#if 0
+               BMVert *v_tri[3];
+               BM_face_as_array_vert_tri(f, v_tri);
+               for (int i = 0; i < 3; i++) {
+                       if (v_tri[i] == v_del) {
+                               v_tri[i] = v_conn;
+                       }
+               }
+#endif
 
                /* Check if a face using these vertices already exists. If so,
                 * skip adding this face and mark the existing one for
                 * deletion as well. Prevents extraneous "flaps" from being
                 * created. */
+#if 0
+               if (UNLIKELY(existing_face = BM_face_exists(v_tri, 3)))
+#else
                if (UNLIKELY(existing_face = bm_face_exists_tri_from_loop_vert(l->next, v_conn)))
+#endif
                {
                        BLI_buffer_append(deleted_faces, BMFace *, existing_face);
                }
@@ -1967,7 +2043,17 @@ void BKE_pbvh_bmesh_node_save_orig(PBVHNode *node)
                if (BM_elem_flag_test(f, BM_ELEM_HIDDEN))
                        continue;
 
+#if 0
+               BMIter bm_iter;
+               BMVert *v;
+               int j = 0;
+               BM_ITER_ELEM (v, &bm_iter, f, BM_VERTS_OF_FACE) {
+                       node->bm_ortri[i][j] = BM_elem_index_get(v);
+                       j++;
+               }
+#else
                bm_face_as_array_index_tri(f, node->bm_ortri[i]);
+#endif
                i++;
        }
        node->bm_tot_ortri = i;
@@ -2190,6 +2276,24 @@ static void pbvh_bmesh_verify(PBVH *bvh)
                }
        }
 
+#if 0
+       /* check that every vert belongs somewhere */
+       /* Slow */
+       BM_ITER_MESH (vi, &iter, bvh->bm, BM_VERTS_OF_MESH) {
+               bool has_unique = false;
+               for (int i = 0; i < bvh->totnode; i++) {
+                       PBVHNode *n = &bvh->nodes[i];
+                       if ((n->bm_unique_verts != NULL) && BLI_gset_haskey(n->bm_unique_verts, vi))
+                               has_unique = true;
+               }
+               BLI_assert(has_unique);
+               vert_count++;
+       }
+
+       /* if totvert differs from number of verts inside the hash. hash-totvert is checked above  */
+       BLI_assert(vert_count == bvh->bm->totvert);
+#endif
+
        /* Check that node elements are recorded in the top level */
        for (int i = 0; i < bvh->totnode; i++) {
                PBVHNode *n = &bvh->nodes[i];
index 70d24718e5a36ef63b05af4145c3285babb994fc..4a483d439e45f580cc2f6edab99086d3e5b476fc 100644 (file)
@@ -212,11 +212,14 @@ static void whiteBalance_apply_threaded(int width, int height, unsigned char *re
                        }
 
                        copy_v4_v4(result, rgba);
-
+#if 0
+                       mul_v3_v3(result, multiplier);
+#else
                        /* similar to division without the clipping */
                        for (int i = 0; i < 3; i++) {
                                result[i] = 1.0f - powf(1.0f - rgba[i], multiplier[i]);
                        }
+#endif
 
                        if (mask_rect_float) {
                                copy_v3_v3(mask, mask_rect_float + pixel_index);
index 416e0ad59c16efcf3de53bec4837e8c6431fdeb6..0d506effae6709b46efb5c2e5f32621cb68180e2 100644 (file)
@@ -120,6 +120,19 @@ ListBase seqbase_clipboard;
 int seqbase_clipboard_frame;
 SequencerDrawView sequencer_view3d_cb = NULL; /* NULL in background mode */
 
+#if 0  /* unused function */
+static void printf_strip(Sequence *seq)
+{
+       fprintf(stderr, "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), "
+               "(startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
+               seq->name, seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->machine,
+               seq->startdisp, seq->enddisp);
+
+       fprintf(stderr, "\tseq_tx_set_final_left: %d %d\n\n", seq_tx_get_final_left(seq, 0),
+               seq_tx_get_final_right(seq, 0));
+}
+#endif
+
 static void sequencer_state_init(SeqRenderState *state)
 {
        state->scene_parents = NULL;
@@ -3732,6 +3745,14 @@ static ImBuf *seq_render_strip_stack(
                return NULL;
        }
 
+#if 0 /* commentind since this breaks keyframing, since it resets the value on draw */
+       if (scene->r.cfra != cfra) {
+               /* XXX for prefetch and overlay offset!..., very bad!!! */
+               AnimData *adt = BKE_animdata_from_id(&scene->id);
+               BKE_animsys_evaluate_animdata(scene, &scene->id, adt, cfra, ADT_RECALC_ANIM);
+       }
+#endif
+
        out = BKE_sequencer_cache_get(context, seq_arr[count - 1],  cfra, SEQ_STRIPELEM_IBUF_COMP);
 
        if (out) {
@@ -4350,6 +4371,16 @@ void BKE_sequence_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
                        if (BKE_sequence_tx_get_final_left(seq, false) >= seq_tx_get_end(seq)) {
                                BKE_sequence_tx_set_final_left(seq, seq_tx_get_end(seq) - 1);
                        }
+
+                       /* dosnt work now - TODO */
+#if 0
+                       if (seq_tx_get_start(seq) >= seq_tx_get_final_right(seq, 0)) {
+                               int ofs;
+                               ofs = seq_tx_get_start(seq) - seq_tx_get_final_right(seq, 0);
+                               seq->start -= ofs;
+                               seq_tx_set_final_left(seq, seq_tx_get_final_left(seq, 0) + ofs);
+                       }
+#endif
                }
        }
 
index e4ea839770a6fe4dafb18feb8600318dda0e528e..e3bd6f9860fcf4b8b0478d6ce91f2feceaf3efd7 100644 (file)
@@ -972,6 +972,9 @@ static int sb_detect_aabb_collisionCached(float UNUSED(force[3]), struct Object
        GHashIterator *ihash;
        float  aabbmin[3], aabbmax[3];
        int deflected=0;
+#if 0
+       int a;
+#endif
 
        if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
        copy_v3_v3(aabbmin, sb->scratch->aabbmin);
@@ -1804,6 +1807,45 @@ static int sb_deflect_face(Object *ob, float *actpos, float *facenormal, float *
        return(deflected);
 }
 
+/* hiding this for now .. but the jacobian may pop up on other tasks .. so i'd like to keep it */
+#if 0
+static void dfdx_spring(int ia, int ic, int op, float dir[3], float L, float len, float factor)
+{
+       float m, delta_ij;
+       int i, j;
+       if (L < len) {
+               for (i=0;i<3;i++) {
+                       for (j=0;j<3;j++) {
+                               delta_ij = (i==j ? (1.0f): (0.0f));
+                               m=factor*(dir[i]*dir[j] + (1-L/len)*(delta_ij - dir[i]*dir[j]));
+                               EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
+                       }
+               }
+       }
+       else {
+               for (i=0;i<3;i++) {
+                       for (j=0;j<3;j++) {
+                               m=factor*dir[i]*dir[j];
+                               EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
+                       }
+               }
+       }
+}
+
+
+static void dfdx_goal(int ia, int ic, int op, float factor)
+{
+       int i;
+       for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, op+ic+i, factor);
+}
+
+static void dfdv_goal(int ia, int ic, float factor)
+{
+       int i;
+       for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, ic+i, factor);
+}
+#endif  /* if 0 */
+
 static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, float UNUSED(forcetime))
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -1811,15 +1853,25 @@ static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, floa
 
        float dir[3], dvel[3];
        float distance, forcefactor, kd, absvel, projvel, kw;
-
+#if 0  /* UNUSED */
+       int ia, ic;
+#endif
        /* prepare depending on which side of the spring we are on */
        if (bpi == bs->v1) {
                bp1 = &sb->bpoint[bs->v1];
                bp2 = &sb->bpoint[bs->v2];
+#if 0  /* UNUSED */
+               ia =3*bs->v1;
+               ic =3*bs->v2;
+#endif
        }
        else if (bpi == bs->v2) {
                bp1 = &sb->bpoint[bs->v2];
                bp2 = &sb->bpoint[bs->v1];
+#if 0  /* UNUSED */
+               ia =3*bs->v2;
+               ic =3*bs->v1;
+#endif
        }
        else {
                /* TODO make this debug option */
@@ -2444,6 +2496,13 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
        aabbmin[0]=aabbmin[1]=aabbmin[2] = 1e20f;
        aabbmax[0]=aabbmax[1]=aabbmax[2] = -1e20f;
 
+       /* old one with homogeneous masses  */
+       /* claim a minimum mass for vertex */
+#if 0
+       if (sb->nodemass > 0.009999f) timeovermass = forcetime / sb->nodemass;
+       else timeovermass = forcetime / 0.009999f;
+#endif
+
        for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
 /* now we have individual masses   */
 /* claim a minimum mass for vertex */
@@ -2488,6 +2547,16 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
                        /* x(t + dt) = x(t) + v(t~) * dt */
                        mul_v3_fl(dx, forcetime);
 
+                       /* the freezer coming sooner or later */
+#if 0
+                       if ((dot_v3v3(dx, dx)<freezeloc )&&(dot_v3v3(bp->force, bp->force)<freezeforce )) {
+                               bp->frozen /=2;
+                       }
+                       else {
+                               bp->frozen = min_ff(bp->frozen*1.05f, 1.0f);
+                       }
+                       mul_v3_fl(dx, bp->frozen);
+#endif
                        /* again some nasty if's to have heun in here too */
                        if (mode ==1) {
                                copy_v3_v3(bp->prevpos, bp->pos);
@@ -2552,6 +2621,81 @@ static void softbody_restore_prev_step(Object *ob)
        }
 }
 
+#if 0
+static void softbody_store_step(Object *ob)
+{
+       SoftBody *sb= ob->soft; /* is supposed to be there*/
+       BodyPoint *bp;
+       int a;
+
+       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+               copy_v3_v3(bp->prevvec, bp->vec);
+               copy_v3_v3(bp->prevpos, bp->pos);
+       }
+}
+
+
+/* used by predictors and correctors */
+static void softbody_store_state(Object *ob, float *ppos, float *pvel)
+{
+       SoftBody *sb= ob->soft; /* is supposed to be there*/
+       BodyPoint *bp;
+       int a;
+       float *pp=ppos, *pv=pvel;
+
+       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+
+               copy_v3_v3(pv, bp->vec);
+               pv+=3;
+
+               copy_v3_v3(pp, bp->pos);
+               pp+=3;
+       }
+}
+
+/* used by predictors and correctors */
+static void softbody_retrieve_state(Object *ob, float *ppos, float *pvel)
+{
+       SoftBody *sb= ob->soft; /* is supposed to be there*/
+       BodyPoint *bp;
+       int a;
+       float *pp=ppos, *pv=pvel;
+
+       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+
+               copy_v3_v3(bp->vec, pv);
+               pv+=3;
+
+               copy_v3_v3(bp->pos, pp);
+               pp+=3;
+       }
+}
+
+/* used by predictors and correctors */
+static void softbody_swap_state(Object *ob, float *ppos, float *pvel)
+{
+       SoftBody *sb= ob->soft; /* is supposed to be there*/
+       BodyPoint *bp;
+       int a;
+       float *pp=ppos, *pv=pvel;
+       float temp[3];
+
+       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+
+               copy_v3_v3(temp, bp->vec);
+               copy_v3_v3(bp->vec, pv);
+               copy_v3_v3(pv, temp);
+               pv+=3;
+
+               copy_v3_v3(temp, bp->pos);
+               copy_v3_v3(bp->pos, pp);
+               copy_v3_v3(pp, temp);
+               pp+=3;
+       }
+}
+#endif
+
+
 /* care for bodypoints taken out of the 'ordinary' solver step
  * because they are screwed to goal by bolts
  * they just need to move along with the goal in time
index 5dc8d6133ebecd3c5d63a10b4c7548c32d9d0b94..d512c4ac78ecbbf5bde1fee1ae373ef7b2043aa5 100644 (file)
@@ -1472,6 +1472,178 @@ static void txt_undo_end(Text *UNUSED(text), TextUndoBuf *utxt)
        utxt->buf[undo_pos_end] = '\0';
 }
 
+/* Call once undo is done. */
+#ifndef NDEBUG
+
+#endif
+
+#if 0  /* UNUSED */
+static void dump_buffer(TextUndoBuf *utxt)
+{
+       int i = 0;
+
+       while (i++ < utxt->undo_pos) printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]);
+}
+
+/* Note: this function is outdated and must be updated if needed for future use */
+void txt_print_undo(Text *text)
+{
+       int i = 0;
+       int op;
+       const char *ops;
+       int linep, charp;
+
+       dump_buffer(text);
+
+       printf("---< Undo Buffer >---\n");
+
+       printf("UndoPosition is %d\n", utxt->pos);
+
+       while (i <= utxt->pos) {
+               op = utxt->buf[i];
+
+               if (op == UNDO_INSERT_1) {
+                       ops = "Insert ascii ";
+               }
+               else if (op == UNDO_INSERT_2) {
+                       ops = "Insert 2 bytes ";
+               }
+               else if (op == UNDO_INSERT_3) {
+                       ops = "Insert 3 bytes ";
+               }
+               else if (op == UNDO_INSERT_4) {
+                       ops = "Insert unicode ";
+               }
+               else if (op == UNDO_BS_1) {
+                       ops = "Backspace for ascii ";
+               }
+               else if (op == UNDO_BS_2) {
+                       ops = "Backspace for 2 bytes ";
+               }
+               else if (op == UNDO_BS_3) {
+                       ops = "Backspace for 3 bytes ";
+               }
+               else if (op == UNDO_BS_4) {
+                       ops = "Backspace for unicode ";
+               }
+               else if (op == UNDO_DEL_1) {
+                       ops = "Delete ascii ";
+               }
+               else if (op == UNDO_DEL_2) {
+                       ops = "Delete 2 bytes ";
+               }
+               else if (op == UNDO_DEL_3) {
+                       ops = "Delete 3 bytes ";
+               }
+               else if (op == UNDO_DEL_4) {
+                       ops = "Delete unicode ";
+               }
+               else if (op == UNDO_DBLOCK) {
+                       ops = "Delete text block";
+               }
+               else if (op == UNDO_IBLOCK) {
+                       ops = "Insert text block";
+               }
+               else if (op == UNDO_INDENT) {
+                       ops = "Indent ";
+               }
+               else if (op == UNDO_UNINDENT) {
+                       ops = "Unindent ";
+               }
+               else if (op == UNDO_COMMENT) {
+                       ops = "Comment ";
+               }
+               else if (op == UNDO_UNCOMMENT) {
+                       ops = "Uncomment ";
+               }
+               else {
+                       ops = "Unknown";
+               }
+
+               printf("Op (%o) at %d = %s", op, i, ops);
+               if (op >= UNDO_INSERT_1 && op <= UNDO_DEL_4) {
+                       i++;
+                       printf(" - Char is ");
+                       switch (op) {
+                               case UNDO_INSERT_1: case UNDO_BS_1: case UNDO_DEL_1:
+                                       printf("%c", utxt->buf[i]);
+                                       i++;
+                                       break;
+                               case UNDO_INSERT_2: case UNDO_BS_2: case UNDO_DEL_2:
+                                       printf("%c%c", utxt->buf[i], utxt->buf[i + 1]);
+                                       i += 2;
+                                       break;
+                               case UNDO_INSERT_3: case UNDO_BS_3: case UNDO_DEL_3:
+                                       printf("%c%c%c", utxt->buf[i], utxt->buf[i + 1], utxt->buf[i + 2]);
+                                       i += 3;
+                                       break;
+                               case UNDO_INSERT_4: case UNDO_BS_4: case UNDO_DEL_4:
+                               {
+                                       unsigned int uc;
+                                       char c[BLI_UTF8_MAX + 1];
+                                       size_t c_len;
+                                       uc = utxt->buf[i]; i++;
+                                       uc = uc + (utxt->buf[i] << 8); i++;
+                                       uc = uc + (utxt->buf[i] << 16); i++;
+                                       uc = uc + (utxt->buf[i] << 24); i++;
+                                       c_len = BLI_str_utf8_from_unicode(uc, c);
+                                       c[c_len] = '\0';
+                                       puts(c);
+                                       break;
+                               }
+                       }
+               }
+               else if (op == UNDO_DBLOCK || op == UNDO_IBLOCK) {
+                       i++;
+
+                       linep = utxt->buf[i]; i++;
+                       linep = linep + (utxt->buf[i] << 8); i++;
+                       linep = linep + (utxt->buf[i] << 16); i++;
+                       linep = linep + (utxt->buf[i] << 24); i++;
+
+                       printf(" (length %d) <", linep);
+
+                       while (linep > 0) {
+                               putchar(utxt->buf[i]);
+                               linep--; i++;
+                       }
+
+                       linep = utxt->buf[i]; i++;
+                       linep = linep + (utxt->buf[i] << 8); i++;
+                       linep = linep + (utxt->buf[i] << 16); i++;
+                       linep = linep + (utxt->buf[i] << 24); i++;
+                       printf("> (%d)", linep);
+               }
+               else if (op == UNDO_INDENT || op == UNDO_UNINDENT) {
+                       i++;
+
+                       charp = utxt->buf[i]; i++;
+                       charp = charp + (utxt->buf[i] << 8); i++;
+
+                       linep = utxt->buf[i]; i++;
+                       linep = linep + (utxt->buf[i] << 8); i++;
+                       linep = linep + (utxt->buf[i] << 16); i++;
+                       linep = linep + (utxt->buf[i] << 24); i++;
+
+                       printf("to <%d, %d> ", linep, charp);
+
+                       charp = utxt->buf[i]; i++;
+                       charp = charp + (utxt->buf[i] << 8); i++;
+
+                       linep = utxt->buf[i]; i++;
+                       linep = linep + (utxt->buf[i] << 8); i++;
+                       linep = linep + (utxt->buf[i] << 16); i++;
+                       linep = linep + (utxt->buf[i] << 24); i++;
+
+                       printf("from <%d, %d>", linep, charp);
+               }
+
+               printf(" %d\n",  i);
+               i++;
+       }
+}
+#endif
+
 static void txt_undo_store_uint16(char *undo_buf, int *undo_pos, unsigned short value)
 {
        undo_buf[*undo_pos] = (value) & 0xff;
index 97605640be408b0ff4e06fd1543813ac26b59c0b..5658c1fd1037aa5546ae90f22be4e35c89d6bf65 100644 (file)
@@ -87,6 +87,11 @@ struct Heap {
 
 BLI_INLINE void heap_swap(Heap *heap, const uint i, const uint j)
 {
+
+#if 0
+       SWAP(uint,  heap->tree[i]->index, heap->tree[j]->index);
+       SWAP(HeapNode *,    heap->tree[i],        heap->tree[j]);
+#else
        HeapNode **tree = heap->tree;
        union {
                uint  index;
@@ -94,6 +99,7 @@ BLI_INLINE void heap_swap(Heap *heap, const uint i, const uint j)
        } tmp;
        SWAP_TVAL(tmp.index, tree[i]->index, tree[j]->index);
        SWAP_TVAL(tmp.node,  tree[i],        tree[j]);
+#endif
 }
 
 static void heap_down(Heap *heap, uint i)
index d59d7b4fe6ad0470616711a1c3eed87ea5d00fba..eae82ff2f4f4111309eb26c12f072d3d787f6f53 100644 (file)
@@ -534,11 +534,19 @@ float dist_signed_squared_to_corner_v3v3v3(
        cross_v3_v3v3(plane_a, dir_a, axis);
        cross_v3_v3v3(plane_b, axis, dir_b);
 
+#if 0
+       plane_from_point_normal_v3(plane_a, v2, plane_a);
+       plane_from_point_normal_v3(plane_b, v2, plane_b);
+
+       dist_a = dist_signed_squared_to_plane_v3(p, plane_a);
+       dist_b = dist_signed_squared_to_plane_v3(p, plane_b);
+#else
        /* calculate without the planes 4th component to avoid float precision issues */
        sub_v3_v3v3(s_p_v2, p, v2);
 
        dist_a = dist_signed_squared_to_plane3_v3(s_p_v2, plane_a);
        dist_b = dist_signed_squared_to_plane3_v3(s_p_v2, plane_b);
+#endif
 
        if (flip) {
                return min_ff(dist_a, dist_b);
index 71da270e1f2220af307c37ee1307b083568c240b..b93a7f55821e76f6e0d45a700456975108ad85d7 100644 (file)
@@ -57,6 +57,19 @@ static float P(float k)
        return (float)(1.0f / 6.0f) * (p1 * p1 * p1 - 4.0f * p2 * p2 * p2 + 6.0f * p3 * p3 * p3 - 4.0f * p4 * p4 * p4);
 }
 
+
+#if 0
+/* older, slower function, works the same as above */
+static float P(float k)
+{
+       return (float)(1.0f / 6.0f) *
+               (pow(MAX2(k + 2.0f, 0), 3.0f) - 4.0f *
+                pow(MAX2(k + 1.0f, 0), 3.0f) + 6.0f *
+                pow(MAX2(k, 0), 3.0f) - 4.0f *
+                pow(MAX2(k - 1.0f, 0), 3.0f));
+}
+#endif
+
 static void vector_from_float(const float *data, float vector[4], int components)
 {
        if (components == 1) {
@@ -166,6 +179,45 @@ BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const fl
 
 /* Done with optimized part */
 
+#if 0
+       /* older, slower function, works the same as above */
+       for (n = -1; n <= 2; n++) {
+               for (m = -1; m <= 2; m++) {
+                       x1 = i + n;
+                       y1 = j + m;
+                       if (x1 > 0 && x1 < width && y1 > 0 && y1 < height) {
+                               float data[4];
+
+                               if (float_output) {
+                                       const float *float_data = float_buffer + width * y1 * components + components * x1;
+
+                                       vector_from_float(float_data, data, components);
+                               }
+                               else {
+                                       const unsigned char *byte_data = byte_buffer + width * y1 * components + components * x1;
+
+                                       vector_from_byte(byte_data, data, components);
+                               }
+
+                               if (components == 1) {
+                                       out[0] += data[0] * P(n - a) * P(b - m);
+                               }
+                               else if (components == 3) {
+                                       out[0] += data[0] * P(n - a) * P(b - m);
+                                       out[1] += data[1] * P(n - a) * P(b - m);
+                                       out[2] += data[2] * P(n - a) * P(b - m);
+                               }
+                               else {
+                                       out[0] += data[0] * P(n - a) * P(b - m);
+                                       out[1] += data[1] * P(n - a) * P(b - m);
+                                       out[2] += data[2] * P(n - a) * P(b - m);
+                                       out[3] += data[3] * P(n - a) * P(b - m);
+                               }
+                       }
+               }
+       }
+#endif
+
        if (float_output) {
                if (components == 1) {
                        float_output[0] = out[0];