static void make_win_fog_coords( GLcontext *ctx, GLvector1f *out,
const GLvector1f *in )
{
GLfloat end = ctx->Fog.End;
GLfloat *v = in->start;
GLuint stride = in->stride;
GLuint n = in->count;
GLfloat *data = out->data;
GLfloat d;
GLuint i;
out->count = in->count;
switch (ctx->Fog.Mode) {
case GL_LINEAR:
if (ctx->Fog.Start == ctx->Fog.End)
d = 1.0F;
else
d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
GLfloat f = (end - ABSF(*v)) * d;
data[i] = CLAMP(f, 0.0F, 1.0F);
}
break;
case GL_EXP:
d = ctx->Fog.Density;
for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride))
NEG_EXP( data[i], d * ABSF(*v) );
break;
case GL_EXP2:
d = ctx->Fog.Density*ctx->Fog.Density;
for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
GLfloat z = *v;
NEG_EXP( data[i], d * z * z );
}
break;
default:
_mesa_problem(ctx, "Bad fog mode in make_fog_coord");
return;
}
}
static void fdf_fill_px(t_fdf_map *map, int i, t_lex_tk *t)
{
float z;
z = ((float)ft_atoi(t->value) / 2.0);
z = (z > 127.0 ? 127.0 : z);
z = (z < -127.0 ? -127.0 : z);
map->m[i][Z_rel] = z;
map->z_max = (map->z_max < (int)z ? (int)z : map->z_max);
map->z_min = (map->z_min > (int)z ? (int)z : map->z_min);
z = ABSF(z);
map->m[i][Fix] = 0.0;
map->m[i][X_rel] = (float)(i % map->x) - (map->x / 2);
map->m[i][Y_rel] = (float)(i / map->x) - (map->y / 2);
fdf_getscr_attr(map, map->m[i]);
}
/*
* Write a span of pixels to the frame buffer while applying a pixel zoom.
* This is only used by glDrawPixels and glCopyPixels.
* Input: n - number of pixels in input row
* x, y - destination of the span
* z - depth values for the span
* red, green, blue, alpha - array of colors
* y0 - location of first row in the image we're drawing.
*/
void
gl_write_zoomed_rgba_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
CONST GLubyte rgba[][4], GLint y0 )
{
GLint m;
GLint r0, r1, row, r;
GLint i, j, skipcol;
GLubyte zrgba[MAX_WIDTH][4]; /* zoomed pixel colors */
GLdepth zdepth[MAX_WIDTH]; /* zoomed depth values */
GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
const GLuint *srcRGBA32 = (const GLuint *) rgba;
GLuint *dstRGBA32 = (GLuint *) zrgba;
/* compute width of output row */
m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
if (m==0) {
return;
}
if (ctx->Pixel.ZoomX<0.0) {
/* adjust x coordinate for left/right mirroring */
x = x - m;
}
/* compute which rows to draw */
row = y-y0;
r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
if (r0==r1) {
return;
}
else if (r1<r0) {
GLint rtmp = r1;
r1 = r0;
r0 = rtmp;
}
/* return early if r0...r1 is above or below window */
if (r0<0 && r1<0) {
/* below window */
return;
}
if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
/* above window */
return;
}
/* check if left edge is outside window */
skipcol = 0;
if (x<0) {
skipcol = -x;
m += x;
}
/* make sure span isn't too long or short */
if (m>maxwidth) {
m = maxwidth;
}
else if (m<=0) {
return;
}
assert( m <= MAX_WIDTH );
/* zoom the span horizontally */
if (ctx->Pixel.ZoomX==-1.0F) {
/* n==m */
for (j=0;j<m;j++) {
i = n - (j+skipcol) - 1;
dstRGBA32[j] = srcRGBA32[i];
zdepth[j] = z[i];
}
}
else {
GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
for (j=0;j<m;j++) {
i = (GLint) ((j+skipcol) * xscale);
if (i<0) i = n + i - 1;
dstRGBA32[j] = srcRGBA32[i];
zdepth[j] = z[i];
}
}
/* write the span */
for (r=r0; r<r1; r++) {
gl_write_rgba_span( ctx, m, x+skipcol, r, zdepth, zrgba, GL_BITMAP );
}
}
