src/libs/icon/IconRenderer.cpp

   1 /*
   2  * Copyright 2006-2007, Haiku. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Stephan Aßmus <superstippi@gmx.de>
   7  */
   8
   9 #include "IconRenderer.h"
  10
  11 #include <new>
  12 #include <stdio.h>
  13
  14 #include <Bitmap.h>
  15 #include <List.h>
  16
  17 #include <agg_span_gradient.h>
  18 #include <agg_span_interpolator_linear.h>
  19
  20 #include "GradientTransformable.h"
  21 #include "Icon.h"
  22 #include "Shape.h"
  23 #include "ShapeContainer.h"
  24 #include "Style.h"
  25 #include "VectorPath.h"
  26
  27 using std::nothrow;
  28
  29 class IconRenderer::StyleHandler {
  30         struct StyleItem {
  31                 Style*                  style;
  32                 Transformation  transformation;
  33         };
  34
  35  public:
  36         StyleHandler(::GammaTable& gammaTable)
  37                 : fStyles(20),
  38                   fGammaTable(gammaTable),
  39                   fTransparent(0, 0, 0, 0),
  40                   fColor(0, 0, 0, 0)
  41         {}
  42
  43         ~StyleHandler()
  44         {
  45                 int32 count = fStyles.CountItems();
  46                 for (int32 i = 0; i < count; i++)
  47                         delete (StyleItem*)fStyles.ItemAtFast(i);
  48         }
  49
  50         bool is_solid(unsigned styleIndex) const
  51         {
  52                 StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
  53                 if (!styleItem)
  54                         return true;
  55
  56                 return styleItem->style->Gradient() == NULL;
  57         }
  58
  59         const agg::rgba8& color(unsigned styleIndex);
  60
  61         void generate_span(agg::rgba8* span, int x, int y,
  62                                            unsigned len, unsigned styleIndex);
  63
  64         bool AddStyle(Style* style, const Transformation& transformation)
  65         {
  66                 if (!style)
  67                         return false;
  68                 StyleItem* item = new (nothrow) StyleItem;
  69                 if (!item)
  70                         return false;
  71                 item->style = style;
  72                 // if the style uses a gradient, the transformation
  73                 // is based on the gradient transformation
  74                 if (Gradient* gradient = style->Gradient()) {
  75                         item->transformation = *gradient;
  76                         item->transformation.multiply(transformation);
  77                 } else {
  78                         item->transformation = transformation;
  79                 }
  80                 item->transformation.invert();
  81                 return fStyles.AddItem((void*)item);
  82         }
  83
  84 private:
  85         template<class GradientFunction>
  86         void _GenerateGradient(agg::rgba8* span, int x, int y, unsigned len,
  87                 GradientFunction function, int32 start, int32 end,
  88                 const agg::rgba8* gradientColors, Transformation& gradientTransform);
  89
  90         BList                           fStyles;
  91         ::GammaTable&           fGammaTable;
  92         agg::rgba8                      fTransparent;
  93         agg::rgba8                      fColor;
  94 };
  95
  96 // color
  97 const agg::rgba8&
  98 IconRenderer::StyleHandler::color(unsigned styleIndex)
  99 {
 100         StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
 101         if (!styleItem) {
 102                 printf("no style at index: %u!\n", styleIndex);
 103                 return fTransparent;
 104         }
 105
 106         const rgb_color& c = styleItem->style->Color();
 107         fColor = agg::rgba8(fGammaTable.dir(c.red), fGammaTable.dir(c.green),
 108                 fGammaTable.dir(c.blue), c.alpha);
 109         fColor.premultiply();
 110     return fColor;
 111 }
 112
 113 // generate_span
 114 void
 115 IconRenderer::StyleHandler::generate_span(agg::rgba8* span, int x, int y,
 116         unsigned len, unsigned styleIndex)
 117 {
 118         StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
 119         if (!styleItem || !styleItem->style->Gradient()) {
 120                 printf("no style/gradient at index: %u!\n", styleIndex);
 121                 // TODO: memset() span?
 122                 return;
 123         }
 124
 125         Style* style = styleItem->style;
 126         Gradient* gradient = style->Gradient();
 127         const agg::rgba8* colors = style->GammaCorrectedColors(fGammaTable);
 128
 129         switch (gradient->Type()) {
 130                 case GRADIENT_LINEAR: {
 131                     agg::gradient_x function;
 132                         _GenerateGradient(span, x, y, len, function, -64, 64, colors,
 133                                 styleItem->transformation);
 134                         break;
 135                 }
 136                 case GRADIENT_CIRCULAR: {
 137                     agg::gradient_radial function;
 138                         _GenerateGradient(span, x, y, len, function, 0, 64, colors,
 139                                 styleItem->transformation);
 140                         break;
 141                 }
 142                 case GRADIENT_DIAMOND: {
 143                     agg::gradient_diamond function;
 144                         _GenerateGradient(span, x, y, len, function, 0, 64, colors,
 145                                 styleItem->transformation);
 146                         break;
 147                 }
 148                 case GRADIENT_CONIC: {
 149                     agg::gradient_conic function;
 150                         _GenerateGradient(span, x, y, len, function, 0, 64, colors,
 151                                 styleItem->transformation);
 152                         break;
 153                 }
 154                 case GRADIENT_XY: {
 155                     agg::gradient_xy function;
 156                         _GenerateGradient(span, x, y, len, function, 0, 64, colors,
 157                                 styleItem->transformation);
 158                         break;
 159                 }
 160                 case GRADIENT_SQRT_XY: {
 161                     agg::gradient_sqrt_xy function;
 162                         _GenerateGradient(span, x, y, len, function, 0, 64, colors,
 163                                 styleItem->transformation);
 164                         break;
 165                 }
 166         }
 167 }
 168
 169 // _GenerateGradient
 170 template<class GradientFunction>
 171 void
 172 IconRenderer::StyleHandler::_GenerateGradient(agg::rgba8* span, int x, int y,
 173         unsigned len, GradientFunction function, int32 start, int32 end,
 174         const agg::rgba8* gradientColors, Transformation& gradientTransform)
 175 {
 176         typedef agg::pod_auto_array<agg::rgba8, 256>    ColorArray;
 177         typedef agg::span_interpolator_linear<>                 Interpolator;
 178         typedef agg::span_gradient<agg::rgba8,
 179                                                            Interpolator,
 180                                                            GradientFunction,
 181                                                            ColorArray>                  GradientGenerator;
 182
 183         Interpolator interpolator(gradientTransform);
 184
 185         ColorArray array(gradientColors);
 186         GradientGenerator gradientGenerator(interpolator, function, array,
 187                 start, end);
 188
 189         gradientGenerator.generate(span, x, y, len);
 190 }
 191
 192 // #pragma mark -
 193
 194 class HintingTransformer {
 195  public:
 196
 197         void transform(double* x, double* y) const
 198         {
 199                 *x = floor(*x + 0.5);
 200                 *y = floor(*y + 0.5);
 201         }
 202 };
 203
 204
 205 // #pragma mark -
 206
 207 // constructor
 208 IconRenderer::IconRenderer(BBitmap* bitmap)
 209         : fBitmap(bitmap),
 210           fBackground(NULL),
 211           fBackgroundColor(0, 0, 0, 0),
 212           fIcon(NULL),
 213
 214           fGammaTable(2.2),
 215
 216           fRenderingBuffer(),
 217           fPixelFormat(fRenderingBuffer),
 218           fPixelFormatPre(fRenderingBuffer),
 219           fBaseRenderer(fPixelFormat),
 220           fBaseRendererPre(fPixelFormatPre),
 221
 222           fScanline(),
 223           fBinaryScanline(),
 224           fSpanAllocator(),
 225
 226           fRasterizer(),
 227
 228           fGlobalTransform()
 229 {
 230         // attach rendering buffer to bitmap
 231         fRenderingBuffer.attach((uint8*)bitmap->Bits(),
 232                 bitmap->Bounds().IntegerWidth() + 1,
 233                 bitmap->Bounds().IntegerHeight() + 1, bitmap->BytesPerRow());
 234
 235         fBaseRendererPre.clip_box(0, 0, bitmap->Bounds().IntegerWidth(),
 236                 bitmap->Bounds().IntegerHeight());
 237 }
 238
 239 // destructor
 240 IconRenderer::~IconRenderer()
 241 {
 242 }
 243
 244 // SetIcon
 245 void
 246 IconRenderer::SetIcon(const Icon* icon)
 247 {
 248         if (fIcon == icon)
 249                 return;
 250
 251         fIcon = icon;
 252         // TODO: ... ?
 253 }
 254
 255 // Render
 256 void
 257 IconRenderer::Render()
 258 {
 259         _Render(fBitmap->Bounds());
 260 }
 261
 262 // Render
 263 void
 264 IconRenderer::Render(const BRect& area)
 265 {
 266         _Render(fBitmap->Bounds() & area);
 267 }
 268
 269 //SetScale
 270 void
 271 IconRenderer::SetScale(double scale)
 272 {
 273         fGlobalTransform.reset();
 274         fGlobalTransform.multiply(agg::trans_affine_scaling(scale));
 275 }
 276
 277 //SetBackground
 278 void
 279 IconRenderer::SetBackground(const BBitmap* background)
 280 {
 281         fBackground = background;
 282 }
 283
 284 //SetBackground
 285 void
 286 IconRenderer::SetBackground(const agg::rgba8& background)
 287 {
 288         fBackgroundColor.r = fGammaTable.dir(background.r);
 289         fBackgroundColor.g = fGammaTable.dir(background.g);
 290         fBackgroundColor.b = fGammaTable.dir(background.b);
 291         fBackgroundColor.a = background.a;
 292 }
 293
 294 // Demultiply
 295 void
 296 IconRenderer::Demultiply()
 297 {
 298         uint8* bits = (uint8*)fBitmap->Bits();
 299         uint32 bpr = fBitmap->BytesPerRow();
 300         uint32 width = fBitmap->Bounds().IntegerWidth() + 1;
 301         uint32 height = fBitmap->Bounds().IntegerHeight() + 1;
 302
 303         for (uint32 y = 0; y < height; y++) {
 304                 uint8* b = bits;
 305                 for (uint32 x = 0; x < width; x++) {
 306                         if (b[3] < 255 && b[3] > 0) {
 307                                 b[0] = (uint8)((int)b[0] * 255 / b[3]);
 308                                 b[1] = (uint8)((int)b[1] * 255 / b[3]);
 309                                 b[2] = (uint8)((int)b[2] * 255 / b[3]);
 310                         }
 311                         b += 4;
 312                 }
 313                 bits += bpr;
 314         }
 315 }
 316
 317 // #pragma mark -
 318
 319 typedef agg::conv_transform<VertexSource, Transformation> ScaledPath;
 320 typedef agg::conv_transform<ScaledPath, HintingTransformer> HintedPath;
 321
 322 // _Render
 323 void
 324 IconRenderer::_Render(const BRect& r)
 325 {
 326         if (!fIcon)
 327                 return;
 328
 329 // TODO: fix clip box for "clear" and "apply_gamma_inv"
 330 //      fBaseRendererPre.clip_box((int)floorf(r.left), (int)floorf(r.top),
 331 //              (int)ceilf(r.right), (int)ceilf(r.bottom));
 332
 333         if (fBackground)
 334                 memcpy(fBitmap->Bits(), fBackground->Bits(), fBitmap->BitsLength());
 335         else
 336                 fBaseRendererPre.clear(fBackgroundColor);
 337
 338 //bigtime_t start = system_time();
 339         StyleHandler styleHandler(fGammaTable);
 340
 341         fRasterizer.reset();
 342         // iterate over the shapes in the icon,
 343         // add the vector paths to the rasterizer
 344         // and associate each shapes style
 345         int32 shapeCount = fIcon->Shapes()->CountShapes();
 346         int32 styleIndex = 0;
 347         for (int32 i = 0; i < shapeCount; i++) {
 348                 Shape* shape = fIcon->Shapes()->ShapeAtFast(i);
 349
 350                 // Don't render shape if the Level Of Detail falls out of range.
 351                 // That's unless the scale is bigger than the maximum
 352                 // MaxVisibilityScale of 4.0f.
 353                 if (fGlobalTransform.scale() < shape->MinVisibilityScale()
 354                         || (fGlobalTransform.scale() > shape->MaxVisibilityScale()
 355                                 && shape->MaxVisibilityScale() < 4.0f)) {
 356                         continue;
 357                 }
 358
 359                 Transformation transform(*shape);
 360                 transform.multiply(fGlobalTransform);
 361                         // NOTE: this works only because "agg::trans_affine",
 362                         // "Transformable" and "Transformation" are all the
 363                         // same thing
 364
 365                 Style* style = shape->Style();
 366                 if (!style)
 367                         continue;
 368
 369                 // add the style either with global transformation or with
 370                 // the shapes transformation, depending on whether there
 371                 // is a gradient and its settings
 372                 Gradient* gradient = style->Gradient();
 373                 bool styleAdded = false;
 374                 if (gradient && !gradient->InheritTransformation()) {
 375                         styleAdded = styleHandler.AddStyle(shape->Style(),
 376                                 fGlobalTransform);
 377                 } else {
 378                         styleAdded = styleHandler.AddStyle(shape->Style(), transform);
 379                 }
 380
 381                 if (!styleAdded) {
 382                         printf("IconRenderer::_Render() - out of memory\n");
 383                         break;
 384                 }
 385
 386                 // if this is not the first shape, and the style contains
 387                 // transparency, commit a render pass of previous shapes
 388                 if (i > 0 && style->HasTransparency())
 389                         _CommitRenderPass(styleHandler);
 390
 391                 fRasterizer.styles(styleIndex, -1);
 392                 styleIndex++;
 393
 394                 // global scale
 395                 shape->SetGlobalScale(max_c(1.0, transform.scale()));
 396                 ScaledPath scaledPath(shape->VertexSource(), transform);
 397                 if (shape->Hinting()) {
 398                         // additional hinting
 399                         HintingTransformer hinter;
 400                         HintedPath hintedPath(scaledPath, hinter);
 401                         fRasterizer.add_path(hintedPath);
 402                 } else {
 403                         fRasterizer.add_path(scaledPath);
 404                 }
 405         }
 406
 407         _CommitRenderPass(styleHandler, false);
 408
 409         if (fGammaTable.gamma() != 1.0)
 410                 fPixelFormat.apply_gamma_inv(fGammaTable);
 411
 412 //if (fRenderingBuffer.width() == 64)
 413 //printf("rendering 64x64: %lld\n", system_time() - start);
 414 }
 415
 416 // _CommitRenderPass
 417 void
 418 IconRenderer::_CommitRenderPass(StyleHandler& styleHandler, bool reset)
 419 {
 420         agg::render_scanlines_compound(fRasterizer, fScanline, fBinaryScanline,
 421                 fBaseRendererPre, fSpanAllocator, styleHandler);
 422
 423         if (reset)
 424                 fRasterizer.reset();
 425 }
 426
 427
 428
 429