X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=render%2Fgradient.c;h=2f9bfd279236b0733993773e0e9d0e9e582cc3af;hb=c716d1788bb4f4b9db403617023f06347ba48102;hp=6b22c6ba412d7a387ade36b5df05fa18eef5edea;hpb=db705f406ccd85dc170beb89f0f35fd3398a0a46;p=chaz%2Fopenbox diff --git a/render/gradient.c b/render/gradient.c index 6b22c6ba..2f9bfd27 100644 --- a/render/gradient.c +++ b/render/gradient.c @@ -1,53 +1,104 @@ -#include -#include +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + gradient.c for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2008 Dana Jansens + Copyright (c) 2003 Derek Foreman + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + See the COPYING file for a copy of the GNU General Public License. +*/ + #include "render.h" #include "gradient.h" -#include "../kernel/openbox.h" #include "color.h" - -void gradient_render(Surface *sf, int w, int h) +#include +#include + +static void highlight(RrSurface *s, RrPixel32 *x, RrPixel32 *y, + gboolean raised); +static void gradient_parentrelative(RrAppearance *a, gint w, gint h); +static void gradient_solid(RrAppearance *l, gint w, gint h); +static void gradient_splitvertical(RrAppearance *a, gint w, gint h); +static void gradient_vertical(RrSurface *sf, gint w, gint h); +static void gradient_horizontal(RrSurface *sf, gint w, gint h); +static void gradient_mirrorhorizontal(RrSurface *sf, gint w, gint h); +static void gradient_diagonal(RrSurface *sf, gint w, gint h); +static void gradient_crossdiagonal(RrSurface *sf, gint w, gint h); +static void gradient_pyramid(RrSurface *sf, gint inw, gint inh); + +void RrRender(RrAppearance *a, gint w, gint h) { - pixel32 *data = sf->data.planar.pixel_data; - pixel32 current; - unsigned int r,g,b; - int off, x; - - switch (sf->data.planar.grad) { - case Background_Solid: /* already handled */ - return; - case Background_Vertical: - gradient_vertical(sf, w, h); + RrPixel32 *data = a->surface.pixel_data; + RrPixel32 current; + guint r,g,b; + gint off, x; + + switch (a->surface.grad) { + case RR_SURFACE_PARENTREL: + gradient_parentrelative(a, w, h); break; - case Background_Horizontal: - gradient_horizontal(sf, w, h); + case RR_SURFACE_SOLID: + gradient_solid(a, w, h); break; - case Background_Diagonal: - gradient_diagonal(sf, w, h); + case RR_SURFACE_SPLIT_VERTICAL: + gradient_splitvertical(a, w, h); break; - case Background_CrossDiagonal: - gradient_crossdiagonal(sf, w, h); + case RR_SURFACE_VERTICAL: + gradient_vertical(&a->surface, w, h); break; - case Background_Pyramid: - gradient_pyramid(sf, w, h); + case RR_SURFACE_HORIZONTAL: + gradient_horizontal(&a->surface, w, h); break; - case Background_PipeCross: - gradient_pipecross(sf, w, h); + case RR_SURFACE_MIRROR_HORIZONTAL: + gradient_mirrorhorizontal(&a->surface, w, h); break; - case Background_Rectangle: - gradient_rectangle(sf, w, h); + case RR_SURFACE_DIAGONAL: + gradient_diagonal(&a->surface, w, h); + break; + case RR_SURFACE_CROSS_DIAGONAL: + gradient_crossdiagonal(&a->surface, w, h); + break; + case RR_SURFACE_PYRAMID: + gradient_pyramid(&a->surface, w, h); break; default: - g_message("unhandled gradient"); + g_assert_not_reached(); /* unhandled gradient */ return; } - - if (sf->data.planar.relief == Flat && sf->data.planar.border) { - r = sf->data.planar.border_color->r; - g = sf->data.planar.border_color->g; - b = sf->data.planar.border_color->b; - current = (r << default_red_offset) - + (g << default_green_offset) - + (b << default_blue_offset); + + if (a->surface.interlaced) { + gint i; + RrPixel32 *p; + + r = a->surface.interlace_color->r; + g = a->surface.interlace_color->g; + b = a->surface.interlace_color->b; + current = (r << RrDefaultRedOffset) + + (g << RrDefaultGreenOffset) + + (b << RrDefaultBlueOffset); + p = data; + for (i = 0; i < h; i += 2, p += w) + for (x = 0; x < w; ++x, ++p) + *p = current; + } + + if (a->surface.relief == RR_RELIEF_FLAT && a->surface.border) { + r = a->surface.border_color->r; + g = a->surface.border_color->g; + b = a->surface.border_color->b; + current = (r << RrDefaultRedOffset) + + (g << RrDefaultGreenOffset) + + (b << RrDefaultBlueOffset); for (off = 0, x = 0; x < w; ++x, off++) { *(data + off) = current; *(data + off + ((h-1) * w)) = current; @@ -58,172 +109,36 @@ void gradient_render(Surface *sf, int w, int h) } } - if (sf->data.planar.relief != Flat) { - if (sf->data.planar.bevel == Bevel1) { + if (a->surface.relief != RR_RELIEF_FLAT) { + if (a->surface.bevel == RR_BEVEL_1) { for (off = 1, x = 1; x < w - 1; ++x, off++) - highlight(data + off, + highlight(&a->surface, data + off, data + off + (h-1) * w, - sf->data.planar.relief==Raised); + a->surface.relief==RR_RELIEF_RAISED); for (off = 0, x = 0; x < h; ++x, off++) - highlight(data + off * w, + highlight(&a->surface, data + off * w, data + off * w + w - 1, - sf->data.planar.relief==Raised); + a->surface.relief==RR_RELIEF_RAISED); } - if (sf->data.planar.bevel == Bevel2) { + if (a->surface.bevel == RR_BEVEL_2) { for (off = 2, x = 2; x < w - 2; ++x, off++) - highlight(data + off + w, + highlight(&a->surface, data + off + w, data + off + (h-2) * w, - sf->data.planar.relief==Raised); + a->surface.relief==RR_RELIEF_RAISED); for (off = 1, x = 1; x < h-1; ++x, off++) - highlight(data + off * w + 1, + highlight(&a->surface, data + off * w + 1, data + off * w + w - 2, - sf->data.planar.relief==Raised); + a->surface.relief==RR_RELIEF_RAISED); } } } - - -void gradient_vertical(Surface *sf, int w, int h) +static void highlight(RrSurface *s, RrPixel32 *x, RrPixel32 *y, gboolean raised) { - pixel32 *data = sf->data.planar.pixel_data; - pixel32 current; - float dr, dg, db; - unsigned int r,g,b; - int x, y; - - dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); - dr/= (float)h; - - dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); - dg/= (float)h; - - db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); - db/= (float)h; - - for (y = 0; y < h; ++y) { - r = sf->data.planar.primary->r + (int)(dr * y); - g = sf->data.planar.primary->g + (int)(dg * y); - b = sf->data.planar.primary->b + (int)(db * y); - current = (r << default_red_offset) - + (g << default_green_offset) - + (b << default_blue_offset); - for (x = 0; x < w; ++x, ++data) - *data = current; - } -} + gint r, g, b; -void gradient_horizontal(Surface *sf, int w, int h) -{ - pixel32 *data = sf->data.planar.pixel_data; - pixel32 current; - float dr, dg, db; - unsigned int r,g,b; - int x, y; - - dr = (float)(sf->data.planar.secondary->r - sf->data.planar.primary->r); - dr/= (float)w; - - dg = (float)(sf->data.planar.secondary->g - sf->data.planar.primary->g); - dg/= (float)w; - - db = (float)(sf->data.planar.secondary->b - sf->data.planar.primary->b); - db/= (float)w; - - for (x = 0; x < w; ++x, ++data) { - r = sf->data.planar.primary->r + (int)(dr * x); - g = sf->data.planar.primary->g + (int)(dg * x); - b = sf->data.planar.primary->b + (int)(db * x); - current = (r << default_red_offset) - + (g << default_green_offset) - + (b << default_blue_offset); - for (y = 0; y < h; ++y) - *(data + y*w) = current; - } -} - -void gradient_diagonal(Surface *sf, int w, int h) -{ - pixel32 *data = sf->data.planar.pixel_data; - pixel32 current; - float drx, dgx, dbx, dry, dgy, dby; - unsigned int r,g,b; - int x, y; - - for (y = 0; y < h; ++y) { - 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); - dgy = dgx/(float)h; - dgx/= (float)w; - - dbx = (float)(sf->data.planar.secondary->b - - sf->data.planar.primary->b); - dby = dbx/(float)h; - dbx/= (float)w; - for (x = 0; x < w; ++x, ++data) { - r = sf->data.planar.primary->r + - ((int)(drx * x) + (int)(dry * y))/2; - g = sf->data.planar.primary->g + - ((int)(dgx * x) + (int)(dgy * y))/2; - b = sf->data.planar.primary->b + - ((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) -{ - pixel32 *data = sf->data.planar.pixel_data; - pixel32 current; - float drx, dgx, dbx, dry, dgy, dby; - unsigned int r,g,b; - int x, y; - - for (y = 0; y < h; ++y) { - 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); - dgy = dgx/(float)h; - dgx/= (float)w; - - dbx = (float)(sf->data.planar.secondary->b - - sf->data.planar.primary->b); - dby = dbx/(float)h; - dbx/= (float)w; - for (x = w; x > 0; --x, ++data) { - r = sf->data.planar.primary->r + - ((int)(drx * (x-1)) + (int)(dry * y))/2; - g = sf->data.planar.primary->g + - ((int)(dgx * (x-1)) + (int)(dgy * y))/2; - b = sf->data.planar.primary->b + - ((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) -{ - int r, g, b; - - pixel32 *up, *down; + RrPixel32 *up, *down; if (raised) { up = x; down = y; @@ -231,526 +146,687 @@ void highlight(pixel32 *x, pixel32 *y, gboolean raised) up = y; down = x; } - r = (*up >> default_red_offset) & 0xFF; - r += r >> 1; - g = (*up >> default_green_offset) & 0xFF; - g += g >> 1; - b = (*up >> default_blue_offset) & 0xFF; - b += b >> 1; + + r = (*up >> RrDefaultRedOffset) & 0xFF; + r += (r * s->bevel_light_adjust) >> 8; + g = (*up >> RrDefaultGreenOffset) & 0xFF; + g += (g * s->bevel_light_adjust) >> 8; + b = (*up >> RrDefaultBlueOffset) & 0xFF; + b += (b * s->bevel_light_adjust) >> 8; if (r > 0xFF) r = 0xFF; if (g > 0xFF) g = 0xFF; if (b > 0xFF) b = 0xFF; - *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); + *up = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset) + + (b << RrDefaultBlueOffset); + + r = (*down >> RrDefaultRedOffset) & 0xFF; + r -= (r * s->bevel_dark_adjust) >> 8; + g = (*down >> RrDefaultGreenOffset) & 0xFF; + g -= (g * s->bevel_dark_adjust) >> 8; + b = (*down >> RrDefaultBlueOffset) & 0xFF; + b -= (b * s->bevel_dark_adjust) >> 8; + *down = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset) + + (b << RrDefaultBlueOffset); } -static void create_bevel_colors(Appearance *l) +static void create_bevel_colors(RrAppearance *l) { - int r, g, b; + gint 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; + r = l->surface.primary->r; + r += (r * l->surface.bevel_light_adjust) >> 8; + g = l->surface.primary->g; + g += (g * l->surface.bevel_light_adjust) >> 8; + b = l->surface.primary->b; + b += (b * l->surface.bevel_light_adjust) >> 8; 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); + g_assert(!l->surface.bevel_light); + l->surface.bevel_light = RrColorNew(l->inst, r, g, b); /* 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); + r = l->surface.primary->r; + r -= (r * l->surface.bevel_dark_adjust) >> 8; + g = l->surface.primary->g; + g -= (g * l->surface.bevel_dark_adjust) >> 8; + b = l->surface.primary->b; + b -= (b * l->surface.bevel_dark_adjust) >> 8; + g_assert(!l->surface.bevel_dark); + l->surface.bevel_dark = RrColorNew(l->inst, r, g, b); +} + +/*! Repeat the first pixel over the entire block of memory + @param start The block of memory. start[0] will be copied + to the rest of the block. + @param w The width of the block of memory (including the already-set first + element +*/ +static inline void repeat_pixel(RrPixel32 *start, gint w) +{ + gint x; + RrPixel32 *dest; + + dest = start + 1; + + /* for really small things, just copy ourselves */ + if (w < 8) { + for (x = w-1; x > 0; --x) + *(dest++) = *start; + } + + /* for >= 8, then use O(log n) memcpy's... */ + else { + gchar *cdest; + gint lenbytes; + + /* copy the first 3 * 32 bits (3 words) ourselves - then we have + 3 + the original 1 = 4 words to make copies of at a time + + this is faster than doing memcpy for 1 or 2 words at a time + */ + for (x = 3; x > 0; --x) + *(dest++) = *start; + + /* cdest is a pointer to the pixel data that is typed char* so that + adding 1 to its position moves it only one byte + + lenbytes is the amount of bytes that we will be copying each + iteration. this doubles each time through the loop. + + x is the number of bytes left to copy into. lenbytes will alwaysa + be bounded by x + + this loop will run O(log n) times (n is the number of bytes we + need to copy into), since the size of the copy is doubled each + iteration. it seems that gcc does some nice optimizations to make + this memcpy very fast on hardware with support for vector operations + such as mmx or see. here is an idea of the kind of speed up we are + getting by doing this (splitvertical3 switches from doing + "*(data++) = color" n times to doing this memcpy thing log n times: + + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 49.44 0.88 0.88 1063 0.83 0.83 splitvertical1 + 47.19 1.72 0.84 1063 0.79 0.79 splitvertical2 + 2.81 1.77 0.05 1063 0.05 0.05 splitvertical3 + */ + cdest = (gchar*)dest; + lenbytes = 4 * sizeof(RrPixel32); + for (x = (w - 4) * sizeof(RrPixel32); x > 0;) { + memcpy(cdest, start, lenbytes); + x -= lenbytes; + cdest += lenbytes; + lenbytes <<= 1; + if (lenbytes > x) + lenbytes = x; + } + } } -void gradient_solid(Appearance *l, int x, int y, int w, int h) +static void gradient_parentrelative(RrAppearance *a, gint w, gint h) { - pixel32 pix; - int i, a, b; - PlanarSurface *sp = &l->surface.data.planar; - int left = x, top = y, right = x + w - 1, bottom = y + h - 1; - - if (sp->primary->gc == None) - color_allocate_gc(sp->primary); - pix = (sp->primary->r << default_red_offset) - + (sp->primary->g << default_green_offset) - + (sp->primary->b << default_blue_offset); - - for (a = 0; a < l->area.width; a++) - for (b = 0; b < l->area.height; b++) - sp->pixel_data[a + b*l->area.width] = pix; - - XFillRectangle(ob_display, l->pixmap, sp->primary->gc, - x, y, w, h); - - if (sp->interlaced) { - if (sp->secondary->gc == None) - color_allocate_gc(sp->secondary); - for (i = y; i < h; i += 2) - XDrawLine(ob_display, l->pixmap, sp->secondary->gc, - x, i, w, i); + RrPixel32 *source, *dest; + gint sw, sh, partial_w, partial_h, i; + + g_assert (a->surface.parent); + g_assert (a->surface.parent->w); + + sw = a->surface.parent->w; + sh = a->surface.parent->h; + + /* This is a little hack. When a texture is parentrelative, and the same + area as the parent, and has a bevel, it will draw its bevel on top + of the parent's, amplifying it. So instead, rerender the child with + the parent's settings, but the child's bevel and interlace */ + if (a->surface.relief != RR_RELIEF_FLAT && + (a->surface.parent->surface.relief != RR_RELIEF_FLAT || + a->surface.parent->surface.border) && + !a->surface.parentx && !a->surface.parenty && + sw == w && sh == h) + { + RrSurface old = a->surface; + a->surface = a->surface.parent->surface; + + /* turn these off for the parent */ + a->surface.relief = RR_RELIEF_FLAT; + a->surface.border = FALSE; + + a->surface.pixel_data = old.pixel_data; + + RrRender(a, w, h); + a->surface = old; + } else { + source = (a->surface.parent->surface.pixel_data + + a->surface.parentx + sw * a->surface.parenty); + dest = a->surface.pixel_data; + + if (a->surface.parentx + w > sw) { + partial_w = sw - a->surface.parentx; + } else partial_w = w; + + if (a->surface.parenty + h > sh) { + partial_h = sh - a->surface.parenty; + } else partial_h = h; + + for (i = 0; i < partial_h; i++, source += sw, dest += w) { + memcpy(dest, source, partial_w * sizeof(RrPixel32)); + } } +} + +static void gradient_solid(RrAppearance *l, gint w, gint h) +{ + gint i; + RrPixel32 pix; + RrPixel32 *data = l->surface.pixel_data; + RrSurface *sp = &l->surface; + gint left = 0, top = 0, right = w - 1, bottom = h - 1; + + pix = (sp->primary->r << RrDefaultRedOffset) + + (sp->primary->g << RrDefaultGreenOffset) + + (sp->primary->b << RrDefaultBlueOffset); + + for (i = 0; i < w * h; i++) + *data++ = pix; + + if (sp->interlaced) + return; + + XFillRectangle(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->primary), + 0, 0, w, h); switch (sp->relief) { - case Raised: + case RR_RELIEF_RAISED: if (!sp->bevel_dark) create_bevel_colors(l); switch (sp->bevel) { - case Bevel1: - XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc, + case RR_BEVEL_1: + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), left, bottom, right, bottom); - XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc, + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), right, bottom, right, top); - - XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc, + + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), left, top, right, top); - XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc, + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), 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); + case RR_BEVEL_2: + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), + left + 2, bottom - 1, right - 2, bottom - 1); + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), + right - 1, bottom - 1, right - 1, top + 1); + + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), + left + 2, top + 1, right - 2, top + 1); + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), + left + 1, bottom - 1, left + 1, top + 1); break; default: g_assert_not_reached(); /* unhandled BevelType */ } break; - case Sunken: + case RR_RELIEF_SUNKEN: if (!sp->bevel_dark) create_bevel_colors(l); switch (sp->bevel) { - case Bevel1: - XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc, + case RR_BEVEL_1: + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), left, bottom, right, bottom); - XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc, + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), right, bottom, right, top); - - XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc, + + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), left, top, right, top); - XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc, + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), 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); - + case RR_BEVEL_2: + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), + left + 2, bottom - 1, right - 2, bottom - 1); + XDrawLine(RrDisplay(l->inst), l->pixmap,RrColorGC(sp->bevel_light), + right - 1, bottom - 1, right - 1, top + 1); + + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), + left + 2, top + 1, right - 2, top + 1); + XDrawLine(RrDisplay(l->inst), l->pixmap, RrColorGC(sp->bevel_dark), + left + 1, bottom - 1, left + 1, top + 1); break; default: g_assert_not_reached(); /* unhandled BevelType */ } break; - case Flat: + case RR_RELIEF_FLAT: if (sp->border) { - if (sp->border_color->gc == None) - color_allocate_gc(sp->border_color); - XDrawRectangle(ob_display, l->pixmap, sp->border_color->gc, + XDrawRectangle(RrDisplay(l->inst), l->pixmap, + RrColorGC(sp->border_color), left, top, right, bottom); } break; - default: + default: g_assert_not_reached(); /* unhandled ReliefType */ } } -void gradient_pyramid(Surface *sf, int inw, int inh) +/* * * * * * * * * * * * * * GRADIENT MAGIC WOOT * * * * * * * * * * * * * * */ + +#define VARS(x) \ + guint color##x[3]; \ + gint len##x, cdelta##x[3], error##x[3] = { 0, 0, 0 }, inc##x[3]; \ + gboolean bigslope##x[3] /* color slope > 1 */ + +#define SETUP(x, from, to, w) \ + len##x = w; \ + \ + color##x[0] = from->r; \ + color##x[1] = from->g; \ + color##x[2] = from->b; \ + \ + cdelta##x[0] = to->r - from->r; \ + cdelta##x[1] = to->g - from->g; \ + cdelta##x[2] = to->b - from->b; \ + \ + if (cdelta##x[0] < 0) { \ + cdelta##x[0] = -cdelta##x[0]; \ + inc##x[0] = -1; \ + } else \ + inc##x[0] = 1; \ + if (cdelta##x[1] < 0) { \ + cdelta##x[1] = -cdelta##x[1]; \ + inc##x[1] = -1; \ + } else \ + inc##x[1] = 1; \ + if (cdelta##x[2] < 0) { \ + cdelta##x[2] = -cdelta##x[2]; \ + inc##x[2] = -1; \ + } else \ + inc##x[2] = 1; \ + bigslope##x[0] = cdelta##x[0] > w;\ + bigslope##x[1] = cdelta##x[1] > w;\ + bigslope##x[2] = cdelta##x[2] > w + +#define COLOR_RR(x, c) \ + c->r = color##x[0]; \ + c->g = color##x[1]; \ + c->b = color##x[2] + +#define COLOR(x) \ + ((color##x[0] << RrDefaultRedOffset) + \ + (color##x[1] << RrDefaultGreenOffset) + \ + (color##x[2] << RrDefaultBlueOffset)) + +#define INCREMENT(x, i) \ + (inc##x[i]) + +#define NEXT(x) \ +{ \ + gint i; \ + for (i = 2; i >= 0; --i) { \ + if (!cdelta##x[i]) continue; \ + \ + if (!bigslope##x[i]) { \ + /* Y (color) is dependant on X */ \ + error##x[i] += cdelta##x[i]; \ + if ((error##x[i] << 1) >= len##x) { \ + color##x[i] += INCREMENT(x, i); \ + error##x[i] -= len##x; \ + } \ + } else { \ + /* X is dependant on Y (color) */ \ + while (1) { \ + color##x[i] += INCREMENT(x, i); \ + error##x[i] += len##x; \ + if ((error##x[i] << 1) >= cdelta##x[i]) { \ + error##x[i] -= cdelta##x[i]; \ + break; \ + } \ + } \ + } \ + } \ +} + +static void gradient_splitvertical(RrAppearance *a, gint w, gint h) +{ + gint y1, y2, y3; + RrSurface *sf = &a->surface; + RrPixel32 *data; + gint y1sz, y2sz, y3sz; + + VARS(y1); + VARS(y2); + VARS(y3); + + /* if h <= 5, then a 0 or 1px middle gradient. + if h > 5, then always a 1px middle gradient. + */ + if (h <= 5) { + y1sz = MAX(h/2, 0); + y2sz = (h < 3 ? 0 : h % 2); + y3sz = MAX(h/2, 1); + } + else { + y1sz = h/2 - (1 - (h % 2)); + y2sz = 1; + y3sz = h/2; + } + + SETUP(y1, sf->split_primary, sf->primary, y1sz); + if (y2sz) { + /* setup to get the colors _in between_ these other 2 */ + SETUP(y2, sf->primary, sf->secondary, y2sz + 2); + NEXT(y2); /* skip the first one, its the same as the last of y1 */ + } + SETUP(y3, sf->secondary, sf->split_secondary, y3sz); + + /* find the color for the first pixel of each row first */ + data = sf->pixel_data; + + for (y1 = y1sz-1; y1 > 0; --y1) { + *data = COLOR(y1); + data += w; + NEXT(y1); + } + *data = COLOR(y1); + data += w; + for (y2 = y2sz-1; y2 > 0; --y2) { + *data = COLOR(y2); + data += w; + NEXT(y2); + } + *data = COLOR(y2); + data += w; + for (y3 = y3sz-1; y3 > 0; --y3) { + *data = COLOR(y3); + data += w; + NEXT(y3); + } + *data = COLOR(y3); + + /* copy the first pixels into the whole rows */ + data = sf->pixel_data; + for (y1 = h; y1 > 0; --y1) { + repeat_pixel(data, w); + data += w; + } +} + +static void gradient_horizontal(RrSurface *sf, gint w, gint h) +{ + gint x, y, cpbytes; + RrPixel32 *data = sf->pixel_data, *datav; + gchar *datac; + + VARS(x); + SETUP(x, sf->primary, sf->secondary, w); + + /* set the color values for the first row */ + datav = data; + for (x = w - 1; x > 0; --x) { /* 0 -> w - 1 */ + *datav = COLOR(x); + ++datav; + NEXT(x); + } + *datav = COLOR(x); + ++datav; + + /* copy the first row to the rest in O(logn) copies */ + datac = (gchar*)datav; + cpbytes = 1 * w * sizeof(RrPixel32); + for (y = (h - 1) * w * sizeof(RrPixel32); y > 0;) { + memcpy(datac, data, cpbytes); + y -= cpbytes; + datac += cpbytes; + cpbytes <<= 1; + if (cpbytes > y) + cpbytes = y; + } +} + +static void gradient_mirrorhorizontal(RrSurface *sf, gint w, gint h) { - pixel32 *data = sf->data.planar.pixel_data; - pixel32 *end = data + inw*inh - 1; - pixel32 current; - float drx, dgx, dbx, dry, dgy, dby; - unsigned int r,g,b; - int x, y, h=(inh/2) + 1, w=(inw/2) + 1; - for (y = 0; y < h; ++y) { - 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); - dgy = dgx/(float)h; - dgx/= (float)w; - - dbx = (float)(sf->data.planar.secondary->b - - sf->data.planar.primary->b); - dby = dbx/(float)h; - dbx/= (float)w; - for (x = 0; x < w; ++x, data) { - r = sf->data.planar.primary->r + - ((int)(drx * x) + (int)(dry * y))/2; - g = sf->data.planar.primary->g + - ((int)(dgx * x) + (int)(dgy * y))/2; - b = sf->data.planar.primary->b + - ((int)(dbx * x) + (int)(dby * y))/2; - 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; + gint x, y, half1, half2, cpbytes; + RrPixel32 *data = sf->pixel_data, *datav; + gchar *datac; + + VARS(x); + + half1 = (w + 1) / 2; + half2 = w / 2; + + /* set the color values for the first row */ + + SETUP(x, sf->primary, sf->secondary, half1); + datav = data; + for (x = half1 - 1; x > 0; --x) { /* 0 -> half1 - 1 */ + *datav = COLOR(x); + ++datav; + NEXT(x); + } + *datav = COLOR(x); + ++datav; + + if (half2 > 0) { + SETUP(x, sf->secondary, sf->primary, half2); + for (x = half2 - 1; x > 0; --x) { /* 0 -> half2 - 1 */ + *datav = COLOR(x); + ++datav; + NEXT(x); } - data+=inw; - end-=inw; + *datav = COLOR(x); + ++datav; + } + + /* copy the first row to the rest in O(logn) copies */ + datac = (gchar*)datav; + cpbytes = 1 * w * sizeof(RrPixel32); + for (y = (h - 1) * w * sizeof(RrPixel32); y > 0;) { + memcpy(datac, data, cpbytes); + y -= cpbytes; + datac += cpbytes; + cpbytes <<= 1; + if (cpbytes > y) + cpbytes = y; } } -void gradient_rectangle(Surface *sf, int inw, int inh) +static void gradient_vertical(RrSurface *sf, gint w, gint h) { - pixel32 *data = sf->data.planar.pixel_data; - pixel32 *end = data + inw*inh - 1; - pixel32 current; - float drx, dgx, dbx, dry, dgy, dby; - unsigned int r,g,b; - int x, y, h=(inh/2) + 1, w=(inw/2) + 1; - int val; - - for (y = 0; y < h; ++y) { - drx = (float)(sf->data.planar.primary->r - - sf->data.planar.secondary->r); - dry = drx/(float)h; - drx/= (float)w; - - dgx = (float)(sf->data.planar.primary->g - - sf->data.planar.secondary->g); - dgy = dgx/(float)h; - dgx/= (float)w; - - dbx = (float)(sf->data.planar.primary->b - - sf->data.planar.secondary->b); - dby = dbx/(float)h; - dbx/= (float)w; - for (x = 0; x < w; ++x, data) { - if ((float)x/(float)w < (float)y/(float)h) val = (int)(drx * x); - else val = (int)(dry * y); - - r = sf->data.planar.secondary->r + val; - 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; + gint y; + RrPixel32 *data; + + VARS(y); + SETUP(y, sf->primary, sf->secondary, h); + + /* find the color for the first pixel of each row first */ + data = sf->pixel_data; + + for (y = h - 1; y > 0; --y) { /* 0 -> h-1 */ + *data = COLOR(y); + data += w; + NEXT(y); + } + *data = COLOR(y); + + /* copy the first pixels into the whole rows */ + data = sf->pixel_data; + for (y = h; y > 0; --y) { + repeat_pixel(data, w); + data += w; + } +} + +static void gradient_diagonal(RrSurface *sf, gint w, gint h) +{ + gint x, y; + RrPixel32 *data = sf->pixel_data; + RrColor left, right; + RrColor extracorner; + + VARS(lefty); + VARS(righty); + VARS(x); + + extracorner.r = (sf->primary->r + sf->secondary->r) / 2; + extracorner.g = (sf->primary->g + sf->secondary->g) / 2; + extracorner.b = (sf->primary->b + sf->secondary->b) / 2; + + SETUP(lefty, sf->primary, (&extracorner), h); + SETUP(righty, (&extracorner), sf->secondary, h); + + for (y = h - 1; y > 0; --y) { /* 0 -> h-1 */ + COLOR_RR(lefty, (&left)); + COLOR_RR(righty, (&right)); + + SETUP(x, (&left), (&right), w); + + for (x = w - 1; x > 0; --x) { /* 0 -> w-1 */ + *(data++) = COLOR(x); + + NEXT(x); } - data+=inw; - end-=inw; + *(data++) = COLOR(x); + + NEXT(lefty); + NEXT(righty); + } + COLOR_RR(lefty, (&left)); + COLOR_RR(righty, (&right)); + + SETUP(x, (&left), (&right), w); + + for (x = w - 1; x > 0; --x) { /* 0 -> w-1 */ + *(data++) = COLOR(x); + + NEXT(x); } + *data = COLOR(x); } -void gradient_pipecross(Surface *sf, int inw, int inh) +static void gradient_crossdiagonal(RrSurface *sf, gint w, gint h) { - pixel32 *data = sf->data.planar.pixel_data; - pixel32 *end = data + inw*inh - 1; - pixel32 current; - float drx, dgx, dbx, dry, dgy, dby; - unsigned int r,g,b; - int x, y, h=(inh/2) + 1, w=(inw/2) + 1; - int val; - - for (y = 0; y < h; ++y) { - 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); - dgy = dgx/(float)h; - dgx/= (float)w; - - dbx = (float)(sf->data.planar.secondary->b - - sf->data.planar.primary->b); - dby = dbx/(float)h; - dbx/= (float)w; - for (x = 0; x < w; ++x, data) { - 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; - 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; + gint x, y; + RrPixel32 *data = sf->pixel_data; + RrColor left, right; + RrColor extracorner; + + VARS(lefty); + VARS(righty); + VARS(x); + + extracorner.r = (sf->primary->r + sf->secondary->r) / 2; + extracorner.g = (sf->primary->g + sf->secondary->g) / 2; + extracorner.b = (sf->primary->b + sf->secondary->b) / 2; + + SETUP(lefty, (&extracorner), sf->secondary, h); + SETUP(righty, sf->primary, (&extracorner), h); + + for (y = h - 1; y > 0; --y) { /* 0 -> h-1 */ + COLOR_RR(lefty, (&left)); + COLOR_RR(righty, (&right)); + + SETUP(x, (&left), (&right), w); + + for (x = w - 1; x > 0; --x) { /* 0 -> w-1 */ + *(data++) = COLOR(x); + + NEXT(x); } - data+=inw; - end-=inw; + *(data++) = COLOR(x); + + NEXT(lefty); + NEXT(righty); } + COLOR_RR(lefty, (&left)); + COLOR_RR(righty, (&right)); + + SETUP(x, (&left), (&right), w); + + for (x = w - 1; x > 0; --x) { /* 0 -> w-1 */ + *(data++) = COLOR(x); + + NEXT(x); + } + *data = COLOR(x); } -#ifdef USE_GL -void render_gl_gradient(Surface *sf, int x, int y, int w, int h) + +static void gradient_pyramid(RrSurface *sf, gint w, gint h) { - float pr,pg,pb; - float sr, sg, sb; - float ar, ag, ab; - - pr = (float)sf->data.planar.primary->r/255.0; - pg = (float)sf->data.planar.primary->g/255.0; - pb = (float)sf->data.planar.primary->b/255.0; - if (sf->data.planar.secondary) { - sr = (float)sf->data.planar.secondary->r/255.0; - sg = (float)sf->data.planar.secondary->g/255.0; - sb = (float)sf->data.planar.secondary->b/255.0; + RrPixel32 *ldata, *rdata; + RrPixel32 *cp; + RrColor left, right; + RrColor extracorner; + gint x, y, halfw, halfh, midx, midy; + + VARS(lefty); + VARS(righty); + VARS(x); + + extracorner.r = (sf->primary->r + sf->secondary->r) / 2; + extracorner.g = (sf->primary->g + sf->secondary->g) / 2; + extracorner.b = (sf->primary->b + sf->secondary->b) / 2; + + halfw = w >> 1; + halfh = h >> 1; + midx = w - halfw - halfw; /* 0 or 1, depending if w is even or odd */ + midy = h - halfh - halfh; /* 0 or 1, depending if h is even or odd */ + + SETUP(lefty, sf->primary, (&extracorner), halfh + midy); + SETUP(righty, (&extracorner), sf->secondary, halfh + midy); + + /* draw the top half + + it is faster to draw both top quarters together than to draw one and + then copy it over to the other side. + */ + + ldata = sf->pixel_data; + rdata = ldata + w - 1; + for (y = halfh + midy; y > 0; --y) { /* 0 -> (h+1)/2 */ + RrPixel32 c; + + COLOR_RR(lefty, (&left)); + COLOR_RR(righty, (&right)); + + SETUP(x, (&left), (&right), halfw + midx); + + for (x = halfw + midx - 1; x > 0; --x) { /* 0 -> (w+1)/2 */ + c = COLOR(x); + *(ldata++) = *(rdata--) = c; + + NEXT(x); + } + c = COLOR(x); + *ldata = *rdata = c; + ldata += halfw + 1; + rdata += halfw - 1 + midx + w; + + NEXT(lefty); + NEXT(righty); } - switch (sf->data.planar.grad) { - case Background_Solid: /* already handled */ - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glVertex2i(x+w, y); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glVertex2i(x, y+h); - glVertex2i(x, y); - glEnd(); - return; - case Background_Horizontal: - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w, y); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glColor3f(pr, pg, pb); - glVertex2i(x, y+h); - glVertex2i(x, y); - glEnd(); - break; - case Background_Vertical: - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glVertex2i(x+w, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glVertex2i(x, y+h); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glEnd(); - break; - case Background_Diagonal: - ar = (pr + sr) / 2.0; - ag = (pg + sg) / 2.0; - ab = (pb + sb) / 2.0; - glBegin(GL_TRIANGLES); - glColor3f(ar, ag, ab); - glVertex2i(x, y); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y); - glColor3f(ar, ag, ab); - glVertex2i(x+w, y+h); - - glColor3f(ar, ag, ab); - glVertex2i(x+w, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x, y+h); - glColor3f(ar, ag, ab); - glVertex2i(x, y); - glEnd(); - break; - case Background_CrossDiagonal: - ar = (pr + sr) / 2.0; - ag = (pg + sg) / 2.0; - ab = (pb + sb) / 2.0; - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glColor3f(ar, ag, ab); - glVertex2i(x+w, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w, y+h); - - glColor3f(sr, sg, sb); - glVertex2i(x+w, y+h); - glColor3f(ar, ag, ab); - glVertex2i(x, y+h); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glEnd(); - break; - case Background_Pyramid: - ar = (pr + sr) / 2.0; - ag = (pg + sg) / 2.0; - ab = (pb + sb) / 2.0; - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(ar, ag, ab); - glVertex2i(x, y+h/2); - - glVertex2i(x, y+h/2); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y+h); - - glVertex2i(x, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(ar, ag, ab); - glVertex2i(x+w/2, y+h); - - glVertex2i(x+w/2, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(ar, ag, ab); - glVertex2i(x+w, y+h/2); - - glVertex2i(x+w, y+h/2); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y); - - glVertex2i(x+w, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(ar, ag, ab); - glVertex2i(x+w/2, y); - - glVertex2i(x+w/2, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glEnd(); - break; - case Background_PipeCross: - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glVertex2i(x, y+h/2); - - glVertex2i(x, y+h/2); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y+h); - - glVertex2i(x, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glVertex2i(x+w/2, y+h); - - glVertex2i(x+w/2, y+h); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glVertex2i(x+w, y+h/2); - - glVertex2i(x+w, y+h/2); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y); - - glVertex2i(x+w, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glVertex2i(x+w/2, y); - - glVertex2i(x+w/2, y); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glEnd(); - break; - case Background_Rectangle: - glBegin(GL_TRIANGLES); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y+h); - - glVertex2i(x, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y+h); - - glVertex2i(x+w, y+h); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x+w, y); - - glVertex2i(x+w, y); - glColor3f(sr, sg, sb); - glVertex2i(x+w/2, y+h/2); - glColor3f(pr, pg, pb); - glVertex2i(x, y); - - glEnd(); - break; - default: - g_message("unhandled gradient"); - return; + + /* copy the top half into the bottom half, mirroring it, so we can only + copy one row at a time + + it is faster, to move the writing pointer forward, and the reading + pointer backward + + this is the current code, moving the write pointer forward and read + pointer backward + 41.78 4.26 1.78 504 3.53 3.53 gradient_pyramid2 + this is the opposite, moving the read pointer forward and the write + pointer backward + 42.27 4.40 1.86 504 3.69 3.69 gradient_pyramid2 + + */ + ldata = sf->pixel_data + (halfh - 1) * w; + cp = ldata + (midy + 1) * w; + for (y = halfh; y > 0; --y) { + memcpy(cp, ldata, w * sizeof(RrPixel32)); + ldata -= w; + cp += w; } } -#endif /* USE_GL */