--- a/hostsupport/hostopenvg/src/src/riImage.cpp Wed Oct 06 17:59:01 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2835 +0,0 @@
-/*------------------------------------------------------------------------
- *
- * OpenVG 1.1 Reference Implementation
- * -----------------------------------
- *
- * Copyright (c) 2007 The Khronos Group Inc.
- * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief Implementation of Color and Image functions.
- * \note
- *//*-------------------------------------------------------------------*/
-
-#include "riImage.h"
-#include "riRasterizer.h"
-#include "riContext.h"
-
-#ifndef __SFDYNAMICBLITTER_H
-# include "sfDynamicBlitter.h"
-#endif
-
-//==============================================================================================
-
-namespace OpenVGRI
-{
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from numBits into a shifted mask
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static RI_INLINE unsigned int bitsToMask(unsigned int bits, unsigned int shift)
-{
- return ((1<<bits)-1) << shift;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from color (RIfloat) to an int with 1.0f mapped to the
-* given maximum with round-to-nearest semantics.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-RI_INLINE int ffloor(RIfloat x)
-{
- return (x >= 0) ? (int)x : (int)(x-1);
-}
-
-//static const float FLOAT_0 = 0.0f;
-static const float FLOAT_0_5 = 0.5f;
-
-/* \note Rewrite this if time. */
-static unsigned int colorToInt(RIfloat c, int maxc)
-{
-#if defined RI_USE_SSE
- /*
- Registers mapping:
- c <-> xmm0,
- maxc <-> xmm1
- 0 <-> xmm2
- */
- _asm
- {
- xorps xmm2, xmm2 ; xmm2 = 0
-
- ;---------------------------------------------
- ; Computing: xmm0 = (c * (RIfloat)maxc + 0.5f)
- ;---------------------------------------------
- movss xmm0, dword ptr [c] ; xmm0 = c
- cvtsi2ss xmm1, dword ptr [maxc] ; xmm1 = (float)maxc
- mulss xmm0, xmm1 ; xmm0 = xmm0 * xmm1 = c * (float)maxc
- addss xmm0, FLOAT_0_5 ; xmm0 = xmm0 + 0.5f = c * (float)maxc + 0.5f
-
- ;---------------------------------------------
- ; Computing: xmm0 = floor(xmm0) = floor(c * (RIfloat)maxc + 0.5f)
- ;---------------------------------------------
- cvttss2si ebx, xmm0 ; ebx = (int)xmm0
- mov eax, ebx ; eax = ebx = (int)xmm0
- shr eax, 31 ; eax = sign(eax) = sign((int)xmm0)
- sub ebx, eax ; ebx = ebx - sign((int)xmm0) = (int)xmm0 - sign((int)xmm0) = (int)floor((int)xmm0)
- cvtsi2ss xmm0, ebx ; xmm0 = floor(xmm0)
-
- pmaxsw xmm0, xmm2; ; xmm0 = MAX(xmm0, 0)
- pminsw xmm0, xmm1 ; xmm0 = MIN(xmm0, maxc)
- cvttss2si eax, xmm0 ; return value = eax = (int)xmm0
- }
-#else
- return RI_INT_MIN(RI_INT_MAX((int)ffloor(c * (RIfloat)maxc + 0.5f), 0), maxc);
-#endif
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from int to color (RIfloat) with the given maximum
-* mapped to 1.0f.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static RI_INLINE RIfloat intToColor(unsigned int i, unsigned int maxi)
-{
- return (RIfloat)(i & maxi) / (RIfloat)maxi;
-}
-
-void Color::Descriptor::toSmallDescriptor(Color::SmallDescriptor& smallDesc) const
-{
- switch (bitsPerPixel)
- {
- case 32:
- smallDesc.size = SIZE_32;
- break;
- case 24:
- smallDesc.size = SIZE_24;
- break;
- case 16:
- smallDesc.size = SIZE_16;
- break;
- case 8:
- smallDesc.size = SIZE_8;
- break;
- case 4:
- smallDesc.size = SIZE_4;
- break;
- default:
- RI_ASSERT(bitsPerPixel == 1);
- smallDesc.size = SIZE_1;
- break;
- }
- smallDesc.shape = shape;
- smallDesc.internalFormat = internalFormat;
-}
-
-Color::Descriptor Color::Descriptor::getDummyDescriptor()
-{
- static const Descriptor dummy = Color::Descriptor(8,0,8,8,8,16,8,24,0,0,sRGBA,32,SHAPE_ABGR);
- return dummy;
-}
-
-/**
- * \brief Determine the shape of the color format from other data.
- * \todo The naming is poor because it may be interpreted as returning the member
- * "shape".
- */
-Color::Shape Color::Descriptor::getShape() const
-{
- // \todo There should be some easier way to define the shape so that it does
- // not need to be determined with so many conditions.
-
- if (isAlphaOnly())
- {
- return SHAPE_A;
- }
- else if (isLuminance())
- {
- if (alphaBits)
- {
- if (alphaShift == 0)
- return SHAPE_LA;
- return SHAPE_AL;
- }
- return SHAPE_L;
- }
- else if (!alphaBits)
- {
- if (bitsPerPixel == 32)
- {
- switch(redShift)
- {
- case 0:
- return SHAPE_XBGR;
- case 8:
- return SHAPE_BGRX;
- case 16:
- return SHAPE_XRGB;
- default:
- RI_ASSERT(redShift == 24);
- return SHAPE_RGBX;
- }
- } else if (bitsPerPixel == 24)
- {
- if (!redShift)
- return SHAPE_BGR;
- else
- {
- RI_ASSERT(redShift == 16);
- return SHAPE_RGB;
- }
- } else
- {
- RI_ASSERT(redBits == 5 && greenBits == 6 && blueBits == 5);
- if(redShift)
- return SHAPE_RGB;
- else
- return SHAPE_BGR;
- }
- }
- else
- {
- if (bitsPerPixel == 32)
- {
- switch(redShift)
- {
- case 0:
- return SHAPE_ABGR;
- case 8:
- return SHAPE_BGRA;
- case 16:
- return SHAPE_ARGB;
- default:
- RI_ASSERT(redShift == 24);
- return SHAPE_RGBA;
- }
- } else
- {
- RI_ASSERT(bitsPerPixel == 16);
- if (redBits == 5)
- {
- RI_ASSERT(greenBits == 5 && blueBits == 5 && alphaBits == 1);
- switch(redShift)
- {
- case 0:
- return SHAPE_ABGR;
- case 1:
- return SHAPE_BGRA;
- case 10:
- return SHAPE_ARGB;
- default:
- RI_ASSERT(redShift == 11);
- return SHAPE_RGBA;
- }
- } else
- {
- RI_ASSERT(redBits == 4 && greenBits == 4 && alphaBits == 4);
- switch(redShift)
- {
- case 0:
- return SHAPE_ABGR;
- case 4:
- return SHAPE_BGRA;
- case 8:
- return SHAPE_ARGB;
- default:
- RI_ASSERT(redShift == 12);
- return SHAPE_RGBA;
- }
- }
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from packed integer in a given format to a Color.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Color::unpack(unsigned int inputData, const Color::Descriptor& inputDesc)
-{
- int rb = inputDesc.redBits;
- int gb = inputDesc.greenBits;
- int bb = inputDesc.blueBits;
- int ab = inputDesc.alphaBits;
- int lb = inputDesc.luminanceBits;
- int rs = inputDesc.redShift;
- int gs = inputDesc.greenShift;
- int bs = inputDesc.blueShift;
- int as = inputDesc.alphaShift;
- int ls = inputDesc.luminanceShift;
-
- m_format = inputDesc.internalFormat;
- if(lb)
- { //luminance
- r = g = b = intToColor(inputData >> ls, (1<<lb)-1);
- a = 1.0f;
- }
- else
- { //rgba
- r = rb ? intToColor(inputData >> rs, (1<<rb)-1) : (RIfloat)1.0f;
- g = gb ? intToColor(inputData >> gs, (1<<gb)-1) : (RIfloat)1.0f;
- b = bb ? intToColor(inputData >> bs, (1<<bb)-1) : (RIfloat)1.0f;
- a = ab ? intToColor(inputData >> as, (1<<ab)-1) : (RIfloat)1.0f;
-
- if(isPremultiplied())
- { //clamp premultiplied color to alpha to enforce consistency
- r = RI_MIN(r, a);
- g = RI_MIN(g, a);
- b = RI_MIN(b, a);
- }
- }
-
- assertConsistency();
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from Color to a packed integer in a given format.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-unsigned int Color::pack(const Color::Descriptor& outputDesc) const
-{
- assertConsistency();
-
- int rb = outputDesc.redBits;
- int gb = outputDesc.greenBits;
- int bb = outputDesc.blueBits;
- int ab = outputDesc.alphaBits;
- int lb = outputDesc.luminanceBits;
- int rs = outputDesc.redShift;
- int gs = outputDesc.greenShift;
- int bs = outputDesc.blueShift;
- int as = outputDesc.alphaShift;
- int ls = outputDesc.luminanceShift;
-
- if(lb)
- { //luminance
- RI_ASSERT(isLuminance());
- return colorToInt(r, (1<<lb)-1) << ls;
- }
- else
- { //rgb
- RI_ASSERT(!isLuminance());
- unsigned int cr = rb ? colorToInt(r, (1<<rb)-1) : 0;
- unsigned int cg = gb ? colorToInt(g, (1<<gb)-1) : 0;
- unsigned int cb = bb ? colorToInt(b, (1<<bb)-1) : 0;
- unsigned int ca = ab ? colorToInt(a, (1<<ab)-1) : 0;
- return packRGBAInteger(cr, rs, cg, gs, cb, bs, ca, as);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from the current internal format to another.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-/* \todo Integer & lookup versions */
-
-static RIfloat gamma(RIfloat c)
-{
- if( c <= 0.00304f )
- c *= 12.92f;
- else
- c = 1.0556f * (RIfloat)pow(c, 1.0f/2.4f) - 0.0556f;
- return c;
-}
-
-static RIfloat invgamma(RIfloat c)
-{
- if( c <= 0.03928f )
- c /= 12.92f;
- else
- c = (RIfloat)pow((c + 0.0556f)/1.0556f, 2.4f);
- return c;
-}
-
-static RIfloat lRGBtoL(RIfloat r, RIfloat g, RIfloat b)
-{
- return 0.2126f*r + 0.7152f*g + 0.0722f*b;
-}
-
-void Color::convert(InternalFormat outputFormat)
-{
- /* \todo This should probably be converted to integer code. */
-
- assertConsistency();
-
- if( m_format == outputFormat )
- return;
-
- if(isPremultiplied())
- { //unpremultiply
- RIfloat ooa = (a != 0.0f) ? 1.0f / a : (RIfloat)0.0f;
- r *= ooa;
- g *= ooa;
- b *= ooa;
- }
-
- //From Section 3.4.2 of OpenVG spec
- //1: sRGB = gamma(lRGB)
- //2: lRGB = invgamma(sRGB)
- //3: lL = 0.2126 lR + 0.7152 lG + 0.0722 lB
- //4: lRGB = lL
- //5: sL = gamma(lL)
- //6: lL = invgamma(sL)
- //7: sRGB = sL
-
- //Source/Dest lRGB sRGB lL sL
- //lRGB - 1 3 3,5
- //sRGB 2 - 2,3 2,3,5
- //lL 4 4,1 - 5
- //sL 7,2 7 6 -
-
- const unsigned int shift = 3;
- unsigned int conversion = (m_format & (NONLINEAR | LUMINANCE)) | ((outputFormat & (NONLINEAR | LUMINANCE)) << shift);
-
- switch(conversion)
- {
- case lRGBA | (sRGBA << shift): r = gamma(r); g = gamma(g); b = gamma(b); break; //1
- case lRGBA | (lLA << shift) : r = g = b = lRGBtoL(r, g, b); break; //3
- case lRGBA | (sLA << shift) : r = g = b = gamma(lRGBtoL(r, g, b)); break; //3,5
- case sRGBA | (lRGBA << shift): r = invgamma(r); g = invgamma(g); b = invgamma(b); break; //2
- case sRGBA | (lLA << shift) : r = g = b = lRGBtoL(invgamma(r), invgamma(g), invgamma(b)); break; //2,3
- case sRGBA | (sLA << shift) : r = g = b = gamma(lRGBtoL(invgamma(r), invgamma(g), invgamma(b))); break;//2,3,5
- case lLA | (lRGBA << shift): break; //4
- case lLA | (sRGBA << shift): r = g = b = gamma(r); break; //4,1
- case lLA | (sLA << shift) : r = g = b = gamma(r); break; //5
- case sLA | (lRGBA << shift): r = g = b = invgamma(r); break; //7,2
- case sLA | (sRGBA << shift): break; //7
- case sLA | (lLA << shift) : r = g = b = invgamma(r); break; //6
- default: RI_ASSERT((m_format & (LUMINANCE | NONLINEAR)) == (outputFormat & (LUMINANCE | NONLINEAR))); break; //nop
- }
-
- if(outputFormat & PREMULTIPLIED)
- { //premultiply
- r *= a;
- g *= a;
- b *= a;
- }
- m_format = outputFormat;
-
- assertConsistency();
-}
-
-/*------------------------------------------------------------------------*//*!
-* \brief Creates a pixel format descriptor out of VGImageFormat
-* \param
-* \return
-* \note Remove this function and use the "const" version for consistency.
-*//*------------------------------------------------------------------------*/
-Color::Descriptor Color::formatToDescriptor(VGImageFormat format)
-{
- Descriptor desc;
- memset(&desc, 0, sizeof(Descriptor));
- RI_ASSERT(isValidImageFormat(format));
-
- int baseFormat = (int)format & 15;
- const int numBaseFormats = 15;
- RI_ASSERT(baseFormat >= 0 && baseFormat < numBaseFormats);
- int swizzleBits = ((int)format >> 6) & 3;
-
- /* base formats
- VG_sRGBX_8888 = 0,
- VG_sRGBA_8888 = 1,
- VG_sRGBA_8888_PRE = 2,
- VG_sRGB_565 = 3,
- VG_sRGBA_5551 = 4,
- VG_sRGBA_4444 = 5,
- VG_sL_8 = 6,
- VG_lRGBX_8888 = 7,
- VG_lRGBA_8888 = 8,
- VG_lRGBA_8888_PRE = 9,
- VG_lL_8 = 10,
- VG_A_8 = 11,
- VG_BW_1 = 12,
- VG_A_1 = 13,
- VG_A_4 = 14,
- */
-
- static const int redBits[numBaseFormats] = {8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};
- static const int greenBits[numBaseFormats] = {8, 8, 8, 6, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};
- static const int blueBits[numBaseFormats] = {8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};
- static const int alphaBits[numBaseFormats] = {0, 8, 8, 0, 1, 4, 0, 0, 8, 8, 0, 8, 0, 1, 4};
- static const int luminanceBits[numBaseFormats] = {0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 1, 0, 0};
-
- static const int redShifts[4*numBaseFormats] = {24, 24, 24, 11, 11, 12, 0, 24, 24, 24, 0, 0, 0, 0, 0, //RGBA
- 16, 16, 16, 11, 10, 8, 0, 16, 16, 16, 0, 0, 0, 0, 0, //ARGB
- 8, 8, 8, 0, 1, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0, //BGRA
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //ABGR
-
- static const int greenShifts[4*numBaseFormats] = {16, 16, 16, 5, 6, 8, 0, 16, 16, 16, 0, 0, 0, 0, 0, //RGBA
- 8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0, //ARGB
- 16, 16, 16, 5, 6, 8, 0, 16, 16, 16, 0, 0, 0, 0, 0, //BGRA
- 8, 8, 8, 5, 5, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0};//ABGR
-
- static const int blueShifts[4*numBaseFormats] = {8, 8, 8, 0, 1, 4, 0, 8, 8, 8, 0, 0, 0, 0, 0, //RGBA
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //ARGB
- 24, 24, 24, 11, 11, 12, 0, 24, 24, 24, 0, 0, 0, 0, 0, //BGRA
- 16, 16, 16, 11, 10, 8, 0, 16, 16, 16, 0, 0, 0, 0, 0};//ABGR
-
- static const int alphaShifts[4*numBaseFormats] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //RGBA
- 0, 24, 24, 0, 15, 12, 0, 0, 24, 24, 0, 0, 0, 0, 0, //ARGB
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //BGRA
- 0, 24, 24, 0, 15, 12, 0, 0, 24, 24, 0, 0, 0, 0, 0};//ABGR
-
- static const int bpps[numBaseFormats] = {32, 32, 32, 16, 16, 16, 8, 32, 32, 32, 8, 8, 1, 1, 4};
-
- static const InternalFormat internalFormats[numBaseFormats] = {sRGBA, sRGBA, sRGBA_PRE, sRGBA, sRGBA, sRGBA, sLA, lRGBA, lRGBA, lRGBA_PRE, lLA, lRGBA, lLA, lRGBA, lRGBA};
-
- desc.redBits = redBits[baseFormat];
- desc.greenBits = greenBits[baseFormat];
- desc.blueBits = blueBits[baseFormat];
- desc.alphaBits = alphaBits[baseFormat];
- desc.luminanceBits = luminanceBits[baseFormat];
-
- desc.redShift = redShifts[swizzleBits * numBaseFormats + baseFormat];
- desc.greenShift = greenShifts[swizzleBits * numBaseFormats + baseFormat];
- desc.blueShift = blueShifts[swizzleBits * numBaseFormats + baseFormat];
- desc.alphaShift = alphaShifts[swizzleBits * numBaseFormats + baseFormat];
- desc.luminanceShift = 0; //always zero
-
- desc.vgFormat = format;
- desc.bitsPerPixel = bpps[baseFormat];
- desc.bytesPerPixel = desc.bitsPerPixel / 8;
- desc.internalFormat = internalFormats[baseFormat];
- desc.shape = desc.getShape();
-
- if (desc.alphaBits)
- {
- desc.maskBits = desc.alphaBits;
- desc.maskShift = desc.alphaShift;
- }
- else if (!desc.isLuminance())
- {
- desc.maskBits = desc.redBits;
- desc.maskShift = desc.redShift;
- }
- else
- {
- desc.maskBits = desc.luminanceBits;
- desc.maskShift = desc.luminanceShift;
- }
-
- return desc;
-}
-
-
-struct DescToFormatMapping
-{
- Color::Descriptor desc;
- VGImageFormat format;
-};
-
-RI_INLINE static bool isDescEqualToMapping(const Color::Descriptor& desc, const DescToFormatMapping &mapping)
-{
- if ((desc.redBits == mapping.desc.redBits) &&
- (desc.redShift == mapping.desc.redShift) &&
- (desc.greenBits == mapping.desc.greenBits) &&
- (desc.greenShift == mapping.desc.greenShift) &&
- (desc.blueBits == mapping.desc.blueBits) &&
- (desc.blueShift == mapping.desc.blueShift) &&
- (desc.alphaBits == mapping.desc.alphaBits) &&
- (desc.alphaShift == mapping.desc.alphaShift) &&
- (desc.luminanceBits == mapping.desc.luminanceBits) &&
- (desc.luminanceShift == mapping.desc.luminanceShift) &&
- (desc.internalFormat == mapping.desc.internalFormat) &&
- (desc.bitsPerPixel == mapping.desc.bitsPerPixel))
- return true;
-
- return false;
-}
-
-VGImageFormat Color::descriptorToVGImageFormat(const Descriptor& desc)
-{
-//Color::Descriptor::Descriptor(int dredBits, int dredShift, int dgreenBits, int dgreenShift, int dblueBits, int dblueShift, int dalphaBits, int dalphaShift, int dluminanceBits, int dluminanceShift, InternalFormat dinternalFormat, int dbpp) :
- // \todo These are hardcoded here only to allow constant initialization, they should be generated
- // using formatToDescriptor!
- static const DescToFormatMapping map[] = {
- /* RGB{A,X} channel ordering */
- { formatToDescriptorConst(VG_sRGBX_8888), VG_sRGBX_8888 },
- { formatToDescriptorConst(VG_sRGBA_8888), VG_sRGBA_8888 },
- { formatToDescriptorConst(VG_sRGBA_8888_PRE), VG_sRGBA_8888_PRE },
- { formatToDescriptorConst(VG_sRGB_565), VG_sRGB_565 },
- { formatToDescriptorConst(VG_sRGBA_5551), VG_sRGBA_5551 },
- { formatToDescriptorConst(VG_sRGBA_4444), VG_sRGBA_4444 },
- { formatToDescriptorConst(VG_sL_8), VG_sL_8 },
- { formatToDescriptorConst(VG_lRGBX_8888), VG_lRGBX_8888 },
- { formatToDescriptorConst(VG_lRGBA_8888), VG_lRGBA_8888 },
- { formatToDescriptorConst(VG_lRGBA_8888_PRE), VG_lRGBA_8888_PRE },
- { formatToDescriptorConst(VG_lL_8), VG_lL_8 },
- { formatToDescriptorConst(VG_A_8), VG_A_8 },
- { formatToDescriptorConst(VG_BW_1), VG_BW_1 },
- { formatToDescriptorConst(VG_A_1), VG_A_1 },
- { formatToDescriptorConst(VG_A_4), VG_A_4 },
-
- /* {A,X}RGB channel ordering */
- { formatToDescriptorConst(VG_sXRGB_8888), VG_sXRGB_8888 },
- { formatToDescriptorConst(VG_sARGB_8888), VG_sARGB_8888 },
- { formatToDescriptorConst(VG_sARGB_8888_PRE), VG_sARGB_8888_PRE },
- { formatToDescriptorConst(VG_sARGB_1555), VG_sARGB_1555 },
- { formatToDescriptorConst(VG_sARGB_4444), VG_sARGB_4444 },
- { formatToDescriptorConst(VG_lXRGB_8888), VG_lXRGB_8888 },
- { formatToDescriptorConst(VG_lARGB_8888), VG_lARGB_8888 },
- { formatToDescriptorConst(VG_lARGB_8888_PRE), VG_lARGB_8888_PRE },
-
- /* BGR{A,X} channel ordering */
- { formatToDescriptorConst(VG_sBGRX_8888), VG_sBGRX_8888 },
- { formatToDescriptorConst(VG_sBGRA_8888), VG_sBGRA_8888 },
- { formatToDescriptorConst(VG_sBGRA_8888_PRE), VG_sBGRA_8888_PRE },
- { formatToDescriptorConst(VG_sBGR_565), VG_sBGR_565 },
- { formatToDescriptorConst(VG_sBGRA_5551), VG_sBGRA_5551 },
- { formatToDescriptorConst(VG_sBGRA_4444), VG_sBGRA_4444 },
- { formatToDescriptorConst(VG_lBGRX_8888), VG_lBGRX_8888 },
- { formatToDescriptorConst(VG_lBGRA_8888), VG_lBGRA_8888 },
- { formatToDescriptorConst(VG_lBGRA_8888_PRE), VG_lBGRA_8888_PRE },
-
- /* {A,X}BGR channel ordering */
- { formatToDescriptorConst(VG_sXBGR_8888), VG_sXBGR_8888 },
- { formatToDescriptorConst(VG_sABGR_8888), VG_sABGR_8888 },
- { formatToDescriptorConst(VG_sABGR_8888_PRE), VG_sABGR_8888_PRE },
- { formatToDescriptorConst(VG_sABGR_1555), VG_sABGR_1555 },
- { formatToDescriptorConst(VG_sABGR_4444), VG_sABGR_4444 },
- { formatToDescriptorConst(VG_lXBGR_8888), VG_lXBGR_8888 },
- { formatToDescriptorConst(VG_lABGR_8888), VG_lABGR_8888 },
- { formatToDescriptorConst(VG_lABGR_8888_PRE), VG_lABGR_8888_PRE },
- };
-
- for (size_t i = 0; i < sizeof(map)/sizeof(map[0]); i++)
- {
- if (isDescEqualToMapping(desc, map[i]))
- return map[i].format;
- }
- RI_ASSERT(false);
- return (VGImageFormat)-1;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Checks if the pixel format descriptor is valid (i.e. all the
-* values are supported by the RI)
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Color::isValidDescriptor(const Color::Descriptor& desc)
-{
- //A valid descriptor has 1, 2, 4, 8, 16, or 32 bits per pixel, and either luminance or rgba channels, but not both.
- //Any of the rgba channels can be missing, and not all bits need to be used. Maximum channel bit depth is 8.
- int rb = desc.redBits;
- int gb = desc.greenBits;
- int bb = desc.blueBits;
- int ab = desc.alphaBits;
- int lb = desc.luminanceBits;
- int rs = desc.redShift;
- int gs = desc.greenShift;
- int bs = desc.blueShift;
- int as = desc.alphaShift;
- int ls = desc.luminanceShift;
- int bpp = desc.bitsPerPixel;
-
- int rgbaBits = rb + gb + bb + ab;
- if(rb < 0 || rb > 8 || rs < 0 || rs + rb > bpp || !(rb || !rs))
- return false; //invalid channel description
- if(gb < 0 || gb > 8 || gs < 0 || gs + gb > bpp || !(gb || !gs))
- return false; //invalid channel description
- if(bb < 0 || bb > 8 || bs < 0 || bs + bb > bpp || !(bb || !bs))
- return false; //invalid channel description
- if(ab < 0 || ab > 8 || as < 0 || as + ab > bpp || !(ab || !as))
- return false; //invalid channel description
- if(lb < 0 || lb > 8 || ls < 0 || ls + lb > bpp || !(lb || !ls))
- return false; //invalid channel description
-
-#if 0
- if(rgbaBits && lb)
- return false; //can't have both rgba and luminance
-#endif
- if(!rgbaBits && !lb)
- return false; //must have either rgba or luminance
- if(rgbaBits)
- { //rgba
- if(rb+gb+bb == 0)
- { //alpha only
- if(rs || gs || bs || as || ls)
- return false; //wrong shifts (even alpha shift must be zero)
- if((ab != 1 && ab != 2 && ab != 4 && ab != 8) || bpp != ab)
- return false; //alpha size must be 1, 2, 4, or, 8, bpp must match
- }
- else
- { //rgba
- if(rgbaBits > bpp)
- return false; //bpp must be greater than or equal to the sum of rgba bits
- if(!(bpp == 32 || bpp == 16 || bpp == 8))
- return false; //only 1, 2, and 4 byte formats are supported for rgba
-
- unsigned int rm = bitsToMask((unsigned int)rb, (unsigned int)rs);
- unsigned int gm = bitsToMask((unsigned int)gb, (unsigned int)gs);
- unsigned int bm = bitsToMask((unsigned int)bb, (unsigned int)bs);
- unsigned int am = bitsToMask((unsigned int)ab, (unsigned int)as);
- if((rm & gm) || (rm & bm) || (rm & am) || (gm & bm) || (gm & am) || (bm & am))
- return false; //channels overlap
- }
- }
- else
- { //luminance
- if(rs || gs || bs || as || ls)
- return false; //wrong shifts (even luminance shift must be zero)
- if(!(lb == 1 || lb == 8) || bpp != lb)
- return false; //luminance size must be either 1 or 8, bpp must match
- }
-
- if(desc.vgFormat != -1)
- {
- if(!isValidImageFormat(desc.vgFormat))
- return false; //invalid image format
-
- Descriptor d = formatToDescriptor(desc.vgFormat);
- if(d.redBits != rb || d.greenBits != gb || d.blueBits != bb || d.alphaBits != ab || d.luminanceBits != lb ||
- d.redShift != rs || d.greenShift != gs || d.blueShift != bs || d.alphaShift != as || d.luminanceShift != ls ||
- d.bitsPerPixel != bpp)
- return false; //if the descriptor has a VGImageFormat, it must match the bits, shifts, and bpp
- }
-
- if((unsigned int)desc.internalFormat & ~(Color::PREMULTIPLIED | Color::NONLINEAR | Color::LUMINANCE))
- return false; //invalid internal format
-
- return true;
-}
-
-//==============================================================================================
-
-//==============================================================================================
-
-IntegerColor::IntegerColor(const Color& color)
-{
- r = (RIuint32)(color.r * 255.0f + 0.5f);
- g = (RIuint32)(color.g * 255.0f + 0.5f);
- b = (RIuint32)(color.b * 255.0f + 0.5f);
- a = (RIuint32)(color.a * 255.0f + 0.5f);
-}
-
-//==============================================================================================
-
-//==============================================================================================
-
-/*-------------------------------------------------------------------*//*!
-* \brief Constructs a blank image.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Image::Image(const Color::Descriptor& desc, int width, int height, VGbitfield allowedQuality) :
- m_desc(desc),
- m_width(width),
- m_height(height),
- m_allowedQuality(allowedQuality),
- m_inUse(0),
- m_stride(0),
- m_data(NULL),
- m_referenceCount(0),
- m_ownsData(true),
- m_parent(NULL),
- m_storageOffsetX(0),
- m_storageOffsetY(0),
- m_unsafeData(false)
-{
- RI_ASSERT(Color::isValidDescriptor(m_desc));
- RI_ASSERT(width > 0 && height > 0);
-
- m_stride = (m_width*m_desc.bitsPerPixel+7)/8;
-
- m_data = RI_NEW_ARRAY(RIuint8, m_stride*m_height); //throws bad_alloc
- memset(m_data, 0, m_stride*m_height); //clear image
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Constructs an image that uses an external array for its data
-* storage.
-* \param
-* \return
-* \note This is meant for internal use to make blitting easier
-* \note Now this is "tagged" into m_unsafeData if necessary.
-* Using this constructor may then affect performance.
-*//*-------------------------------------------------------------------*/
-
-Image::Image(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data) :
- m_desc(desc),
- m_width(width),
- m_height(height),
- m_allowedQuality(0),
- m_inUse(0),
- m_stride(stride),
- m_data(data),
- m_referenceCount(0),
- m_ownsData(false),
- m_parent(NULL),
- m_storageOffsetX(0),
- m_storageOffsetY(0),
- m_unsafeData(false)
-{
- RI_ASSERT(Color::isValidDescriptor(m_desc));
- RI_ASSERT(width > 0 && height > 0);
- RI_ASSERT(data);
- setUnsafe(true); // External data always potentially unsafe, see note above.
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Construcs a child image.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Image::Image(Image* parent, int x, int y, int width, int height) :
- m_desc(Color::formatToDescriptor(VG_sRGBA_8888)), //dummy initialization, will be overwritten below (can't read from parent->m_desc before knowing the pointer is valid)
- m_width(width),
- m_height(height),
- m_allowedQuality(0),
- m_inUse(0),
- m_stride(0),
- m_data(NULL),
- m_referenceCount(0),
- m_ownsData(false),
- m_parent(parent),
- m_storageOffsetX(0),
- m_storageOffsetY(0),
- m_unsafeData(false)
-{
- RI_ASSERT(parent);
- RI_ASSERT(x >= 0 && y >= 0 && width > 0 && height > 0);
- RI_ASSERT(RI_INT_ADDSATURATE(x,width) <= parent->m_width && RI_INT_ADDSATURATE(y,height) <= parent->m_height); //child image must be contained in parent
-
- m_desc = parent->m_desc;
- RI_ASSERT(Color::isValidDescriptor(m_desc));
- m_allowedQuality = parent->m_allowedQuality;
- m_stride = parent->m_stride;
- m_data = parent->m_data;
- m_storageOffsetX = parent->m_storageOffsetX + x;
- m_storageOffsetY = parent->m_storageOffsetY + y;
-
- //increase the reference and use count of the parent
- addInUse();
- parent->addInUse();
- parent->addReference();
- m_unsafeData = parent->m_unsafeData;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Image destructor.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Image::~Image()
-{
- RI_ASSERT(m_referenceCount == 0);
-
- if(m_parent)
- {
- //decrease the reference and use count of the parent
- removeInUse();
- m_parent->removeInUse();
- if(!m_parent->removeReference())
- RI_DELETE(m_parent);
- }
- RI_ASSERT(m_inUse == 0);
-
-
- if(m_ownsData)
- {
- RI_ASSERT(!m_parent); //can't have parent if owns the data
- RI_DELETE_ARRAY(m_data); //delete image data if we own it
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Returns true if the two images share pixels.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Image::overlaps(const Image* src) const
-{
- RI_ASSERT(src);
-
- if(m_data != src->m_data)
- return false; //images don't share data
-
- //check if the image storage regions overlap
- Rectangle r(m_storageOffsetX, m_storageOffsetY, m_width, m_height);
- r.intersect(Rectangle(src->m_storageOffsetX, src->m_storageOffsetY, src->m_width, src->m_height));
- if(!r.width || !r.height)
- return false; //intersection is empty, images don't overlap
-
- return true;
-}
-
-/**
- * \brief Expand log2 bpp packed pixel (single value) to 8 bits. This will
- * Result in 8, 4, or 2 same pixel values to be packed into the return value.
- */
-RI_INLINE static RIuint32 logExpand8(RIuint32 packedColor, int srcBits)
-{
- RI_ASSERT(srcBits == 4 || srcBits == 2 || srcBits == 1);
- RIuint32 ret = packedColor;
- int n = srcBits;
- while (n < 8)
- {
- ret |= ret << n;
- n += n;
- }
- return ret;
-}
-
-RI_INLINE void Image::fillPacked(RIuint32 packedColor)
-{
- RIuint32 pc = packedColor;
- int Bpp = m_desc.bitsPerPixel / 8;
- int nSetsPerScanline = m_width;
-
- RI_ASSERT(nSetsPerScanline);
- // \todo 1bpp and 4bpp mask formats must be supported. fillPackedPixels should
- // automatically work, but riMemSet32 path needs a bit more logic.
- // \note < 8bpp formats are always rounded to 8-bit boundaries at scanline end.
- // It is assumed that the "padding bits" may be filled.
-
- if (m_desc.bitsPerPixel < 8)
- {
- pc = logExpand8(packedColor, m_desc.bitsPerPixel);
- Bpp = 1;
- nSetsPerScanline = (m_width * m_desc.bitsPerPixel + 7) / 8;
- //nSetsPerScanline /= (8/m_desc.bitsPerPixel);
- }
-
- RI_ASSERT(Bpp <= 4 && Bpp >= 1);
-
- if (m_stride == ((m_desc.bitsPerPixel*m_width+7)/8))
- {
- const int nPixels = nSetsPerScanline * m_height;
- riMemSet32(m_data, pc, nPixels, Bpp);
- } else
- {
- RIuint8 *ptr = (RIuint8*)m_data;
- // set per-scanline
- for (int y = 0; y < m_height; y++)
- {
- riMemSet32(ptr, pc, nSetsPerScanline, Bpp);
- ptr += m_stride;
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Clears a rectangular portion of an image with the given clear color.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::clear(const Color& clearColor, int x, int y, int w, int h)
-{
- RI_ASSERT(m_data);
- RI_ASSERT(m_referenceCount > 0);
-
-
- //intersect clear region with image bounds
- Rectangle r(0,0,m_width,m_height);
- r.intersect(Rectangle(x,y,w,h));
- if(!r.width || !r.height)
- return; //intersection is empty or one of the rectangles is invalid
-
- Color col = clearColor;
- col.clamp();
- col.convert(getDescriptor().internalFormat);
-
- IntegerColor ic = IntegerColor(col);
- ic.truncateColor(getDescriptor());
- const RIuint32 c = ic.getPackedColor(getDescriptor());
-
- if (r.width == getWidth() && r.height == getHeight() && !m_parent)
- fillPacked(c);
- else
- {
- fillPackedRectangle(r.x, r.y, r.width, r.height, c);
- }
-}
-
-#if 0
-static RIfloat ditherChannel(RIfloat c, int bits, RIfloat m)
-{
- RIfloat fc = c * (RIfloat)((1<<bits)-1);
- RIfloat ic = (RIfloat)floor(fc);
- if(fc - ic > m) ic += 1.0f;
- return RI_MIN(ic / (RIfloat)((1<<bits)-1), 1.0f);
-}
-#endif
-
-static void computeBlitRegion(int& sx, int& sy, int& dx, int& dy, int& w, int& h, int srcWidth, int srcHeight, int dstWidth, int dstHeight)
-{
- RI_ASSERT(w > 0 && h > 0);
- sx = RI_INT_MIN(RI_INT_MAX(sx, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));
- sy = RI_INT_MIN(RI_INT_MAX(sy, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));
- dx = RI_INT_MIN(RI_INT_MAX(dx, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));
- dy = RI_INT_MIN(RI_INT_MAX(dy, (int)(RI_INT32_MIN>>2)), (int)(RI_INT32_MAX>>2));
- w = RI_INT_MIN(w, (int)(RI_INT32_MAX>>2));
- h = RI_INT_MIN(h, (int)(RI_INT32_MAX>>2));
- int srcsx = sx, srcex = sx + w, dstsx = dx, dstex = dx + w;
- if(srcsx < 0)
- {
- dstsx -= srcsx;
- srcsx = 0;
- }
- if(srcex > srcWidth)
- {
- dstex -= srcex - srcWidth;
- srcex = srcWidth;
- }
- if(dstsx < 0)
- {
- srcsx -= dstsx;
- dstsx = 0;
- }
- if(dstex > dstWidth)
- {
- srcex -= dstex - dstWidth;
- dstex = dstWidth;
- }
- RI_ASSERT(srcsx >= 0 && dstsx >= 0 && srcex <= srcWidth && dstex <= dstWidth);
- w = srcex - srcsx;
- RI_ASSERT(w == dstex - dstsx);
-
- int srcsy = sy, srcey = sy + h, dstsy = dy, dstey = dy + h;
- if(srcsy < 0)
- {
- dstsy -= srcsy;
- srcsy = 0;
- }
- if(srcey > srcHeight)
- {
- dstey -= srcey - srcHeight;
- srcey = srcHeight;
- }
- if(dstsy < 0)
- {
- srcsy -= dstsy;
- dstsy = 0;
- }
- if(dstey > dstHeight)
- {
- srcey -= dstey - dstHeight;
- dstey = dstHeight;
- }
- RI_ASSERT(srcsy >= 0 && dstsy >= 0 && srcey <= srcHeight && dstey <= dstHeight);
- h = srcey - srcsy;
- RI_ASSERT(h == dstey - dstsy);
- sx = srcsx;
- sy = srcsy;
- dx = dstsx;
- dy = dstsy;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Blits a source region to destination. Source and destination
-* can overlap.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-// \todo Extract dithering kernel and put it into the blitter
-#if 0
-void Image::blit(VGContext* context, const Image* src, int sx, int sy, int dx, int dy, int w, int h, bool dither)
-{
- //img=>img: vgCopyImage
- //img=>user: vgGetImageSubData
- //user=>img: vgImageSubData
-
- // \todo Implement dither to blitter.
- this->blit(context, src, sx, sy, dx, dy, w, h, NULL, dither);
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- computeBlitRegion(sx, sy, dx, dy, w, h, src.m_width, src.m_height, m_width, m_height);
- if(w <= 0 || h <= 0)
- return; //zero area
-
- Array<Color> tmp;
- tmp.resize(w*h); //throws bad_alloc
-
- //copy source region to tmp
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color c = src.readPixel(sx + i, sy + j);
- c.convert(m_desc.internalFormat);
- tmp[j*w+i] = c;
- }
- }
-
- int rbits = m_desc.redBits, gbits = m_desc.greenBits, bbits = m_desc.blueBits, abits = m_desc.alphaBits;
- if(m_desc.isLuminance())
- {
- rbits = gbits = bbits = m_desc.luminanceBits;
- abits = 0;
- }
-
- //write tmp to destination region
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color col = tmp[j*w+i];
-
- if(dither)
- {
- static const int matrix[16] = {
- 0, 8, 2, 10,
- 12, 4, 14, 6,
- 3, 11, 1, 9,
- 15, 7, 13, 5};
- int x = i & 3;
- int y = j & 3;
- RIfloat m = matrix[y*4+x] / 16.0f;
-
- if(rbits) col.r = ditherChannel(col.r, rbits, m);
- if(gbits) col.g = ditherChannel(col.g, gbits, m);
- if(bbits) col.b = ditherChannel(col.b, bbits, m);
- if(abits) col.a = ditherChannel(col.a, abits, m);
- }
-
- writePixel(dx + i, dy + j, col);
- }
- }
-}
-#endif
-
-/**
- * \brief Common body for drawImage-functions (one is the actual drawImage, and the
- * other one is used for scissored image-set operations.
- * \todo Reorganize all image draw operations to use this function.
- */
-static bool drawImageBody(VGContext* context, Image* image, const Matrix3x3& userToSurfaceMatrix,
- VGImageQuality imageQuality,
- VGBlendMode blendMode,
- bool hasMasking,
- bool hasColorTransform,
- VGImageMode imageMode)
-{
- Drawable* drawable = context->getCurrentDrawable();
- if(!drawable)
- return false; //no EGL surface is current at the moment
-
- Image* img = (Image*)image;
- //transform image corners into the surface space
- Vector3 p0(0, 0, 1);
- Vector3 p1(0, (RIfloat)img->getHeight(), 1);
- Vector3 p2((RIfloat)img->getWidth(), (RIfloat)img->getHeight(), 1);
- Vector3 p3((RIfloat)img->getWidth(), 0, 1);
-
- p0 = userToSurfaceMatrix * p0;
- p1 = userToSurfaceMatrix * p1;
- p2 = userToSurfaceMatrix * p2;
- p3 = userToSurfaceMatrix * p3;
- if(p0.z <= 0.0f || p1.z <= 0.0f || p2.z <= 0.0f || p3.z <= 0.0f)
- return false;
-
- //projection
- p0 *= 1.0f/p0.z;
- p1 *= 1.0f/p1.z;
- p2 *= 1.0f/p2.z;
- p3 *= 1.0f/p3.z;
-
- Rasterizer& rasterizer = context->m_rasterizer;
- rasterizer.clear();
-
- if(context->m_scissoring)
- rasterizer.setScissor(context->m_scissor); //throws bad_alloc
-
- PixelPipe& pixelPipe = context->m_pixelPipe;
- pixelPipe.setTileFillColor(context->m_tileFillColor);
- pixelPipe.setPaint((Paint*)context->m_fillPaint);
- const bool aa = imageQuality == VG_IMAGE_QUALITY_NONANTIALIASED ? false : true;
- rasterizer.setAntiAliasing(aa);
- pixelPipe.setImageQuality(imageQuality);
- pixelPipe.setBlendMode(blendMode);
- pixelPipe.setRenderToMask(false);
- pixelPipe.setDrawable(drawable);
- pixelPipe.setMask(hasMasking);
- pixelPipe.setColorTransform(hasColorTransform, context->m_colorTransformValues);
-
- Matrix3x3 surfaceToImageMatrix = userToSurfaceMatrix;
- Matrix3x3 surfaceToPaintMatrix = userToSurfaceMatrix * context->m_fillPaintToUser;
- if(surfaceToImageMatrix.invert() && surfaceToPaintMatrix.invert())
- {
- VGImageMode imode = imageMode;
-
- if(!surfaceToPaintMatrix.isAffine())
- imode = VG_DRAW_IMAGE_NORMAL; //if paint matrix is not affine, always use normal image mode
-
- surfaceToPaintMatrix[2].set(0,0,1); //force affine
-
- pixelPipe.setImage(img, imode);
- pixelPipe.setSurfaceToPaintMatrix(surfaceToPaintMatrix);
- pixelPipe.setSurfaceToImageMatrix(surfaceToImageMatrix);
- pixelPipe.prepareSpanUniforms(aa);
- rasterizer.setup(0, 0, drawable->getWidth(), drawable->getHeight(), VG_EVEN_ODD, &pixelPipe);
-
- rasterizer.addEdge(Vector2(p0.x,p0.y), Vector2(p1.x,p1.y)); //throws bad_alloc
- rasterizer.addEdge(Vector2(p1.x,p1.y), Vector2(p2.x,p2.y)); //throws bad_alloc
- rasterizer.addEdge(Vector2(p2.x,p2.y), Vector2(p3.x,p3.y)); //throws bad_alloc
- rasterizer.addEdge(Vector2(p3.x,p3.y), Vector2(p0.x,p0.y)); //throws bad_alloc
-
- rasterizer.fill(); //throws bad_alloc
- }
-
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Converts from multisampled format to display format.
-* \param unsafeInput Data may contain incorrect values (user data)
-* \return
-* \note May throw std::bad_alloc on cases where blitting within the
-* same buffer and overlapping regions (this may change in the
-* future).
-*//*-------------------------------------------------------------------*/
-
-void Image::blit(VGContext* context, const Image* src,
- int sx, int sy, int dx, int dy, int w, int h,
- Array<Rectangle>* scissors,
- bool dither)
-{
- bool overlap = false;
- (void)dither;
- DynamicBlitter& blitter = context->getBlitter();
-
- //RI_ASSERT(!src->isInUse(this));
- //int isx = sx, isy = sy, idx = dx, idy = dy, iw = w, ih = h;
-
- computeBlitRegion(sx, sy, dx, dy, w, h, src->getWidth(), src->getHeight(), m_width, m_height);
-
- if(w <= 0 || h <= 0)
- return; //zero area
-
- if (this->m_data == src->m_data)
- {
- // The images may overlap.
- int minsx = RI_INT_MIN(sx, dx);
- int minsy = RI_INT_MIN(sy, dy);
- int maxsx = RI_INT_MAX(sx, dx);
- int maxsy = RI_INT_MAX(sy, dy);
-
- if ((maxsx < (minsx + w)) && (maxsy < (minsy + h)))
- {
- overlap = true;
- }
- }
-
- if (!scissors)
- {
- // Currently the blitter does not support scissors
- if (!overlap)
- {
- blitter.prepareBlit(this, src, sx+src->m_storageOffsetX, sy+src->m_storageOffsetY,
- dx+m_storageOffsetX, dy+m_storageOffsetY, w, h);
- blitter.blit();
- } else
- {
- Image temp(src->getDescriptor(), w, h, VG_IMAGE_QUALITY_NONANTIALIASED);
- blitter.prepareBlit(&temp, src, sx+src->m_storageOffsetX, sy+src->m_storageOffsetY, 0, 0, w, h);
- blitter.blit();
- blitter.prepareBlit(this, &temp, 0, 0, dx+m_storageOffsetX, dy+m_storageOffsetY, w, h);
- blitter.blit();
- }
- } else
- {
- // For the moment, use the generic poly-rasterizer for scissored images.
- if (!overlap)
- {
- // Create a child image
- Image blitImage((Image*)src, sx, sy, w, h);
- Matrix3x3 tx;
- tx.set(1, 0, dx, 0, 1, dy, 0, 0, 1);
-
- drawImageBody(context, &blitImage, tx,
- VG_IMAGE_QUALITY_NONANTIALIASED,
- VG_BLEND_SRC,
- false,
- false,
- VG_DRAW_IMAGE_NORMAL);
- } else
- {
- // Create a copy of the source region
- Image temp(src->getDescriptor(), w, h, VG_IMAGE_QUALITY_NONANTIALIASED);
- blitter.prepareBlit(&temp, src, sx, sy, 0, 0, w, h);
- blitter.blit();
-
- Image blitImage((Image*)src, sx, sy, w, h);
- Matrix3x3 tx;
- tx.set(1, 0, dx, 0, 1, dy, 0, 0, 1);
-
- drawImageBody(context, &blitImage, tx,
- VG_IMAGE_QUALITY_NONANTIALIASED,
- VG_BLEND_SRC,
- false,
- false,
- VG_DRAW_IMAGE_NORMAL);
- }
- }
-
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Returns the color at pixel (x,y).
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Color Image::readPixel(int x, int y) const
-{
- const RIuint32 p = readPackedPixel(x, y);
-
- Color c;
- c.unpack(p, m_desc);
- return c;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Writes the color to pixel (x,y). Internal color formats must
-* match.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::writePixel(int x, int y, const Color& c)
-{
- RI_ASSERT(c.getInternalFormat() == m_desc.internalFormat);
-
- RIuint32 p = c.pack(m_desc);
- writePackedPixel(x, y, p);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Writes a filtered color to destination surface
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::writeFilteredPixel(int i, int j, const Color& color, VGbitfield channelMask)
-{
- //section 3.4.4: before color space conversion, premultiplied colors are
- //clamped to alpha, and the color is converted to nonpremultiplied format
- //section 11.2: how to deal with channel mask
- //step 1
- Color f = color;
- f.clamp(); //vgColorMatrix and vgLookups can produce colors that exceed alpha or [0,1] range
-
- //step 2: color space conversion
- f.convert((Color::InternalFormat)(m_desc.internalFormat & (Color::NONLINEAR | Color::LUMINANCE)));
-
- //step 3: read the destination color and convert it to nonpremultiplied
- Color d = readPixel(i,j);
- d.unpremultiply();
- RI_ASSERT(d.getInternalFormat() == f.getInternalFormat());
-
- //step 4: replace the destination channels specified by the channelMask (channelmask is ignored for luminance formats)
- if(!m_desc.isLuminance())
- { //rgba format => use channelmask
- if(channelMask & VG_RED)
- d.r = f.r;
- if(channelMask & VG_GREEN)
- d.g = f.g;
- if(channelMask & VG_BLUE)
- d.b = f.b;
- if(channelMask & VG_ALPHA)
- d.a = f.a;
- }
- else d = f;
-
- //step 5: if destination is premultiplied, convert to premultiplied format
- if(m_desc.isPremultiplied())
- d.premultiply();
- //write the color to destination
- writePixel(i,j,d);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Reads the pixel (x,y) and converts it into an alpha mask value.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-RIfloat Image::readMaskPixel(int x, int y) const
-{
- RI_ASSERT(m_data);
- RI_ASSERT(x >= 0 && x < m_width);
- RI_ASSERT(y >= 0 && y < m_height);
- RI_ASSERT(m_referenceCount > 0);
-
- Color c = readPixel(x,y);
- if(m_desc.isLuminance())
- {
- return c.r;
- }
- else
- { //rgba
- if(m_desc.alphaBits)
- return c.a;
- return c.r;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Writes the alpha mask to pixel (x,y).
-* \param
-* \return
-* \note Overwrites color.
-*//*-------------------------------------------------------------------*/
-
-void Image::writeMaskPixel(int x, int y, RIfloat m)
-{
- RI_ASSERT(m_data);
- RI_ASSERT(x >= 0 && x < m_width);
- RI_ASSERT(y >= 0 && y < m_height);
- RI_ASSERT(m_referenceCount > 0);
-
- //if luminance or no alpha, red channel will be used, otherwise alpha channel will be used
- writePixel(x, y, Color(m,m,m,m,m_desc.internalFormat));
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Reads a texel (u,v) at the given mipmap level. Tiling modes and
-* color space conversion are applied. Outputs color in premultiplied
-* format.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Color Image::readTexel(int u, int v, int level, VGTilingMode tilingMode, const Color& tileFillColor) const
-{
- const Image* image = this;
- if( level > 0 )
- {
- RI_ASSERT(false);
- }
- RI_ASSERT(image);
-
- Color p;
- if(tilingMode == VG_TILE_FILL)
- {
- if(u < 0 || v < 0 || u >= image->m_width || v >= image->m_height)
- p = tileFillColor;
- else
- p = image->readPixel(u, v);
- }
- else if(tilingMode == VG_TILE_PAD)
- {
- u = RI_INT_MIN(RI_INT_MAX(u,0),image->m_width-1);
- v = RI_INT_MIN(RI_INT_MAX(v,0),image->m_height-1);
- p = image->readPixel(u, v);
- }
- else if(tilingMode == VG_TILE_REPEAT)
- {
- u = RI_INT_MOD(u, image->m_width);
- v = RI_INT_MOD(v, image->m_height);
- p = image->readPixel(u, v);
- }
- else
- {
- RI_ASSERT(tilingMode == VG_TILE_REFLECT);
-
- u = RI_INT_MOD(u, image->m_width*2);
- v = RI_INT_MOD(v, image->m_height*2);
- if( u >= image->m_width ) u = image->m_width*2-1 - u;
- if( v >= image->m_height ) v = image->m_height*2-1 - v;
- p = image->readPixel(u, v);
- }
-
- p.premultiply(); //interpolate in premultiplied format
- return p;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Maps point (x,y) to an image and returns a filtered,
-* premultiplied color value.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Color Image::resample(RIfloat x, RIfloat y, const Matrix3x3& surfaceToImage, VGImageQuality quality, VGTilingMode tilingMode, const Color& tileFillColor) //throws bad_alloc
-{
- RI_ASSERT(m_referenceCount > 0);
-
- VGbitfield aq = getAllowedQuality();
- aq &= (VGbitfield)quality;
-
- Vector3 uvw(x,y,1.0f);
- uvw = surfaceToImage * uvw;
- RIfloat oow = 1.0f / uvw.z;
- uvw *= oow;
-
-#if 0
- if(aq & VG_IMAGE_QUALITY_BETTER)
- { //EWA on mipmaps
- makeMipMaps(); //throws bad_alloc
-
- Color::InternalFormat procFormat = (Color::InternalFormat)(m_desc.internalFormat | Color::PREMULTIPLIED);
-
- RIfloat m_pixelFilterRadius = 1.25f;
- RIfloat m_resamplingFilterRadius = 1.25f;
-
- RIfloat Ux = (surfaceToImage[0][0] - uvw.x * surfaceToImage[2][0]) * oow * m_pixelFilterRadius;
- RIfloat Vx = (surfaceToImage[1][0] - uvw.y * surfaceToImage[2][0]) * oow * m_pixelFilterRadius;
- RIfloat Uy = (surfaceToImage[0][1] - uvw.x * surfaceToImage[2][1]) * oow * m_pixelFilterRadius;
- RIfloat Vy = (surfaceToImage[1][1] - uvw.y * surfaceToImage[2][1]) * oow * m_pixelFilterRadius;
- RIfloat U0 = uvw.x;
- RIfloat V0 = uvw.y;
-
- //calculate mip level
- int level = 0;
- RIfloat axis1sq = Ux*Ux + Vx*Vx;
- RIfloat axis2sq = Uy*Uy + Vy*Vy;
- RIfloat minorAxissq = RI_MIN(axis1sq,axis2sq);
- while(minorAxissq > 9.0f && level < m_mipmaps.size()) //half the minor axis must be at least three texels
- {
- level++;
- minorAxissq *= 0.25f;
- }
-
- RIfloat sx = 1.0f;
- RIfloat sy = 1.0f;
- if(level > 0)
- {
- sx = (RIfloat)m_mipmaps[level-1]->m_width / (RIfloat)m_width;
- sy = (RIfloat)m_mipmaps[level-1]->m_height / (RIfloat)m_height;
- }
- Ux *= sx;
- Vx *= sx;
- U0 *= sx;
- Uy *= sy;
- Vy *= sy;
- V0 *= sy;
-
- //clamp filter size so that filtering doesn't take excessive amount of time (clamping results in aliasing)
- RIfloat lim = 100.0f;
- axis1sq = Ux*Ux + Vx*Vx;
- axis2sq = Uy*Uy + Vy*Vy;
- if( axis1sq > lim*lim )
- {
- RIfloat s = lim / (RIfloat)sqrt(axis1sq);
- Ux *= s;
- Vx *= s;
- }
- if( axis2sq > lim*lim )
- {
- RIfloat s = lim / (RIfloat)sqrt(axis2sq);
- Uy *= s;
- Vy *= s;
- }
-
-
- //form elliptic filter by combining texel and pixel filters
- RIfloat A = Vx*Vx + Vy*Vy + 1.0f;
- RIfloat B = -2.0f*(Ux*Vx + Uy*Vy);
- RIfloat C = Ux*Ux + Uy*Uy + 1.0f;
- //scale by the user-defined size of the kernel
- A *= m_resamplingFilterRadius;
- B *= m_resamplingFilterRadius;
- C *= m_resamplingFilterRadius;
-
- //calculate bounding box in texture space
- RIfloat usize = (RIfloat)sqrt(C);
- RIfloat vsize = (RIfloat)sqrt(A);
- int u1 = (int)floor(U0 - usize + 0.5f);
- int u2 = (int)floor(U0 + usize + 0.5f);
- int v1 = (int)floor(V0 - vsize + 0.5f);
- int v2 = (int)floor(V0 + vsize + 0.5f);
- if( u1 == u2 || v1 == v2 )
- return Color(0,0,0,0,procFormat);
-
- //scale the filter so that Q = 1 at the cutoff radius
- RIfloat F = A*C - 0.25f * B*B;
- if( F <= 0.0f )
- return Color(0,0,0,0,procFormat); //invalid filter shape due to numerical inaccuracies => return black
- RIfloat ooF = 1.0f / F;
- A *= ooF;
- B *= ooF;
- C *= ooF;
-
- //evaluate filter by using forward differences to calculate Q = A*U^2 + B*U*V + C*V^2
- Color color(0,0,0,0,procFormat);
- RIfloat sumweight = 0.0f;
- RIfloat DDQ = 2.0f * A;
- RIfloat U = (RIfloat)u1 - U0 + 0.5f;
- for(int v=v1;v<v2;v++)
- {
- RIfloat V = (RIfloat)v - V0 + 0.5f;
- RIfloat DQ = A*(2.0f*U+1.0f) + B*V;
- RIfloat Q = (C*V+B*U)*V + A*U*U;
- for(int u=u1;u<u2;u++)
- {
- if( Q >= 0.0f && Q < 1.0f )
- { //Q = r^2, fit gaussian to the range [0,1]
- RIfloat weight = (RIfloat)exp(-0.5f * 10.0f * Q); //gaussian at radius 10 equals 0.0067
- color += weight * readTexel(u, v, level, tilingMode, tileFillColor);
- sumweight += weight;
- }
- Q += DQ;
- DQ += DDQ;
- }
- }
- if( sumweight == 0.0f )
- return Color(0,0,0,0,procFormat);
- RI_ASSERT(sumweight > 0.0f);
- sumweight = 1.0f / sumweight;
- return color * sumweight;
- }
- else
-#endif
- //if(aq & VG_IMAGE_QUALITY_FASTER)
- if(aq & VG_IMAGE_QUALITY_BETTER)
- { //bilinear
- uvw.x -= 0.5f;
- uvw.y -= 0.5f;
- int u = (int)floor(uvw.x);
- int v = (int)floor(uvw.y);
- Color c00 = readTexel(u,v, 0, tilingMode, tileFillColor);
- Color c10 = readTexel(u+1,v, 0, tilingMode, tileFillColor);
- Color c01 = readTexel(u,v+1, 0, tilingMode, tileFillColor);
- Color c11 = readTexel(u+1,v+1, 0, tilingMode, tileFillColor);
- RIfloat fu = uvw.x - (RIfloat)u;
- RIfloat fv = uvw.y - (RIfloat)v;
- Color c0 = c00 * (1.0f - fu) + c10 * fu;
- Color c1 = c01 * (1.0f - fu) + c11 * fu;
- return c0 * (1.0f - fv) + c1 * fv;
- }
- else //VG_IMAGE_QUALITY_FASTER and VG_IMAGE_QUALITY_NONANTIALIASED
- { //point sampling
- return readTexel((int)floor(uvw.x), (int)floor(uvw.y), 0, tilingMode, tileFillColor);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies color matrix filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::colorMatrix(const Image& src, const RIfloat* matrix, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(matrix);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- Color::InternalFormat srcFormat = src.m_desc.internalFormat;
- Color::InternalFormat procFormat = (Color::InternalFormat)(srcFormat & ~Color::LUMINANCE); //process in RGB, not luminance
- if(filterFormatLinear)
- procFormat = (Color::InternalFormat)(procFormat & ~Color::NONLINEAR);
- else
- procFormat = (Color::InternalFormat)(procFormat | Color::NONLINEAR);
-
- if(filterFormatPremultiplied)
- procFormat = (Color::InternalFormat)(procFormat | Color::PREMULTIPLIED);
- else
- procFormat = (Color::InternalFormat)(procFormat & ~Color::PREMULTIPLIED);
-
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color s = src.readPixel(i,j); //convert to RGBA [0,1]
- s.convert(procFormat);
-
- Color d(0,0,0,0,procFormat);
- d.r = matrix[0+4*0] * s.r + matrix[0+4*1] * s.g + matrix[0+4*2] * s.b + matrix[0+4*3] * s.a + matrix[0+4*4];
- d.g = matrix[1+4*0] * s.r + matrix[1+4*1] * s.g + matrix[1+4*2] * s.b + matrix[1+4*3] * s.a + matrix[1+4*4];
- d.b = matrix[2+4*0] * s.r + matrix[2+4*1] * s.g + matrix[2+4*2] * s.b + matrix[2+4*3] * s.a + matrix[2+4*4];
- d.a = matrix[3+4*0] * s.r + matrix[3+4*1] * s.g + matrix[3+4*2] * s.b + matrix[3+4*3] * s.a + matrix[3+4*4];
-
- writeFilteredPixel(i, j, d, channelMask);
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Reads a pixel from image with tiling mode applied.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static Color readTiledPixel(int x, int y, int w, int h, VGTilingMode tilingMode, const Array<Color>& image, const Color& edge)
-{
- Color s;
- if(x < 0 || x >= w || y < 0 || y >= h)
- { //apply tiling mode
- switch(tilingMode)
- {
- case VG_TILE_FILL:
- s = edge;
- break;
- case VG_TILE_PAD:
- x = RI_INT_MIN(RI_INT_MAX(x, 0), w-1);
- y = RI_INT_MIN(RI_INT_MAX(y, 0), h-1);
- RI_ASSERT(x >= 0 && x < w && y >= 0 && y < h);
- s = image[y*w+x];
- break;
- case VG_TILE_REPEAT:
- x = RI_INT_MOD(x, w);
- y = RI_INT_MOD(y, h);
- RI_ASSERT(x >= 0 && x < w && y >= 0 && y < h);
- s = image[y*w+x];
- break;
- default:
- RI_ASSERT(tilingMode == VG_TILE_REFLECT);
- x = RI_INT_MOD(x, w*2);
- y = RI_INT_MOD(y, h*2);
- if(x >= w) x = w*2-1-x;
- if(y >= h) y = h*2-1-y;
- RI_ASSERT(x >= 0 && x < w && y >= 0 && y < h);
- s = image[y*w+x];
- break;
- }
- }
- else
- {
- RI_ASSERT(x >= 0 && x < w && y >= 0 && y < h);
- s = image[y*w+x];
- }
- return s;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Returns processing format for filtering.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static Color::InternalFormat getProcessingFormat(Color::InternalFormat srcFormat, bool filterFormatLinear, bool filterFormatPremultiplied)
-{
- Color::InternalFormat procFormat = (Color::InternalFormat)(srcFormat & ~Color::LUMINANCE); //process in RGB, not luminance
- if(filterFormatLinear)
- procFormat = (Color::InternalFormat)(procFormat & ~Color::NONLINEAR);
- else
- procFormat = (Color::InternalFormat)(procFormat | Color::NONLINEAR);
-
- if(filterFormatPremultiplied)
- procFormat = (Color::InternalFormat)(procFormat | Color::PREMULTIPLIED);
- else
- procFormat = (Color::InternalFormat)(procFormat & ~Color::PREMULTIPLIED);
- return procFormat;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies convolution filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::convolve(const Image& src, int kernelWidth, int kernelHeight, int shiftX, int shiftY, const RIint16* kernel, RIfloat scale, RIfloat bias, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(kernel && kernelWidth > 0 && kernelHeight > 0);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- //the area to be written is an intersection of source and destination image areas.
- //lower-left corners of the images are aligned.
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- Color::InternalFormat procFormat = getProcessingFormat(src.m_desc.internalFormat, filterFormatLinear, filterFormatPremultiplied);
-
- Color edge = edgeFillColor;
- edge.clamp();
- edge.convert(procFormat);
-
- Array<Color> tmp;
- tmp.resize(src.m_width*src.m_height); //throws bad_alloc
-
- //copy source region to tmp and do conversion
- for(int j=0;j<src.m_height;j++)
- {
- for(int i=0;i<src.m_width;i++)
- {
- Color s = src.readPixel(i, j);
- s.convert(procFormat);
- tmp[j*src.m_width+i] = s;
- }
- }
-
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color sum(0,0,0,0,procFormat);
-
- for(int kj=0;kj<kernelHeight;kj++)
- {
- for(int ki=0;ki<kernelWidth;ki++)
- {
- int x = i+ki-shiftX;
- int y = j+kj-shiftY;
- Color s = readTiledPixel(x, y, src.m_width, src.m_height, tilingMode, tmp, edge);
-
- int kx = kernelWidth-ki-1;
- int ky = kernelHeight-kj-1;
- RI_ASSERT(kx >= 0 && kx < kernelWidth && ky >= 0 && ky < kernelHeight);
-
- sum += (RIfloat)kernel[kx*kernelHeight+ky] * s;
- }
- }
-
- sum *= scale;
- sum.r += bias;
- sum.g += bias;
- sum.b += bias;
- sum.a += bias;
-
- writeFilteredPixel(i, j, sum, channelMask);
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies separable convolution filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::separableConvolve(const Image& src, int kernelWidth, int kernelHeight, int shiftX, int shiftY, const RIint16* kernelX, const RIint16* kernelY, RIfloat scale, RIfloat bias, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(kernelX && kernelY && kernelWidth > 0 && kernelHeight > 0);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- //the area to be written is an intersection of source and destination image areas.
- //lower-left corners of the images are aligned.
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- Color::InternalFormat procFormat = getProcessingFormat(src.m_desc.internalFormat, filterFormatLinear, filterFormatPremultiplied);
-
- Color edge = edgeFillColor;
- edge.clamp();
- edge.convert(procFormat);
-
- Array<Color> tmp;
- tmp.resize(src.m_width*src.m_height); //throws bad_alloc
-
- //copy source region to tmp and do conversion
- for(int j=0;j<src.m_height;j++)
- {
- for(int i=0;i<src.m_width;i++)
- {
- Color s = src.readPixel(i, j);
- s.convert(procFormat);
- tmp[j*src.m_width+i] = s;
- }
- }
-
- Array<Color> tmp2;
- tmp2.resize(w*src.m_height); //throws bad_alloc
- for(int j=0;j<src.m_height;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color sum(0,0,0,0,procFormat);
- for(int ki=0;ki<kernelWidth;ki++)
- {
- int x = i+ki-shiftX;
- Color s = readTiledPixel(x, j, src.m_width, src.m_height, tilingMode, tmp, edge);
-
- int kx = kernelWidth-ki-1;
- RI_ASSERT(kx >= 0 && kx < kernelWidth);
-
- sum += (RIfloat)kernelX[kx] * s;
- }
- tmp2[j*w+i] = sum;
- }
- }
-
- if(tilingMode == VG_TILE_FILL)
- { //convolve the edge color
- Color sum(0,0,0,0,procFormat);
- for(int ki=0;ki<kernelWidth;ki++)
- {
- sum += (RIfloat)kernelX[ki] * edge;
- }
- edge = sum;
- }
-
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color sum(0,0,0,0,procFormat);
- for(int kj=0;kj<kernelHeight;kj++)
- {
- int y = j+kj-shiftY;
- Color s = readTiledPixel(i, y, w, src.m_height, tilingMode, tmp2, edge);
-
- int ky = kernelHeight-kj-1;
- RI_ASSERT(ky >= 0 && ky < kernelHeight);
-
- sum += (RIfloat)kernelY[ky] * s;
- }
-
- sum *= scale;
- sum.r += bias;
- sum.g += bias;
- sum.b += bias;
- sum.a += bias;
-
- writeFilteredPixel(i, j, sum, channelMask);
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies Gaussian blur filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::gaussianBlur(const Image& src, RIfloat stdDeviationX, RIfloat stdDeviationY, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(stdDeviationX > 0.0f && stdDeviationY > 0.0f);
- RI_ASSERT(stdDeviationX <= RI_MAX_GAUSSIAN_STD_DEVIATION && stdDeviationY <= RI_MAX_GAUSSIAN_STD_DEVIATION);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- //the area to be written is an intersection of source and destination image areas.
- //lower-left corners of the images are aligned.
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- Color::InternalFormat procFormat = getProcessingFormat(src.m_desc.internalFormat, filterFormatLinear, filterFormatPremultiplied);
-
- Color edge = edgeFillColor;
- edge.clamp();
- edge.convert(procFormat);
-
- Array<Color> tmp;
- tmp.resize(src.m_width*src.m_height); //throws bad_alloc
-
- //copy source region to tmp and do conversion
- for(int j=0;j<src.m_height;j++)
- {
- for(int i=0;i<src.m_width;i++)
- {
- Color s = src.readPixel(i, j);
- s.convert(procFormat);
- tmp[j*src.m_width+i] = s;
- }
- }
-
- RIfloat expScaleX = -1.0f / (2.0f*stdDeviationX*stdDeviationX);
- RIfloat expScaleY = -1.0f / (2.0f*stdDeviationY*stdDeviationY);
-
- int kernelWidth = (int)(stdDeviationX * 4.0f + 1.0f);
- int kernelHeight = (int)(stdDeviationY * 4.0f + 1.0f);
-
- //make a separable kernel
- Array<RIfloat> kernelX;
- kernelX.resize(kernelWidth*2+1);
- int shiftX = kernelWidth;
- RIfloat scaleX = 0.0f;
- for(int i=0;i<kernelX.size();i++)
- {
- int x = i-shiftX;
- kernelX[i] = (RIfloat)exp((RIfloat)x*(RIfloat)x * expScaleX);
- scaleX += kernelX[i];
- }
- scaleX = 1.0f / scaleX; //NOTE: using the mathematical definition of the scaling term doesn't work since we cut the filter support early for performance
-
- Array<RIfloat> kernelY;
- kernelY.resize(kernelHeight*2+1);
- int shiftY = kernelHeight;
- RIfloat scaleY = 0.0f;
- for(int i=0;i<kernelY.size();i++)
- {
- int y = i-shiftY;
- kernelY[i] = (RIfloat)exp((RIfloat)y*(RIfloat)y * expScaleY);
- scaleY += kernelY[i];
- }
- scaleY = 1.0f / scaleY; //NOTE: using the mathematical definition of the scaling term doesn't work since we cut the filter support early for performance
-
- Array<Color> tmp2;
- tmp2.resize(w*src.m_height); //throws bad_alloc
- //horizontal pass
- for(int j=0;j<src.m_height;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color sum(0,0,0,0,procFormat);
- for(int ki=0;ki<kernelX.size();ki++)
- {
- int x = i+ki-shiftX;
- sum += kernelX[ki] * readTiledPixel(x, j, src.m_width, src.m_height, tilingMode, tmp, edge);
- }
- tmp2[j*w+i] = sum * scaleX;
- }
- }
- //vertical pass
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color sum(0,0,0,0,procFormat);
- for(int kj=0;kj<kernelY.size();kj++)
- {
- int y = j+kj-shiftY;
- sum += kernelY[kj] * readTiledPixel(i, y, w, src.m_height, tilingMode, tmp2, edge);
- }
- writeFilteredPixel(i, j, sum * scaleY, channelMask);
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Returns lookup table format for lookup filters.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static Color::InternalFormat getLUTFormat(bool outputLinear, bool outputPremultiplied)
-{
- Color::InternalFormat lutFormat = Color::lRGBA;
- if(outputLinear && outputPremultiplied)
- lutFormat = Color::lRGBA_PRE;
- else if(!outputLinear && !outputPremultiplied)
- lutFormat = Color::sRGBA;
- else if(!outputLinear && outputPremultiplied)
- lutFormat = Color::sRGBA_PRE;
- return lutFormat;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies multi-channel lookup table filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::lookup(const Image& src, const RIuint8 * redLUT, const RIuint8 * greenLUT, const RIuint8 * blueLUT, const RIuint8 * alphaLUT, bool outputLinear, bool outputPremultiplied, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(redLUT && greenLUT && blueLUT && alphaLUT);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- //the area to be written is an intersection of source and destination image areas.
- //lower-left corners of the images are aligned.
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- Color::InternalFormat procFormat = getProcessingFormat(src.m_desc.internalFormat, filterFormatLinear, filterFormatPremultiplied);
- Color::InternalFormat lutFormat = getLUTFormat(outputLinear, outputPremultiplied);
-
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color s = src.readPixel(i,j); //convert to RGBA [0,1]
- s.convert(procFormat);
-
- Color d(0,0,0,0,lutFormat);
- d.r = intToColor( redLUT[colorToInt(s.r, 255)], 255);
- d.g = intToColor(greenLUT[colorToInt(s.g, 255)], 255);
- d.b = intToColor( blueLUT[colorToInt(s.b, 255)], 255);
- d.a = intToColor(alphaLUT[colorToInt(s.a, 255)], 255);
-
- writeFilteredPixel(i, j, d, channelMask);
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Applies single channel lookup table filter.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Image::lookupSingle(const Image& src, const RIuint32 * lookupTable, VGImageChannel sourceChannel, bool outputLinear, bool outputPremultiplied, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask)
-{
- RI_ASSERT(src.m_data); //source exists
- RI_ASSERT(m_data); //destination exists
- RI_ASSERT(lookupTable);
- RI_ASSERT(m_referenceCount > 0 && src.m_referenceCount > 0);
-
- //the area to be written is an intersection of source and destination image areas.
- //lower-left corners of the images are aligned.
- int w = RI_INT_MIN(m_width, src.m_width);
- int h = RI_INT_MIN(m_height, src.m_height);
- RI_ASSERT(w > 0 && h > 0);
-
- if(src.m_desc.isLuminance())
- sourceChannel = VG_RED;
- else if(src.m_desc.redBits + src.m_desc.greenBits + src.m_desc.blueBits == 0)
- {
- RI_ASSERT(src.m_desc.alphaBits);
- sourceChannel = VG_ALPHA;
- }
-
- Color::InternalFormat procFormat = getProcessingFormat(src.m_desc.internalFormat, filterFormatLinear, filterFormatPremultiplied);
- Color::InternalFormat lutFormat = getLUTFormat(outputLinear, outputPremultiplied);
-
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- Color s = src.readPixel(i,j); //convert to RGBA [0,1]
- s.convert(procFormat);
- int e;
- switch(sourceChannel)
- {
- case VG_RED:
- e = colorToInt(s.r, 255);
- break;
- case VG_GREEN:
- e = colorToInt(s.g, 255);
- break;
- case VG_BLUE:
- e = colorToInt(s.b, 255);
- break;
- default:
- RI_ASSERT(sourceChannel == VG_ALPHA);
- e = colorToInt(s.a, 255);
- break;
- }
-
- RIuint32 l = ((const RIuint32*)lookupTable)[e];
- Color d(0,0,0,0,lutFormat);
- d.r = intToColor((l>>24), 255);
- d.g = intToColor((l>>16), 255);
- d.b = intToColor((l>> 8), 255);
- d.a = intToColor((l ), 255);
-
- writeFilteredPixel(i, j, d, channelMask);
- }
- }
-}
-
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Surface::Surface(const Color::Descriptor& desc, int width, int height, int numSamples) :
- m_width(width),
- m_height(height),
- m_numSamples(numSamples),
- m_referenceCount(0),
- m_image(NULL)
-{
- RI_ASSERT(width > 0 && height > 0 && numSamples > 0 && numSamples <= 32);
- m_image = RI_NEW(Image, (desc, width*numSamples, height, 0)); //throws bad_alloc
- m_image->addReference();
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Surface::Surface(Image* image) :
- m_width(0),
- m_height(0),
- m_numSamples(1),
- m_referenceCount(0),
- m_image(image)
-{
- RI_ASSERT(image);
- m_width = image->getWidth();
- m_height = image->getHeight();
- m_image->addReference();
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Surface::Surface(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data) :
- m_width(width),
- m_height(height),
- m_numSamples(1),
- m_referenceCount(0),
- m_image(NULL)
-{
- RI_ASSERT(width > 0 && height > 0);
- m_image = RI_NEW(Image, (desc, width, height, stride, data)); //throws bad_alloc
- m_image->addReference();
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Surface::~Surface()
-{
- RI_ASSERT(m_referenceCount == 0);
- if(!m_image->removeReference())
- RI_DELETE(m_image);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Surface::clear(const Color& clearColor, int x, int y, int w, int h, const Array<Rectangle>* scissors)
-{
- RI_ASSERT(m_numSamples == 1);
-
- Image* image = m_image;
-
- Color col = clearColor;
- col.clamp();
- col.convert(m_image->getDescriptor().internalFormat);
-
- IntegerColor ic = IntegerColor(col);
- ic.truncateColor(m_image->getDescriptor());
- const RIuint32 c = ic.getPackedColor(m_image->getDescriptor());
-
- if (x != 0 || y != 0 || w != image->getWidth() || h != image->getHeight() || scissors)
- {
- // Simple implementation: intersect with surface and clip rects -> may clear the
- // same area several times. Best if scissors are non-overlapping
- Rectangle r(0,0,getWidth(),getHeight());
- r.intersect(Rectangle(x,y,w,h));
-
- if (r.isEmpty() || (scissors && scissors->size() == 0))
- return;
-
- if (scissors && scissors->size())
- {
- for (int i = 0; i < scissors->size(); i++)
- {
- Rectangle s = (*scissors)[i];
- s.intersect(r);
-
- if (s.isEmpty())
- continue;
-
- image->fillPackedRectangle(s.x, s.y, s.width, s.height, c);
- }
- }
- else
- {
- image->fillPackedRectangle(r.x, r.y, r.width, r.height, c);
- }
- }
- else
- {
- // Clear the whole buffer
-
- m_image->fillPacked(c);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-#if 0
-void Surface::blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h)
-{
- Rectangle rect;
- rect.x = 0;
- rect.y = 0;
- rect.width = getWidth();
- rect.height = getHeight();
- Array<Rectangle> scissors;
- scissors.push_back(rect);
- blit(src, sx, sy, dx, dy, w, h, scissors);
-}
-#endif
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note no overlap is possible. Single sample to single or multisample (replicate)
-*//*-------------------------------------------------------------------*/
-
-#if 0
-void Surface::blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h, const Array<Rectangle>& scissors)
-{
- //img=>fb: vgSetPixels
- //user=>fb: vgWritePixels
- computeBlitRegion(sx, sy, dx, dy, w, h, src.getWidth(), src.getHeight(), getWidth(), getHeight());
- if(w <= 0 || h <= 0)
- return; //zero area
-
- Array<ScissorEdge> scissorEdges;
- for(int i=0;i<scissors.size();i++)
- {
- if(scissors[i].width > 0 && scissors[i].height > 0)
- {
- ScissorEdge e;
- e.miny = scissors[i].y;
- e.maxy = RI_INT_ADDSATURATE(scissors[i].y, scissors[i].height);
-
- e.x = scissors[i].x;
- e.direction = 1;
- scissorEdges.push_back(e); //throws bad_alloc
- e.x = RI_INT_ADDSATURATE(scissors[i].x, scissors[i].width);
- e.direction = -1;
- scissorEdges.push_back(e); //throws bad_alloc
- }
- }
- if(!scissorEdges.size())
- return; //there are no scissor rectangles => nothing is visible
-
- //sort scissor edges by edge x
- scissorEdges.sort();
-
- Array<ScissorEdge> scissorAet;
- for(int j=0;j<h;j++)
- {
- //gather scissor edges intersecting this scanline
- scissorAet.clear();
- for(int e=0;e<scissorEdges.size();e++)
- {
- const ScissorEdge& se = scissorEdges[e];
- if(dy + j >= se.miny && dy + j < se.maxy)
- scissorAet.push_back(scissorEdges[e]); //throws bad_alloc
- }
- if(!scissorAet.size())
- continue; //scissoring is on, but there are no scissor rectangles on this scanline
-
- //blit a scanline
- int scissorWinding = 0;
- int scissorIndex = 0;
- for(int i=0;i<w;i++)
- {
- while(scissorIndex < scissorAet.size() && scissorAet[scissorIndex].x <= dx + i)
- scissorWinding += scissorAet[scissorIndex++].direction;
- RI_ASSERT(scissorWinding >= 0);
-
- if(scissorWinding)
- {
- Color c = src.readPixel(sx + i, sy + j);
- c.convert(getDescriptor().internalFormat);
- for(int s=0;s<m_numSamples;s++)
- writeSample(dx + i, dy + j, s, c);
- }
- }
- }
-}
-#endif
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-#if 0
-void Surface::blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h)
-{
- Rectangle rect;
- rect.x = 0;
- rect.y = 0;
- rect.width = getWidth();
- rect.height = getHeight();
- Array<Rectangle> scissors;
- scissors.push_back(rect);
- blit(src, sx, sy, dx, dy, w, h, scissors);
-}
-#endif
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-#if 0
-void Surface::blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h, const Array<Rectangle>& scissors)
-{
- RI_ASSERT(m_numSamples == src->m_numSamples);
-
- //fb=>fb: vgCopyPixels
- computeBlitRegion(sx, sy, dx, dy, w, h, src->getWidth(), src->getHeight(), getWidth(), getHeight());
- if(w <= 0 || h <= 0)
- return; //zero area
-
- Array<ScissorEdge> scissorEdges;
- for(int i=0;i<scissors.size();i++)
- {
- if(scissors[i].width > 0 && scissors[i].height > 0)
- {
- ScissorEdge e;
- e.miny = scissors[i].y;
- e.maxy = RI_INT_ADDSATURATE(scissors[i].y, scissors[i].height);
-
- e.x = scissors[i].x;
- e.direction = 1;
- scissorEdges.push_back(e); //throws bad_alloc
- e.x = RI_INT_ADDSATURATE(scissors[i].x, scissors[i].width);
- e.direction = -1;
- scissorEdges.push_back(e); //throws bad_alloc
- }
- }
- if(!scissorEdges.size())
- return; //there are no scissor rectangles => nothing is visible
-
- //sort scissor edges by edge x
- scissorEdges.sort();
-
- Array<Color> tmp;
- tmp.resize(w*m_numSamples*h); //throws bad_alloc
-
- //copy source region to tmp
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- int numSamples = m_numSamples;
- for(int s=0;s<numSamples;s++)
- {
- Color c = src->m_image->readPixel((sx + i)*m_numSamples+s, sy + j);
- c.convert(m_image->getDescriptor().internalFormat);
- tmp[(j*w+i)*m_numSamples+s] = c;
- }
- }
- }
-
- Array<ScissorEdge> scissorAet;
- for(int j=0;j<h;j++)
- {
- //gather scissor edges intersecting this scanline
- scissorAet.clear();
- for(int e=0;e<scissorEdges.size();e++)
- {
- const ScissorEdge& se = scissorEdges[e];
- if(dy + j >= se.miny && dy + j < se.maxy)
- scissorAet.push_back(scissorEdges[e]); //throws bad_alloc
- }
- if(!scissorAet.size())
- continue; //scissoring is on, but there are no scissor rectangles on this scanline
-
- //blit a scanline
- int scissorWinding = 0;
- int scissorIndex = 0;
- for(int i=0;i<w;i++)
- {
- while(scissorIndex < scissorAet.size() && scissorAet[scissorIndex].x <= dx + i)
- scissorWinding += scissorAet[scissorIndex++].direction;
- RI_ASSERT(scissorWinding >= 0);
-
- if(scissorWinding)
- {
- int numSamples = m_numSamples;
- for(int s=0;s<numSamples;s++)
- {
- m_image->writePixel((dx + i)*m_numSamples+s, dy + j, tmp[(j*w+i)*m_numSamples+s]);
- }
- }
- }
- }
-}
-#endif
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Surface::mask(DynamicBlitter& blitter, const Image* src, VGMaskOperation operation, int x, int y, int w, int h)
-{
- RI_ASSERT(w > 0 && h > 0);
- RI_ASSERT(m_numSamples == 1);
-
- if(operation == VG_CLEAR_MASK || operation == VG_FILL_MASK)
- {
- //intersect clear region with image bounds
- Rectangle r(0,0,getWidth(),getHeight());
- r.intersect(Rectangle(x,y,w,h));
-
- if(!r.width || !r.height)
- return; //intersection is empty or one of the rectangles is invalid
-
- {
- Color mcolor(1.0f, 1.0f, 1.0f, 1.0f, Color::sRGBA_PRE);
- if (operation == VG_CLEAR_MASK)
- mcolor = Color(0,0,0,0, Color::sRGBA_PRE);
- IntegerColor ic = IntegerColor(mcolor);
- RIuint32 p = ic.getPackedMaskColor(m_image->getDescriptor());
- m_image->fillPackedRectangle(r.x, r.y, r.width, r.height, p);
- }
- }
- else
- {
- int sx = 0, sy = 0, dx = x, dy = y;
-
- computeBlitRegion(sx, sy, dx, dy, w, h, src->getWidth(), src->getHeight(), getWidth(), getHeight());
-
- if(w <= 0 || h <= 0)
- return; //zero area
-
- blitter.enableMaskOperation(true);
- blitter.setMaskOperation(operation);
- blitter.prepareBlit(this->m_image, src, sx, sy, dx, dy, w, h);
- blitter.blit();
- blitter.enableMaskOperation(false);
-#if 0
- RI_ASSERT(src);
-
- int sx = 0, sy = 0, dx = x, dy = y;
- computeBlitRegion(sx, sy, dx, dy, w, h, src->getWidth(), src->getHeight(), getWidth(), getHeight());
- if(w <= 0 || h <= 0)
- return; //zero area
-
- {
- for(int j=0;j<h;j++)
- {
- for(int i=0;i<w;i++)
- {
- RIfloat amask = src->readMaskPixel(sx + i, sy + j);
- if(operation == VG_SET_MASK)
- writeMaskCoverage(dx + i, dy + j, amask);
- else
- {
- RIfloat aprev = readMaskCoverage(dx + i, dy + j);
- RIfloat anew = 0.0f;
- switch(operation)
- {
- case VG_UNION_MASK: anew = 1.0f - (1.0f - amask)*(1.0f - aprev); break;
- case VG_INTERSECT_MASK: anew = amask * aprev; break;
- default: anew = aprev * (1.0f - amask); RI_ASSERT(operation == VG_SUBTRACT_MASK); break;
- }
- writeMaskCoverage(dx + i, dy + j, anew);
- }
- }
- }
- }
-#endif
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-RIfloat Surface::readMaskCoverage(int x, int y) const
-{
- RI_ASSERT(x >= 0 && x < m_width && y >= 0 && y < m_height);
- RI_ASSERT(m_numSamples == 1);
- return m_image->readMaskPixel(x, y);
-}
-
-void Surface::writeMaskCoverage(int x, int y, RIfloat m)
-{
- RI_ASSERT(x >= 0 && x < m_width && y >= 0 && y < m_height);
- RI_ASSERT(m_numSamples == 1);
- m_image->writeMaskPixel(x, y, m); //TODO support other than alpha formats but don't write to color channels?
-}
-
-unsigned int Surface::readMaskMSAA(int x, int y) const
-{
- RI_ASSERT(x >= 0 && x < m_width && y >= 0 && y < m_height);
- RI_ASSERT(m_numSamples > 1);
- unsigned int m = 0;
- for(int i=0;i<m_numSamples;i++)
- {
- if(m_image->readMaskPixel(x*m_numSamples+i, y) > 0.5f) //TODO is this the right formula for converting alpha to bit mask? does it matter?
- m |= 1<<i;
- }
- return m;
-}
-
-void Surface::writeMaskMSAA(int x, int y, unsigned int m)
-{
- RI_ASSERT(x >= 0 && x < m_width && y >= 0 && y < m_height);
- RI_ASSERT(m_numSamples > 1);
- for(int i=0;i<m_numSamples;i++)
- {
- RIfloat a = 0.0f;
- if(m & (1<<i))
- a = 1.0f;
- m_image->writeMaskPixel(x*m_numSamples+i, y, a); //TODO support other than alpha formats but don't write to color channels?
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Color Surface::FSAAResolve(int x, int y) const
-{
- if(m_numSamples == 1)
- return readSample(x, y, 0);
-
- Color::InternalFormat aaFormat = getDescriptor().isLuminance() ? Color::lLA_PRE : Color::lRGBA_PRE; //antialias in linear color space
- Color r(0.0f, 0.0f, 0.0f, 0.0f, aaFormat);
- for(int i=0;i<m_numSamples;i++)
- {
- Color d = readSample(x, y, i);
- d.convert(aaFormat);
- r += d;
- }
- r *= 1.0f/m_numSamples;
- return r;
-}
-
-
-/**
- * \brief Return a resolved sample in packed format.
- * \note Further operations on color may require unpack.
- */
-RI_INLINE RIuint32 Surface::FSAAResolvePacked(int x, int y) const
-{
- if (m_numSamples == 1)
- return readPackedSample(x, y, 0);
-
- RI_ASSERT(false); /* Not implemented yet. */
- return 0xffffffffu;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Drawable::Drawable(const Color::Descriptor& desc, int width, int height, int numSamples, int maskBits) :
- m_referenceCount(0),
- m_color(NULL),
- m_mask(NULL)
-{
- RI_ASSERT(width > 0 && height > 0 && numSamples > 0 && numSamples <= 32);
- RI_ASSERT(maskBits == 0 || maskBits == 1 || maskBits == 4 || maskBits == 8);
- m_color = RI_NEW(Surface, (desc, width, height, numSamples)); //throws bad_alloc
- m_color->addReference();
- if(maskBits)
- {
- VGImageFormat mf = VG_A_1;
- if(maskBits == 4)
- mf = VG_A_4;
- else if(maskBits == 8)
- mf = VG_A_8;
- m_mask = RI_NEW(Surface, (Color::formatToDescriptor(mf), width, height, numSamples));
- m_mask->addReference();
- m_mask->clear(Color(1,1,1,1,Color::sRGBA), 0, 0, width, height);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Drawable::Drawable(Image* image, int maskBits) :
- m_referenceCount(0),
- m_color(NULL),
- m_mask(NULL)
-{
- RI_ASSERT(maskBits == 0 || maskBits == 1 || maskBits == 4 || maskBits == 8);
- RI_ASSERT(image);
- m_color = RI_NEW(Surface, (image));
- m_color->addReference();
- if(maskBits)
- {
- VGImageFormat mf = VG_A_1;
- if(maskBits == 4)
- mf = VG_A_4;
- else if(maskBits == 8)
- mf = VG_A_8;
- m_mask = RI_NEW(Surface, (Color::formatToDescriptor(mf), image->getWidth(), image->getHeight(), 1));
- m_mask->addReference();
- m_mask->clear(Color(1,1,1,1,Color::sRGBA), 0, 0, image->getWidth(), image->getHeight());
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Drawable::Drawable(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data, int maskBits) :
- m_referenceCount(0),
- m_color(NULL),
- m_mask(NULL)
-{
- RI_ASSERT(width > 0 && height > 0);
- RI_ASSERT(maskBits == 0 || maskBits == 1 || maskBits == 4 || maskBits == 8);
- m_color = RI_NEW(Surface, (desc, width, height, stride, data)); //throws bad_alloc
- m_color->addReference();
- if(maskBits)
- {
- VGImageFormat mf = VG_A_1;
- if(maskBits == 4)
- mf = VG_A_4;
- else if(maskBits == 8)
- mf = VG_A_8;
- m_mask = RI_NEW(Surface, (Color::formatToDescriptor(mf), width, height, 1));
- m_mask->addReference();
- m_mask->clear(Color(1,1,1,1,Color::sRGBA), 0, 0, width, height);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Drawable::~Drawable()
-{
- RI_ASSERT(m_referenceCount == 0);
- if(!m_color->removeReference())
- RI_DELETE(m_color);
- if(m_mask)
- if(!m_mask->removeReference())
- RI_DELETE(m_mask);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Drawable::resize(VGContext* context, int newWidth, int newHeight)
-{
- Surface* oldcolor = m_color;
- Surface* oldmask = m_mask;
- int oldWidth = m_color->getWidth();
- int oldHeight = m_color->getHeight();
-
- //TODO check that image is not a proxy
- m_color = RI_NEW(Surface, (m_color->getDescriptor(), newWidth, newHeight, m_color->getNumSamples()));
- m_color->addReference();
- if(m_mask)
- {
- m_mask = RI_NEW(Surface, (m_mask->getDescriptor(), newWidth, newHeight, m_mask->getNumSamples()));
- m_mask->addReference();
- }
-
- int wmin = RI_INT_MIN(newWidth,oldWidth);
- int hmin = RI_INT_MIN(newHeight,oldHeight);
- m_color->clear(Color(0.0f, 0.0f, 0.0f, 0.0f, getDescriptor().internalFormat), 0, 0, m_color->getWidth(), m_color->getHeight());
- m_color->m_image->blit(context, oldcolor->m_image, 0, 0, 0, 0, wmin, hmin);
- if(m_mask)
- {
- m_mask->clear(Color(1.0f, 1.0f, 1.0f, 1.0f, getDescriptor().internalFormat), 0, 0, m_mask->getWidth(), m_mask->getHeight());
- m_mask->m_image->blit(context, oldmask->m_image, 0, 0, 0, 0, wmin, hmin);
- }
-
- if(!oldcolor->removeReference())
- RI_DELETE(oldcolor);
- if(oldmask)
- if(!oldmask->removeReference())
- RI_DELETE(oldmask);
-}
-
-#ifndef RI_COMPILE_LLVM_BYTECODE
-
-#endif /* RI_COMPILE_LLVM_BYTECODE */
-
-//==============================================================================================
-
-} //namespace OpenVGRI
-
-//==============================================================================================