Fix #30064: Image editor: paint on image, rename image, undo -> crash
[blender.git] / source / blender / editors / sculpt_paint / paint_image.c
1 /*
2  * imagepaint.c
3  *
4  * Functions to paint images in 2D and 3D.
5  * 
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20  *
21  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
22  * All rights reserved.
23  *
24  * The Original Code is: some of this file.
25  *
26  * Contributor(s): Jens Ole Wund (bjornmose), Campbell Barton (ideasman42)
27  *
28  * ***** END GPL LICENSE BLOCK *****
29  */
30
31 /** \file blender/editors/sculpt_paint/paint_image.c
32  *  \ingroup edsculpt
33  */
34
35
36 #include <float.h>
37 #include <string.h>
38 #include <stdio.h>
39 #include <math.h>
40
41 #include "MEM_guardedalloc.h"
42
43 #ifdef WIN32
44 #include "BLI_winstuff.h"
45 #endif
46 #include "BLI_math.h"
47 #include "BLI_blenlib.h"
48 #include "BLI_dynstr.h"
49 #include "BLI_linklist.h"
50 #include "BLI_memarena.h"
51 #include "BLI_threads.h"
52 #include "BLI_utildefines.h"
53 #include "BLI_editVert.h"
54
55 #include "PIL_time.h"
56
57 #include "IMB_imbuf.h"
58 #include "IMB_imbuf_types.h"
59
60 #include "DNA_brush_types.h"
61 #include "DNA_camera_types.h"
62 #include "DNA_mesh_types.h"
63 #include "DNA_meshdata_types.h"
64 #include "DNA_node_types.h"
65 #include "DNA_object_types.h"
66 #include "DNA_scene_types.h"
67 #include "DNA_texture_types.h"
68
69 #include "BKE_camera.h"
70 #include "BKE_context.h"
71 #include "BKE_depsgraph.h"
72 #include "BKE_DerivedMesh.h"
73 #include "BKE_idprop.h"
74 #include "BKE_brush.h"
75 #include "BKE_image.h"
76 #include "BKE_library.h"
77 #include "BKE_main.h"
78 #include "BKE_mesh.h"
79 #include "BKE_node.h"
80 #include "BKE_object.h"
81 #include "BKE_paint.h"
82 #include "BKE_report.h"
83 #include "BKE_scene.h"
84 #include "BKE_global.h"
85 #include "BKE_deform.h"
86
87 #include "BIF_gl.h"
88 #include "BIF_glutil.h"
89
90 #include "UI_view2d.h"
91
92 #include "ED_image.h"
93 #include "ED_screen.h"
94 #include "ED_sculpt.h"
95 #include "ED_uvedit.h"
96 #include "ED_view3d.h"
97 #include "ED_mesh.h"
98
99 #include "WM_api.h"
100 #include "WM_types.h"
101
102 #include "RNA_access.h"
103 #include "RNA_define.h"
104 #include "RNA_enum_types.h"
105
106 #include "GPU_draw.h"
107 #include "GPU_extensions.h"
108
109 #include "paint_intern.h"
110
111 /* Defines and Structs */
112
113 #define IMAPAINT_CHAR_TO_FLOAT(c) ((c)/255.0f)
114
115 #define IMAPAINT_FLOAT_RGB_TO_CHAR(c, f)  {                                   \
116         (c)[0]= FTOCHAR((f)[0]);                                                  \
117         (c)[1]= FTOCHAR((f)[1]);                                                  \
118         (c)[2]= FTOCHAR((f)[2]);                                                  \
119 }
120 #define IMAPAINT_FLOAT_RGBA_TO_CHAR(c, f)  {                                  \
121         (c)[0]= FTOCHAR((f)[0]);                                                  \
122         (c)[1]= FTOCHAR((f)[1]);                                                  \
123         (c)[2]= FTOCHAR((f)[2]);                                                  \
124         (c)[3]= FTOCHAR((f)[3]);                                                  \
125 }
126 #define IMAPAINT_CHAR_RGB_TO_FLOAT(f, c)  {                                   \
127         (f)[0]= IMAPAINT_CHAR_TO_FLOAT((c)[0]);                                   \
128         (f)[1]= IMAPAINT_CHAR_TO_FLOAT((c)[1]);                                   \
129         (f)[2]= IMAPAINT_CHAR_TO_FLOAT((c)[2]);                                   \
130 }
131 #define IMAPAINT_CHAR_RGBA_TO_FLOAT(f, c)  {                                  \
132         (f)[0]= IMAPAINT_CHAR_TO_FLOAT((c)[0]);                                   \
133         (f)[1]= IMAPAINT_CHAR_TO_FLOAT((c)[1]);                                   \
134         (f)[2]= IMAPAINT_CHAR_TO_FLOAT((c)[2]);                                   \
135         (f)[3]= IMAPAINT_CHAR_TO_FLOAT((c)[3]);                                   \
136 }
137
138 #define IMAPAINT_FLOAT_RGB_COPY(a, b) copy_v3_v3(a, b)
139
140 #define IMAPAINT_TILE_BITS                      6
141 #define IMAPAINT_TILE_SIZE                      (1 << IMAPAINT_TILE_BITS)
142 #define IMAPAINT_TILE_NUMBER(size)      (((size)+IMAPAINT_TILE_SIZE-1) >> IMAPAINT_TILE_BITS)
143
144 static void imapaint_image_update(SpaceImage *sima, Image *image, ImBuf *ibuf, short texpaint);
145
146
147 typedef struct ImagePaintState {
148         SpaceImage *sima;
149         View2D *v2d;
150         Scene *scene;
151         bScreen *screen;
152
153         Brush *brush;
154         short tool, blend;
155         Image *image;
156         ImBuf *canvas;
157         ImBuf *clonecanvas;
158         short clonefreefloat;
159         char *warnpackedfile;
160         char *warnmultifile;
161
162         /* texture paint only */
163         Object *ob;
164         Mesh *me;
165         int faceindex;
166         float uv[2];
167 } ImagePaintState;
168
169 typedef struct ImagePaintPartialRedraw {
170         int x1, y1, x2, y2;
171         int enabled;
172 } ImagePaintPartialRedraw;
173
174 typedef struct ImagePaintRegion {
175         int destx, desty;
176         int srcx, srcy;
177         int width, height;
178 } ImagePaintRegion;
179
180 /* ProjectionPaint defines */
181
182 /* approx the number of buckets to have under the brush,
183  * used with the brush size to set the ps->buckets_x and ps->buckets_y value.
184  * 
185  * When 3 - a brush should have ~9 buckets under it at once
186  * ...this helps for threading while painting as well as
187  * avoiding initializing pixels that wont touch the brush */
188 #define PROJ_BUCKET_BRUSH_DIV 4
189
190 #define PROJ_BUCKET_RECT_MIN 4
191 #define PROJ_BUCKET_RECT_MAX 256
192
193 #define PROJ_BOUNDBOX_DIV 8
194 #define PROJ_BOUNDBOX_SQUARED  (PROJ_BOUNDBOX_DIV * PROJ_BOUNDBOX_DIV)
195
196 //#define PROJ_DEBUG_PAINT 1
197 //#define PROJ_DEBUG_NOSEAMBLEED 1
198 //#define PROJ_DEBUG_PRINT_CLIP 1
199 #define PROJ_DEBUG_WINCLIP 1
200
201 /* projectFaceSeamFlags options */
202 //#define PROJ_FACE_IGNORE      (1<<0)  /* When the face is hidden, backfacing or occluded */
203 //#define PROJ_FACE_INIT        (1<<1)  /* When we have initialized the faces data */
204 #define PROJ_FACE_SEAM1 (1<<0)  /* If this face has a seam on any of its edges */
205 #define PROJ_FACE_SEAM2 (1<<1)
206 #define PROJ_FACE_SEAM3 (1<<2)
207 #define PROJ_FACE_SEAM4 (1<<3)
208
209 #define PROJ_FACE_NOSEAM1       (1<<4)
210 #define PROJ_FACE_NOSEAM2       (1<<5)
211 #define PROJ_FACE_NOSEAM3       (1<<6)
212 #define PROJ_FACE_NOSEAM4       (1<<7)
213
214 #define PROJ_SRC_VIEW           1
215 #define PROJ_SRC_IMAGE_CAM      2
216 #define PROJ_SRC_IMAGE_VIEW     3
217
218 #define PROJ_VIEW_DATA_ID "view_data"
219 #define PROJ_VIEW_DATA_SIZE (4*4 + 4*4 + 3) /* viewmat + winmat + clipsta + clipend + is_ortho */
220
221
222 /* a slightly scaled down face is used to get fake 3D location for edge pixels in the seams
223  * as this number approaches  1.0f the likelihood increases of float precision errors where
224  * it is occluded by an adjacent face */
225 #define PROJ_FACE_SCALE_SEAM    0.99f
226
227 #define PROJ_BUCKET_NULL                0
228 #define PROJ_BUCKET_INIT                (1<<0)
229 // #define PROJ_BUCKET_CLONE_INIT       (1<<1)
230
231 /* used for testing doubles, if a point is on a line etc */
232 #define PROJ_GEOM_TOLERANCE 0.00075f
233
234 /* vert flags */
235 #define PROJ_VERT_CULL 1
236
237 #define PI_80_DEG ((M_PI_2 / 9) * 8)
238
239 /* This is mainly a convenience struct used so we can keep an array of images we use
240  * Thir imbufs, etc, in 1 array, When using threads this array is copied for each thread
241  * because 'partRedrawRect' and 'touch' values would not be thread safe */
242 typedef struct ProjPaintImage {
243         Image *ima;
244         ImBuf *ibuf;
245         ImagePaintPartialRedraw *partRedrawRect;
246         void **undoRect; /* only used to build undo tiles after painting */
247         int touch;
248 } ProjPaintImage;
249
250 /* Main projection painting struct passed to all projection painting functions */
251 typedef struct ProjPaintState {
252         View3D *v3d;
253         RegionView3D *rv3d;
254         ARegion *ar;
255         Scene *scene;
256         int source; /* PROJ_SRC_**** */
257
258         Brush *brush;
259         short tool, blend;
260         Object *ob;
261         /* end similarities with ImagePaintState */
262         
263         DerivedMesh    *dm;
264         int                     dm_totface;
265         int                     dm_totvert;
266         int                             dm_release;
267         
268         MVert              *dm_mvert;
269         MFace              *dm_mface;
270         MTFace             *dm_mtface;
271         MTFace             *dm_mtface_clone;    /* other UV map, use for cloning between layers */
272         MTFace             *dm_mtface_stencil;
273         
274         /* projection painting only */
275         MemArena *arena_mt[BLENDER_MAX_THREADS];/* for multithreading, the first item is sometimes used for non threaded cases too */
276         LinkNode **bucketRect;                          /* screen sized 2D array, each pixel has a linked list of ProjPixel's */
277         LinkNode **bucketFaces;                         /* bucketRect aligned array linkList of faces overlapping each bucket */
278         unsigned char *bucketFlags;                                     /* store if the bucks have been initialized  */
279 #ifndef PROJ_DEBUG_NOSEAMBLEED
280         char *faceSeamFlags;                            /* store info about faces, if they are initialized etc*/
281         float (*faceSeamUVs)[4][2];                     /* expanded UVs for faces to use as seams */
282         LinkNode **vertFaces;                           /* Only needed for when seam_bleed_px is enabled, use to find UV seams */
283 #endif
284         char *vertFlags;                                        /* store options per vert, now only store if the vert is pointing away from the view */
285         int buckets_x;                                          /* The size of the bucket grid, the grid span's screenMin/screenMax so you can paint outsize the screen or with 2 brushes at once */
286         int buckets_y;
287         
288         ProjPaintImage *projImages;
289         
290         int image_tot;                          /* size of projectImages array */
291         
292         float (*screenCoords)[4];       /* verts projected into floating point screen space */
293         
294         float screenMin[2];                     /* 2D bounds for mesh verts on the screen's plane (screenspace) */
295         float screenMax[2]; 
296         float screen_width;                     /* Calculated from screenMin & screenMax */
297         float screen_height;
298         int winx, winy;                         /* from the carea or from the projection render */
299         
300         /* options for projection painting */
301         int do_layer_clone;
302         int do_layer_stencil;
303         int do_layer_stencil_inv;
304         
305         short do_occlude;                       /* Use raytraced occlusion? - ortherwise will paint right through to the back*/
306         short do_backfacecull;  /* ignore faces with normals pointing away, skips a lot of raycasts if your normals are correctly flipped */
307         short do_mask_normal;                   /* mask out pixels based on their normals */
308         short do_new_shading_nodes;     /* cache scene_use_new_shading_nodes value */
309         float normal_angle;                             /* what angle to mask at*/
310         float normal_angle_inner;
311         float normal_angle_range;               /* difference between normal_angle and normal_angle_inner, for easy access */
312         
313         short is_ortho;
314         short is_airbrush;                                      /* only to avoid using (ps.brush->flag & BRUSH_AIRBRUSH) */
315         short is_texbrush;                                      /* only to avoid running  */
316 #ifndef PROJ_DEBUG_NOSEAMBLEED
317         float seam_bleed_px;
318 #endif
319         /* clone vars */
320         float cloneOffset[2];
321         
322         float projectMat[4][4];         /* Projection matrix, use for getting screen coords */
323         float viewDir[3];                       /* View vector, use for do_backfacecull and for ray casting with an ortho viewport  */
324         float viewPos[3];                       /* View location in object relative 3D space, so can compare to verts  */
325         float clipsta, clipend;
326         
327         /* reproject vars */
328         Image *reproject_image;
329         ImBuf *reproject_ibuf;
330
331
332         /* threads */
333         int thread_tot;
334         int bucketMin[2];
335         int bucketMax[2];
336         int context_bucket_x, context_bucket_y; /* must lock threads while accessing these */
337 } ProjPaintState;
338
339 typedef union pixelPointer
340 {
341         float *f_pt;                    /* float buffer */
342         unsigned int *uint_pt; /* 2 ways to access a char buffer */
343         unsigned char *ch_pt;
344 } PixelPointer;
345
346 typedef union pixelStore
347 {
348         unsigned char ch[4];
349         unsigned int uint;
350         float f[4];
351 } PixelStore;
352
353 typedef struct ProjPixel {
354         float projCoSS[2]; /* the floating point screen projection of this pixel */
355         
356         /* Only used when the airbrush is disabled.
357          * Store the max mask value to avoid painting over an area with a lower opacity
358          * with an advantage that we can avoid touching the pixel at all, if the 
359          * new mask value is lower then mask_max */
360         unsigned short mask_max;
361         
362         /* for various reasons we may want to mask out painting onto this pixel */
363         unsigned short mask;
364         
365         short x_px, y_px;
366         
367         PixelStore origColor;
368         PixelStore newColor;
369         PixelPointer pixel;
370         
371         short image_index; /* if anyone wants to paint onto more then 32768 images they can bite me */
372         unsigned char bb_cell_index;
373 } ProjPixel;
374
375 typedef struct ProjPixelClone {
376         struct ProjPixel __pp;
377         PixelStore clonepx;
378 } ProjPixelClone;
379
380 /* Finish projection painting structs */
381
382 typedef struct UndoImageTile {
383         struct UndoImageTile *next, *prev;
384
385         char idname[MAX_ID_NAME];       /* name instead of pointer*/
386         char ibufname[IB_FILENAME_SIZE];
387
388         void *rect;
389         int x, y;
390
391         short source, use_float;
392         char gen_type;
393 } UndoImageTile;
394
395 static ImagePaintPartialRedraw imapaintpartial = {0, 0, 0, 0, 0};
396
397 /* UNDO */
398
399 static void undo_copy_tile(UndoImageTile *tile, ImBuf *tmpibuf, ImBuf *ibuf, int restore)
400 {
401         /* copy or swap contents of tile->rect and region in ibuf->rect */
402         IMB_rectcpy(tmpibuf, ibuf, 0, 0, tile->x*IMAPAINT_TILE_SIZE,
403                 tile->y*IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE);
404
405         if(ibuf->rect_float) {
406                 SWAP(void*, tmpibuf->rect_float, tile->rect);
407         } else {
408                 SWAP(void*, tmpibuf->rect, tile->rect);
409         }
410         
411         if(restore)
412                 IMB_rectcpy(ibuf, tmpibuf, tile->x*IMAPAINT_TILE_SIZE,
413                         tile->y*IMAPAINT_TILE_SIZE, 0, 0, IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE);
414 }
415
416 static void *image_undo_push_tile(Image *ima, ImBuf *ibuf, ImBuf **tmpibuf, int x_tile, int y_tile)
417 {
418         ListBase *lb= undo_paint_push_get_list(UNDO_PAINT_IMAGE);
419         UndoImageTile *tile;
420         int allocsize;
421         short use_float = ibuf->rect_float ? 1 : 0;
422
423         for(tile=lb->first; tile; tile=tile->next)
424                 if(tile->x == x_tile && tile->y == y_tile && ima->gen_type == tile->gen_type && ima->source == tile->source)
425                         if(tile->use_float == use_float)
426                                 if(strcmp(tile->idname, ima->id.name)==0 && strcmp(tile->ibufname, ibuf->name)==0)
427                                         return tile->rect;
428         
429         if (*tmpibuf==NULL)
430                 *tmpibuf = IMB_allocImBuf(IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE, 32, IB_rectfloat|IB_rect);
431         
432         tile= MEM_callocN(sizeof(UndoImageTile), "UndoImageTile");
433         BLI_strncpy(tile->idname, ima->id.name, sizeof(tile->idname));
434         tile->x= x_tile;
435         tile->y= y_tile;
436
437         allocsize= IMAPAINT_TILE_SIZE*IMAPAINT_TILE_SIZE*4;
438         allocsize *= (ibuf->rect_float)? sizeof(float): sizeof(char);
439         tile->rect= MEM_mapallocN(allocsize, "UndeImageTile.rect");
440
441         BLI_strncpy(tile->ibufname, ibuf->name, sizeof(tile->ibufname));
442
443         tile->gen_type= ima->gen_type;
444         tile->source= ima->source;
445         tile->use_float= use_float;
446
447         undo_copy_tile(tile, *tmpibuf, ibuf, 0);
448         undo_paint_push_count_alloc(UNDO_PAINT_IMAGE, allocsize);
449
450         BLI_addtail(lb, tile);
451         
452         return tile->rect;
453 }
454
455 static void image_undo_restore(bContext *C, ListBase *lb)
456 {
457         Main *bmain= CTX_data_main(C);
458         Image *ima = NULL;
459         ImBuf *ibuf, *tmpibuf;
460         UndoImageTile *tile;
461
462         tmpibuf= IMB_allocImBuf(IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE, 32,
463                                                         IB_rectfloat|IB_rect);
464         
465         for(tile=lb->first; tile; tile=tile->next) {
466                 short use_float;
467
468                 /* find image based on name, pointer becomes invalid with global undo */
469                 if(ima && strcmp(tile->idname, ima->id.name)==0) {
470                         /* ima is valid */
471                 }
472                 else {
473                         ima= BLI_findstring(&bmain->image, tile->idname, offsetof(ID, name));
474                 }
475
476                 ibuf= BKE_image_get_ibuf(ima, NULL);
477
478                 if(ima && ibuf && strcmp(tile->ibufname, ibuf->name)!=0) {
479                         /* current ImBuf filename was changed, probably current frame
480                            was changed when paiting on image sequence, rather than storing
481                            full image user (which isn't so obvious, btw) try to find ImBuf with
482                            matched file name in list of already loaded images */
483
484                         ibuf= BLI_findstring(&ima->ibufs, tile->ibufname, offsetof(ImBuf, name));
485                 }
486
487                 if (!ima || !ibuf || !(ibuf->rect || ibuf->rect_float))
488                         continue;
489
490                 if (ima->gen_type != tile->gen_type || ima->source != tile->source)
491                         continue;
492
493                 use_float = ibuf->rect_float ? 1 : 0;
494
495                 if (use_float != tile->use_float)
496                         continue;
497
498                 undo_copy_tile(tile, tmpibuf, ibuf, 1);
499
500                 GPU_free_image(ima); /* force OpenGL reload */
501                 if(ibuf->rect_float)
502                         ibuf->userflags |= IB_RECT_INVALID; /* force recreate of char rect */
503                 if(ibuf->mipmap[0])
504                         ibuf->userflags |= IB_MIPMAP_INVALID; /* force mipmap recreatiom */
505
506         }
507
508         IMB_freeImBuf(tmpibuf);
509 }
510
511 static void image_undo_free(ListBase *lb)
512 {
513         UndoImageTile *tile;
514
515         for(tile=lb->first; tile; tile=tile->next)
516                 MEM_freeN(tile->rect);
517 }
518
519 /* get active image for face depending on old/new shading system */
520
521 static Image *imapaint_face_image(const ImagePaintState *s, int face_index)
522 {
523         Image *ima;
524
525         if(scene_use_new_shading_nodes(s->scene)) {
526                 MFace *mf = s->me->mface+face_index;
527                 ED_object_get_active_image(s->ob, mf->mat_nr, &ima, NULL, NULL);
528         }
529         else {
530                 MTFace *tf = s->me->mtface+face_index;
531                 ima = tf->tpage;
532         }
533
534         return ima;
535 }
536
537 static Image *project_paint_face_image(const ProjPaintState *ps, MTFace *dm_mtface, int face_index)
538 {
539         Image *ima;
540
541         if(ps->do_new_shading_nodes) { /* cached scene_use_new_shading_nodes result */
542                 MFace *mf = ps->dm_mface+face_index;
543                 ED_object_get_active_image(ps->ob, mf->mat_nr, &ima, NULL, NULL);
544         }
545         else {
546                 ima = dm_mtface[face_index].tpage;
547         }
548
549         return ima;
550 }
551
552 /* fast projection bucket array lookup, use the safe version for bound checking  */
553 static int project_bucket_offset(const ProjPaintState *ps, const float projCoSS[2])
554 {
555         /* If we were not dealing with screenspace 2D coords we could simple do...
556          * ps->bucketRect[x + (y*ps->buckets_y)] */
557         
558         /* please explain?
559          * projCoSS[0] - ps->screenMin[0]       : zero origin
560          * ... / ps->screen_width                               : range from 0.0 to 1.0
561          * ... * ps->buckets_x          : use as a bucket index
562          *
563          * Second multiplication does similar but for vertical offset
564          */
565         return  (       (int)(((projCoSS[0] - ps->screenMin[0]) / ps->screen_width)  * ps->buckets_x)) + 
566                 (       (       (int)(((projCoSS[1] - ps->screenMin[1])  / ps->screen_height) * ps->buckets_y)) * ps->buckets_x);
567 }
568
569 static int project_bucket_offset_safe(const ProjPaintState *ps, const float projCoSS[2])
570 {
571         int bucket_index = project_bucket_offset(ps, projCoSS);
572         
573         if (bucket_index < 0 || bucket_index >= ps->buckets_x*ps->buckets_y) {  
574                 return -1;
575         }
576         else {
577                 return bucket_index;
578         }
579 }
580
581 /* still use 2D X,Y space but this works for verts transformed by a perspective matrix, using their 4th component as a weight */
582 static void barycentric_weights_v2_persp(float v1[4], float v2[4], float v3[4], float co[2], float w[3])
583 {
584         float wtot_inv, wtot;
585
586         w[0] = area_tri_signed_v2(v2, v3, co) / v1[3];
587         w[1] = area_tri_signed_v2(v3, v1, co) / v2[3];
588         w[2] = area_tri_signed_v2(v1, v2, co) / v3[3];
589         wtot = w[0]+w[1]+w[2];
590
591         if (wtot != 0.0f) {
592                 wtot_inv = 1.0f/wtot;
593
594                 w[0] = w[0]*wtot_inv;
595                 w[1] = w[1]*wtot_inv;
596                 w[2] = w[2]*wtot_inv;
597         }
598         else /* dummy values for zero area face */
599                 w[0] = w[1] = w[2] = 1.0f/3.0f;
600 }
601
602 static float VecZDepthOrtho(float pt[2], float v1[3], float v2[3], float v3[3], float w[3])
603 {
604         barycentric_weights_v2(v1, v2, v3, pt, w);
605         return (v1[2]*w[0]) + (v2[2]*w[1]) + (v3[2]*w[2]);
606 }
607
608 static float VecZDepthPersp(float pt[2], float v1[4], float v2[4], float v3[4], float w[3])
609 {
610         float wtot_inv, wtot;
611         float w_tmp[3];
612
613         barycentric_weights_v2_persp(v1, v2, v3, pt, w);
614         /* for the depth we need the weights to match what
615          * barycentric_weights_v2 would return, in this case its easiest just to
616          * undo the 4th axis division and make it unit-sum
617          *
618          * don't call barycentric_weights_v2() becaue our callers expect 'w'
619          * to be weighted from the perspective */
620         w_tmp[0]= w[0] * v1[3];
621         w_tmp[1]= w[1] * v2[3];
622         w_tmp[2]= w[2] * v3[3];
623
624         wtot = w_tmp[0]+w_tmp[1]+w_tmp[2];
625
626         if (wtot != 0.0f) {
627                 wtot_inv = 1.0f/wtot;
628
629                 w_tmp[0] = w_tmp[0]*wtot_inv;
630                 w_tmp[1] = w_tmp[1]*wtot_inv;
631                 w_tmp[2] = w_tmp[2]*wtot_inv;
632         }
633         else /* dummy values for zero area face */
634                 w_tmp[0] = w_tmp[1] = w_tmp[2] = 1.0f/3.0f;
635         /* done mimicing barycentric_weights_v2() */
636
637         return (v1[2]*w_tmp[0]) + (v2[2]*w_tmp[1]) + (v3[2]*w_tmp[2]);
638 }
639
640
641 /* Return the top-most face index that the screen space coord 'pt' touches (or -1) */
642 static int project_paint_PickFace(const ProjPaintState *ps, float pt[2], float w[3], int *side)
643 {
644         LinkNode *node;
645         float w_tmp[3];
646         float *v1, *v2, *v3, *v4;
647         int bucket_index;
648         int face_index;
649         int best_side = -1;
650         int best_face_index = -1;
651         float z_depth_best = FLT_MAX, z_depth;
652         MFace *mf;
653         
654         bucket_index = project_bucket_offset_safe(ps, pt);
655         if (bucket_index==-1)
656                 return -1;
657         
658         
659         
660         /* we could return 0 for 1 face buckets, as long as this function assumes
661          * that the point its testing is only every originated from an existing face */
662         
663         for (node= ps->bucketFaces[bucket_index]; node; node= node->next) {
664                 face_index = GET_INT_FROM_POINTER(node->link);
665                 mf= ps->dm_mface + face_index;
666                 
667                 v1= ps->screenCoords[mf->v1];
668                 v2= ps->screenCoords[mf->v2];
669                 v3= ps->screenCoords[mf->v3];
670                 
671                 if (isect_point_tri_v2(pt, v1, v2, v3)) {
672                         if (ps->is_ortho)       z_depth= VecZDepthOrtho(pt, v1, v2, v3, w_tmp);
673                         else                            z_depth= VecZDepthPersp(pt, v1, v2, v3, w_tmp);
674                         
675                         if (z_depth < z_depth_best) {
676                                 best_face_index = face_index;
677                                 best_side = 0;
678                                 z_depth_best = z_depth;
679                                 copy_v3_v3(w, w_tmp);
680                         }
681                 }
682                 else if (mf->v4) {
683                         v4= ps->screenCoords[mf->v4];
684                         
685                         if (isect_point_tri_v2(pt, v1, v3, v4)) {
686                                 if (ps->is_ortho)       z_depth= VecZDepthOrtho(pt, v1, v3, v4, w_tmp);
687                                 else                            z_depth= VecZDepthPersp(pt, v1, v3, v4, w_tmp);
688
689                                 if (z_depth < z_depth_best) {
690                                         best_face_index = face_index;
691                                         best_side= 1;
692                                         z_depth_best = z_depth;
693                                         copy_v3_v3(w, w_tmp);
694                                 }
695                         }
696                 }
697         }
698         
699         *side = best_side;
700         return best_face_index; /* will be -1 or a valid face */
701 }
702
703 /* Converts a uv coord into a pixel location wrapping if the uv is outside 0-1 range */
704 static void uvco_to_wrapped_pxco(float uv[2], int ibuf_x, int ibuf_y, float *x, float *y)
705 {
706         /* use */
707         *x = (float)fmodf(uv[0], 1.0f);
708         *y = (float)fmodf(uv[1], 1.0f);
709         
710         if (*x < 0.0f) *x += 1.0f;
711         if (*y < 0.0f) *y += 1.0f;
712         
713         *x = *x * ibuf_x - 0.5f;
714         *y = *y * ibuf_y - 0.5f;
715 }
716
717 /* Set the top-most face color that the screen space coord 'pt' touches (or return 0 if none touch) */
718 static int project_paint_PickColor(const ProjPaintState *ps, float pt[2], float *rgba_fp, unsigned char *rgba, const int interp)
719 {
720         float w[3], uv[2];
721         int side;
722         int face_index;
723         MTFace *tf;
724         Image *ima;
725         ImBuf *ibuf;
726         int xi, yi;
727         
728         
729         face_index = project_paint_PickFace(ps, pt, w, &side);
730         
731         if (face_index == -1)
732                 return 0;
733         
734         tf = ps->dm_mtface + face_index;
735         
736         if (side == 0) {
737                 interp_v2_v2v2v2(uv, tf->uv[0], tf->uv[1], tf->uv[2], w);
738         }
739         else { /* QUAD */
740                 interp_v2_v2v2v2(uv, tf->uv[0], tf->uv[2], tf->uv[3], w);
741         }
742
743         ima = project_paint_face_image(ps, ps->dm_mtface, face_index);
744         ibuf = ima->ibufs.first; /* we must have got the imbuf before getting here */
745         if (!ibuf) return 0;
746         
747         if (interp) {
748                 float x, y;
749                 uvco_to_wrapped_pxco(uv, ibuf->x, ibuf->y, &x, &y);
750                 
751                 if (ibuf->rect_float) {
752                         if (rgba_fp) {
753                                 bilinear_interpolation_color_wrap(ibuf, NULL, rgba_fp, x, y);
754                         }
755                         else {
756                                 float rgba_tmp_f[4];
757                                 bilinear_interpolation_color_wrap(ibuf, NULL, rgba_tmp_f, x, y);
758                                 IMAPAINT_FLOAT_RGBA_TO_CHAR(rgba, rgba_tmp_f);
759                         }
760                 }
761                 else {
762                         if (rgba) {
763                                 bilinear_interpolation_color_wrap(ibuf, rgba, NULL, x, y);
764                         }
765                         else {
766                                 unsigned char rgba_tmp[4];
767                                 bilinear_interpolation_color_wrap(ibuf, rgba_tmp, NULL, x, y);
768                                 IMAPAINT_CHAR_RGBA_TO_FLOAT(rgba_fp, rgba_tmp);
769                         }
770                 }
771         }
772         else {
773                 //xi = (int)((uv[0]*ibuf->x) + 0.5f);
774                 //yi = (int)((uv[1]*ibuf->y) + 0.5f);
775                 //if (xi<0 || xi>=ibuf->x  ||  yi<0 || yi>=ibuf->y) return 0;
776                 
777                 /* wrap */
778                 xi = ((int)(uv[0]*ibuf->x)) % ibuf->x;
779                 if (xi<0) xi += ibuf->x;
780                 yi = ((int)(uv[1]*ibuf->y)) % ibuf->y;
781                 if (yi<0) yi += ibuf->y;
782                 
783                 
784                 if (rgba) {
785                         if (ibuf->rect_float) {
786                                 float *rgba_tmp_fp = ibuf->rect_float + (xi + yi * ibuf->x * 4);
787                                 IMAPAINT_FLOAT_RGBA_TO_CHAR(rgba, rgba_tmp_fp);
788                         }
789                         else {
790                                 *((unsigned int *)rgba) = *(unsigned int *)(((char *)ibuf->rect) + ((xi + yi * ibuf->x) * 4));
791                         }
792                 }
793                 
794                 if (rgba_fp) {
795                         if (ibuf->rect_float) {
796                                 copy_v4_v4(rgba_fp, ((float *)ibuf->rect_float + ((xi + yi * ibuf->x) * 4)));
797                         }
798                         else {
799                                 char *tmp_ch= ((char *)ibuf->rect) + ((xi + yi * ibuf->x) * 4);
800                                 IMAPAINT_CHAR_RGBA_TO_FLOAT(rgba_fp, tmp_ch);
801                         }
802                 }
803         }
804         return 1;
805 }
806
807 /* Check if 'pt' is infront of the 3 verts on the Z axis (used for screenspace occlusuion test)
808  * return...
809  *  0   : no occlusion
810  * -1   : no occlusion but 2D intersection is true (avoid testing the other half of a quad)
811  *  1   : occluded
812         2       : occluded with w[3] weights set (need to know in some cases) */
813
814 static int project_paint_occlude_ptv(float pt[3], float v1[4], float v2[4], float v3[4], float w[3], int is_ortho)
815 {
816         /* if all are behind us, return false */
817         if(v1[2] > pt[2] && v2[2] > pt[2] && v3[2] > pt[2])
818                 return 0;
819                 
820         /* do a 2D point in try intersection */
821         if (!isect_point_tri_v2(pt, v1, v2, v3))
822                 return 0; /* we know there is  */
823         
824
825         /* From here on we know there IS an intersection */
826         /* if ALL of the verts are infront of us then we know it intersects ? */
827         if(v1[2] < pt[2] && v2[2] < pt[2] && v3[2] < pt[2]) {
828                 return 1;
829         }
830         else {
831                 /* we intersect? - find the exact depth at the point of intersection */
832                 /* Is this point is occluded by another face? */
833                 if (is_ortho) {
834                         if (VecZDepthOrtho(pt, v1, v2, v3, w) < pt[2]) return 2;
835                 }
836                 else {
837                         if (VecZDepthPersp(pt, v1, v2, v3, w) < pt[2]) return 2;
838                 }
839         }
840         return -1;
841 }
842
843
844 static int project_paint_occlude_ptv_clip(
845                 const ProjPaintState *ps, const MFace *mf,
846                 float pt[3], float v1[4], float v2[4], float v3[4],
847                 const int side )
848 {
849         float w[3], wco[3];
850         int ret = project_paint_occlude_ptv(pt, v1, v2, v3, w, ps->is_ortho);
851
852         if (ret <= 0)
853                 return ret;
854
855         if (ret==1) { /* weights not calculated */
856                 if (ps->is_ortho)       barycentric_weights_v2(v1, v2, v3, pt, w);
857                 else                            barycentric_weights_v2_persp(v1, v2, v3, pt, w);
858         }
859
860         /* Test if we're in the clipped area, */
861         if (side)       interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v3].co, ps->dm_mvert[mf->v4].co, w);
862         else            interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v2].co, ps->dm_mvert[mf->v3].co, w);
863         
864         if(!ED_view3d_test_clipping(ps->rv3d, wco, 1)) {
865                 return 1;
866         }
867         
868         return -1;
869 }
870
871
872 /* Check if a screenspace location is occluded by any other faces
873  * check, pixelScreenCo must be in screenspace, its Z-Depth only needs to be used for comparison
874  * and dosn't need to be correct in relation to X and Y coords (this is the case in perspective view) */
875 static int project_bucket_point_occluded(const ProjPaintState *ps, LinkNode *bucketFace, const int orig_face, float pixelScreenCo[4])
876 {
877         MFace *mf;
878         int face_index;
879         int isect_ret;
880         float w[3]; /* not needed when clipping */
881         const short do_clip= ps->rv3d ? ps->rv3d->rflag & RV3D_CLIPPING : 0;
882         
883         /* we could return 0 for 1 face buckets, as long as this function assumes
884          * that the point its testing is only every originated from an existing face */
885
886         for (; bucketFace; bucketFace = bucketFace->next) {
887                 face_index = GET_INT_FROM_POINTER(bucketFace->link);
888
889                 if (orig_face != face_index) {
890                         mf = ps->dm_mface + face_index;
891                         if(do_clip)
892                                 isect_ret = project_paint_occlude_ptv_clip(ps, mf, pixelScreenCo, ps->screenCoords[mf->v1], ps->screenCoords[mf->v2], ps->screenCoords[mf->v3], 0);
893                         else
894                                 isect_ret = project_paint_occlude_ptv(pixelScreenCo, ps->screenCoords[mf->v1], ps->screenCoords[mf->v2], ps->screenCoords[mf->v3], w, ps->is_ortho);
895
896                         /* Note, if isect_ret==-1 then we dont want to test the other side of the quad */
897                         if (isect_ret==0 && mf->v4) {
898                                 if(do_clip)
899                                         isect_ret = project_paint_occlude_ptv_clip(ps, mf, pixelScreenCo, ps->screenCoords[mf->v1], ps->screenCoords[mf->v3], ps->screenCoords[mf->v4], 1);
900                                 else
901                                         isect_ret = project_paint_occlude_ptv(pixelScreenCo, ps->screenCoords[mf->v1], ps->screenCoords[mf->v3], ps->screenCoords[mf->v4], w, ps->is_ortho);
902                         }
903                         if (isect_ret>=1) {
904                                 /* TODO - we may want to cache the first hit,
905                                  * it is not possible to swap the face order in the list anymore */
906                                 return 1;
907                         }
908                 }
909         }
910         return 0;
911 }
912
913 /* basic line intersection, could move to math_geom.c, 2 points with a horiz line
914  * 1 for an intersection, 2 if the first point is aligned, 3 if the second point is aligned */
915 #define ISECT_TRUE 1
916 #define ISECT_TRUE_P1 2
917 #define ISECT_TRUE_P2 3
918 static int line_isect_y(const float p1[2], const float p2[2], const float y_level, float *x_isect)
919 {
920         float y_diff;
921         
922         if (y_level==p1[1]) { /* are we touching the first point? - no interpolation needed */
923                 *x_isect = p1[0];
924                 return ISECT_TRUE_P1;
925         }
926         if (y_level==p2[1]) { /* are we touching the second point? - no interpolation needed */
927                 *x_isect = p2[0];
928                 return ISECT_TRUE_P2;
929         }
930         
931         y_diff= fabsf(p1[1]-p2[1]); /* yuck, horizontal line, we cant do much here */
932         
933         if (y_diff < 0.000001f) {
934                 *x_isect = (p1[0]+p2[0]) * 0.5f;
935                 return ISECT_TRUE;              
936         }
937         
938         if (p1[1] > y_level && p2[1] < y_level) {
939                 *x_isect = (p2[0]*(p1[1]-y_level) + p1[0]*(y_level-p2[1])) / y_diff;  /*(p1[1]-p2[1]);*/
940                 return ISECT_TRUE;
941         }
942         else if (p1[1] < y_level && p2[1] > y_level) {
943                 *x_isect = (p2[0]*(y_level-p1[1]) + p1[0]*(p2[1]-y_level)) / y_diff;  /*(p2[1]-p1[1]);*/
944                 return ISECT_TRUE;
945         }
946         else {
947                 return 0;
948         }
949 }
950
951 static int line_isect_x(const float p1[2], const float p2[2], const float x_level, float *y_isect)
952 {
953         float x_diff;
954         
955         if (x_level==p1[0]) { /* are we touching the first point? - no interpolation needed */
956                 *y_isect = p1[1];
957                 return ISECT_TRUE_P1;
958         }
959         if (x_level==p2[0]) { /* are we touching the second point? - no interpolation needed */
960                 *y_isect = p2[1];
961                 return ISECT_TRUE_P2;
962         }
963         
964         x_diff= fabsf(p1[0]-p2[0]); /* yuck, horizontal line, we cant do much here */
965         
966         if (x_diff < 0.000001f) { /* yuck, vertical line, we cant do much here */
967                 *y_isect = (p1[0]+p2[0]) * 0.5f;
968                 return ISECT_TRUE;              
969         }
970         
971         if (p1[0] > x_level && p2[0] < x_level) {
972                 *y_isect = (p2[1]*(p1[0]-x_level) + p1[1]*(x_level-p2[0])) / x_diff; /*(p1[0]-p2[0]);*/
973                 return ISECT_TRUE;
974         }
975         else if (p1[0] < x_level && p2[0] > x_level) {
976                 *y_isect = (p2[1]*(x_level-p1[0]) + p1[1]*(p2[0]-x_level)) / x_diff; /*(p2[0]-p1[0]);*/
977                 return ISECT_TRUE;
978         }
979         else {
980                 return 0;
981         }
982 }
983
984 /* simple func use for comparing UV locations to check if there are seams.
985  * Its possible this gives incorrect results, when the UVs for 1 face go into the next 
986  * tile, but do not do this for the adjacent face, it could return a false positive.
987  * This is so unlikely that Id not worry about it. */
988 #ifndef PROJ_DEBUG_NOSEAMBLEED
989 static int cmp_uv(const float vec2a[2], const float vec2b[2])
990 {
991         /* if the UV's are not between 0.0 and 1.0 */
992         float xa = (float)fmodf(vec2a[0], 1.0f);
993         float ya = (float)fmodf(vec2a[1], 1.0f);
994         
995         float xb = (float)fmodf(vec2b[0], 1.0f);
996         float yb = (float)fmodf(vec2b[1], 1.0f);        
997         
998         if (xa < 0.0f) xa += 1.0f;
999         if (ya < 0.0f) ya += 1.0f;
1000         
1001         if (xb < 0.0f) xb += 1.0f;
1002         if (yb < 0.0f) yb += 1.0f;
1003         
1004         return ((fabsf(xa-xb) < PROJ_GEOM_TOLERANCE) && (fabsf(ya-yb) < PROJ_GEOM_TOLERANCE)) ? 1:0;
1005 }
1006 #endif
1007
1008 /* set min_px and max_px to the image space bounds of the UV coords 
1009  * return zero if there is no area in the returned rectangle */
1010 #ifndef PROJ_DEBUG_NOSEAMBLEED
1011 static int pixel_bounds_uv(
1012                 const float uv1[2], const float uv2[2], const float uv3[2], const float uv4[2],
1013                 rcti *bounds_px,
1014                 const int ibuf_x, const int ibuf_y,
1015                 int is_quad
1016 ) {
1017         float min_uv[2], max_uv[2]; /* UV bounds */
1018         
1019         INIT_MINMAX2(min_uv, max_uv);
1020         
1021         DO_MINMAX2(uv1, min_uv, max_uv);
1022         DO_MINMAX2(uv2, min_uv, max_uv);
1023         DO_MINMAX2(uv3, min_uv, max_uv);
1024         if (is_quad)
1025                 DO_MINMAX2(uv4, min_uv, max_uv);
1026         
1027         bounds_px->xmin = (int)(ibuf_x * min_uv[0]);
1028         bounds_px->ymin = (int)(ibuf_y * min_uv[1]);
1029         
1030         bounds_px->xmax = (int)(ibuf_x * max_uv[0]) +1;
1031         bounds_px->ymax = (int)(ibuf_y * max_uv[1]) +1;
1032         
1033         /*printf("%d %d %d %d \n", min_px[0], min_px[1], max_px[0], max_px[1]);*/
1034         
1035         /* face uses no UV area when quantized to pixels? */
1036         return (bounds_px->xmin == bounds_px->xmax || bounds_px->ymin == bounds_px->ymax) ? 0 : 1;
1037 }
1038 #endif
1039
1040 static int pixel_bounds_array(float (* uv)[2], rcti *bounds_px, const int ibuf_x, const int ibuf_y, int tot)
1041 {
1042         float min_uv[2], max_uv[2]; /* UV bounds */
1043         
1044         if (tot==0) {
1045                 return 0;
1046         }
1047         
1048         INIT_MINMAX2(min_uv, max_uv);
1049         
1050         while (tot--) {
1051                 DO_MINMAX2((*uv), min_uv, max_uv);
1052                 uv++;
1053         }
1054         
1055         bounds_px->xmin = (int)(ibuf_x * min_uv[0]);
1056         bounds_px->ymin = (int)(ibuf_y * min_uv[1]);
1057         
1058         bounds_px->xmax = (int)(ibuf_x * max_uv[0]) +1;
1059         bounds_px->ymax = (int)(ibuf_y * max_uv[1]) +1;
1060         
1061         /*printf("%d %d %d %d \n", min_px[0], min_px[1], max_px[0], max_px[1]);*/
1062         
1063         /* face uses no UV area when quantized to pixels? */
1064         return (bounds_px->xmin == bounds_px->xmax || bounds_px->ymin == bounds_px->ymax) ? 0 : 1;
1065 }
1066
1067 #ifndef PROJ_DEBUG_NOSEAMBLEED
1068
1069 /* This function returns 1 if this face has a seam along the 2 face-vert indices
1070  * 'orig_i1_fidx' and 'orig_i2_fidx' */
1071 static int check_seam(const ProjPaintState *ps, const int orig_face, const int orig_i1_fidx, const int orig_i2_fidx, int *other_face, int *orig_fidx)
1072 {
1073         LinkNode *node;
1074         int face_index;
1075         unsigned int i1, i2;
1076         int i1_fidx = -1, i2_fidx = -1; /* index in face */
1077         MFace *mf;
1078         MTFace *tf;
1079         const MFace *orig_mf = ps->dm_mface + orig_face;  
1080         const MTFace *orig_tf = ps->dm_mtface + orig_face;
1081         
1082         /* vert indices from face vert order indices */
1083         i1 = (*(&orig_mf->v1 + orig_i1_fidx));
1084         i2 = (*(&orig_mf->v1 + orig_i2_fidx));
1085         
1086         for (node = ps->vertFaces[i1]; node; node = node->next) {
1087                 face_index = GET_INT_FROM_POINTER(node->link);
1088
1089                 if (face_index != orig_face) {
1090                         mf = ps->dm_mface + face_index;
1091                         /* could check if the 2 faces images match here,
1092                          * but then there wouldn't be a way to return the opposite face's info */
1093                         
1094                         
1095                         /* We need to know the order of the verts in the adjacent face 
1096                          * set the i1_fidx and i2_fidx to (0,1,2,3) */
1097                         if              (mf->v1==i1)                    i1_fidx = 0;
1098                         else if (mf->v2==i1)                    i1_fidx = 1;
1099                         else if (mf->v3==i1)                    i1_fidx = 2;
1100                         else if (mf->v4 && mf->v4==i1)  i1_fidx = 3;
1101                         
1102                         if              (mf->v1==i2)                    i2_fidx = 0;
1103                         else if (mf->v2==i2)                    i2_fidx = 1;
1104                         else if (mf->v3==i2)                    i2_fidx = 2;
1105                         else if (mf->v4 && mf->v4==i2)  i2_fidx = 3;
1106                         
1107                         /* Only need to check if 'i2_fidx' is valid because we know i1_fidx is the same vert on both faces */
1108                         if (i2_fidx != -1) {
1109                                 Image *tpage = project_paint_face_image(ps, ps->dm_mtface, face_index);
1110                                 Image *orig_tpage = project_paint_face_image(ps, ps->dm_mtface, orig_face);
1111
1112                                 /* This IS an adjacent face!, now lets check if the UVs are ok */
1113                                 tf = ps->dm_mtface + face_index;
1114                                 
1115                                 /* set up the other face */
1116                                 *other_face = face_index;
1117                                 *orig_fidx = (i1_fidx < i2_fidx) ? i1_fidx : i2_fidx;
1118                                 
1119                                 /* first test if they have the same image */
1120                                 if (    (orig_tpage == tpage) &&
1121                                                 cmp_uv(orig_tf->uv[orig_i1_fidx], tf->uv[i1_fidx]) &&
1122                                                 cmp_uv(orig_tf->uv[orig_i2_fidx], tf->uv[i2_fidx]) )
1123                                 {
1124                                         // printf("SEAM (NONE)\n");
1125                                         return 0;
1126                                         
1127                                 }
1128                                 else {
1129                                         // printf("SEAM (UV GAP)\n");
1130                                         return 1;
1131                                 }
1132                         }
1133                 }
1134         }
1135         // printf("SEAM (NO FACE)\n");
1136         *other_face = -1;
1137         return 1;
1138 }
1139
1140 /* Calculate outset UV's, this is not the same as simply scaling the UVs,
1141  * since the outset coords are a margin that keep an even distance from the original UV's,
1142  * note that the image aspect is taken into account */
1143 static void uv_image_outset(float (*orig_uv)[2], float (*outset_uv)[2], const float scaler, const int ibuf_x, const int ibuf_y, const int is_quad)
1144 {
1145         float a1, a2, a3, a4=0.0f;
1146         float puv[4][2]; /* pixelspace uv's */
1147         float no1[2], no2[2], no3[2], no4[2]; /* normals */
1148         float dir1[2], dir2[2], dir3[2], dir4[2];
1149         float ibuf_inv[2];
1150
1151         ibuf_inv[0]= 1.0f / (float)ibuf_x;
1152         ibuf_inv[1]= 1.0f / (float)ibuf_y;
1153
1154         /* make UV's in pixel space so we can */
1155         puv[0][0] = orig_uv[0][0] * ibuf_x;
1156         puv[0][1] = orig_uv[0][1] * ibuf_y;
1157         
1158         puv[1][0] = orig_uv[1][0] * ibuf_x;
1159         puv[1][1] = orig_uv[1][1] * ibuf_y;
1160         
1161         puv[2][0] = orig_uv[2][0] * ibuf_x;
1162         puv[2][1] = orig_uv[2][1] * ibuf_y;
1163         
1164         if (is_quad) {
1165                 puv[3][0] = orig_uv[3][0] * ibuf_x;
1166                 puv[3][1] = orig_uv[3][1] * ibuf_y;
1167         }
1168         
1169         /* face edge directions */
1170         sub_v2_v2v2(dir1, puv[1], puv[0]);
1171         sub_v2_v2v2(dir2, puv[2], puv[1]);
1172         normalize_v2(dir1);
1173         normalize_v2(dir2);
1174         
1175         if (is_quad) {
1176                 sub_v2_v2v2(dir3, puv[3], puv[2]);
1177                 sub_v2_v2v2(dir4, puv[0], puv[3]);
1178                 normalize_v2(dir3);
1179                 normalize_v2(dir4);
1180         }
1181         else {
1182                 sub_v2_v2v2(dir3, puv[0], puv[2]);
1183                 normalize_v2(dir3);
1184         }
1185
1186         /* TODO - angle_normalized_v2v2(...) * (M_PI/180.0f)
1187          * This is incorrect. Its already given radians but without it wont work.
1188          * need to look into a fix - campbell */
1189         if (is_quad) {
1190                 a1 = shell_angle_to_dist(angle_normalized_v2v2(dir4, dir1) * ((float)M_PI/180.0f));
1191                 a2 = shell_angle_to_dist(angle_normalized_v2v2(dir1, dir2) * ((float)M_PI/180.0f));
1192                 a3 = shell_angle_to_dist(angle_normalized_v2v2(dir2, dir3) * ((float)M_PI/180.0f));
1193                 a4 = shell_angle_to_dist(angle_normalized_v2v2(dir3, dir4) * ((float)M_PI/180.0f));
1194         }
1195         else {
1196                 a1 = shell_angle_to_dist(angle_normalized_v2v2(dir3, dir1) * ((float)M_PI/180.0f));
1197                 a2 = shell_angle_to_dist(angle_normalized_v2v2(dir1, dir2) * ((float)M_PI/180.0f));
1198                 a3 = shell_angle_to_dist(angle_normalized_v2v2(dir2, dir3) * ((float)M_PI/180.0f));
1199         }
1200         
1201         if (is_quad) {
1202                 sub_v2_v2v2(no1, dir4, dir1);
1203                 sub_v2_v2v2(no2, dir1, dir2);
1204                 sub_v2_v2v2(no3, dir2, dir3);
1205                 sub_v2_v2v2(no4, dir3, dir4);
1206                 normalize_v2(no1);
1207                 normalize_v2(no2);
1208                 normalize_v2(no3);
1209                 normalize_v2(no4);
1210                 mul_v2_fl(no1, a1*scaler);
1211                 mul_v2_fl(no2, a2*scaler);
1212                 mul_v2_fl(no3, a3*scaler);
1213                 mul_v2_fl(no4, a4*scaler);
1214                 add_v2_v2v2(outset_uv[0], puv[0], no1);
1215                 add_v2_v2v2(outset_uv[1], puv[1], no2);
1216                 add_v2_v2v2(outset_uv[2], puv[2], no3);
1217                 add_v2_v2v2(outset_uv[3], puv[3], no4);
1218                 mul_v2_v2(outset_uv[0], ibuf_inv);
1219                 mul_v2_v2(outset_uv[1], ibuf_inv);
1220                 mul_v2_v2(outset_uv[2], ibuf_inv);
1221                 mul_v2_v2(outset_uv[3], ibuf_inv);
1222         }
1223         else {
1224                 sub_v2_v2v2(no1, dir3, dir1);
1225                 sub_v2_v2v2(no2, dir1, dir2);
1226                 sub_v2_v2v2(no3, dir2, dir3);
1227                 normalize_v2(no1);
1228                 normalize_v2(no2);
1229                 normalize_v2(no3);
1230                 mul_v2_fl(no1, a1*scaler);
1231                 mul_v2_fl(no2, a2*scaler);
1232                 mul_v2_fl(no3, a3*scaler);
1233                 add_v2_v2v2(outset_uv[0], puv[0], no1);
1234                 add_v2_v2v2(outset_uv[1], puv[1], no2);
1235                 add_v2_v2v2(outset_uv[2], puv[2], no3);
1236
1237                 mul_v2_v2(outset_uv[0], ibuf_inv);
1238                 mul_v2_v2(outset_uv[1], ibuf_inv);
1239                 mul_v2_v2(outset_uv[2], ibuf_inv);
1240         }
1241 }
1242
1243 /* 
1244  * Be tricky with flags, first 4 bits are PROJ_FACE_SEAM1 to 4, last 4 bits are PROJ_FACE_NOSEAM1 to 4
1245  * 1<<i - where i is (0-3) 
1246  * 
1247  * If we're multithreadng, make sure threads are locked when this is called
1248  */
1249 static void project_face_seams_init(const ProjPaintState *ps, const int face_index, const int is_quad)
1250 {
1251         int other_face, other_fidx; /* vars for the other face, we also set its flag */
1252         int fidx1 = is_quad ? 3 : 2;
1253         int fidx2 = 0; /* next fidx in the face (0,1,2,3) -> (1,2,3,0) or (0,1,2) -> (1,2,0) for a tri */
1254         
1255         do {
1256                 if ((ps->faceSeamFlags[face_index] & (1<<fidx1|16<<fidx1)) == 0) {
1257                         if (check_seam(ps, face_index, fidx1, fidx2, &other_face, &other_fidx)) {
1258                                 ps->faceSeamFlags[face_index] |= 1<<fidx1;
1259                                 if (other_face != -1)
1260                                         ps->faceSeamFlags[other_face] |= 1<<other_fidx;
1261                         }
1262                         else {
1263                                 ps->faceSeamFlags[face_index] |= 16<<fidx1;
1264                                 if (other_face != -1)
1265                                         ps->faceSeamFlags[other_face] |= 16<<other_fidx; /* second 4 bits for disabled */
1266                         }
1267                 }
1268                 
1269                 fidx2 = fidx1;
1270         } while (fidx1--);
1271 }
1272 #endif // PROJ_DEBUG_NOSEAMBLEED
1273
1274
1275 /* Converts a UV location to a 3D screenspace location
1276  * Takes a 'uv' and 3 UV coords, and sets the values of pixelScreenCo
1277  * 
1278  * This is used for finding a pixels location in screenspace for painting */
1279 static void screen_px_from_ortho(
1280                 float uv[2],
1281                 float v1co[3], float v2co[3], float v3co[3], /* Screenspace coords */
1282                 float uv1co[2], float uv2co[2], float uv3co[2],
1283                 float pixelScreenCo[4],
1284                 float w[3])
1285 {
1286         barycentric_weights_v2(uv1co, uv2co, uv3co, uv, w);
1287         interp_v3_v3v3v3(pixelScreenCo, v1co, v2co, v3co, w);
1288 }
1289
1290 /* same as screen_px_from_ortho except we need to take into account
1291  * the perspective W coord for each vert */
1292 static void screen_px_from_persp(
1293                 float uv[2],
1294                 float v1co[4], float v2co[4], float v3co[4], /* screenspace coords */
1295                 float uv1co[2], float uv2co[2], float uv3co[2],
1296                 float pixelScreenCo[4],
1297                 float w[3])
1298 {
1299
1300         float wtot_inv, wtot;
1301         barycentric_weights_v2(uv1co, uv2co, uv3co, uv, w);
1302         
1303         /* re-weight from the 4th coord of each screen vert */
1304         w[0] *= v1co[3];
1305         w[1] *= v2co[3];
1306         w[2] *= v3co[3];
1307         
1308         wtot = w[0]+w[1]+w[2];
1309         
1310         if (wtot > 0.0f) {
1311                 wtot_inv = 1.0f / wtot;
1312                 w[0] *= wtot_inv;
1313                 w[1] *= wtot_inv;
1314                 w[2] *= wtot_inv;
1315         }
1316         else {
1317                 w[0] = w[1] = w[2] = 1.0f/3.0f; /* dummy values for zero area face */
1318         }
1319         /* done re-weighting */
1320         
1321         interp_v3_v3v3v3(pixelScreenCo, v1co, v2co, v3co, w);
1322 }
1323
1324 static void project_face_pixel(const MTFace *tf_other, ImBuf *ibuf_other, const float w[3], int side, unsigned char rgba_ub[4], float rgba_f[4])
1325 {
1326         float *uvCo1, *uvCo2, *uvCo3;
1327         float uv_other[2], x, y;
1328         
1329         uvCo1 =  (float *)tf_other->uv[0];
1330         if (side==1) {
1331                 uvCo2 =  (float *)tf_other->uv[2];
1332                 uvCo3 =  (float *)tf_other->uv[3];
1333         }
1334         else {
1335                 uvCo2 =  (float *)tf_other->uv[1];
1336                 uvCo3 =  (float *)tf_other->uv[2];
1337         }
1338         
1339         interp_v2_v2v2v2(uv_other, uvCo1, uvCo2, uvCo3, (float*)w);
1340         
1341         /* use */
1342         uvco_to_wrapped_pxco(uv_other, ibuf_other->x, ibuf_other->y, &x, &y);
1343         
1344         
1345         if (ibuf_other->rect_float) { /* from float to float */
1346                 bilinear_interpolation_color_wrap(ibuf_other, NULL, rgba_f, x, y);
1347         }
1348         else { /* from char to float */
1349                 bilinear_interpolation_color_wrap(ibuf_other, rgba_ub, NULL, x, y);
1350         }
1351                 
1352 }
1353
1354 /* run this outside project_paint_uvpixel_init since pixels with mask 0 dont need init */
1355 static float project_paint_uvpixel_mask(
1356                 const ProjPaintState *ps,
1357                 const int face_index,
1358                 const int side,
1359                 const float w[3])
1360 {
1361         float mask;
1362         
1363         /* Image Mask */
1364         if (ps->do_layer_stencil) {
1365                 /* another UV maps image is masking this one's */
1366                 ImBuf *ibuf_other;
1367                 Image *other_tpage = project_paint_face_image(ps, ps->dm_mtface_stencil, face_index);
1368                 const MTFace *tf_other = ps->dm_mtface_stencil + face_index;
1369                 
1370                 if (other_tpage && (ibuf_other = BKE_image_get_ibuf(other_tpage, NULL))) {
1371                         /* BKE_image_get_ibuf - TODO - this may be slow */
1372                         unsigned char rgba_ub[4];
1373                         float rgba_f[4];
1374                         
1375                         project_face_pixel(tf_other, ibuf_other, w, side, rgba_ub, rgba_f);
1376                         
1377                         if (ibuf_other->rect_float) { /* from float to float */
1378                                 mask = ((rgba_f[0]+rgba_f[1]+rgba_f[2])/3.0f) * rgba_f[3];
1379                         }
1380                         else { /* from char to float */
1381                                 mask = ((rgba_ub[0]+rgba_ub[1]+rgba_ub[2])/(256*3.0f)) * (rgba_ub[3]/256.0f);
1382                         }
1383                         
1384                         if (!ps->do_layer_stencil_inv) /* matching the gimps layer mask black/white rules, white==full opacity */
1385                                 mask = (1.0f - mask);
1386
1387                         if (mask == 0.0f) {
1388                                 return 0.0f;
1389                         }
1390                 }
1391                 else {
1392                         return 0.0f;
1393                 }
1394         } else {
1395                 mask = 1.0f;
1396         }
1397         
1398         /* calculate mask */
1399         if (ps->do_mask_normal) {
1400                 MFace *mf = ps->dm_mface + face_index;
1401                 short *no1, *no2, *no3;
1402                 float no[3], angle;
1403                 no1 = ps->dm_mvert[mf->v1].no;
1404                 if (side==1) {
1405                         no2 = ps->dm_mvert[mf->v3].no;
1406                         no3 = ps->dm_mvert[mf->v4].no;
1407                 }
1408                 else {
1409                         no2 = ps->dm_mvert[mf->v2].no;
1410                         no3 = ps->dm_mvert[mf->v3].no;
1411                 }
1412                 
1413                 no[0] = w[0]*no1[0] + w[1]*no2[0] + w[2]*no3[0];
1414                 no[1] = w[0]*no1[1] + w[1]*no2[1] + w[2]*no3[1];
1415                 no[2] = w[0]*no1[2] + w[1]*no2[2] + w[2]*no3[2];
1416                 normalize_v3(no);
1417                 
1418                 /* now we can use the normal as a mask */
1419                 if (ps->is_ortho) {
1420                         angle = angle_normalized_v3v3((float *)ps->viewDir, no);
1421                 }
1422                 else {
1423                         /* Annoying but for the perspective view we need to get the pixels location in 3D space :/ */
1424                         float viewDirPersp[3];
1425                         float *co1, *co2, *co3;
1426                         co1 = ps->dm_mvert[mf->v1].co;
1427                         if (side==1) {
1428                                 co2 = ps->dm_mvert[mf->v3].co;
1429                                 co3 = ps->dm_mvert[mf->v4].co;
1430                         }
1431                         else {
1432                                 co2 = ps->dm_mvert[mf->v2].co;
1433                                 co3 = ps->dm_mvert[mf->v3].co;
1434                         }
1435
1436                         /* Get the direction from the viewPoint to the pixel and normalize */
1437                         viewDirPersp[0] = (ps->viewPos[0] - (w[0]*co1[0] + w[1]*co2[0] + w[2]*co3[0]));
1438                         viewDirPersp[1] = (ps->viewPos[1] - (w[0]*co1[1] + w[1]*co2[1] + w[2]*co3[1]));
1439                         viewDirPersp[2] = (ps->viewPos[2] - (w[0]*co1[2] + w[1]*co2[2] + w[2]*co3[2]));
1440                         normalize_v3(viewDirPersp);
1441                         
1442                         angle = angle_normalized_v3v3(viewDirPersp, no);
1443                 }
1444                 
1445                 if (angle >= ps->normal_angle) {
1446                         return 0.0f; /* outsize the normal limit*/
1447                 }
1448                 else if (angle > ps->normal_angle_inner) {
1449                         mask *= (ps->normal_angle - angle) / ps->normal_angle_range;
1450                 } /* otherwise no mask normal is needed, were within the limit */
1451         }
1452         
1453         // This only works when the opacity dosnt change while painting, stylus pressure messes with this
1454         // so dont use it.
1455         // if (ps->is_airbrush==0) mask *= brush_alpha(ps->brush);
1456         
1457         return mask;
1458 }
1459
1460 /* run this function when we know a bucket's, face's pixel can be initialized,
1461  * return the ProjPixel which is added to 'ps->bucketRect[bucket_index]' */
1462 static ProjPixel *project_paint_uvpixel_init(
1463                 const ProjPaintState *ps,
1464                 MemArena *arena,
1465                 const ImBuf *ibuf,
1466                 short x_px, short y_px,
1467                 const float mask,
1468                 const int face_index,
1469                 const int image_index,
1470                 const float pixelScreenCo[4],
1471                 const int side,
1472                 const float w[3])
1473 {
1474         ProjPixel *projPixel;
1475         short size;
1476         
1477         /* wrap pixel location */
1478         x_px = x_px % ibuf->x;
1479         if (x_px<0) x_px += ibuf->x;
1480         y_px = y_px % ibuf->y;
1481         if (y_px<0) y_px += ibuf->y;
1482         
1483         if (ps->tool==PAINT_TOOL_CLONE) {
1484                 size = sizeof(ProjPixelClone);
1485         }
1486         else if (ps->tool==PAINT_TOOL_SMEAR) {
1487                 size = sizeof(ProjPixelClone);
1488         }
1489         else {
1490                 size = sizeof(ProjPixel);
1491         }
1492         
1493         projPixel = (ProjPixel *)BLI_memarena_alloc(arena, size);
1494         //memset(projPixel, 0, size);
1495         
1496         if (ibuf->rect_float) {
1497                 projPixel->pixel.f_pt = (float *)ibuf->rect_float + ((x_px + y_px * ibuf->x) * 4);
1498                 projPixel->origColor.f[0] = projPixel->newColor.f[0] = projPixel->pixel.f_pt[0];  
1499                 projPixel->origColor.f[1] = projPixel->newColor.f[1] = projPixel->pixel.f_pt[1];  
1500                 projPixel->origColor.f[2] = projPixel->newColor.f[2] = projPixel->pixel.f_pt[2];  
1501                 projPixel->origColor.f[3] = projPixel->newColor.f[3] = projPixel->pixel.f_pt[3];  
1502         }
1503         else {
1504                 projPixel->pixel.ch_pt = ((unsigned char *)ibuf->rect + ((x_px + y_px * ibuf->x) * 4));
1505                 projPixel->origColor.uint = projPixel->newColor.uint = *projPixel->pixel.uint_pt;
1506         }
1507         
1508         /* screenspace unclamped, we could keep its z and w values but dont need them at the moment */
1509         copy_v2_v2(projPixel->projCoSS, pixelScreenCo);
1510         
1511         projPixel->x_px = x_px;
1512         projPixel->y_px = y_px;
1513         
1514         projPixel->mask = (unsigned short)(mask * 65535);
1515         projPixel->mask_max = 0;
1516         
1517         /* which bounding box cell are we in?, needed for undo */
1518         projPixel->bb_cell_index = ((int)(((float)x_px/(float)ibuf->x) * PROJ_BOUNDBOX_DIV)) + ((int)(((float)y_px/(float)ibuf->y) * PROJ_BOUNDBOX_DIV)) * PROJ_BOUNDBOX_DIV ;
1519         
1520         /* done with view3d_project_float inline */
1521         if (ps->tool==PAINT_TOOL_CLONE) {
1522                 if (ps->dm_mtface_clone) {
1523                         ImBuf *ibuf_other;
1524                         Image *other_tpage = project_paint_face_image(ps, ps->dm_mtface_clone, face_index);
1525                         const MTFace *tf_other = ps->dm_mtface_clone + face_index;
1526                         
1527                         if (other_tpage && (ibuf_other = BKE_image_get_ibuf(other_tpage, NULL))) {
1528                                 /* BKE_image_get_ibuf - TODO - this may be slow */
1529                                 
1530                                 if (ibuf->rect_float) {
1531                                         if (ibuf_other->rect_float) { /* from float to float */
1532                                                 project_face_pixel(tf_other, ibuf_other, w, side, NULL, ((ProjPixelClone *)projPixel)->clonepx.f);
1533                                         }
1534                                         else { /* from char to float */
1535                                                 unsigned char rgba_ub[4];
1536                                                 project_face_pixel(tf_other, ibuf_other, w, side, rgba_ub, NULL);
1537                                                 IMAPAINT_CHAR_RGBA_TO_FLOAT(((ProjPixelClone *)projPixel)->clonepx.f, rgba_ub);
1538                                         }
1539                                 }
1540                                 else {
1541                                         if (ibuf_other->rect_float) { /* float to char */
1542                                                 float rgba[4];
1543                                                 project_face_pixel(tf_other, ibuf_other, w, side, NULL, rgba);
1544                                                 IMAPAINT_FLOAT_RGBA_TO_CHAR(((ProjPixelClone *)projPixel)->clonepx.ch, rgba)
1545                                         }
1546                                         else { /* char to char */
1547                                                 project_face_pixel(tf_other, ibuf_other, w, side, ((ProjPixelClone *)projPixel)->clonepx.ch, NULL);
1548                                         }
1549                                 }
1550                         }
1551                         else {
1552                                 if (ibuf->rect_float) {
1553                                         ((ProjPixelClone *)projPixel)->clonepx.f[3] = 0;
1554                                 }
1555                                 else {
1556                                         ((ProjPixelClone *)projPixel)->clonepx.ch[3] = 0;
1557                                 }
1558                         }
1559                         
1560                 }
1561                 else {
1562                         float co[2];
1563                         sub_v2_v2v2(co, projPixel->projCoSS, (float *)ps->cloneOffset);
1564                         
1565                         /* no need to initialize the bucket, we're only checking buckets faces and for this
1566                          * the faces are already initialized in project_paint_delayed_face_init(...) */
1567                         if (ibuf->rect_float) {
1568                                 if (!project_paint_PickColor(ps, co, ((ProjPixelClone *)projPixel)->clonepx.f, NULL, 1)) {
1569                                         ((ProjPixelClone *)projPixel)->clonepx.f[3] = 0; /* zero alpha - ignore */
1570                                 }
1571                         }
1572                         else {
1573                                 if (!project_paint_PickColor(ps, co, NULL, ((ProjPixelClone *)projPixel)->clonepx.ch, 1)) {
1574                                         ((ProjPixelClone *)projPixel)->clonepx.ch[3] = 0; /* zero alpha - ignore */
1575                                 }
1576                         }
1577                 }
1578         }
1579         
1580 #ifdef PROJ_DEBUG_PAINT
1581         if (ibuf->rect_float)   projPixel->pixel.f_pt[0] = 0;
1582         else                                    projPixel->pixel.ch_pt[0] = 0;
1583 #endif
1584         projPixel->image_index = image_index;
1585         
1586         return projPixel;
1587 }
1588
1589 static int line_clip_rect2f(
1590                 rctf *rect,
1591                 const float l1[2], const float l2[2],
1592                 float l1_clip[2], float l2_clip[2])
1593 {
1594         /* first account for horizontal, then vertical lines */
1595         /* horiz */
1596         if (fabsf(l1[1]-l2[1]) < PROJ_GEOM_TOLERANCE) {
1597                 /* is the line out of range on its Y axis? */
1598                 if (l1[1] < rect->ymin || l1[1] > rect->ymax) {
1599                         return 0;
1600                 }
1601                 /* line is out of range on its X axis */
1602                 if ((l1[0] < rect->xmin && l2[0] < rect->xmin) || (l1[0] > rect->xmax && l2[0] > rect->xmax)) {
1603                         return 0;
1604                 }
1605                 
1606                 
1607                 if (fabsf(l1[0]-l2[0]) < PROJ_GEOM_TOLERANCE) { /* this is a single point  (or close to)*/
1608                         if (BLI_in_rctf(rect, l1[0], l1[1])) {
1609                                 copy_v2_v2(l1_clip, l1);
1610                                 copy_v2_v2(l2_clip, l2);
1611                                 return 1;
1612                         }
1613                         else {
1614                                 return 0;
1615                         }
1616                 }
1617                 
1618                 copy_v2_v2(l1_clip, l1);
1619                 copy_v2_v2(l2_clip, l2);
1620                 CLAMP(l1_clip[0], rect->xmin, rect->xmax);
1621                 CLAMP(l2_clip[0], rect->xmin, rect->xmax);
1622                 return 1;
1623         }
1624         else if (fabsf(l1[0]-l2[0]) < PROJ_GEOM_TOLERANCE) {
1625                 /* is the line out of range on its X axis? */
1626                 if (l1[0] < rect->xmin || l1[0] > rect->xmax) {
1627                         return 0;
1628                 }
1629                 
1630                 /* line is out of range on its Y axis */
1631                 if ((l1[1] < rect->ymin && l2[1] < rect->ymin) || (l1[1] > rect->ymax && l2[1] > rect->ymax)) {
1632                         return 0;
1633                 }
1634                 
1635                 if (fabsf(l1[1]-l2[1]) < PROJ_GEOM_TOLERANCE) { /* this is a single point  (or close to)*/
1636                         if (BLI_in_rctf(rect, l1[0], l1[1])) {
1637                                 copy_v2_v2(l1_clip, l1);
1638                                 copy_v2_v2(l2_clip, l2);
1639                                 return 1;
1640                         }
1641                         else {
1642                                 return 0;
1643                         }
1644                 }
1645                 
1646                 copy_v2_v2(l1_clip, l1);
1647                 copy_v2_v2(l2_clip, l2);
1648                 CLAMP(l1_clip[1], rect->ymin, rect->ymax);
1649                 CLAMP(l2_clip[1], rect->ymin, rect->ymax);
1650                 return 1;
1651         }
1652         else {
1653                 float isect;
1654                 short ok1 = 0;
1655                 short ok2 = 0;
1656                 
1657                 /* Done with vertical lines */
1658                 
1659                 /* are either of the points inside the rectangle ? */
1660                 if (BLI_in_rctf(rect, l1[0], l1[1])) {
1661                         copy_v2_v2(l1_clip, l1);
1662                         ok1 = 1;
1663                 }
1664                 
1665                 if (BLI_in_rctf(rect, l2[0], l2[1])) {
1666                         copy_v2_v2(l2_clip, l2);
1667                         ok2 = 1;
1668                 }
1669                 
1670                 /* line inside rect */
1671                 if (ok1 && ok2) return 1;
1672                 
1673                 /* top/bottom */
1674                 if (line_isect_y(l1, l2, rect->ymin, &isect) && (isect >= rect->xmin) && (isect <= rect->xmax)) {
1675                         if (l1[1] < l2[1]) { /* line 1 is outside */
1676                                 l1_clip[0] = isect;
1677                                 l1_clip[1] = rect->ymin;
1678                                 ok1 = 1;
1679                         }
1680                         else {
1681                                 l2_clip[0] = isect;
1682                                 l2_clip[1] = rect->ymin;
1683                                 ok2 = 2;
1684                         }
1685                 }
1686                 
1687                 if (ok1 && ok2) return 1;
1688                 
1689                 if (line_isect_y(l1, l2, rect->ymax, &isect) && (isect >= rect->xmin) && (isect <= rect->xmax)) {
1690                         if (l1[1] > l2[1]) { /* line 1 is outside */
1691                                 l1_clip[0] = isect;
1692                                 l1_clip[1] = rect->ymax;
1693                                 ok1 = 1;
1694                         }
1695                         else {
1696                                 l2_clip[0] = isect;
1697                                 l2_clip[1] = rect->ymax;
1698                                 ok2 = 2;
1699                         }
1700                 }
1701                 
1702                 if (ok1 && ok2) return 1;
1703                 
1704                 /* left/right */
1705                 if (line_isect_x(l1, l2, rect->xmin, &isect) && (isect >= rect->ymin) && (isect <= rect->ymax)) {
1706                         if (l1[0] < l2[0]) { /* line 1 is outside */
1707                                 l1_clip[0] = rect->xmin;
1708                                 l1_clip[1] = isect;
1709                                 ok1 = 1;
1710                         }
1711                         else {
1712                                 l2_clip[0] = rect->xmin;
1713                                 l2_clip[1] = isect;
1714                                 ok2 = 2;
1715                         }
1716                 }
1717         
1718                 if (ok1 && ok2) return 1;
1719                 
1720                 if (line_isect_x(l1, l2, rect->xmax, &isect) && (isect >= rect->ymin) && (isect <= rect->ymax)) {
1721                         if (l1[0] > l2[0]) { /* line 1 is outside */
1722                                 l1_clip[0] = rect->xmax;
1723                                 l1_clip[1] = isect;
1724                                 ok1 = 1;
1725                         }
1726                         else {
1727                                 l2_clip[0] = rect->xmax;
1728                                 l2_clip[1] = isect;
1729                                 ok2 = 2;
1730                         }
1731                 }
1732                 
1733                 if (ok1 && ok2) {
1734                         return 1;
1735                 }
1736                 else {
1737                         return 0;
1738                 }
1739         }
1740 }
1741
1742
1743
1744 /* scale the quad & tri about its center
1745  * scaling by PROJ_FACE_SCALE_SEAM (0.99x) is used for getting fake UV pixel coords that are on the
1746  * edge of the face but slightly inside it occlusion tests dont return hits on adjacent faces */
1747 #ifndef PROJ_DEBUG_NOSEAMBLEED
1748 static void scale_quad(float insetCos[4][3], float *origCos[4], const float inset)
1749 {
1750         float cent[3];
1751         cent[0] = (origCos[0][0] + origCos[1][0] + origCos[2][0] + origCos[3][0]) / 4.0f;
1752         cent[1] = (origCos[0][1] + origCos[1][1] + origCos[2][1] + origCos[3][1]) / 4.0f;
1753         cent[2] = (origCos[0][2] + origCos[1][2] + origCos[2][2] + origCos[3][2]) / 4.0f;
1754         
1755         sub_v3_v3v3(insetCos[0], origCos[0], cent);
1756         sub_v3_v3v3(insetCos[1], origCos[1], cent);
1757         sub_v3_v3v3(insetCos[2], origCos[2], cent);
1758         sub_v3_v3v3(insetCos[3], origCos[3], cent);
1759         
1760         mul_v3_fl(insetCos[0], inset);
1761         mul_v3_fl(insetCos[1], inset);
1762         mul_v3_fl(insetCos[2], inset);
1763         mul_v3_fl(insetCos[3], inset);
1764         
1765         add_v3_v3(insetCos[0], cent);
1766         add_v3_v3(insetCos[1], cent);
1767         add_v3_v3(insetCos[2], cent);
1768         add_v3_v3(insetCos[3], cent);
1769 }
1770
1771
1772 static void scale_tri(float insetCos[4][3], float *origCos[4], const float inset)
1773 {
1774         float cent[3];
1775         cent[0] = (origCos[0][0] + origCos[1][0] + origCos[2][0]) / 3.0f;
1776         cent[1] = (origCos[0][1] + origCos[1][1] + origCos[2][1]) / 3.0f;
1777         cent[2] = (origCos[0][2] + origCos[1][2] + origCos[2][2]) / 3.0f;
1778         
1779         sub_v3_v3v3(insetCos[0], origCos[0], cent);
1780         sub_v3_v3v3(insetCos[1], origCos[1], cent);
1781         sub_v3_v3v3(insetCos[2], origCos[2], cent);
1782         
1783         mul_v3_fl(insetCos[0], inset);
1784         mul_v3_fl(insetCos[1], inset);
1785         mul_v3_fl(insetCos[2], inset);
1786         
1787         add_v3_v3(insetCos[0], cent);
1788         add_v3_v3(insetCos[1], cent);
1789         add_v3_v3(insetCos[2], cent);
1790 }
1791 #endif //PROJ_DEBUG_NOSEAMBLEED
1792
1793 static float len_squared_v2v2_alt(const float *v1, const float v2_1, const float v2_2)
1794 {
1795         float x, y;
1796
1797         x = v1[0]-v2_1;
1798         y = v1[1]-v2_2;
1799         return x*x+y*y;
1800 }
1801
1802 /* note, use a squared value so we can use len_squared_v2v2
1803  * be sure that you have done a bounds check first or this may fail */
1804 /* only give bucket_bounds as an arg because we need it elsewhere */
1805 static int project_bucket_isect_circle(const float cent[2], const float radius_squared, rctf *bucket_bounds)
1806 {
1807          
1808         /* Would normally to a simple intersection test, however we know the bounds of these 2 already intersect 
1809          * so we only need to test if the center is inside the vertical or horizontal bounds on either axis,
1810          * this is even less work then an intersection test
1811          * 
1812         if (BLI_in_rctf(bucket_bounds, cent[0], cent[1]))
1813                 return 1;
1814          */
1815         
1816         if ( (bucket_bounds->xmin <= cent[0] && bucket_bounds->xmax >= cent[0]) ||
1817              (bucket_bounds->ymin <= cent[1] && bucket_bounds->ymax >= cent[1]) )
1818         {
1819                 return 1;
1820         }
1821         
1822         /* out of bounds left */
1823         if (cent[0] < bucket_bounds->xmin) {
1824                 /* lower left out of radius test */
1825                 if (cent[1] < bucket_bounds->ymin) {
1826                         return (len_squared_v2v2_alt(cent, bucket_bounds->xmin, bucket_bounds->ymin) < radius_squared) ? 1 : 0;
1827                 } 
1828                 /* top left test */
1829                 else if (cent[1] > bucket_bounds->ymax) {
1830                         return (len_squared_v2v2_alt(cent, bucket_bounds->xmin, bucket_bounds->ymax) < radius_squared) ? 1 : 0;
1831                 }
1832         }
1833         else if (cent[0] > bucket_bounds->xmax) {
1834                 /* lower right out of radius test */
1835                 if (cent[1] < bucket_bounds->ymin) {
1836                         return (len_squared_v2v2_alt(cent, bucket_bounds->xmax, bucket_bounds->ymin) < radius_squared) ? 1 : 0;
1837                 } 
1838                 /* top right test */
1839                 else if (cent[1] > bucket_bounds->ymax) {
1840                         return (len_squared_v2v2_alt(cent, bucket_bounds->xmax, bucket_bounds->ymax) < radius_squared) ? 1 : 0;
1841                 }
1842         }
1843         
1844         return 0;
1845 }
1846
1847
1848
1849 /* Note for rect_to_uvspace_ortho() and rect_to_uvspace_persp()
1850  * in ortho view this function gives good results when bucket_bounds are outside the triangle
1851  * however in some cases, perspective view will mess up with faces that have minimal screenspace area (viewed from the side)
1852  * 
1853  * for this reason its not relyable in this case so we'll use the Simple Barycentric' funcs that only account for points inside the triangle.
1854  * however switching back to this for ortho is always an option */
1855
1856 static void rect_to_uvspace_ortho(
1857                 rctf *bucket_bounds,
1858                 float *v1coSS, float *v2coSS, float *v3coSS,
1859                 float *uv1co, float *uv2co, float *uv3co,
1860                 float bucket_bounds_uv[4][2],
1861                 const int flip)
1862 {
1863         float uv[2];
1864         float w[3];
1865         
1866         /* get the UV space bounding box */
1867         uv[0] = bucket_bounds->xmax;
1868         uv[1] = bucket_bounds->ymin;
1869         barycentric_weights_v2(v1coSS, v2coSS, v3coSS, uv, w);
1870         interp_v2_v2v2v2(bucket_bounds_uv[flip?3:0], uv1co, uv2co, uv3co, w);
1871
1872         //uv[0] = bucket_bounds->xmax; // set above
1873         uv[1] = bucket_bounds->ymax;
1874         barycentric_weights_v2(v1coSS, v2coSS, v3coSS, uv, w);
1875         interp_v2_v2v2v2(bucket_bounds_uv[flip?2:1], uv1co, uv2co, uv3co, w);
1876
1877         uv[0] = bucket_bounds->xmin;
1878         //uv[1] = bucket_bounds->ymax; // set above
1879         barycentric_weights_v2(v1coSS, v2coSS, v3coSS, uv, w);
1880         interp_v2_v2v2v2(bucket_bounds_uv[flip?1:2], uv1co, uv2co, uv3co, w);
1881
1882         //uv[0] = bucket_bounds->xmin; // set above
1883         uv[1] = bucket_bounds->ymin;
1884         barycentric_weights_v2(v1coSS, v2coSS, v3coSS, uv, w);
1885         interp_v2_v2v2v2(bucket_bounds_uv[flip?0:3], uv1co, uv2co, uv3co, w);
1886 }
1887
1888 /* same as above but use barycentric_weights_v2_persp */
1889 static void rect_to_uvspace_persp(
1890                 rctf *bucket_bounds,
1891                 float *v1coSS, float *v2coSS, float *v3coSS,
1892                 float *uv1co, float *uv2co, float *uv3co,
1893                 float bucket_bounds_uv[4][2],
1894                 const int flip
1895         )
1896 {
1897         float uv[2];
1898         float w[3];
1899         
1900         /* get the UV space bounding box */
1901         uv[0] = bucket_bounds->xmax;
1902         uv[1] = bucket_bounds->ymin;
1903         barycentric_weights_v2_persp(v1coSS, v2coSS, v3coSS, uv, w);
1904         interp_v2_v2v2v2(bucket_bounds_uv[flip?3:0], uv1co, uv2co, uv3co, w);
1905
1906         //uv[0] = bucket_bounds->xmax; // set above
1907         uv[1] = bucket_bounds->ymax;
1908         barycentric_weights_v2_persp(v1coSS, v2coSS, v3coSS, uv, w);
1909         interp_v2_v2v2v2(bucket_bounds_uv[flip?2:1], uv1co, uv2co, uv3co, w);
1910
1911         uv[0] = bucket_bounds->xmin;
1912         //uv[1] = bucket_bounds->ymax; // set above
1913         barycentric_weights_v2_persp(v1coSS, v2coSS, v3coSS, uv, w);
1914         interp_v2_v2v2v2(bucket_bounds_uv[flip?1:2], uv1co, uv2co, uv3co, w);
1915
1916         //uv[0] = bucket_bounds->xmin; // set above
1917         uv[1] = bucket_bounds->ymin;
1918         barycentric_weights_v2_persp(v1coSS, v2coSS, v3coSS, uv, w);
1919         interp_v2_v2v2v2(bucket_bounds_uv[flip?0:3], uv1co, uv2co, uv3co, w);
1920 }
1921
1922 /* This works as we need it to but we can save a few steps and not use it */
1923
1924 #if 0
1925 static float angle_2d_clockwise(const float p1[2], const float p2[2], const float p3[2])
1926 {
1927         float v1[2], v2[2];
1928         
1929         v1[0] = p1[0]-p2[0];    v1[1] = p1[1]-p2[1];
1930         v2[0] = p3[0]-p2[0];    v2[1] = p3[1]-p2[1];
1931         
1932         return -atan2(v1[0]*v2[1] - v1[1]*v2[0], v1[0]*v2[0]+v1[1]*v2[1]);
1933 }
1934 #endif
1935
1936 #define ISECT_1 (1)
1937 #define ISECT_2 (1<<1)
1938 #define ISECT_3 (1<<2)
1939 #define ISECT_4 (1<<3)
1940 #define ISECT_ALL3 ((1<<3)-1)
1941 #define ISECT_ALL4 ((1<<4)-1)
1942
1943 /* limit must be a fraction over 1.0f */
1944 static int IsectPT2Df_limit(float pt[2], float v1[2], float v2[2], float v3[2], float limit)
1945 {
1946         return ((area_tri_v2(pt,v1,v2) + area_tri_v2(pt,v2,v3) + area_tri_v2(pt,v3,v1)) / (area_tri_v2(v1,v2,v3))) < limit;
1947 }
1948
1949 /* Clip the face by a bucket and set the uv-space bucket_bounds_uv
1950  * so we have the clipped UV's to do pixel intersection tests with 
1951  * */
1952 static int float_z_sort_flip(const void *p1, const void *p2)
1953 {
1954         return (((float *)p1)[2] < ((float *)p2)[2] ? 1:-1);
1955 }
1956
1957 static int float_z_sort(const void *p1, const void *p2)
1958 {
1959         return (((float *)p1)[2] < ((float *)p2)[2] ?-1:1);
1960 }
1961
1962 static void project_bucket_clip_face(
1963                 const int is_ortho,
1964                 rctf *bucket_bounds,
1965                 float *v1coSS, float *v2coSS, float *v3coSS,
1966                 float *uv1co, float *uv2co, float *uv3co,
1967                 float bucket_bounds_uv[8][2],
1968                 int *tot)
1969 {
1970         int inside_bucket_flag = 0;
1971         int inside_face_flag = 0;
1972         const int flip = ((line_point_side_v2(v1coSS, v2coSS, v3coSS) > 0.0f) != (line_point_side_v2(uv1co, uv2co, uv3co) > 0.0f));
1973         
1974         float bucket_bounds_ss[4][2];
1975
1976         /* get the UV space bounding box */
1977         inside_bucket_flag |= BLI_in_rctf(bucket_bounds, v1coSS[0], v1coSS[1]);
1978         inside_bucket_flag |= BLI_in_rctf(bucket_bounds, v2coSS[0], v2coSS[1])          << 1;
1979         inside_bucket_flag |= BLI_in_rctf(bucket_bounds, v3coSS[0], v3coSS[1])          << 2;
1980         
1981         if (inside_bucket_flag == ISECT_ALL3) {
1982                 /* all screenspace points are inside the bucket bounding box, this means we dont need to clip and can simply return the UVs */
1983                 if (flip) { /* facing the back? */
1984                         copy_v2_v2(bucket_bounds_uv[0], uv3co);
1985                         copy_v2_v2(bucket_bounds_uv[1], uv2co);
1986                         copy_v2_v2(bucket_bounds_uv[2], uv1co);
1987                 }
1988                 else {
1989                         copy_v2_v2(bucket_bounds_uv[0], uv1co);
1990                         copy_v2_v2(bucket_bounds_uv[1], uv2co);
1991                         copy_v2_v2(bucket_bounds_uv[2], uv3co);
1992                 }
1993                 
1994                 *tot = 3; 
1995                 return;
1996         }
1997         
1998         /* get the UV space bounding box */
1999         /* use IsectPT2Df_limit here so we catch points are are touching the tri edge (or a small fraction over) */
2000         bucket_bounds_ss[0][0] = bucket_bounds->xmax;
2001         bucket_bounds_ss[0][1] = bucket_bounds->ymin;
2002         inside_face_flag |= (IsectPT2Df_limit(bucket_bounds_ss[0], v1coSS, v2coSS, v3coSS, 1+PROJ_GEOM_TOLERANCE) ? ISECT_1 : 0);
2003         
2004         bucket_bounds_ss[1][0] = bucket_bounds->xmax;
2005         bucket_bounds_ss[1][1] = bucket_bounds->ymax;
2006         inside_face_flag |= (IsectPT2Df_limit(bucket_bounds_ss[1], v1coSS, v2coSS, v3coSS, 1+PROJ_GEOM_TOLERANCE) ? ISECT_2 : 0);
2007
2008         bucket_bounds_ss[2][0] = bucket_bounds->xmin;
2009         bucket_bounds_ss[2][1] = bucket_bounds->ymax;
2010         inside_face_flag |= (IsectPT2Df_limit(bucket_bounds_ss[2], v1coSS, v2coSS, v3coSS, 1+PROJ_GEOM_TOLERANCE) ? ISECT_3 : 0);
2011
2012         bucket_bounds_ss[3][0] = bucket_bounds->xmin;
2013         bucket_bounds_ss[3][1] = bucket_bounds->ymin;
2014         inside_face_flag |= (IsectPT2Df_limit(bucket_bounds_ss[3], v1coSS, v2coSS, v3coSS, 1+PROJ_GEOM_TOLERANCE) ? ISECT_4 : 0);
2015         
2016         if (inside_face_flag == ISECT_ALL4) {
2017                 /* bucket is totally inside the screenspace face, we can safely use weights */
2018                 
2019                 if (is_ortho)   rect_to_uvspace_ortho(bucket_bounds, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, bucket_bounds_uv, flip);
2020                 else                    rect_to_uvspace_persp(bucket_bounds, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, bucket_bounds_uv, flip);
2021                 
2022                 *tot = 4;
2023                 return;
2024         }
2025         else {
2026                 /* The Complicated Case! 
2027                  * 
2028                  * The 2 cases above are where the face is inside the bucket or the bucket is inside the face.
2029                  * 
2030                  * we need to make a convex polyline from the intersection between the screenspace face
2031                  * and the bucket bounds.
2032                  * 
2033                  * There are a number of ways this could be done, currently it just collects all intersecting verts,
2034                  * and line intersections,  then sorts them clockwise, this is a lot easier then evaluating the geometry to
2035                  * do a correct clipping on both shapes. */
2036                 
2037                 
2038                 /* add a bunch of points, we know must make up the convex hull which is the clipped rect and triangle */
2039                 
2040                 
2041                 
2042                 /* Maximum possible 6 intersections when using a rectangle and triangle */
2043                 float isectVCosSS[8][3]; /* The 3rd float is used to store angle for qsort(), NOT as a Z location */
2044                 float v1_clipSS[2], v2_clipSS[2];
2045                 float w[3];
2046                 
2047                 /* calc center*/
2048                 float cent[2] = {0.0f, 0.0f};
2049                 /*float up[2] = {0.0f, 1.0f};*/
2050                 int i;
2051                 short doubles;
2052                 
2053                 (*tot) = 0;
2054                 
2055                 if (inside_face_flag & ISECT_1) { copy_v2_v2(isectVCosSS[*tot], bucket_bounds_ss[0]); (*tot)++; }
2056                 if (inside_face_flag & ISECT_2) { copy_v2_v2(isectVCosSS[*tot], bucket_bounds_ss[1]); (*tot)++; }
2057                 if (inside_face_flag & ISECT_3) { copy_v2_v2(isectVCosSS[*tot], bucket_bounds_ss[2]); (*tot)++; }
2058                 if (inside_face_flag & ISECT_4) { copy_v2_v2(isectVCosSS[*tot], bucket_bounds_ss[3]); (*tot)++; }
2059                 
2060                 if (inside_bucket_flag & ISECT_1) {     copy_v2_v2(isectVCosSS[*tot], v1coSS); (*tot)++; }
2061                 if (inside_bucket_flag & ISECT_2) {     copy_v2_v2(isectVCosSS[*tot], v2coSS); (*tot)++; }
2062                 if (inside_bucket_flag & ISECT_3) {     copy_v2_v2(isectVCosSS[*tot], v3coSS); (*tot)++; }
2063                 
2064                 if ((inside_bucket_flag & (ISECT_1|ISECT_2)) != (ISECT_1|ISECT_2)) {
2065                         if (line_clip_rect2f(bucket_bounds, v1coSS, v2coSS, v1_clipSS, v2_clipSS)) {
2066                                 if ((inside_bucket_flag & ISECT_1)==0) { copy_v2_v2(isectVCosSS[*tot], v1_clipSS); (*tot)++; }
2067                                 if ((inside_bucket_flag & ISECT_2)==0) { copy_v2_v2(isectVCosSS[*tot], v2_clipSS); (*tot)++; }
2068                         }
2069                 }
2070                 
2071                 if ((inside_bucket_flag & (ISECT_2|ISECT_3)) != (ISECT_2|ISECT_3)) {
2072                         if (line_clip_rect2f(bucket_bounds, v2coSS, v3coSS, v1_clipSS, v2_clipSS)) {
2073                                 if ((inside_bucket_flag & ISECT_2)==0) { copy_v2_v2(isectVCosSS[*tot], v1_clipSS); (*tot)++; }
2074                                 if ((inside_bucket_flag & ISECT_3)==0) { copy_v2_v2(isectVCosSS[*tot], v2_clipSS); (*tot)++; }
2075                         }
2076                 }       
2077                 
2078                 if ((inside_bucket_flag & (ISECT_3|ISECT_1)) != (ISECT_3|ISECT_1)) {
2079                         if (line_clip_rect2f(bucket_bounds, v3coSS, v1coSS, v1_clipSS, v2_clipSS)) {
2080                                 if ((inside_bucket_flag & ISECT_3)==0) { copy_v2_v2(isectVCosSS[*tot], v1_clipSS); (*tot)++; }
2081                                 if ((inside_bucket_flag & ISECT_1)==0) { copy_v2_v2(isectVCosSS[*tot], v2_clipSS); (*tot)++; }
2082                         }
2083                 }
2084                 
2085                 
2086                 if ((*tot) < 3) { /* no intersections to speak of */
2087                         *tot = 0;
2088                         return;
2089                 }
2090         
2091                 /* now we have all points we need, collect their angles and sort them clockwise */
2092                 
2093                 for(i=0; i<(*tot); i++) {
2094                         cent[0] += isectVCosSS[i][0];
2095                         cent[1] += isectVCosSS[i][1];
2096                 }
2097                 cent[0] = cent[0] / (float)(*tot);
2098                 cent[1] = cent[1] / (float)(*tot);
2099                 
2100                 
2101                 
2102                 /* Collect angles for every point around the center point */
2103
2104                 
2105 #if 0   /* uses a few more cycles then the above loop */
2106                 for(i=0; i<(*tot); i++) {
2107                         isectVCosSS[i][2] = angle_2d_clockwise(up, cent, isectVCosSS[i]);
2108                 }
2109 #endif
2110
2111                 v1_clipSS[0] = cent[0]; /* Abuse this var for the loop below */
2112                 v1_clipSS[1] = cent[1] + 1.0f;
2113                 
2114                 for(i=0; i<(*tot); i++) {
2115                         v2_clipSS[0] = isectVCosSS[i][0] - cent[0];
2116                         v2_clipSS[1] = isectVCosSS[i][1] - cent[1];
2117                         isectVCosSS[i][2] = atan2f(v1_clipSS[0]*v2_clipSS[1] - v1_clipSS[1]*v2_clipSS[0], v1_clipSS[0]*v2_clipSS[0]+v1_clipSS[1]*v2_clipSS[1]); 
2118                 }
2119                 
2120                 if (flip)       qsort(isectVCosSS, *tot, sizeof(float)*3, float_z_sort_flip);
2121                 else            qsort(isectVCosSS, *tot, sizeof(float)*3, float_z_sort);
2122                 
2123                 /* remove doubles */
2124                 /* first/last check */
2125                 if (fabsf(isectVCosSS[0][0]-isectVCosSS[(*tot)-1][0]) < PROJ_GEOM_TOLERANCE &&  fabsf(isectVCosSS[0][1]-isectVCosSS[(*tot)-1][1]) < PROJ_GEOM_TOLERANCE) {
2126                         (*tot)--;
2127                 }
2128                 
2129                 /* its possible there is only a few left after remove doubles */
2130                 if ((*tot) < 3) {
2131                         // printf("removed too many doubles A\n");
2132                         *tot = 0;
2133                         return;
2134                 }
2135                 
2136                 doubles = TRUE;
2137                 while (doubles==TRUE) {
2138                         doubles = FALSE;
2139                         for(i=1; i<(*tot); i++) {
2140                                 if (fabsf(isectVCosSS[i-1][0]-isectVCosSS[i][0]) < PROJ_GEOM_TOLERANCE &&
2141                                         fabsf(isectVCosSS[i-1][1]-isectVCosSS[i][1]) < PROJ_GEOM_TOLERANCE)
2142                                 {
2143                                         int j;
2144                                         for(j=i+1; j<(*tot); j++) {
2145                                                 isectVCosSS[j-1][0] = isectVCosSS[j][0]; 
2146                                                 isectVCosSS[j-1][1] = isectVCosSS[j][1]; 
2147                                         }
2148                                         doubles = TRUE; /* keep looking for more doubles */
2149                                         (*tot)--;
2150                                 }
2151                         }
2152                 }
2153                 
2154                 /* its possible there is only a few left after remove doubles */
2155                 if ((*tot) < 3) {
2156                         // printf("removed too many doubles B\n");
2157                         *tot = 0;
2158                         return;
2159                 }
2160                 
2161                 
2162                 if (is_ortho) {
2163                         for(i=0; i<(*tot); i++) {
2164                                 barycentric_weights_v2(v1coSS, v2coSS, v3coSS, isectVCosSS[i], w);
2165                                 interp_v2_v2v2v2(bucket_bounds_uv[i], uv1co, uv2co, uv3co, w);
2166                         }
2167                 }
2168                 else {
2169                         for(i=0; i<(*tot); i++) {
2170                                 barycentric_weights_v2_persp(v1coSS, v2coSS, v3coSS, isectVCosSS[i], w);
2171                                 interp_v2_v2v2v2(bucket_bounds_uv[i], uv1co, uv2co, uv3co, w);
2172                         }
2173                 }
2174         }
2175
2176 #ifdef PROJ_DEBUG_PRINT_CLIP
2177         /* include this at the bottom of the above function to debug the output */
2178
2179         {
2180                 /* If there are ever any problems, */
2181                 float test_uv[4][2];
2182                 int i;
2183                 if (is_ortho)   rect_to_uvspace_ortho(bucket_bounds, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, test_uv, flip);
2184                 else                            rect_to_uvspace_persp(bucket_bounds, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, test_uv, flip);
2185                 printf("(  [(%f,%f), (%f,%f), (%f,%f), (%f,%f)], ", test_uv[0][0], test_uv[0][1],   test_uv[1][0], test_uv[1][1],    test_uv[2][0], test_uv[2][1],    test_uv[3][0], test_uv[3][1]);
2186                 
2187                 printf("  [(%f,%f), (%f,%f), (%f,%f)], ", uv1co[0], uv1co[1],   uv2co[0], uv2co[1],    uv3co[0], uv3co[1]);
2188                 
2189                 printf("[");
2190                 for (i=0; i < (*tot); i++) {
2191                         printf("(%f, %f),", bucket_bounds_uv[i][0], bucket_bounds_uv[i][1]);
2192                 }
2193                 printf("]),\\\n");
2194         }
2195 #endif
2196 }
2197
2198         /*
2199 # This script creates faces in a blender scene from printed data above.
2200
2201 project_ls = [
2202 ...(output from above block)...
2203 ]
2204  
2205 from Blender import Scene, Mesh, Window, sys, Mathutils
2206
2207 import bpy
2208
2209 V = Mathutils.Vector
2210
2211 def main():
2212         sce = bpy.data.scenes.active
2213         
2214         for item in project_ls:
2215                 bb = item[0]
2216                 uv = item[1]
2217                 poly = item[2]
2218                 
2219                 me = bpy.data.meshes.new()
2220                 ob = sce.objects.new(me)
2221                 
2222                 me.verts.extend([V(bb[0]).resize3D(), V(bb[1]).resize3D(), V(bb[2]).resize3D(), V(bb[3]).resize3D()])
2223                 me.faces.extend([(0,1,2,3),])
2224                 me.verts.extend([V(uv[0]).resize3D(), V(uv[1]).resize3D(), V(uv[2]).resize3D()])
2225                 me.faces.extend([(4,5,6),])
2226                 
2227                 vs = [V(p).resize3D() for p in poly]
2228                 print len(vs)
2229                 l = len(me.verts)
2230                 me.verts.extend(vs)
2231                 
2232                 i = l
2233                 while i < len(me.verts):
2234                         ii = i+1
2235                         if ii==len(me.verts):
2236                                 ii = l
2237                         me.edges.extend([i, ii])
2238                         i+=1
2239
2240 if __name__ == '__main__':
2241         main()
2242  */     
2243
2244
2245 #undef ISECT_1
2246 #undef ISECT_2
2247 #undef ISECT_3
2248 #undef ISECT_4
2249 #undef ISECT_ALL3
2250 #undef ISECT_ALL4
2251
2252         
2253 /* checks if pt is inside a convex 2D polyline, the polyline must be ordered rotating clockwise
2254  * otherwise it would have to test for mixed (line_point_side_v2 > 0.0f) cases */
2255 static int IsectPoly2Df(const float pt[2], float uv[][2], const int tot)
2256 {
2257         int i;
2258         if (line_point_side_v2(uv[tot-1], uv[0], pt) < 0.0f)
2259                 return 0;
2260         
2261         for (i=1; i<tot; i++) {
2262                 if (line_point_side_v2(uv[i-1], uv[i], pt) < 0.0f)
2263                         return 0;
2264                 
2265         }
2266         
2267         return 1;
2268 }
2269 static int IsectPoly2Df_twoside(const float pt[2], float uv[][2], const int tot)
2270 {
2271         int i;
2272         int side = (line_point_side_v2(uv[tot-1], uv[0], pt) > 0.0f);
2273         
2274         for (i=1; i<tot; i++) {
2275                 if ((line_point_side_v2(uv[i-1], uv[i], pt) > 0.0f) != side)
2276                         return 0;
2277                 
2278         }
2279         
2280         return 1;
2281 }
2282
2283 /* One of the most important function for projectiopn painting, since it selects the pixels to be added into each bucket.
2284  * initialize pixels from this face where it intersects with the bucket_index, optionally initialize pixels for removing seams */
2285 static void project_paint_face_init(const ProjPaintState *ps, const int thread_index, const int bucket_index, const int face_index, const int image_index, rctf *bucket_bounds, const ImBuf *ibuf, const short clamp_u, const short clamp_v)
2286 {
2287         /* Projection vars, to get the 3D locations into screen space  */
2288         MemArena *arena = ps->arena_mt[thread_index];
2289         LinkNode **bucketPixelNodes = ps->bucketRect + bucket_index;
2290         LinkNode *bucketFaceNodes = ps->bucketFaces[bucket_index];
2291         
2292         const MFace *mf = ps->dm_mface + face_index;
2293         const MTFace *tf = ps->dm_mtface + face_index;
2294         
2295         /* UV/pixel seeking data */
2296         int x; /* Image X-Pixel */
2297         int y;/* Image Y-Pixel */
2298         float mask;
2299         float uv[2]; /* Image floating point UV - same as x, y but from 0.0-1.0 */
2300         
2301         int side;
2302         float *v1coSS, *v2coSS, *v3coSS; /* vert co screen-space, these will be assigned to mf->v1,2,3 or mf->v1,3,4 */
2303         
2304         float *vCo[4]; /* vertex screenspace coords */
2305         
2306         float w[3], wco[3];
2307         
2308         float *uv1co, *uv2co, *uv3co; /* for convenience only, these will be assigned to tf->uv[0],1,2 or tf->uv[0],2,3 */
2309         float pixelScreenCo[4];
2310         
2311         rcti bounds_px; /* ispace bounds */
2312         /* vars for getting uvspace bounds */
2313         
2314         float tf_uv_pxoffset[4][2]; /* bucket bounds in UV space so we can init pixels only for this face,  */
2315         float xhalfpx, yhalfpx;
2316         const float ibuf_xf = (float)ibuf->x, ibuf_yf = (float)ibuf->y;
2317         
2318         int has_x_isect = 0, has_isect = 0; /* for early loop exit */
2319         
2320         int i1, i2, i3;
2321         
2322         float uv_clip[8][2];
2323         int uv_clip_tot;
2324         const short is_ortho = ps->is_ortho;
2325         const short do_backfacecull = ps->do_backfacecull;
2326         const short do_clip= ps->rv3d ? ps->rv3d->rflag & RV3D_CLIPPING : 0;
2327         
2328         vCo[0] = ps->dm_mvert[mf->v1].co;
2329         vCo[1] = ps->dm_mvert[mf->v2].co;
2330         vCo[2] = ps->dm_mvert[mf->v3].co;
2331         
2332         
2333         /* Use tf_uv_pxoffset instead of tf->uv so we can offset the UV half a pixel
2334          * this is done so we can avoid offseting all the pixels by 0.5 which causes
2335          * problems when wrapping negative coords */
2336         xhalfpx = (0.5f+   (PROJ_GEOM_TOLERANCE/3.0f)   ) / ibuf_xf;
2337         yhalfpx = (0.5f+   (PROJ_GEOM_TOLERANCE/4.0f)   ) / ibuf_yf;
2338         
2339         /* Note about (PROJ_GEOM_TOLERANCE/x) above...
2340           Needed to add this offset since UV coords are often quads aligned to pixels.
2341           In this case pixels can be exactly between 2 triangles causing nasty
2342           artifacts.
2343           
2344           This workaround can be removed and painting will still work on most cases
2345           but since the first thing most people try is painting onto a quad- better make it work.
2346          */
2347
2348
2349
2350         tf_uv_pxoffset[0][0] = tf->uv[0][0] - xhalfpx;
2351         tf_uv_pxoffset[0][1] = tf->uv[0][1] - yhalfpx;
2352
2353         tf_uv_pxoffset[1][0] = tf->uv[1][0] - xhalfpx;
2354         tf_uv_pxoffset[1][1] = tf->uv[1][1] - yhalfpx;
2355         
2356         tf_uv_pxoffset[2][0] = tf->uv[2][0] - xhalfpx;
2357         tf_uv_pxoffset[2][1] = tf->uv[2][1] - yhalfpx;  
2358         
2359         if (mf->v4) {
2360                 vCo[3] = ps->dm_mvert[ mf->v4 ].co;
2361                 
2362                 tf_uv_pxoffset[3][0] = tf->uv[3][0] - xhalfpx;
2363                 tf_uv_pxoffset[3][1] = tf->uv[3][1] - yhalfpx;
2364                 side = 1;
2365         }
2366         else {
2367                 side = 0;
2368         }
2369         
2370         do {
2371                 if (side==1) {
2372                         i1=0; i2=2; i3=3;
2373                 }
2374                 else {
2375                         i1=0; i2=1; i3=2;
2376                 }
2377                 
2378                 uv1co = tf_uv_pxoffset[i1]; // was tf->uv[i1];
2379                 uv2co = tf_uv_pxoffset[i2]; // was tf->uv[i2];
2380                 uv3co = tf_uv_pxoffset[i3]; // was tf->uv[i3];
2381
2382                 v1coSS = ps->screenCoords[ (*(&mf->v1 + i1)) ];
2383                 v2coSS = ps->screenCoords[ (*(&mf->v1 + i2)) ];
2384                 v3coSS = ps->screenCoords[ (*(&mf->v1 + i3)) ];
2385                 
2386                 /* This funtion gives is a concave polyline in UV space from the clipped quad and tri*/
2387                 project_bucket_clip_face(
2388                                 is_ortho, bucket_bounds,
2389                                 v1coSS, v2coSS, v3coSS,
2390                                 uv1co, uv2co, uv3co,
2391                                 uv_clip, &uv_clip_tot
2392                 );
2393
2394                 /* sometimes this happens, better just allow for 8 intersectiosn even though there should be max 6 */
2395                 /*
2396                 if (uv_clip_tot>6) {
2397                         printf("this should never happen! %d\n", uv_clip_tot);
2398                 }*/
2399                 
2400
2401                 if (pixel_bounds_array(uv_clip, &bounds_px, ibuf->x, ibuf->y, uv_clip_tot)) {
2402
2403                         if(clamp_u) {
2404                                 CLAMP(bounds_px.xmin, 0, ibuf->x);
2405                                 CLAMP(bounds_px.xmax, 0, ibuf->x);
2406                         }
2407
2408                         if(clamp_v) {
2409                                 CLAMP(bounds_px.ymin, 0, ibuf->y);
2410                                 CLAMP(bounds_px.ymax, 0, ibuf->y);
2411                         }
2412
2413                         /* clip face and */
2414                         
2415                         has_isect = 0;
2416                         for (y = bounds_px.ymin; y < bounds_px.ymax; y++) {
2417                                 //uv[1] = (((float)y) + 0.5f) / (float)ibuf->y;
2418                                 uv[1] = (float)y / ibuf_yf; /* use pixel offset UV coords instead */
2419
2420                                 has_x_isect = 0;
2421                                 for (x = bounds_px.xmin; x < bounds_px.xmax; x++) {
2422                                         //uv[0] = (((float)x) + 0.5f) / ibuf->x;
2423                                         uv[0] = (float)x / ibuf_xf; /* use pixel offset UV coords instead */
2424                                         
2425                                         /* Note about IsectPoly2Df_twoside, checking the face or uv flipping doesnt work,
2426                                          * could check the poly direction but better to do this */
2427                                         if(     (do_backfacecull                && IsectPoly2Df(uv, uv_clip, uv_clip_tot)) ||
2428                                                 (do_backfacecull==0             && IsectPoly2Df_twoside(uv, uv_clip, uv_clip_tot))) {
2429                                                 
2430                                                 has_x_isect = has_isect = 1;
2431                                                 
2432                                                 if (is_ortho)   screen_px_from_ortho(uv, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, pixelScreenCo, w);
2433                                                 else                    screen_px_from_persp(uv, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, pixelScreenCo, w);
2434                                                 
2435                                                 /* a pitty we need to get the worldspace pixel location here */
2436                                                 if(do_clip) {
2437                                                         interp_v3_v3v3v3(wco, ps->dm_mvert[ (*(&mf->v1 + i1)) ].co, ps->dm_mvert[ (*(&mf->v1 + i2)) ].co, ps->dm_mvert[ (*(&mf->v1 + i3)) ].co, w);
2438                                                         if(ED_view3d_test_clipping(ps->rv3d, wco, 1)) {
2439                                                                 continue; /* Watch out that no code below this needs to run */
2440                                                         }
2441                                                 }
2442                                                 
2443                                                 /* Is this UV visible from the view? - raytrace */
2444                                                 /* project_paint_PickFace is less complex, use for testing */
2445                                                 //if (project_paint_PickFace(ps, pixelScreenCo, w, &side) == face_index) {
2446                                                 if (ps->do_occlude==0 || !project_bucket_point_occluded(ps, bucketFaceNodes, face_index, pixelScreenCo)) {
2447                                                         
2448                                                         mask = project_paint_uvpixel_mask(ps, face_index, side, w);
2449                                                         
2450                                                         if (mask > 0.0f) {
2451                                                                 BLI_linklist_prepend_arena(
2452                                                                         bucketPixelNodes,
2453                                                                         project_paint_uvpixel_init(ps, arena, ibuf, x, y, mask, face_index, image_index, pixelScreenCo, side, w),
2454                                                                         arena
2455                                                                 );
2456                                                         }
2457                                                 }
2458                                                 
2459                                         }
2460 //#if 0
2461                                         else if (has_x_isect) {
2462                                                 /* assuming the face is not a bow-tie - we know we cant intersect again on the X */
2463                                                 break;
2464                                         }
2465 //#endif
2466                                 }
2467                                 
2468                                 
2469 #if 0                   /* TODO - investigate why this dosnt work sometimes! it should! */
2470                                 /* no intersection for this entire row, after some intersection above means we can quit now */
2471                                 if (has_x_isect==0 && has_isect) { 
2472                                         break;
2473                                 }
2474 #endif
2475                         }
2476                 }
2477         } while(side--);
2478
2479         
2480         
2481 #ifndef PROJ_DEBUG_NOSEAMBLEED
2482         if (ps->seam_bleed_px > 0.0f) {
2483                 int face_seam_flag;
2484                 
2485                 if (ps->thread_tot > 1)
2486                         BLI_lock_thread(LOCK_CUSTOM1); /* Other threads could be modifying these vars */
2487                 
2488                 face_seam_flag = ps->faceSeamFlags[face_index];
2489                 
2490                 /* are any of our edges un-initialized? */
2491                 if ((face_seam_flag & (PROJ_FACE_SEAM1|PROJ_FACE_NOSEAM1))==0 || 
2492                         (face_seam_flag & (PROJ_FACE_SEAM2|PROJ_FACE_NOSEAM2))==0 || 
2493                         (face_seam_flag & (PROJ_FACE_SEAM3|PROJ_FACE_NOSEAM3))==0 || 
2494                         (face_seam_flag & (PROJ_FACE_SEAM4|PROJ_FACE_NOSEAM4))==0
2495                 ) {
2496                         project_face_seams_init(ps, face_index, mf->v4);
2497                         face_seam_flag = ps->faceSeamFlags[face_index];
2498                         //printf("seams - %d %d %d %d\n", flag&PROJ_FACE_SEAM1, flag&PROJ_FACE_SEAM2, flag&PROJ_FACE_SEAM3, flag&PROJ_FACE_SEAM4);
2499                 }
2500                 
2501                 if ((face_seam_flag & (PROJ_FACE_SEAM1|PROJ_FACE_SEAM2|PROJ_FACE_SEAM3|PROJ_FACE_SEAM4))==0) {
2502                         
2503                         if (ps->thread_tot > 1)
2504                                 BLI_unlock_thread(LOCK_CUSTOM1); /* Other threads could be modifying these vars */
2505                         
2506                 }
2507                 else {
2508                         /* we have a seam - deal with it! */
2509                         
2510                         /* Now create new UV's for the seam face */
2511                         float (*outset_uv)[2] = ps->faceSeamUVs[face_index];
2512                         float insetCos[4][3]; /* inset face coords.  NOTE!!! ScreenSace for ortho, Worldspace in prespective view */
2513
2514                         float fac;
2515                         float *vCoSS[4]; /* vertex screenspace coords */
2516                         
2517                         float bucket_clip_edges[2][2]; /* store the screenspace coords of the face, clipped by the bucket's screen aligned rectangle */
2518                         float edge_verts_inset_clip[2][3];
2519                         int fidx1, fidx2; /* face edge pairs - loop throuh these ((0,1), (1,2), (2,3), (3,0)) or ((0,1), (1,2), (2,0)) for a tri */
2520                         
2521                         float seam_subsection[4][2];
2522                         float fac1, fac2, ftot;
2523                         
2524                         
2525                         if (outset_uv[0][0]==FLT_MAX) /* first time initialize */
2526                                 uv_image_outset(tf_uv_pxoffset, outset_uv, ps->seam_bleed_px, ibuf->x, ibuf->y, mf->v4);
2527                         
2528                         /* ps->faceSeamUVs cant be modified when threading, now this is done we can unlock */
2529                         if (ps->thread_tot > 1)
2530                                 BLI_unlock_thread(LOCK_CUSTOM1); /* Other threads could be modifying these vars */
2531                         
2532                         vCoSS[0] = ps->screenCoords[mf->v1];
2533                         vCoSS[1] = ps->screenCoords[mf->v2];
2534                         vCoSS[2] = ps->screenCoords[mf->v3];
2535                         if (mf->v4)
2536                                 vCoSS[3] = ps->screenCoords[ mf->v4 ];
2537                         
2538                         /* PROJ_FACE_SCALE_SEAM must be slightly less then 1.0f */
2539                         if (is_ortho) {
2540                                 if (mf->v4)     scale_quad(insetCos, vCoSS, PROJ_FACE_SCALE_SEAM);
2541                                 else            scale_tri(insetCos, vCoSS, PROJ_FACE_SCALE_SEAM);
2542                         }
2543                         else {
2544                                 if (mf->v4)     scale_quad(insetCos, vCo, PROJ_FACE_SCALE_SEAM);
2545                                 else            scale_tri(insetCos, vCo, PROJ_FACE_SCALE_SEAM);
2546                         }
2547                         
2548                         side = 0; /* for triangles this wont need to change */
2549                         
2550                         for (fidx1 = 0; fidx1 < (mf->v4 ? 4 : 3); fidx1++) {
2551                                 if (mf->v4)             fidx2 = (fidx1==3) ? 0 : fidx1+1; /* next fidx in the face (0,1,2,3) -> (1,2,3,0) */
2552                                 else                    fidx2 = (fidx1==2) ? 0 : fidx1+1; /* next fidx in the face (0,1,2) -> (1,2,0) */
2553                                 
2554                                 if (    (face_seam_flag & (1<<fidx1)) && /* 1<<fidx1 -> PROJ_FACE_SEAM# */
2555                                                 line_clip_rect2f(bucket_bounds, vCoSS[fidx1], vCoSS[fidx2], bucket_clip_edges[0], bucket_clip_edges[1])
2556                                 ) {
2557
2558                                         ftot = len_v2v2(vCoSS[fidx1], vCoSS[fidx2]); /* screenspace edge length */
2559                                         
2560                                         if (ftot > 0.0f) { /* avoid div by zero */
2561                                                 if (mf->v4) {
2562                                                         if (fidx1==2 || fidx2==2)       side= 1;
2563                                                         else                                            side= 0;
2564                                                 }
2565                                                 
2566                                                 fac1 = len_v2v2(vCoSS[fidx1], bucket_clip_edges[0]) / ftot;
2567                                                 fac2 = len_v2v2(vCoSS[fidx1], bucket_clip_edges[1]) / ftot;
2568                                                 
2569                                                 interp_v2_v2v2(seam_subsection[0], tf_uv_pxoffset[fidx1], tf_uv_pxoffset[fidx2], fac1);
2570                                                 interp_v2_v2v2(seam_subsection[1], tf_uv_pxoffset[fidx1], tf_uv_pxoffset[fidx2], fac2);
2571
2572                                                 interp_v2_v2v2(seam_subsection[2], outset_uv[fidx1], outset_uv[fidx2], fac2);
2573                                                 interp_v2_v2v2(seam_subsection[3], outset_uv[fidx1], outset_uv[fidx2], fac1);
2574                                                 
2575                                                 /* if the bucket_clip_edges values Z values was kept we could avoid this
2576                                                  * Inset needs to be added so occlusion tests wont hit adjacent faces */
2577                                                 interp_v3_v3v3(edge_verts_inset_clip[0], insetCos[fidx1], insetCos[fidx2], fac1);
2578                                                 interp_v3_v3v3(edge_verts_inset_clip[1], insetCos[fidx1], insetCos[fidx2], fac2);
2579                                                 
2580
2581                                                 if (pixel_bounds_uv(seam_subsection[0], seam_subsection[1], seam_subsection[2], seam_subsection[3], &bounds_px, ibuf->x, ibuf->y, 1)) {
2582                                                         /* bounds between the seam rect and the uvspace bucket pixels */
2583                                                         
2584                                                         has_isect = 0;
2585                                                         for (y = bounds_px.ymin; y < bounds_px.ymax; y++) {
2586                                                                 // uv[1] = (((float)y) + 0.5f) / (float)ibuf->y;
2587                                                                 uv[1] = (float)y / ibuf_yf; /* use offset uvs instead */
2588                                                                 
2589                                                                 has_x_isect = 0;
2590                                                                 for (x = bounds_px.xmin; x < bounds_px.xmax; x++) {
2591                                                                         //uv[0] = (((float)x) + 0.5f) / (float)ibuf->x;
2592                                                                         uv[0] = (float)x / ibuf_xf; /* use offset uvs instead */
2593                                                                         
2594                                                                         /* test we're inside uvspace bucket and triangle bounds */
2595                                                                         if (isect_point_quad_v2(uv, seam_subsection[0], seam_subsection[1], seam_subsection[2], seam_subsection[3])) {
2596                                                                                 
2597                                                                                 /* We need to find the closest point along the face edge,
2598                                                                                  * getting the screen_px_from_*** wont work because our actual location
2599                                                                                  * is not relevent, since we are outside the face, Use VecLerpf to find
2600                                                                                  * our location on the side of the face's UV */
2601                                                                                 /*
2602                                                                                 if (is_ortho)   screen_px_from_ortho(ps, uv, v1co, v2co, v3co, uv1co, uv2co, uv3co, pixelScreenCo);
2603                                                                                 else                                    screen_px_from_persp(ps, uv, v1co, v2co, v3co, uv1co, uv2co, uv3co, pixelScreenCo);
2604                                                                                 */
2605                                                                                 
2606                                                                                 /* Since this is a seam we need to work out where on the line this pixel is */
2607                                                                                 //fac = line_point_factor_v2(uv, uv_seam_quad[0], uv_seam_quad[1]);
2608                                                                                 
2609                                                                                 fac = line_point_factor_v2(uv, seam_subsection[0], seam_subsection[1]);
2610                                                                                 if (fac < 0.0f)         { copy_v3_v3(pixelScreenCo, edge_verts_inset_clip[0]); }
2611                                                                                 else if (fac > 1.0f)    { copy_v3_v3(pixelScreenCo, edge_verts_inset_clip[1]); }
2612                                                                                 else                            { interp_v3_v3v3(pixelScreenCo, edge_verts_inset_clip[0], edge_verts_inset_clip[1], fac); }
2613                                                                                 
2614                                                                                 if (!is_ortho) {
2615                                                                                         pixelScreenCo[3] = 1.0f;
2616                                                                                         mul_m4_v4((float(*)[4])ps->projectMat, pixelScreenCo); /* cast because of const */
2617                                                                                         pixelScreenCo[0] = (float)(ps->winx/2.0f)+(ps->winx/2.0f)*pixelScreenCo[0]/pixelScreenCo[3];
2618                                                                                         pixelScreenCo[1] = (float)(ps->winy/2.0f)+(ps->winy/2.0f)*pixelScreenCo[1]/pixelScreenCo[3];
2619                                                                                         pixelScreenCo[2] = pixelScreenCo[2]/pixelScreenCo[3]; /* Use the depth for bucket point occlusion */
2620                                                                                 }
2621                                                                                 
2622                                                                                 if (ps->do_occlude==0 || !project_bucket_point_occluded(ps, bucketFaceNodes, face_index, pixelScreenCo)) {
2623                                                                                         
2624                                                                                         /* Only bother calculating the weights if we intersect */
2625                                                                                         if (ps->do_mask_normal || ps->dm_mtface_clone) {
2626 #if 1
2627                                                                                                 /* get the UV on the line since we want to copy the pixels from there for bleeding */
2628                                                                                                 float uv_close[2];
2629                                                                                                 float fac= closest_to_line_v2(uv_close, uv, tf_uv_pxoffset[fidx1], tf_uv_pxoffset[fidx2]);
2630                                                                                                 if              (fac < 0.0f) copy_v2_v2(uv_close, tf_uv_pxoffset[fidx1]);
2631                                                                                                 else if (fac > 1.0f) copy_v2_v2(uv_close, tf_uv_pxoffset[fidx2]);
2632
2633                                                                                                 if (side) {
2634                                                                                                         barycentric_weights_v2(tf_uv_pxoffset[0], tf_uv_pxoffset[2], tf_uv_pxoffset[3], uv_close, w);
2635                                                                                                 }
2636                                                                                                 else {
2637                                                                                                         barycentric_weights_v2(tf_uv_pxoffset[0], tf_uv_pxoffset[1], tf_uv_pxoffset[2], uv_close, w);
2638                                                                                                 }
2639 #else                                                                                   /* this is buggy with quads, dont use for now */
2640
2641                                                                                                 /* Cheat, we know where we are along the edge so work out the weights from that */
2642                                                                                                 fac = fac1 + (fac * (fac2-fac1));
2643
2644                                                                                                 w[0]=w[1]=w[2]= 0.0;
2645                                                                                                 if (side) {
2646                                                                                                         w[fidx1?fidx1-1:0] = 1.0f-fac;
2647                                                                                                         w[fidx2?fidx2-1:0] = fac;
2648                                                                                                 }
2649                                                                                                 else {
2650                                                                                                         w[fidx1] = 1.0f-fac;
2651                                                                                                         w[fidx2] = fac;
2652                                                                                                 }
2653 #endif
2654                                                                                         }
2655                                                                                         
2656                                                                                         /* a pitty we need to get the worldspace pixel location here */
2657                                                                                         if(do_clip) {
2658                                                                                                 if (side)       interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v3].co, ps->dm_mvert[mf->v4].co, w);
2659                                                                                                 else            interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v2].co, ps->dm_mvert[mf->v3].co, w);
2660
2661                                                                                                 if(ED_view3d_test_clipping(ps->rv3d, wco, 1)) {
2662                                                                                                         continue; /* Watch out that no code below this needs to run */
2663                                                                                                 }
2664                                                                                         }
2665                                                                                         
2666                                                                                         mask = project_paint_uvpixel_mask(ps, face_index, side, w);
2667                                                                                         
2668                                                                                         if (mask > 0.0f) {
2669                                                                                                 BLI_linklist_prepend_arena(
2670                                                                                                         bucketPixelNodes,
2671                                                                                                         project_paint_uvpixel_init(ps, arena, ibuf, x, y, mask, face_index, image_index, pixelScreenCo, side, w),
2672                                                                                                         arena
2673                                                                                                 );
2674                                                                                         }
2675                                                                                         
2676                                                                                 }
2677                                                                         }
2678                                                                         else if (has_x_isect) {
2679                                                                                 /* assuming the face is not a bow-tie - we know we cant intersect again on the X */
2680                                                                                 break;
2681                                                                         }
2682                                                                 }
2683                                                                 
2684 #if 0                                                   /* TODO - investigate why this dosnt work sometimes! it should! */
2685                                                                 /* no intersection for this entire row, after some intersection above means we can quit now */
2686                                                                 if (has_x_isect==0 && has_isect) { 
2687                                                                         break;
2688                                                                 }
2689 #endif
2690                                                         }
2691                                                 }
2692                                         }
2693                                 }
2694                         }
2695                 }
2696         }
2697 #endif // PROJ_DEBUG_NOSEAMBLEED
2698 }
2699
2700
2701 /* takes floating point screenspace min/max and returns int min/max to be used as indices for ps->bucketRect, ps->bucketFlags */
2702 static void project_paint_bucket_bounds(const ProjPaintState *ps, const float min[2], const float max[2], int bucketMin[2], int bucketMax[2])
2703 {
2704         /* divide by bucketWidth & bucketHeight so the bounds are offset in bucket grid units */
2705         /* XXX: the offset of 0.5 is always truncated to zero and the offset of 1.5f is always truncated to 1, is this really correct?? - jwilkins */
2706         bucketMin[0] = (int)((int)(((float)(min[0] - ps->screenMin[0]) / ps->screen_width) * ps->buckets_x) + 0.5f); /* these offsets of 0.5 and 1.5 seem odd but they are correct */
2707         bucketMin[1] = (int)((int)(((float)(min[1] - ps->screenMin[1]) / ps->screen_height) * ps->buckets_y) + 0.5f);
2708         
2709         bucketMax[0] = (int)((int)(((float)(max[0] - ps->screenMin[0]) / ps->screen_width) * ps->buckets_x) + 1.5f);
2710         bucketMax[1] = (int)((int)(((float)(max[1] - ps->screenMin[1]) / ps->screen_height) * ps->buckets_y) + 1.5f);
2711         
2712         /* incase the rect is outside the mesh 2d bounds */
2713         CLAMP(bucketMin[0], 0, ps->buckets_x);
2714         CLAMP(bucketMin[1], 0, ps->buckets_y);
2715         
2716         CLAMP(bucketMax[0], 0, ps->buckets_x);
2717         CLAMP(bucketMax[1], 0, ps->buckets_y);
2718 }
2719
2720 /* set bucket_bounds to a screen space-aligned floating point bound-box */
2721 static void project_bucket_bounds(const ProjPaintState *ps, const int bucket_x, const int bucket_y, rctf *bucket_bounds)
2722 {
2723         bucket_bounds->xmin =   ps->screenMin[0]+((bucket_x)*(ps->screen_width / ps->buckets_x));               /* left */
2724         bucket_bounds->xmax =   ps->screenMin[0]+((bucket_x+1)*(ps->screen_width / ps->buckets_x));     /* right */
2725         
2726         bucket_bounds->ymin =   ps->screenMin[1]+((bucket_y)*(ps->screen_height / ps->buckets_y));              /* bottom */
2727         bucket_bounds->ymax =   ps->screenMin[1]+((bucket_y+1)*(ps->screen_height  / ps->buckets_y));   /* top */
2728 }
2729
2730 /* Fill this bucket with pixels from the faces that intersect it.
2731  * 
2732  * have bucket_bounds as an argument so we don;t need to give bucket_x/y the rect function needs */
2733 static void project_bucket_init(const ProjPaintState *ps, const int thread_index, const int bucket_index, rctf *bucket_bounds)
2734 {
2735         LinkNode *node;
2736         int face_index, image_index=0;
2737         ImBuf *ibuf = NULL;
2738         Image *tpage_last = NULL, *tpage;
2739         Image *ima = NULL;
2740
2741         if (ps->image_tot==1) {
2742                 /* Simple loop, no context switching */
2743                 ibuf = ps->projImages[0].ibuf;
2744                 ima = ps->projImages[0].ima;
2745
2746                 for (node = ps->bucketFaces[bucket_index]; node; node= node->next) { 
2747                         project_paint_face_init(ps, thread_index, bucket_index, GET_INT_FROM_POINTER(node->link), 0, bucket_bounds, ibuf, ima->tpageflag & IMA_CLAMP_U, ima->tpageflag & IMA_CLAMP_V);
2748                 }
2749         }
2750         else {
2751                 
2752                 /* More complicated loop, switch between images */
2753                 for (node = ps->bucketFaces[bucket_index]; node; node= node->next) {
2754                         face_index = GET_INT_FROM_POINTER(node->link);
2755                                 
2756                         /* Image context switching */
2757                         tpage = project_paint_face_image(ps, ps->dm_mtface, face_index);
2758                         if (tpage_last != tpage) {
2759                                 tpage_last = tpage;
2760
2761                                 for (image_index=0; image_index < ps->image_tot; image_index++) {
2762                                         if (ps->projImages[image_index].ima == tpage_last) {
2763                                                 ibuf = ps->projImages[image_index].ibuf;
2764                                                 ima = ps->projImages[image_index].ima;
2765                                                 break;
2766                                         }
2767                                 }
2768                         }
2769                         /* context switching done */
2770                         
2771                         project_paint_face_init(ps, thread_index, bucket_index, face_index, image_index, bucket_bounds, ibuf, ima->tpageflag & IMA_CLAMP_U, ima->tpageflag & IMA_CLAMP_V);
2772                 }
2773         }
2774         
2775         ps->bucketFlags[bucket_index] |= PROJ_BUCKET_INIT;
2776 }
2777
2778
2779 /* We want to know if a bucket and a face overlap in screen-space
2780  * 
2781  * Note, if this ever returns false positives its not that bad, since a face in the bounding area will have its pixels
2782  * calculated when it might not be needed later, (at the moment at least)
2783  * obviously it shouldn't have bugs though */
2784
2785 static int project_bucket_face_isect(ProjPaintState *ps, int bucket_x, int bucket_y, const MFace *mf)
2786 {
2787         /* TODO - replace this with a tricker method that uses sideofline for all screenCoords's edges against the closest bucket corner */
2788         rctf bucket_bounds;
2789         float p1[2], p2[2], p3[2], p4[2];
2790         float *v, *v1,*v2,*v3,*v4=NULL;
2791         int fidx;
2792         
2793         project_bucket_bounds(ps, bucket_x, bucket_y, &bucket_bounds);
2794         
2795         /* Is one of the faces verts in the bucket bounds? */
2796         
2797         fidx = mf->v4 ? 3:2;
2798         do {
2799                 v = ps->screenCoords[ (*(&mf->v1 + fidx)) ];
2800                 if (BLI_in_rctf(&bucket_bounds, v[0], v[1])) {
2801                         return 1;
2802                 }
2803         } while (fidx--);
2804         
2805         v1 = ps->screenCoords[mf->v1];
2806         v2 = ps->screenCoords[mf->v2];
2807         v3 = ps->screenCoords[mf->v3];
2808         if (mf->v4) {
2809                 v4 = ps->screenCoords[mf->v4];
2810         }
2811         
2812         p1[0] = bucket_bounds.xmin; p1[1] = bucket_bounds.ymin;
2813         p2[0] = bucket_bounds.xmin;     p2[1] = bucket_bounds.ymax;
2814         p3[0] = bucket_bounds.xmax;     p3[1] = bucket_bounds.ymax;
2815         p4[0] = bucket_bounds.xmax;     p4[1] = bucket_bounds.ymin;
2816                 
2817         if (mf->v4) {
2818                 if ( isect_point_quad_v2(p1, v1, v2, v3, v4) ||
2819                      isect_point_quad_v2(p2, v1, v2, v3, v4) ||
2820                      isect_point_quad_v2(p3, v1, v2, v3, v4) ||
2821                      isect_point_quad_v2(p4, v1, v2, v3, v4) ||
2822
2823                         /* we can avoid testing v3,v1 because another intersection MUST exist if this intersects */
2824                         (isect_line_line_v2(p1, p2, v1, v2) || isect_line_line_v2(p1, p2, v2, v3) || isect_line_line_v2(p1, p2, v3, v4)) ||
2825                         (isect_line_line_v2(p2, p3, v1, v2) || isect_line_line_v2(p2, p3, v2, v3) || isect_line_line_v2(p2, p3, v3, v4)) ||
2826                         (isect_line_line_v2(p3, p4, v1, v2) || isect_line_line_v2(p3, p4, v2, v3) || isect_line_line_v2(p3, p4, v3, v4)) ||
2827                         (isect_line_line_v2(p4, p1, v1, v2) || isect_line_line_v2(p4, p1, v2, v3) || isect_line_line_v2(p4, p1, v3, v4))
2828                 ) {
2829                         return 1;
2830                 }
2831         }
2832         else {
2833                 if ( isect_point_tri_v2(p1, v1, v2, v3) ||
2834                      isect_point_tri_v2(p2, v1, v2, v3) ||
2835                      isect_point_tri_v2(p3, v1, v2, v3) ||
2836                      isect_point_tri_v2(p4, v1, v2, v3) ||
2837                         /* we can avoid testing v3,v1 because another intersection MUST exist if this intersects */
2838                         (isect_line_line_v2(p1, p2, v1, v2) ||