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