nilix/openbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

reindent the file....

Browse source 
but while i'm at it:
  - add support for bevels/borders on solid textures.
  - reverse the colors in the rectangle gradient, the pipecross and pyramid
    ones may need to be reversed as well.
This commit is contained in:
Dana Jansens 2003-05-20 07:30:27 +00:00
parent 13f701bdb1
commit 895cd9f43d
1 changed files with 429 additions and 362 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

787
render/gradient.c
View file

@ -6,455 +6,522 @@
void gradient_render(Surface *sf, int w, int h) void gradient_render(Surface *sf, int w, int h)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 current; pixel32 current;
unsigned int r,g,b; unsigned int r,g,b;
int off, x; int off, x;
switch (sf->data.planar.grad) { switch (sf->data.planar.grad) {
case Background_Solid: /* already handled */ case Background_Solid: /* already handled */
return; return;
case Background_Vertical: case Background_Vertical:
gradient_vertical(sf, w, h); gradient_vertical(sf, w, h);
break; break;
case Background_Horizontal: case Background_Horizontal:
gradient_horizontal(sf, w, h); gradient_horizontal(sf, w, h);
break; break;
case Background_Diagonal: case Background_Diagonal:
gradient_diagonal(sf, w, h); gradient_diagonal(sf, w, h);
break; break;
case Background_CrossDiagonal: case Background_CrossDiagonal:
gradient_crossdiagonal(sf, w, h); gradient_crossdiagonal(sf, w, h);
break; break;
case Background_Pyramid: case Background_Pyramid:
gradient_pyramid(sf, w, h); gradient_pyramid(sf, w, h);
break; break;
case Background_PipeCross: case Background_PipeCross:
gradient_pipecross(sf, w, h); gradient_pipecross(sf, w, h);
break; break;
case Background_Rectangle: case Background_Rectangle:
gradient_rectangle(sf, w, h); gradient_rectangle(sf, w, h);
break; break;
default: default:
g_message("unhandled gradient"); g_message("unhandled gradient");
return; return;
} }
if (sf->data.planar.relief == Flat && sf->data.planar.border) { if (sf->data.planar.relief == Flat && sf->data.planar.border) {
r = sf->data.planar.border_color->r; r = sf->data.planar.border_color->r;
g = sf->data.planar.border_color->g; g = sf->data.planar.border_color->g;
b = sf->data.planar.border_color->b; b = sf->data.planar.border_color->b;
current = (r << default_red_offset) current = (r << default_red_offset)
+ (g << default_green_offset) + (g << default_green_offset)
+ (b << default_blue_offset); + (b << default_blue_offset);
for (off = 0, x = 0; x < w; ++x, off++) { for (off = 0, x = 0; x < w; ++x, off++) {
*(data + off) = current; *(data + off) = current;
*(data + off + ((h-1) * w)) = current; *(data + off + ((h-1) * w)) = current;
} }
for (off = 0, x = 0; x < h; ++x, off++) { for (off = 0, x = 0; x < h; ++x, off++) {
*(data + (off * w)) = current; *(data + (off * w)) = current;
*(data + (off * w) + w - 1) = current; *(data + (off * w) + w - 1) = current;
} }
}
if (sf->data.planar.relief != Flat) {
if (sf->data.planar.bevel == Bevel1) {
for (off = 1, x = 1; x < w - 1; ++x, off++)
highlight(data + off,
data + off + (h-1) * w,
sf->data.planar.relief==Raised);
for (off = 0, x = 0; x < h; ++x, off++)
highlight(data + off * w,
data + off * w + w - 1,
sf->data.planar.relief==Raised);
} }
if (sf->data.planar.bevel == Bevel2) { if (sf->data.planar.relief != Flat) {
for (off = 2, x = 2; x < w - 2; ++x, off++) if (sf->data.planar.bevel == Bevel1) {
highlight(data + off + w, for (off = 1, x = 1; x < w - 1; ++x, off++)
data + off + (h-2) * w, highlight(data + off,
sf->data.planar.relief==Raised); data + off + (h-1) * w,
for (off = 1, x = 1; x < h-1; ++x, off++) sf->data.planar.relief==Raised);
highlight(data + off * w + 1, for (off = 0, x = 0; x < h; ++x, off++)
data + off * w + w - 2, highlight(data + off * w,
sf->data.planar.relief==Raised); data + off * w + w - 1,
sf->data.planar.relief==Raised);
}
if (sf->data.planar.bevel == Bevel2) {
for (off = 2, x = 2; x < w - 2; ++x, off++)
highlight(data + off + w,
data + off + (h-2) * w,
sf->data.planar.relief==Raised);
for (off = 1, x = 1; x < h-1; ++x, off++)
highlight(data + off * w + 1,
data + off * w + w - 2,
sf->data.planar.relief==Raised);
}
} }
}
} }
void gradient_vertical(Surface *sf, int w, int h) void gradient_vertical(Surface *sf, int w, int h)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 current; pixel32 current;
float dr, dg, db; float dr, dg, db;
unsigned int r,g,b; unsigned int r,g,b;
int x, y; int x, y;
dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r);
dr/= (float)h; dr/= (float)h;
dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g);
dg/= (float)h; dg/= (float)h;
db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b);
db/= (float)h; db/= (float)h;
for (y = 0; y < h; ++y) { for (y = 0; y < h; ++y) {
r = sf->data.planar.primary->r + (int)(dr * y); r = sf->data.planar.primary->r + (int)(dr * y);
g = sf->data.planar.primary->g + (int)(dg * y); g = sf->data.planar.primary->g + (int)(dg * y);
b = sf->data.planar.primary->b + (int)(db * y); b = sf->data.planar.primary->b + (int)(db * y);
current = (r << default_red_offset) current = (r << default_red_offset)
+ (g << default_green_offset) + (g << default_green_offset)
+ (b << default_blue_offset); + (b << default_blue_offset);
for (x = 0; x < w; ++x, ++data) for (x = 0; x < w; ++x, ++data)
*data = current; *data = current;
} }
} }
void gradient_horizontal(Surface *sf, int w, int h) void gradient_horizontal(Surface *sf, int w, int h)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 current; pixel32 current;
float dr, dg, db; float dr, dg, db;
unsigned int r,g,b; unsigned int r,g,b;
int x, y; int x, y;
dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r);
dr/= (float)w; dr/= (float)w;
dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g);
dg/= (float)w; dg/= (float)w;
db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b);
db/= (float)w; db/= (float)w;
for (x = 0; x < w; ++x, ++data) { for (x = 0; x < w; ++x, ++data) {
r = sf->data.planar.primary->r + (int)(dr * x); r = sf->data.planar.primary->r + (int)(dr * x);
g = sf->data.planar.primary->g + (int)(dg * x); g = sf->data.planar.primary->g + (int)(dg * x);
b = sf->data.planar.primary->b + (int)(db * x); b = sf->data.planar.primary->b + (int)(db * x);
current = (r << default_red_offset) current = (r << default_red_offset)
+ (g << default_green_offset) + (g << default_green_offset)
+ (b << default_blue_offset); + (b << default_blue_offset);
for (y = 0; y < h; ++y) for (y = 0; y < h; ++y)
*(data + y*w) = current; *(data + y*w) = current;
} }
} }
void gradient_diagonal(Surface *sf, int w, int h) void gradient_diagonal(Surface *sf, int w, int h)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 current; pixel32 current;
float drx, dgx, dbx, dry, dgy, dby; float drx, dgx, dbx, dry, dgy, dby;
unsigned int r,g,b; unsigned int r,g,b;
int x, y; int x, y;
for (y = 0; y < h; ++y) { for (y = 0; y < h; ++y) {
drx = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); drx = (float)(sf->data.planar.secondary->r -
dry = drx/(float)h; sf->data.planar.primary->r);
drx/= (float)w; dry = drx/(float)h;
drx/= (float)w;
dgx = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); dgx = (float)(sf->data.planar.secondary->g -
dgy = dgx/(float)h; sf->data.planar.primary->g);
dgx/= (float)w; dgy = dgx/(float)h;
dgx/= (float)w;
dbx = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); dbx = (float)(sf->data.planar.secondary->b -
dby = dbx/(float)h; sf->data.planar.primary->b);
dbx/= (float)w; dby = dbx/(float)h;
for (x = 0; x < w; ++x, ++data) { dbx/= (float)w;
r = sf->data.planar.primary->r + ((int)(drx * x) + (int)(dry * y))/2; for (x = 0; x < w; ++x, ++data) {
g = sf->data.planar.primary->g + ((int)(dgx * x) + (int)(dgy * y))/2; r = sf->data.planar.primary->r +
b = sf->data.planar.primary->b + ((int)(dbx * x) + (int)(dby * y))/2; ((int)(drx * x) + (int)(dry * y))/2;
current = (r << default_red_offset) g = sf->data.planar.primary->g +
+ (g << default_green_offset) ((int)(dgx * x) + (int)(dgy * y))/2;
+ (b << default_blue_offset); b = sf->data.planar.primary->b +
*data = current; ((int)(dbx * x) + (int)(dby * y))/2;
current = (r << default_red_offset)
+ (g << default_green_offset)
+ (b << default_blue_offset);
*data = current;
}
} }
}
} }
void gradient_crossdiagonal(Surface *sf, int w, int h) void gradient_crossdiagonal(Surface *sf, int w, int h)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 current; pixel32 current;
float drx, dgx, dbx, dry, dgy, dby; float drx, dgx, dbx, dry, dgy, dby;
unsigned int r,g,b; unsigned int r,g,b;
int x, y; int x, y;
for (y = 0; y < h; ++y) { for (y = 0; y < h; ++y) {
drx = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); drx = (float)(sf->data.planar.secondary->r -
dry = drx/(float)h; sf->data.planar.primary->r);
drx/= (float)w; dry = drx/(float)h;
drx/= (float)w;
dgx = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); dgx = (float)(sf->data.planar.secondary->g -
dgy = dgx/(float)h; sf->data.planar.primary->g);
dgx/= (float)w; dgy = dgx/(float)h;
dgx/= (float)w;
dbx = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); dbx = (float)(sf->data.planar.secondary->b -
dby = dbx/(float)h; sf->data.planar.primary->b);
dbx/= (float)w; dby = dbx/(float)h;
for (x = w; x > 0; --x, ++data) { dbx/= (float)w;
r = sf->data.planar.primary->r + ((int)(drx * (x-1)) + (int)(dry * y))/2; for (x = w; x > 0; --x, ++data) {
g = sf->data.planar.primary->g + ((int)(dgx * (x-1)) + (int)(dgy * y))/2; r = sf->data.planar.primary->r +
b = sf->data.planar.primary->b + ((int)(dbx * (x-1)) + (int)(dby * y))/2; ((int)(drx * (x-1)) + (int)(dry * y))/2;
current = (r << default_red_offset) g = sf->data.planar.primary->g +
+ (g << default_green_offset) ((int)(dgx * (x-1)) + (int)(dgy * y))/2;
+ (b << default_blue_offset); b = sf->data.planar.primary->b +
*data = current; ((int)(dbx * (x-1)) + (int)(dby * y))/2;
current = (r << default_red_offset)
+ (g << default_green_offset)
+ (b << default_blue_offset);
*data = current;
}
} }
}
} }
void highlight(pixel32 *x, pixel32 *y, gboolean raised) void highlight(pixel32 *x, pixel32 *y, gboolean raised)
{ {
int r, g, b; int r, g, b;
pixel32 *up, *down; pixel32 *up, *down;
if (raised) { if (raised) {
up = x; up = x;
down = y; down = y;
} else { } else {
up = y; up = y;
down = x; down = x;
} }
r = (*up >> default_red_offset) & 0xFF; r = (*up >> default_red_offset) & 0xFF;
r += r >> 1; r += r >> 1;
g = (*up >> default_green_offset) & 0xFF; g = (*up >> default_green_offset) & 0xFF;
g += g >> 1; g += g >> 1;
b = (*up >> default_blue_offset) & 0xFF; b = (*up >> default_blue_offset) & 0xFF;
b += b >> 1; b += b >> 1;
if (r > 255) r = 255; if (r > 0xFF) r = 0xFF;
if (g > 255) g = 255; if (g > 0xFF) g = 0xFF;
if (b > 255) b = 255; if (b > 0xFF) b = 0xFF;
*up = (r << default_red_offset) + (g << default_green_offset) *up = (r << default_red_offset) + (g << default_green_offset)
+ (b << default_blue_offset);
r = (*down >> default_red_offset) & 0xFF;
r = (r >> 1) + (r >> 2);
g = (*down >> default_green_offset) & 0xFF;
g = (g >> 1) + (g >> 2);
b = (*down >> default_blue_offset) & 0xFF;
b = (b >> 1) + (b >> 2);
*down = (r << default_red_offset) + (g << default_green_offset)
+ (b << default_blue_offset); + (b << default_blue_offset);
r = (*down >> default_red_offset) & 0xFF;
r = (r >> 1) + (r >> 2);
g = (*down >> default_green_offset) & 0xFF;
g = (g >> 1) + (g >> 2);
b = (*down >> default_blue_offset) & 0xFF;
b = (b >> 1) + (b >> 2);
*down = (r << default_red_offset) + (g << default_green_offset)
+ (b << default_blue_offset);
}
static void create_bevel_colors(Appearance *l)
{
int r, g, b;
/* light color */
r = l->surface.data.planar.primary->r;
r += r >> 1;
g = l->surface.data.planar.primary->g;
g += g >> 1;
b = l->surface.data.planar.primary->b;
b += b >> 1;
if (r > 0xFF) r = 0xFF;
if (g > 0xFF) g = 0xFF;
if (b > 0xFF) b = 0xFF;
g_assert(!l->surface.data.planar.bevel_light);
l->surface.data.planar.bevel_light = color_new(r, g, b);
color_allocate_gc(l->surface.data.planar.bevel_light);
/* dark color */
r = l->surface.data.planar.primary->r;
r = (r >> 1) + (r >> 2);
g = l->surface.data.planar.primary->g;
g = (g >> 1) + (g >> 2);
b = l->surface.data.planar.primary->b;
b = (b >> 1) + (b >> 2);
g_assert(!l->surface.data.planar.bevel_dark);
l->surface.data.planar.bevel_dark = color_new(r, g, b);
color_allocate_gc(l->surface.data.planar.bevel_dark);
} }
void gradient_solid(Appearance *l, int x, int y, int w, int h) void gradient_solid(Appearance *l, int x, int y, int w, int h)
{ {
pixel32 pix; pixel32 pix;
int i, a, b; int i, a, b;
PlanarSurface *sp = &l->surface.data.planar; PlanarSurface *sp = &l->surface.data.planar;
int left = x, top = y, right = w - 1, bottom = h - 1; int left = x, top = y, right = x + w - 1, bottom = y + h - 1;
if (sp->primary->gc == None) if (sp->primary->gc == None)
color_allocate_gc(sp->primary); color_allocate_gc(sp->primary);
pix = (sp->primary->r << default_red_offset) pix = (sp->primary->r << default_red_offset)
+ (sp->primary->g << default_green_offset) + (sp->primary->g << default_green_offset)
+ (sp->primary->b << default_blue_offset); + (sp->primary->b << default_blue_offset);
for (a = 0; a < l->area.width; a++) for (a = 0; a < l->area.width; a++)
for (b = 0; b < l->area.height; b++) for (b = 0; b < l->area.height; b++)
sp->pixel_data[a + b*l->area.width] = pix; sp->pixel_data[a + b*l->area.width] = pix;
XFillRectangle(ob_display, l->pixmap, sp->primary->gc XFillRectangle(ob_display, l->pixmap, sp->primary->gc,
, x, y, w, h); x, y, w, h);
if (l->surface.data.planar.interlaced) { if (sp->interlaced) {
if (sp->secondary->gc == None) if (sp->secondary->gc == None)
color_allocate_gc(sp->secondary); color_allocate_gc(sp->secondary);
for (i = y; i < h; i += 2) for (i = y; i < h; i += 2)
XDrawLine(ob_display, l->pixmap, sp->secondary->gc, XDrawLine(ob_display, l->pixmap, sp->secondary->gc,
x, i, w, i); x, i, w, i);
}
/*
switch (texture.relief()) {
case RenderTexture::Raised:
switch (texture.bevel()) {
case RenderTexture::Bevel1:
XDrawLine(ob_display, l->pixmap, texture.bevelDarkColor().gc(),
left, bottom, right, bottom);
XDrawLine(ob_display, l->pixmap, texture.bevelDarkColor().gc(),
right, bottom, right, top);
XDrawLine(ob_display, l->pixmap, texture.bevelLightColor().gc(),
left, top, right, top);
XDrawLine(ob_display, l->pixmap, texture.bevelLightColor().gc(),
left, bottom, left, top);
break;
case RenderTexture::Bevel2:
XDrawLine(ob_display, l->pixmap, texture.bevelDarkColor().gc(),
left + 1, bottom - 2, right - 2, bottom - 2);
XDrawLine(ob_display, l->pixmap, texture.bevelDarkColor().gc(),
right - 2, bottom - 2, right - 2, top + 1);
XDrawLine(ob_display, l->pixmap, texture.bevelLightColor().gc(),
left + 1, top + 1, right - 2, top + 1);
XDrawLine(**display, sf.pixmap(), texture.bevelLightColor().gc(),
left + 1, bottom - 2, left + 1, top + 1);
break;
default:
assert(false); // unhandled RenderTexture::BevelType
} }
break;
case RenderTexture::Sunken:
switch (texture.bevel()) {
case RenderTexture::Bevel1:
XDrawLine(**display, sf.pixmap(), texture.bevelLightColor().gc(),
left, bottom, right, bottom);
XDrawLine(**display, sf.pixmap(), texture.bevelLightColor().gc(),
right, bottom, right, top);
XDrawLine(**display, sf.pixmap(), texture.bevelDarkColor().gc(), switch (sp->relief) {
left, top, right, top); case Raised:
XDrawLine(**display, sf.pixmap(), texture.bevelDarkColor().gc(), if (!sp->bevel_dark)
left, bottom, left, top); create_bevel_colors(l);
break;
case RenderTexture::Bevel2:
XDrawLine(**display, sf.pixmap(), texture.bevelLightColor().gc(),
left + 1, bottom - 2, right - 2, bottom - 2);
XDrawLine(**display, sf.pixmap(), texture.bevelLightColor().gc(),
right - 2, bottom - 2, right - 2, top + 1);
XDrawLine(**display, sf.pixmap(), texture.bevelDarkColor().gc(), switch (sp->bevel) {
left + 1, top + 1, right - 2, top + 1); case Bevel1:
XDrawLine(**display, sf.pixmap(), texture.bevelDarkColor().gc(), XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
left + 1, bottom - 2, left + 1, top + 1); left, bottom, right, bottom);
XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
right, bottom, right, top);
break; XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
left, top, right, top);
XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
left, bottom, left, top);
break;
case Bevel2:
XDrawLine(ob_display, l->pixmap,
sp->bevel_dark->gc,
left + 1, bottom - 2, right - 2, bottom - 2);
XDrawLine(ob_display, l->pixmap,
sp->bevel_dark->gc,
right - 2, bottom - 2, right - 2, top + 1);
XDrawLine(ob_display, l->pixmap,
sp->bevel_light->gc,
left + 1, top + 1, right - 2, top + 1);
XDrawLine(ob_display, l->pixmap,
sp->bevel_light->gc,
left + 1, bottom - 2, left + 1, top + 1);
break;
default:
g_assert_not_reached(); /* unhandled BevelType */
}
break;
case Sunken:
if (!sp->bevel_dark)
create_bevel_colors(l);
switch (sp->bevel) {
case Bevel1:
XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
left, bottom, right, bottom);
XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
right, bottom, right, top);
XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
left, top, right, top);
XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
left, bottom, left, top);
break;
case Bevel2:
XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
left + 1, bottom - 2, right - 2, bottom - 2);
XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
right - 2, bottom - 2, right - 2, top + 1);
XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
left + 1, top + 1, right - 2, top + 1);
XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
left + 1, bottom - 2, left + 1, top + 1);
break;
default:
g_assert_not_reached(); /* unhandled BevelType */
}
break;
case Flat:
if (sp->border)
XDrawRectangle(ob_display, l->pixmap, sp->border_color->gc,
left, top, right, bottom);
break;
default: default:
assert(false); // unhandled RenderTexture::BevelType g_assert_not_reached(); /* unhandled ReliefType */
} }
break;
case RenderTexture::Flat:
if (texture.border())
XDrawRectangle(**display, sf.pixmap(), texture.borderColor().gc(),
left, top, right, bottom);
break;
default:
assert(false); // unhandled RenderTexture::ReliefType
}
*/
} }
void gradient_pyramid(Surface *sf, int inw, int inh) void gradient_pyramid(Surface *sf, int inw, int inh)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 *end = data + inw*inh; pixel32 *end = data + inw*inh;
pixel32 current; pixel32 current;
float drx, dgx, dbx, dry, dgy, dby; float drx, dgx, dbx, dry, dgy, dby;
unsigned int r,g,b; unsigned int r,g,b;
int x, y, h=(inh/2) + 1, w=(inw/2) + 1; int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
for (y = 0; y < h; ++y) { for (y = 0; y < h; ++y) {
drx = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); drx = (float)(sf->data.planar.secondary->r -
dry = drx/(float)h; sf->data.planar.primary->r);
drx/= (float)w; dry = drx/(float)h;
drx/= (float)w;
dgx = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); dgx = (float)(sf->data.planar.secondary->g -
dgy = dgx/(float)h; sf->data.planar.primary->g);
dgx/= (float)w; dgy = dgx/(float)h;
dgx/= (float)w;
dbx = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); dbx = (float)(sf->data.planar.secondary->b -
dby = dbx/(float)h; sf->data.planar.primary->b);
dbx/= (float)w; dby = dbx/(float)h;
for (x = 0; x < w; ++x, data) { dbx/= (float)w;
r = sf->data.planar.primary->r + ((int)(drx * x) + (int)(dry * y))/2; for (x = 0; x < w; ++x, data) {
g = sf->data.planar.primary->g + ((int)(dgx * x) + (int)(dgy * y))/2; r = sf->data.planar.primary->r +
b = sf->data.planar.primary->b + ((int)(dbx * x) + (int)(dby * y))/2; ((int)(drx * x) + (int)(dry * y))/2;
current = (r << default_red_offset) g = sf->data.planar.primary->g +
+ (g << default_green_offset) ((int)(dgx * x) + (int)(dgy * y))/2;
+ (b << default_blue_offset); b = sf->data.planar.primary->b +
*(data+x) = current; ((int)(dbx * x) + (int)(dby * y))/2;
*(data+inw-x) = current; current = (r << default_red_offset)
*(end-x) = current; + (g << default_green_offset)
*(end-(inw-x)) = current; + (b << default_blue_offset);
*(data+x) = current;
*(data+inw-x) = current;
*(end-x) = current;
*(end-(inw-x)) = current;
}
data+=inw;
end-=inw;
} }
data+=inw;
end-=inw;
}
} }
void gradient_rectangle(Surface *sf, int inw, int inh) void gradient_rectangle(Surface *sf, int inw, int inh)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 *end = data + inw*inh; pixel32 *end = data + inw*inh;
pixel32 current; pixel32 current;
float drx, dgx, dbx, dry, dgy, dby; float drx, dgx, dbx, dry, dgy, dby;
unsigned int r,g,b; unsigned int r,g,b;
int x, y, h=(inh/2) + 1, w=(inw/2) + 1; int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
int val; int val;
for (y = 0; y < h; ++y) { g_message("rectangle");
drx = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r);
dry = drx/(float)h;
drx/= (float)w;
dgx = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); for (y = 0; y < h; ++y) {
dgy = dgx/(float)h; drx = (float)(sf->data.planar.primary->r -
dgx/= (float)w; sf->data.planar.secondary->r);
dry = drx/(float)h;
drx/= (float)w;
dbx = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); dgx = (float)(sf->data.planar.primary->g -
dby = dbx/(float)h; sf->data.planar.secondary->g);
dbx/= (float)w; dgy = dgx/(float)h;
for (x = 0; x < w; ++x, data) { dgx/= (float)w;
if ((float)x/(float)w < (float)y/(float)h) val = (int)(drx * x);
else val = (int)(dry * y);
r = sf->data.planar.primary->r + val; dbx = (float)(sf->data.planar.primary->b -
g = sf->data.planar.primary->g + val; sf->data.planar.secondary->b);
b = sf->data.planar.primary->b + val; dby = dbx/(float)h;
current = (r << default_red_offset) dbx/= (float)w;
+ (g << default_green_offset) for (x = 0; x < w; ++x, data) {
+ (b << default_blue_offset); if ((float)x/(float)w < (float)y/(float)h) val = (int)(drx * x);
*(data+x) = current; else val = (int)(dry * y);
*(data+inw-x) = current;
*(end-x) = current; r = sf->data.planar.secondary->r + val;
*(end-(inw-x)) = current; g = sf->data.planar.secondary->g + val;
b = sf->data.planar.secondary->b + val;
current = (r << default_red_offset)
+ (g << default_green_offset)
+ (b << default_blue_offset);
*(data+x) = current;
*(data+inw-x) = current;
*(end-x) = current;
*(end-(inw-x)) = current;
}
data+=inw;
end-=inw;
} }
data+=inw;
end-=inw;
}
} }
void gradient_pipecross(Surface *sf, int inw, int inh) void gradient_pipecross(Surface *sf, int inw, int inh)
{ {
pixel32 *data = sf->data.planar.pixel_data; pixel32 *data = sf->data.planar.pixel_data;
pixel32 *end = data + inw*inh; pixel32 *end = data + inw*inh;
pixel32 current; pixel32 current;
float drx, dgx, dbx, dry, dgy, dby; float drx, dgx, dbx, dry, dgy, dby;
unsigned int r,g,b; unsigned int r,g,b;
int x, y, h=(inh/2) + 1, w=(inw/2) + 1; int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
int val; int val;
for (y = 0; y < h; ++y) { g_message("pipecross");
drx = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r);
dry = drx/(float)h;
drx/= (float)w;
dgx = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); for (y = 0; y < h; ++y) {
dgy = dgx/(float)h; drx = (float)(sf->data.planar.secondary->r -
dgx/= (float)w; sf->data.planar.primary->r);
dry = drx/(float)h;
drx/= (float)w;
dbx = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); dgx = (float)(sf->data.planar.secondary->g -
dby = dbx/(float)h; sf->data.planar.primary->g);
dbx/= (float)w; dgy = dgx/(float)h;
for (x = 0; x < w; ++x, data) { dgx/= (float)w;
if ((float)x/(float)w > (float)y/(float)h) val = (int)(drx * x);
else val = (int)(dry * y);
r = sf->data.planar.primary->r + val; dbx = (float)(sf->data.planar.secondary->b -
g = sf->data.planar.primary->g + val; sf->data.planar.primary->b);
b = sf->data.planar.primary->b + val; dby = dbx/(float)h;
current = (r << default_red_offset) dbx/= (float)w;
+ (g << default_green_offset) for (x = 0; x < w; ++x, data) {
+ (b << default_blue_offset); if ((float)x/(float)w > (float)y/(float)h) val = (int)(drx * x);
*(data+x) = current; else val = (int)(dry * y);
*(data+inw-x) = current;
*(end-x) = current; r = sf->data.planar.primary->r + val;
*(end-(inw-x)) = current; g = sf->data.planar.primary->g + val;
b = sf->data.planar.primary->b + val;
current = (r << default_red_offset)
+ (g << default_green_offset)
+ (b << default_blue_offset);
*(data+x) = current;
*(data+inw-x) = current;
*(end-x) = current;
*(end-(inw-x)) = current;
}
data+=inw;
end-=inw;
} }
data+=inw;
end-=inw;
}
} }