<sob>dropping OpenGL float buffer drawing... it seems that this isn't

a well supported feature for glDrawPixels(), especially on ATIs crashes
happen with it irregularly. (note; drawing float is a regular opengl 1.0
feature...).

Now all scanline/part updates in renderwindow is converted to 32 bits
before drawing, also the in the UV Image window only 32 bits RGBA is drawn.

What is still float: drawing the final image after render in renderwindow,
and drawing the Z or Alpha in renderwindow and UV image.

Of course we need to test this first. :) Will await reports...

source/blender/src/drawimage.c

@@ -1490,21 +1490,21 @@ void drawimagespace(ScrArea *sa, void *spacedata)
 					
 					/* detect if we need to redo the curve map. 
 					   ibuf->rect is zero for compositor and render results after change 
-					   also: if no curves are active, we only keep the float rect
+					   convert to 32 bits always... drawing float rects isnt supported well (atis)
 					*/
 					if(ibuf->rect_float) {
-						if(image_curves_active(sa)) {
+						if(ibuf->rect==NULL) {
-							if(ibuf->rect==NULL)
+							if(image_curves_active(sa))
 								curvemapping_do_image(G.sima->cumap, G.sima->image);
+							else 
+								IMB_rect_from_float(ibuf);
 						}
-						else if(ibuf->rect)
-							imb_freerectImBuf(ibuf);
 					}
 
 					if(ibuf->rect)
 						glaDrawPixelsSafe(x1, y1, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
-					else
+//					else
-						glaDrawPixelsSafe(x1, y1, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_FLOAT, ibuf->rect_float);
+//						glaDrawPixelsSafe(x1, y1, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_FLOAT, ibuf->rect_float);
 					
 					if(sima->flag & SI_USE_ALPHA)
 						glDisable(GL_BLEND);

source/blender/src/renderwin.c

@@ -743,6 +743,34 @@ static void renderwin_clear_display_cb(RenderResult *rr)
 	}
 }
 
+#define FTOCHAR(val) val<=0.0f?0: (val>=1.0f?255: (char)(255.0f*val))
+static void glaDrawPixelsSafe_to32(float fx, float fy, int img_w, int img_h, int row_w, int format, int type, float *rectf)
+{
+	float *rf;
+	int x, y;
+	char *rect32, *rc;
+	
+	/* copy imgw-imgh to a temporal 32 bits rect */
+	if(img_w<1 || img_h<1) return;
+	
+	rc= rect32= MEM_mallocN(img_w*img_h*sizeof(int), "temp 32 bits");
+	
+	for(y=0; y<img_h; y++) {
+		rf= rectf;
+		for(x=0; x<img_w; x++, rf+=4, rc+=4) {
+			rc[0]= FTOCHAR(rf[0]);
+			rc[1]= FTOCHAR(rf[1]);
+			rc[2]= FTOCHAR(rf[2]);
+			rc[3]= FTOCHAR(rf[3]);
+		}
+		rectf+= 4*row_w;
+	}
+	
+	glaDrawPixelsSafe(fx, fy, img_w, img_h, img_w, GL_RGBA, GL_UNSIGNED_BYTE, rect32);
+		
+	MEM_freeN(rect32);
+}
+
 /* XXX, this is not good, we do this without any regard to state
 * ... better is to make this an optimization of a more clear
 * implementation. the bug shows up when you do something like
@@ -809,7 +837,7 @@ static void renderwin_progress(RenderWin *rw, RenderResult *rr, volatile rcti *r
 	glDrawBuffer(GL_FRONT);
 #endif
 	glPixelZoom(rw->zoom, rw->zoom);
-	glaDrawPixelsSafe(fullrect[0][0], fullrect[0][1], rr->rectx-2*rr->crop, ymax, rr->rectx, 
+	glaDrawPixelsSafe_to32(fullrect[0][0], fullrect[0][1], rr->rectx-2*rr->crop, ymax, rr->rectx, 
 					  GL_RGBA, GL_FLOAT, rectf);
 	glPixelZoom(1.0, 1.0);
 	
@@ -969,7 +997,7 @@ static void init_test_break_callback()
 
 	tmevalue.it_interval.tv_sec = 0;
 	tmevalue.it_interval.tv_usec = 250000;
-	/* wanneer de eerste ? */
+	/* when the first ? */
 	tmevalue.it_value.tv_sec = 0;
 	tmevalue.it_value.tv_usec = 10000;