a6743ff85a
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@219 626c5289-ae23-0410-ae9c-e8d60b6d4f22
924 lines
23 KiB
C
924 lines
23 KiB
C
/* -----------------------------------------------------------------------------
|
|
* frame.c
|
|
*
|
|
* Frame buffer management
|
|
*
|
|
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
|
|
* Copyright (C) 1995-1996
|
|
*
|
|
* See the file LICENSE for information on usage and redistribution.
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
#define FRAME
|
|
#include "gifplot.h"
|
|
#include <float.h>
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer *new_FrameBuffer(int width, int height)
|
|
|
|
Creates a new framebuffer for storing data.
|
|
------------------------------------------------------------------------ */
|
|
|
|
FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height) {
|
|
|
|
FrameBuffer *f;
|
|
int FrameBuffer_resize(FrameBuffer *f, int width, int height);
|
|
|
|
/* Create a new frame buffer */
|
|
|
|
f = (FrameBuffer *) malloc(sizeof(FrameBuffer));
|
|
f->pixels = (Pixel **) 0;
|
|
f->zbuffer = (Zvalue **) 0;
|
|
/* Set its size */
|
|
|
|
if (FrameBuffer_resize(f, width, height) == -1) {
|
|
free((char *) f);
|
|
return (FrameBuffer *) 0;
|
|
}
|
|
|
|
f->xmin = 0;
|
|
f->ymin = 0;
|
|
f->xmax = width;
|
|
f->ymax = height;
|
|
return f;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void delete_FrameBuffer(FrameBuffer *f)
|
|
|
|
Destroys the given framebuffer
|
|
------------------------------------------------------------------------ */
|
|
|
|
void delete_FrameBuffer(FrameBuffer *f) {
|
|
|
|
if (f) {
|
|
if (f->pixels) {
|
|
free((char *) f->pixels[0]);
|
|
free((char *) f->pixels);
|
|
}
|
|
if (f->zbuffer) {
|
|
free((char *) f->zbuffer[0]);
|
|
free((char *) f->zbuffer);
|
|
}
|
|
free((char *)f);
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
int *FrameBuffer_resize(FrameBuffer *f, int width, int height)
|
|
|
|
Resize the given framebuffer. Returns 0 on success, -1 on failure.
|
|
------------------------------------------------------------------------ */
|
|
|
|
int FrameBuffer_resize(FrameBuffer *f, int width, int height) {
|
|
int i;
|
|
if ((f) && (width > 0) && (height > 0)) {
|
|
if (f->pixels) {
|
|
free((char *)f->pixels[0]);
|
|
free((char *)f->pixels);
|
|
}
|
|
f->pixels = (Pixel **) malloc (height*sizeof(Pixel *));
|
|
if (!f->pixels) return -1;
|
|
f->pixels[0] = (Pixel *) malloc(height*width*sizeof(Pixel));
|
|
if (!f->pixels[0]) {
|
|
free((char *)f->pixels);
|
|
return -1;
|
|
}
|
|
for (i = 0; i < height; i++)
|
|
f->pixels[i] = f->pixels[0] + i*width;
|
|
f->width = width;
|
|
f->height = height;
|
|
if (f->zbuffer) {
|
|
FrameBuffer_zresize(f,width,height);
|
|
}
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_clear(FrameBuffer *f, Pixel color)
|
|
|
|
Clears the current FrameBuffer
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_clear(FrameBuffer *f, Pixel color) {
|
|
Pixel *p;
|
|
unsigned int i;
|
|
p = &f->pixels[0][0];
|
|
|
|
for (i = 0; i < f->width*f->height; i++, p++)
|
|
*p = color;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_plot(FrameBuffer *f, int x1, int y1, Pixel color)
|
|
|
|
Plots a point and does a bounds check.
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_plot(FrameBuffer *f, int x1, int y1, Pixel color) {
|
|
|
|
if ((x1 < f->xmin) || (x1 >= f->xmax) || (y1 < f->ymin) || (y1 >= f->ymax))
|
|
return;
|
|
f->pixels[y1][x1] = color;
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer_horizontal(Framebuffer *f, int xmin, int xmax, int y, Pixel color)
|
|
|
|
Draw a horizontal line (clipped)
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_horizontal(FrameBuffer *f, int xmin, int xmax, int y, Pixel color) {
|
|
|
|
Pixel *p;
|
|
int i;
|
|
|
|
if ((y < f->ymin) || (y >= f->ymax)) return;
|
|
if (xmin < f->xmin) xmin = f->xmin;
|
|
if (xmax >= f->xmax) xmax = f->xmax - 1;
|
|
|
|
p = &f->pixels[y][xmin];
|
|
for (i = xmin; i <= xmax; i++, p++)
|
|
*p = color;
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer_horizontalinterp(Framebuffer *f, int xmin, int xmax, int y,
|
|
Pixel c1, Pixel c2)
|
|
|
|
Draw a horizontal line (clipped) with color interpolation.
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_horizontalinterp(FrameBuffer *f, int xmin, int xmax, int y,
|
|
Pixel c1, Pixel c2) {
|
|
|
|
Pixel *p;
|
|
int i;
|
|
double mc;
|
|
int x1;
|
|
if ((y < f->ymin) || (y >= f->ymax)) return;
|
|
|
|
x1 = xmin;
|
|
if (xmin < f->xmin) xmin = f->xmin;
|
|
if (xmax >= f->xmax) xmax = f->xmax - 1;
|
|
if (xmax < f->xmin) return;
|
|
if (xmin >= f->xmax) return;
|
|
|
|
if (xmin != xmax)
|
|
mc = (double)(c2 - c1)/(double) (xmax - xmin);
|
|
else
|
|
mc = 0.0;
|
|
|
|
p = &f->pixels[y][xmin];
|
|
for (i = xmin; i <= xmax; i++, p++)
|
|
*p = (Pixel) (mc*(i-x1) + c1);
|
|
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer_vertical(Framebuffer *f, int xmin, int xmax, int y, Pixel color)
|
|
|
|
Draw a Vertical line (clipped)
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_vertical(FrameBuffer *f, int ymin, int ymax, int x, Pixel color) {
|
|
|
|
Pixel *p;
|
|
int i;
|
|
|
|
if ((x < f->xmin) || (x >= f->xmax)) return;
|
|
if (ymax < f->ymin) return;
|
|
if (ymin > f->ymax) return;
|
|
if (ymin < f->ymin) ymin = f->ymin;
|
|
if (ymax >= f->ymax) ymax = f->ymax - 1;
|
|
|
|
p = &f->pixels[ymin][x];
|
|
for (i = 0; i <= (ymax - ymin); i++, p+=f->width)
|
|
*p = color;
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_box(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color)
|
|
|
|
Makes an outline box.
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_box(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color) {
|
|
|
|
int xt, yt;
|
|
|
|
/* Make sure points are in correct order */
|
|
|
|
if (x2 < x1) {
|
|
xt = x2;
|
|
x2 = x1;
|
|
x1 = xt;
|
|
}
|
|
if (y2 < y1) {
|
|
yt = y2;
|
|
y2 = y1;
|
|
y1 = yt;
|
|
}
|
|
|
|
/* Draw lower edge */
|
|
|
|
FrameBuffer_horizontal(f,x1,x2,y1,color);
|
|
|
|
/* Draw upper edge */
|
|
|
|
FrameBuffer_horizontal(f,x1,x2,y2,color);
|
|
|
|
/* Draw left side */
|
|
|
|
FrameBuffer_vertical(f,y1,y2,x1,color);
|
|
|
|
/* Draw right side */
|
|
|
|
FrameBuffer_vertical(f,y1,y2,x2,color);
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_solidbox(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color)
|
|
|
|
Makes an solid box.
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_solidbox(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color) {
|
|
|
|
int xt, yt;
|
|
|
|
/* Make sure points are in correct order */
|
|
|
|
if (x2 < x1) {
|
|
xt = x2;
|
|
x2 = x1;
|
|
x1 = xt;
|
|
}
|
|
if (y2 < y1) {
|
|
yt = y2;
|
|
y2 = y1;
|
|
y1 = yt;
|
|
}
|
|
|
|
/* Now perform some clipping */
|
|
|
|
if (y1 < f->ymin) y1 = f->ymin;
|
|
if (y2 >= f->ymax) y2 = f->ymax - 1;
|
|
|
|
/* Fill it in using horizontal lines */
|
|
|
|
for (yt = y1; yt <= y2; yt++)
|
|
FrameBuffer_horizontal(f,x1,x2,yt,color);
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_interpbox(FrameBuffer *f, int x1, int y1, int x2, int y2
|
|
Pixel c1, Pixel c2, Pixel c3, Pixel c4)
|
|
|
|
Makes a box with interpolated color. Colors are assigned as follows :
|
|
(x1,y1) = c1
|
|
(x1,y2) = c2
|
|
(x2,y1) = c3
|
|
(x2,y2) = c4
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_interpbox(FrameBuffer *f, int x1, int y1, int x2, int y2,
|
|
Pixel c1, Pixel c2, Pixel c3, Pixel c4) {
|
|
|
|
int xt, yt;
|
|
Pixel ct;
|
|
double mc1,mc2;
|
|
int ystart;
|
|
/* Make sure points are in correct order */
|
|
|
|
if (x2 < x1) {
|
|
xt = x2;
|
|
x2 = x1;
|
|
x1 = xt;
|
|
ct = c1;
|
|
c1 = c3;
|
|
c3 = ct;
|
|
ct = c2;
|
|
c2 = c4;
|
|
c4 = ct;
|
|
}
|
|
if (y2 < y1) {
|
|
yt = y2;
|
|
y2 = y1;
|
|
y1 = yt;
|
|
ct = c1;
|
|
c1 = c2;
|
|
c2 = ct;
|
|
ct = c3;
|
|
c3 = c4;
|
|
c4 = ct;
|
|
}
|
|
|
|
/* Now perform some clipping */
|
|
|
|
ystart = y1;
|
|
mc1 = (double) (c2 - c1)/(double) (y2 - y1);
|
|
mc2 = (double) (c4 - c3)/(double) (y2 - y1);
|
|
if (y1 < f->ymin) y1 = f->ymin;
|
|
if (y2 >= f->ymax) y2 = f->ymax - 1;
|
|
|
|
/* Fill it in using horizontal lines */
|
|
|
|
for (yt = y1; yt <= y2; yt++)
|
|
FrameBuffer_horizontalinterp(f,x1,x2,yt,(Pixel) ((mc1*(yt - ystart)) + c1),
|
|
(Pixel) ((mc2*(yt-ystart))+c3));
|
|
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
FrameBuffer_line(FrameBuffer *f, int x1, int y1, int x2, int y2, color)
|
|
|
|
Draws a line on the framebuffer using the Bresenham line algorithm. The
|
|
line is clipped to fit within the current view window.
|
|
---------------------------------------------------------------------------- */
|
|
|
|
void FrameBuffer_line(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel c) {
|
|
|
|
int dx,dy,dxneg,dyneg, inc1,inc2,di;
|
|
int x, y, xpixels, ypixels, xt, yt;
|
|
Pixel *p;
|
|
double m;
|
|
int end1 = 0, end2 = 0;
|
|
|
|
/* Need to figure out where in the heck this line is */
|
|
|
|
dx = x2 - x1;
|
|
dy = y2 - y1;
|
|
|
|
if (dx == 0) {
|
|
/* Draw a Vertical Line */
|
|
if (y1 < y2)
|
|
FrameBuffer_vertical(f,y1,y2,x1,c);
|
|
else
|
|
FrameBuffer_vertical(f,y2,y1,x1,c);
|
|
return;
|
|
}
|
|
if (dy == 0) {
|
|
/* Draw a Horizontal Line */
|
|
if (x1 < x2)
|
|
FrameBuffer_horizontal(f,x1,x2,y1,c);
|
|
else
|
|
FrameBuffer_horizontal(f,x2,x1,y1,c);
|
|
return;
|
|
}
|
|
|
|
/* Figure out where in the heck these lines are using the
|
|
Cohen-Sutherland Line Clipping Scheme. */
|
|
|
|
end1 = ((x1 - f->xmin) < 0) |
|
|
(((f->xmax- 1 - x1) < 0) << 1) |
|
|
(((y1 - f->ymin) < 0) << 2) |
|
|
(((f->ymax-1 - y1) < 0) << 3);
|
|
|
|
end2 = ((x2 - f->xmin) < 0) |
|
|
(((f->xmax-1 - x2) < 0) << 1) |
|
|
(((y2 - f->ymin) < 0) << 2) |
|
|
(((f->ymax-1 - y2) < 0) << 3);
|
|
|
|
if (end1 & end2) return; /* Nope : Not visible */
|
|
|
|
/* Make sure points have a favorable orientation */
|
|
|
|
if (x1 > x2) {
|
|
xt = x1;
|
|
x1 = x2;
|
|
x2 = xt;
|
|
yt = y1;
|
|
y1 = y2;
|
|
y2 = yt;
|
|
}
|
|
|
|
/* Clip against the boundaries */
|
|
m = (y2 - y1)/(double) (x2-x1);
|
|
if (x1 < f->xmin) {
|
|
y1 = (int) ((f->xmin - x1)*m + y1);
|
|
x1 = (int) f->xmin;
|
|
}
|
|
if (x2 >= f->xmax) {
|
|
y2 = (int) ((f->xmax -1 -x1)*m + y1);
|
|
x2 = (int) (f->xmax - 1);
|
|
}
|
|
|
|
if (y1 > y2) {
|
|
xt = x1;
|
|
x1 = x2;
|
|
x2 = xt;
|
|
yt = y1;
|
|
y1 = y2;
|
|
y2 = yt;
|
|
}
|
|
|
|
m = 1/m;
|
|
if (y1 < f->ymin) {
|
|
x1 = (int) ((f->ymin - y1)*m + x1);
|
|
y1 = (int) f->ymin;
|
|
}
|
|
if (y2 >= f->ymax) {
|
|
x2 = (int) ((f->ymax-1-y1)*m + x1);
|
|
y2 = (int) (f->ymax-1);
|
|
}
|
|
|
|
if ((x1 < f->xmin) || (x1 >= f->xmax) || (y1 < f->ymin) || (y1 >= f->ymax) ||
|
|
(x2 < f->xmin) || (x2 >= f->xmax) || (y2 < f->ymin) || (y2 >= f->ymax)) return;
|
|
|
|
dx = x2 - x1;
|
|
dy = y2 - y1;
|
|
xpixels = f->width;
|
|
ypixels = f->height;
|
|
|
|
dxneg = (dx < 0) ? 1 : 0;
|
|
dyneg = (dy < 0) ? 1 : 0;
|
|
|
|
dx = abs(dx);
|
|
dy = abs(dy);
|
|
if (dx >= dy) {
|
|
/* Slope between -1 and 1. */
|
|
if (dxneg) {
|
|
x = x1;
|
|
y = y1;
|
|
x1 = x2;
|
|
y1 = y2;
|
|
x2 = x;
|
|
y2 = y;
|
|
dyneg = !dyneg;
|
|
}
|
|
inc1 = 2*dy;
|
|
inc2 = 2*(dy-dx);
|
|
di = 2*dy-dx;
|
|
|
|
/* Draw a line using x as independent variable */
|
|
|
|
p = &f->pixels[y1][x1];
|
|
x = x1;
|
|
while (x <= x2) {
|
|
*(p++) = c;
|
|
if (di < 0) {
|
|
di = di + inc1;
|
|
} else {
|
|
if (dyneg) {
|
|
p = p - xpixels;
|
|
di = di + inc2;
|
|
} else {
|
|
p = p + xpixels;
|
|
di = di + inc2;
|
|
}
|
|
}
|
|
x++;
|
|
}
|
|
} else {
|
|
/* Slope < -1 or > 1 */
|
|
if (dyneg) {
|
|
x = x1;
|
|
y = y1;
|
|
x1 = x2;
|
|
y1 = y2;
|
|
x2 = x;
|
|
y2 = y;
|
|
dxneg = !dxneg;
|
|
}
|
|
inc1 = 2*dx;
|
|
inc2 = 2*(dx-dy);
|
|
di = 2*dx-dy;
|
|
|
|
/* Draw a line using y as independent variable */
|
|
|
|
p = &f->pixels[y1][x1];
|
|
y = y1;
|
|
while (y <= y2) {
|
|
*p = c;
|
|
p = p + xpixels;
|
|
if (di < 0) {
|
|
di = di + inc1;
|
|
} else {
|
|
if (dxneg) {
|
|
p = p - 1;
|
|
di = di + inc2;
|
|
} else {
|
|
p = p + 1;
|
|
di = di + inc2;
|
|
}
|
|
}
|
|
y++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
FrameBuffer_circle(FrameBuffer f, int xc, int yc, int radius, Pixel c)
|
|
|
|
Create an outline circle
|
|
------------------------------------------------------------------------- */
|
|
|
|
#define plot_circle(x,y,c) \
|
|
if ((x >= xmin) && (x < xmax) && \
|
|
(y >= ymin) && (y < ymax)) \
|
|
pixels[y][x] = c;
|
|
|
|
void FrameBuffer_circle(FrameBuffer *f, int xc, int yc, int radius, Pixel c) {
|
|
|
|
int xpixels, ypixels, x, y, p;
|
|
int xmin, ymin, xmax, ymax;
|
|
Pixel **pixels;
|
|
|
|
if (radius <= 0) return;
|
|
xpixels = f->width;
|
|
ypixels = f->height;
|
|
pixels = f->pixels;
|
|
xmin = f->xmin;
|
|
ymin = f->ymin;
|
|
xmax = f->xmax;
|
|
ymax = f->ymax;
|
|
x = 0;
|
|
y = radius;
|
|
p = 3-2*radius;
|
|
while (x <= y) {
|
|
plot_circle(xc+x,yc+y,c);
|
|
plot_circle(xc-x,yc+y,c);
|
|
plot_circle(xc+x,yc-y,c);
|
|
plot_circle(xc-x,yc-y,c);
|
|
plot_circle(xc+y,yc+x,c);
|
|
plot_circle(xc-y,yc+x,c);
|
|
plot_circle(xc+y,yc-x,c);
|
|
plot_circle(xc-y,yc-x,c);
|
|
if (p < 0) p = p + 4*x + 6;
|
|
else {
|
|
p = p + 4*(x-y) + 10;
|
|
y = y -1;
|
|
}
|
|
x++;
|
|
}
|
|
}
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
FrameBuffer_solidcircle(FrameBuffer f, int xc, int yc, int radius, Pixel c)
|
|
|
|
Create an filled circle
|
|
------------------------------------------------------------------------- */
|
|
|
|
|
|
#define fill_circle(x,y,c) \
|
|
x1 = xc - x; \
|
|
x2 = xc + x; \
|
|
FrameBuffer_horizontal(f,x1,x2,y,c);
|
|
|
|
void FrameBuffer_solidcircle(FrameBuffer *f, int xc, int yc, int radius, Pixel c) {
|
|
|
|
int xpixels, ypixels, x, y, p;
|
|
int x1,x2;
|
|
int xmin, ymin, xmax, ymax;
|
|
Pixel **pixels;
|
|
|
|
if (radius <= 0) return;
|
|
xpixels = f->width;
|
|
ypixels = f->height;
|
|
pixels = f->pixels;
|
|
xmin = f->xmin;
|
|
ymin = f->ymin;
|
|
xmax = f->xmax;
|
|
ymax = f->ymax;
|
|
x = 0;
|
|
y = radius;
|
|
p = 3-2*radius;
|
|
while (x <= y) {
|
|
fill_circle(x,yc+y,c);
|
|
fill_circle(x,yc-y,c);
|
|
fill_circle(y,yc+x,c);
|
|
fill_circle(y,yc-x,c);
|
|
if (p < 0) p = p + 4*x + 6;
|
|
else {
|
|
p = p + 4*(x-y) + 10;
|
|
y = y -1;
|
|
}
|
|
x++;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_setclip(f,xmin,ymin,xmax,ymax)
|
|
|
|
Set clipping region for plotting
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_setclip(FrameBuffer *f, int xmin, int ymin, int xmax, int ymax) {
|
|
|
|
if (xmin >= xmax) return;
|
|
if (ymin >= ymax) return;
|
|
|
|
if (xmin < 0) xmin = 0;
|
|
if (ymin < 0) ymin = 0;
|
|
if (xmax > (int) f->width) xmax = f->width;
|
|
if (ymax > (int) f->height) ymax = f->height;
|
|
|
|
f->xmin = xmin;
|
|
f->ymin = ymin;
|
|
f->xmax = xmax;
|
|
f->ymax = ymax;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
void FrameBuffer_noclip(f)
|
|
|
|
Disable clipping region
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_noclip(FrameBuffer *f) {
|
|
f->xmin = 0;
|
|
f->ymin = 0;
|
|
f->xmax = f->width;
|
|
f->ymax = f->height;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer_zresize(FrameBuffer *f, int width, int height)
|
|
|
|
This function resizes the framebuffer's zbuffer. If none exist, it
|
|
creates a new one.
|
|
------------------------------------------------------------------------ */
|
|
|
|
void FrameBuffer_zresize(FrameBuffer *f, int width, int height) {
|
|
int i;
|
|
|
|
if (f->zbuffer) {
|
|
free((char *)f->zbuffer[0]);
|
|
free((char *)f->zbuffer);
|
|
}
|
|
f->zbuffer = (Zvalue **) malloc(height*sizeof(Zvalue *));
|
|
f->zbuffer[0] = (Zvalue *) malloc(height*width*sizeof(Zvalue));
|
|
for (i = 0; i < height; i++)
|
|
f->zbuffer[i] = f->zbuffer[0]+i*width;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
FrameBuffer_zclear(FrameBuffer *f)
|
|
|
|
Clears the z-buffer for a particular frame. Sets all of the z-values to
|
|
ZMIN.
|
|
------------------------------------------------------------------------- */
|
|
|
|
void FrameBuffer_zclear(FrameBuffer *f) {
|
|
unsigned int i,j;
|
|
if (f) {
|
|
if (f->zbuffer) {
|
|
for (i = 0; i < f->width; i++)
|
|
for (j = 0; j < f->height; j++)
|
|
f->zbuffer[j][i] = ZMIN;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
FrameBuffer_solidtriangle(FrameBuffer *f, int tx1, int ty2,
|
|
int tx2, int ty2,
|
|
int tx3, int ty3, Pixel color)
|
|
|
|
This function draws a 2D filled triangle.
|
|
|
|
General idea :
|
|
1. Transform the three points into screen coordinates
|
|
2. Order three points vertically on screen.
|
|
3. Check for degenerate cases (where 3 points are colinear).
|
|
4. Fill in the resulting triangle using horizontal lines.
|
|
-------------------------------------------------------------------------- */
|
|
|
|
void FrameBuffer_solidtriangle(FrameBuffer *f, int tx1, int ty1,
|
|
int tx2, int ty2,
|
|
int tx3, int ty3, Pixel color) {
|
|
int tempx, tempy;
|
|
double m1,m2,m3;
|
|
int y;
|
|
int ix1, ix2;
|
|
|
|
/* Figure out which point has the greatest "y" value */
|
|
|
|
if (ty2 > ty1) { /* Swap points 1 and 2 if 2 is higher */
|
|
tempx = tx1;
|
|
tempy = ty1;
|
|
tx1 = tx2;
|
|
ty1 = ty2;
|
|
tx2 = tempx;
|
|
ty2 = tempy;
|
|
}
|
|
if (ty3 > ty1) { /* Swap points 1 and 3 if 3 is higher */
|
|
tempx = tx1;
|
|
tempy = ty1;
|
|
tx1 = tx3;
|
|
ty1 = ty3;
|
|
tx3 = tempx;
|
|
ty3 = tempy;
|
|
}
|
|
if (ty3 > ty2) { /* Swap points 2 and 3 if 3 is higher */
|
|
tempx = tx2;
|
|
tempy = ty2;
|
|
tx2 = tx3;
|
|
ty2 = ty3;
|
|
tx3 = tempx;
|
|
ty3 = tempy;
|
|
}
|
|
|
|
/* Points are now order so that t_1 is the highest point, t_2 is the
|
|
middle point, and t_3 is the lowest point */
|
|
|
|
/* Check for degenerate cases here */
|
|
|
|
if ((ty1 == ty2) && (ty2 == ty3)) {
|
|
|
|
/* Points are aligned horizontally. Handle as a special case */
|
|
/* Just draw three lines using the outline color */
|
|
|
|
FrameBuffer_line(f,tx1,ty1,tx2,ty2,color);
|
|
FrameBuffer_line(f,tx1,ty1,tx3,ty3,color);
|
|
FrameBuffer_line(f,tx2,ty2,tx3,ty3,color);
|
|
|
|
} else {
|
|
|
|
if (ty2 < ty1) {
|
|
/* First process line segments between (x1,y1)-(x2,y2)
|
|
And between (x1,y1),(x3,y3) */
|
|
|
|
m1 = (double) (tx2 - tx1)/(double) (ty2 - ty1);
|
|
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
|
|
|
|
y = ty1;
|
|
while (y >= ty2) {
|
|
/* Calculate x values from slope */
|
|
ix1 = (int) (m1*(y-ty1)+0.5) + tx1;
|
|
ix2 = (int) (m2*(y-ty1)+0.5) + tx1;
|
|
if (ix1 > ix2)
|
|
FrameBuffer_horizontal(f,ix2,ix1,y,color);
|
|
else
|
|
FrameBuffer_horizontal(f,ix1,ix2,y,color);
|
|
y--;
|
|
}
|
|
}
|
|
if (ty3 < ty2) {
|
|
/* Draw lower half of the triangle */
|
|
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
|
|
m3 = (double) (tx3 - tx2)/(double)(ty3 - ty2);
|
|
y = ty2;
|
|
while (y >= ty3) {
|
|
ix1 = (int) (m3*(y-ty2)+0.5)+tx2;
|
|
ix2 = (int) (m2*(y-ty1)+0.5)+tx1;
|
|
if (ix1 > ix2)
|
|
FrameBuffer_horizontal(f,ix2,ix1,y,color);
|
|
else
|
|
FrameBuffer_horizontal(f,ix1,ix2,y,color);
|
|
y--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------
|
|
FrameBuffer_interptriangle(FrameBuffer *f,
|
|
int tx1, int ty2, Pixel c1,
|
|
int tx2, int ty2, Pixel c2,
|
|
int tx3, int ty3, Pixel c3)
|
|
|
|
This function draws a filled triangle with color
|
|
interpolation.
|
|
|
|
General idea :
|
|
1. Transform the three points into screen coordinates
|
|
2. Order three points vertically on screen.
|
|
3. Check for degenerate cases (where 3 points are colinear).
|
|
4. Fill in the resulting triangle using horizontal lines.
|
|
5. Colors are interpolated between end points
|
|
-------------------------------------------------------------------------- */
|
|
|
|
void FrameBuffer_interptriangle(FrameBuffer *f,
|
|
int tx1, int ty1, Pixel c1,
|
|
int tx2, int ty2, Pixel c2,
|
|
int tx3, int ty3, Pixel c3) {
|
|
int tempx, tempy;
|
|
double m1,m2,m3;
|
|
double mc1,mc2,mc3;
|
|
Pixel ic1,ic2,tempc;
|
|
int y;
|
|
int ix1, ix2;
|
|
|
|
/* Figure out which point has the greatest "y" value */
|
|
|
|
if (ty2 > ty1) { /* Swap points 1 and 2 if 2 is higher */
|
|
tempx = tx1;
|
|
tempy = ty1;
|
|
tempc = c1;
|
|
tx1 = tx2;
|
|
ty1 = ty2;
|
|
c1 = c2;
|
|
tx2 = tempx;
|
|
ty2 = tempy;
|
|
c2 = tempc;
|
|
}
|
|
if (ty3 > ty1) { /* Swap points 1 and 3 if 3 is higher */
|
|
tempx = tx1;
|
|
tempy = ty1;
|
|
tempc = c1;
|
|
tx1 = tx3;
|
|
ty1 = ty3;
|
|
c1 = c3;
|
|
tx3 = tempx;
|
|
ty3 = tempy;
|
|
c3 = tempc;
|
|
}
|
|
if (ty3 > ty2) { /* Swap points 2 and 3 if 3 is higher */
|
|
tempx = tx2;
|
|
tempy = ty2;
|
|
tempc = c2;
|
|
tx2 = tx3;
|
|
ty2 = ty3;
|
|
c2 = c3;
|
|
tx3 = tempx;
|
|
ty3 = tempy;
|
|
c3 = tempc;
|
|
}
|
|
|
|
/* Points are now order so that t_1 is the highest point, t_2 is the
|
|
middle point, and t_3 is the lowest point */
|
|
|
|
/* Check for degenerate cases here */
|
|
|
|
if ((ty1 == ty2) && (ty2 == ty3)) {
|
|
|
|
/* Points are aligned horizontally. Handle as a special case */
|
|
/* Just draw three lines using the outline color */
|
|
|
|
if (tx2 > tx1)
|
|
FrameBuffer_horizontalinterp(f,tx1,tx2,ty1,c1,c2);
|
|
else
|
|
FrameBuffer_horizontalinterp(f,tx2,tx1,ty1,c2,c1);
|
|
if (tx3 > tx1)
|
|
FrameBuffer_horizontalinterp(f,tx1,tx3,ty1,c1,c3);
|
|
else
|
|
FrameBuffer_horizontalinterp(f,tx3,tx1,ty1,c3,c1);
|
|
if (tx3 > tx2)
|
|
FrameBuffer_horizontalinterp(f,tx2,tx3,ty2,c2,c3);
|
|
else
|
|
FrameBuffer_horizontalinterp(f,tx3,tx2,ty2,c3,c2);
|
|
|
|
} else {
|
|
|
|
/* First process line segments between (x1,y1)-(x2,y2)
|
|
And between (x1,y1),(x3,y3) */
|
|
|
|
if (ty2 < ty1) {
|
|
m1 = (double) (tx2 - tx1)/(double) (ty2 - ty1);
|
|
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
|
|
mc1 = (c2 - c1)/(double) (ty2 - ty1);
|
|
mc2 = (c3 - c1)/(double) (ty3 - ty1);
|
|
|
|
y = ty1;
|
|
while (y >= ty2) {
|
|
/* Calculate x values from slope */
|
|
ix1 = (int) (m1*(y-ty1)+0.5) + tx1;
|
|
ix2 = (int) (m2*(y-ty1)+0.5) + tx1;
|
|
ic1 = (int) (mc1*(y-ty1) + c1);
|
|
ic2 = (int) (mc2*(y-ty1) + c1);
|
|
if (ix1 > ix2)
|
|
FrameBuffer_horizontalinterp(f,ix2,ix1,y,ic2,ic1);
|
|
else
|
|
FrameBuffer_horizontalinterp(f,ix1,ix2,y,ic1,ic2);
|
|
y--;
|
|
}
|
|
}
|
|
if (ty3 < ty2) {
|
|
/* Draw lower half of the triangle */
|
|
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
|
|
mc2 = (c3 - c1)/(double) (ty3 - ty1);
|
|
m3 = (double) (tx3 - tx2)/(double)(ty3 - ty2);
|
|
mc3 = (c3 - c2)/(double) (ty3 - ty2);
|
|
y = ty2;
|
|
while (y >= ty3) {
|
|
ix1 = (int) (m3*(y-ty2)+0.5)+tx2;
|
|
ix2 = (int) (m2*(y-ty1)+0.5)+tx1;
|
|
ic1 = (int) (mc3*(y-ty2)+c2);
|
|
ic2 = (int) (mc2*(y-ty1)+c1);
|
|
if (ix1 > ix2)
|
|
FrameBuffer_horizontalinterp(f,ix2,ix1,y,ic2,ic1);
|
|
else
|
|
FrameBuffer_horizontalinterp(f,ix1,ix2,y,ic1,ic2);
|
|
y--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|