irrlicht/source/Irrlicht/CImage.cpp

1437 lines
29 KiB
C++

// Copyright (C) 2002-2007 Nikolaus Gebhardt / Thomas Alten
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#include "CImage.h"
#include "irrString.h"
#include "SoftwareDriver2_helper.h"
#include "CColorConverter.h"
namespace irr
{
struct SBlitJob
{
AbsRectangle Dest;
AbsRectangle Source;
u32 argb;
void * src;
void * dst;
s32 width;
s32 height;
u32 srcPitch;
u32 dstPitch;
u32 srcPixelMul;
u32 dstPixelMul;
};
// Blitter Operation
enum eBlitter
{
BLITTER_INVALID = 0,
BLITTER_COLOR,
BLITTER_COLOR_ALPHA,
BLITTER_TEXTURE,
BLITTER_TEXTURE_ALPHA_BLEND,
BLITTER_TEXTURE_ALPHA_COLOR_BLEND
};
typedef void (*tExecuteBlit) ( const SBlitJob * job );
// Bitfields Cohen Sutherland
enum eClipCode
{
CLIPCODE_EMPTY = 0,
CLIPCODE_BOTTOM = 1,
CLIPCODE_TOP = 2,
CLIPCODE_LEFT = 4,
CLIPCODE_RIGHT = 8
};
inline u32 GetClipCode ( const AbsRectangle &r, const core::position2d<s32> &p )
{
u32 code = CLIPCODE_EMPTY;
if ( p.X < r.x0 )
code = CLIPCODE_LEFT;
else
if ( p.X > r.x1 )
code = CLIPCODE_RIGHT;
if ( p.Y < r.y0 )
code |= CLIPCODE_TOP;
else
if ( p.Y > r.y1 )
code |= CLIPCODE_BOTTOM;
return code;
}
/*!
Cohen Sutherland clipping
@return: 1 if valid
*/
static int ClipLine (const AbsRectangle &clipping,
core::position2d<s32> &p0,
core::position2d<s32> &p1,
const core::position2d<s32>& p0_in,
const core::position2d<s32>& p1_in)
{
u32 code0;
u32 code1;
u32 code;
p0 = p0_in;
p1 = p1_in;
code0 = GetClipCode ( clipping, p0 );
code1 = GetClipCode ( clipping, p1 );
// trivial accepted
while ( code0 | code1 )
{
s32 x=0;
s32 y=0;
// trivial reject
if ( code0 & code1 )
return 0;
if ( code0 )
{
// clip first point
code = code0;
}
else
{
// clip last point
code = code1;
}
if ( (code & CLIPCODE_BOTTOM) == CLIPCODE_BOTTOM )
{
// clip bottom viewport
y = clipping.y1;
x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y );
}
else
if ( (code & CLIPCODE_TOP) == CLIPCODE_TOP )
{
// clip to viewport
y = clipping.y0;
x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y );
}
else
if ( (code & CLIPCODE_RIGHT) == CLIPCODE_RIGHT )
{
// clip right viewport
x = clipping.x1;
y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X );
}
else
if ( (code & CLIPCODE_LEFT) == CLIPCODE_LEFT )
{
// clip left viewport
x = clipping.x0;
y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X );
}
if ( code == code0 )
{
// modify first point
p0.X = x;
p0.Y = y;
code0 = GetClipCode ( clipping, p0 );
}
else
{
// modify second point
p1.X = x;
p1.Y = y;
code1 = GetClipCode ( clipping, p1 );
}
}
return 1;
}
/*
*/
inline void GetClip(AbsRectangle &clipping, video::IImage * t)
{
clipping.x0 = 0;
clipping.y0 = 0;
clipping.x1 = t->getDimension().Width - 1;
clipping.y1 = t->getDimension().Height - 1;
}
/*
*/
static void RenderLine32_Decal(video::IImage *t,
const core::position2d<s32> &p0,
const core::position2d<s32> &p1,
u32 argb )
{
s32 dx = p1.X - p0.X;
s32 dy = p1.Y - p0.Y;
s32 c;
s32 m;
s32 d = 0;
s32 run;
s32 xInc = 4;
s32 yInc = (s32) t->getPitch();
if ( dx < 0 )
{
xInc = -xInc;
dx = -dx;
}
if ( dy < 0 )
{
yInc = -yInc;
dy = -dy;
}
u32 *dst;
dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) );
if ( dy > dx )
{
s32 tmp;
tmp = dx;
dx = dy;
dy = tmp;
tmp = xInc;
xInc = yInc;
yInc = tmp;
}
c = dx << 1;
m = dy << 1;
run = dx;
while ( run )
{
*dst = argb;
dst = (u32*) ( (u8*) dst + xInc ); // x += xInc
d += m;
if ( d > dx )
{
dst = (u32*) ( (u8*) dst + yInc ); // y += yInc
d -= c;
}
run -= 1;
}
t->unlock();
}
/*
*/
static void RenderLine32_Blend(video::IImage *t,
const core::position2d<s32> &p0,
const core::position2d<s32> &p1,
u32 argb, u32 alpha)
{
s32 dx = p1.X - p0.X;
s32 dy = p1.Y - p0.Y;
s32 c;
s32 m;
s32 d = 0;
s32 run;
s32 xInc = 4;
s32 yInc = (s32) t->getPitch();
if ( dx < 0 )
{
xInc = -xInc;
dx = -dx;
}
if ( dy < 0 )
{
yInc = -yInc;
dy = -dy;
}
u32 *dst;
dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) );
if ( dy > dx )
{
s32 tmp;
tmp = dx;
dx = dy;
dy = tmp;
tmp = xInc;
xInc = yInc;
yInc = tmp;
}
c = dx << 1;
m = dy << 1;
run = dx;
while ( run )
{
*dst = PixelBlend32 ( *dst, argb, alpha );
dst = (u32*) ( (u8*) dst + xInc ); // x += xInc
d += m;
if ( d > dx )
{
dst = (u32*) ( (u8*) dst + yInc ); // y += yInc
d -= c;
}
run -= 1;
}
t->unlock();
}
/*
*/
static void RenderLine16_Decal (video::IImage *t,
const core::position2d<s32> &p0,
const core::position2d<s32> &p1,
u32 argb )
{
s32 dx = p1.X - p0.X;
s32 dy = p1.Y - p0.Y;
s32 c;
s32 m;
s32 d = 0;
s32 run;
s32 xInc = 2;
s32 yInc = (s32) t->getPitch();
if ( dx < 0 )
{
xInc = -xInc;
dx = -dx;
}
if ( dy < 0 )
{
yInc = -yInc;
dy = -dy;
}
u16 *dst;
dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) );
if ( dy > dx )
{
s32 tmp;
tmp = dx;
dx = dy;
dy = tmp;
tmp = xInc;
xInc = yInc;
yInc = tmp;
}
c = dx << 1;
m = dy << 1;
run = dx;
while ( run )
{
*dst = argb;
dst = (u16*) ( (u8*) dst + xInc ); // x += xInc
d += m;
if ( d > dx )
{
dst = (u16*) ( (u8*) dst + yInc ); // y += yInc
d -= c;
}
run -= 1;
}
t->unlock();
}
/*
*/
static void RenderLine16_Blend (video::IImage *t,
const core::position2d<s32> &p0,
const core::position2d<s32> &p1,
u32 argb,
u32 alpha)
{
s32 dx = p1.X - p0.X;
s32 dy = p1.Y - p0.Y;
s32 c;
s32 m;
s32 d = 0;
s32 run;
s32 xInc = 2;
s32 yInc = (s32) t->getPitch();
if ( dx < 0 )
{
xInc = -xInc;
dx = -dx;
}
if ( dy < 0 )
{
yInc = -yInc;
dy = -dy;
}
u16 *dst;
dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) );
if ( dy > dx )
{
s32 tmp;
tmp = dx;
dx = dy;
dy = tmp;
tmp = xInc;
xInc = yInc;
yInc = tmp;
}
c = dx << 1;
m = dy << 1;
run = dx;
while ( run )
{
*dst = PixelBlend16 ( *dst, argb, alpha );
dst = (u16*) ( (u8*) dst + xInc ); // x += xInc
d += m;
if ( d > dx )
{
dst = (u16*) ( (u8*) dst + yInc ); // y += yInc
d -= c;
}
run -= 1;
}
t->unlock();
}
/*!
*/
static void executeBlit_TextureCopy_x_to_x ( const SBlitJob * job )
{
const void *src = (void*) job->src;
void *dst = (void*) job->dst;
const u32 widthPitch = job->width * job->dstPixelMul;
for ( s32 dy = 0; dy != job->height; ++dy )
{
memcpy ( dst, src, widthPitch );
src = (void*) ( (u8*) (src) + job->srcPitch );
dst = (void*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureCopy_32_to_16 ( const SBlitJob * job )
{
const u32 *src = static_cast<const u32*>(job->src);
u16 *dst = static_cast<u16*>(job->dst);
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
//16 bit Blitter depends on pre-multiplied color
const u32 s = PixelLerp32 ( src[dx] | 0xFF000000, extractAlpha ( src[dx] ) );
dst[dx] = video::A8R8G8B8toA1R5G5B5 ( s );
}
src = (u32*) ( (u8*) (src) + job->srcPitch );
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureCopy_24_to_16 ( const SBlitJob * job )
{
const void *src = (void*) job->src;
u16 *dst = (u16*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
u8 * s = (u8*) src;
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = video::RGB16(s[0], s[1], s[2]);
s += 3;
}
src = (void*) ( (u8*) (src) + job->srcPitch );
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureCopy_16_to_32 ( const SBlitJob * job )
{
const u16 *src = (u16*) job->src;
u32 *dst = (u32*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = video::A1R5G5B5toA8R8G8B8 ( src[dx] );
}
src = (u16*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureCopy_24_to_32 ( const SBlitJob * job )
{
void *src = (void*) job->src;
u32 *dst = (u32*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
u8 * s = (u8*) src;
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2];
s += 3;
}
src = (void*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureBlend_16_to_16 ( const SBlitJob * job )
{
u32 dx;
s32 dy;
u32 *src = (u32*) job->src;
u32 *dst = (u32*) job->dst;
const u32 rdx = job->width >> 1;
const u32 off = core::if_c_a_else_b ( job->width & 1 ,job->width - 1, 0 );
if ( 0 == off )
{
for ( dy = 0; dy != job->height; ++dy )
{
for ( dx = 0; dx != rdx; ++dx )
{
dst[dx] = PixelBlend16_simd ( dst[dx], src[dx] );
}
src = (u32*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
else
{
for ( dy = 0; dy != job->height; ++dy )
{
for ( dx = 0; dx != rdx; ++dx )
{
dst[dx] = PixelBlend16_simd ( dst[dx], src[dx] );
}
((u16*) dst)[off] = PixelBlend16 ( ((u16*) dst)[off], ((u16*) src)[off] );
src = (u32*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
}
/*!
*/
static void executeBlit_TextureBlend_32_to_32 ( const SBlitJob * job )
{
u32 *src = (u32*) job->src;
u32 *dst = (u32*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = PixelBlend32 ( dst[dx], src[dx] );
}
src = (u32*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureBlendColor_16_to_16 ( const SBlitJob * job )
{
u16 *src = (u16*) job->src;
u16 *dst = (u16*) job->dst;
u16 blend = video::A8R8G8B8toA1R5G5B5 ( job->argb );
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = PixelBlend16 ( dst[dx], PixelMul16_2 ( src[dx], blend ) );
}
src = (u16*) ( (u8*) (src) + job->srcPitch );
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_TextureBlendColor_32_to_32 ( const SBlitJob * job )
{
u32 *src = (u32*) job->src;
u32 *dst = (u32*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = PixelBlend32 ( dst[dx], PixelMul32_2 ( src[dx], job->argb ) );
}
src = (u32*) ( (u8*) (src) + job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_Color_16_to_16 ( const SBlitJob * job )
{
u16 *dst = (u16*) job->dst;
u16 c0 = video::A8R8G8B8toA1R5G5B5 ( job->argb );
u32 c = c0 | c0 << 16;
if ( 0 == (job->srcPitch & 3 ) )
{
for ( s32 dy = 0; dy != job->height; ++dy )
{
memset32 ( dst, c, job->srcPitch );
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
else
{
s32 dx = job->width - 1;
for ( s32 dy = 0; dy != job->height; ++dy )
{
memset32 ( dst, c, job->srcPitch );
dst[dx] = c0;
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
}
/*!
*/
static void executeBlit_Color_32_to_32 ( const SBlitJob * job )
{
u32 *dst = (u32*) job->dst;
for ( s32 dy = 0; dy != job->height; ++dy )
{
memset32 ( dst, job->argb, job->srcPitch );
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_ColorAlpha_16_to_16 ( const SBlitJob * job )
{
u16 *dst = (u16*) job->dst;
const u32 alpha = extractAlpha ( job->argb ) >> 3;
const u32 src = video::A8R8G8B8toA1R5G5B5 ( job->argb );
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = PixelBlend16 ( dst[dx], src, alpha );
}
dst = (u16*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static void executeBlit_ColorAlpha_32_to_32 ( const SBlitJob * job )
{
u32 *dst = (u32*) job->dst;
const u32 alpha = extractAlpha ( job->argb );
const u32 src = job->argb;
for ( s32 dy = 0; dy != job->height; ++dy )
{
for ( s32 dx = 0; dx != job->width; ++dx )
{
dst[dx] = PixelBlend32 ( dst[dx], src, alpha );
}
dst = (u32*) ( (u8*) (dst) + job->dstPitch );
}
}
/*!
*/
static tExecuteBlit getBlitter ( eBlitter operation,const video::IImage * dest,const video::IImage * source )
{
video::ECOLOR_FORMAT sourceFormat = (video::ECOLOR_FORMAT) -1;
video::ECOLOR_FORMAT destFormat = (video::ECOLOR_FORMAT) -1;
if ( source )
sourceFormat = source->getColorFormat ();
if ( dest )
destFormat = dest->getColorFormat ();
switch ( operation )
{
case BLITTER_TEXTURE:
{
if ( sourceFormat == destFormat )
return executeBlit_TextureCopy_x_to_x;
if ( destFormat == video::ECF_A1R5G5B5 && sourceFormat == video::ECF_A8R8G8B8 )
return executeBlit_TextureCopy_32_to_16;
if ( destFormat == video::ECF_A1R5G5B5 && sourceFormat == video::ECF_R8G8B8 )
return executeBlit_TextureCopy_24_to_16;
if ( destFormat == video::ECF_A8R8G8B8 && sourceFormat == video::ECF_A1R5G5B5 )
return executeBlit_TextureCopy_16_to_32;
if ( destFormat == video::ECF_A8R8G8B8 && sourceFormat == video::ECF_R8G8B8 )
return executeBlit_TextureCopy_24_to_32;
} break;
case BLITTER_TEXTURE_ALPHA_BLEND:
{
if ( destFormat == video::ECF_A1R5G5B5 && sourceFormat == video::ECF_A1R5G5B5 )
return executeBlit_TextureBlend_16_to_16;
if ( destFormat == video::ECF_A8R8G8B8 && sourceFormat == video::ECF_A8R8G8B8 )
return executeBlit_TextureBlend_32_to_32;
} break;
case BLITTER_TEXTURE_ALPHA_COLOR_BLEND:
{
if ( destFormat == video::ECF_A1R5G5B5 && sourceFormat == video::ECF_A1R5G5B5 )
return executeBlit_TextureBlendColor_16_to_16;
if ( destFormat == video::ECF_A8R8G8B8 && sourceFormat == video::ECF_A8R8G8B8 )
return executeBlit_TextureBlendColor_32_to_32;
} break;
case BLITTER_COLOR:
{
if ( destFormat == video::ECF_A1R5G5B5 )
return executeBlit_Color_16_to_16;
if ( destFormat == video::ECF_A8R8G8B8 )
return executeBlit_Color_32_to_32;
} break;
case BLITTER_COLOR_ALPHA:
{
if ( destFormat == video::ECF_A1R5G5B5 )
return executeBlit_ColorAlpha_16_to_16;
if ( destFormat == video::ECF_A8R8G8B8 )
return executeBlit_ColorAlpha_32_to_32;
} break;
case BLITTER_INVALID:
break;
}
/*
char buf[64];
sprintf ( buf, "Blit: %d %d->%d unsupported",operation,sourceFormat,destFormat );
os::Printer::log (buf );
*/
return 0;
}
/*!
a generic 2D Blitter
*/
static s32 Blit ( eBlitter operation,
video::IImage * dest,
const core::rect<s32> *destClipping,
const core::position2d<s32> *destPos,
video::IImage * const source,
const core::rect<s32> *sourceClipping,
u32 argb
)
{
tExecuteBlit blitter = getBlitter ( operation, dest, source );
if ( 0 == blitter )
{
return 0;
}
// Clipping
AbsRectangle sourceClip;
AbsRectangle destClip;
AbsRectangle v;
SBlitJob job;
if ( sourceClipping )
{
sourceClip.x0 = sourceClipping->UpperLeftCorner.X;
sourceClip.y0 = sourceClipping->UpperLeftCorner.Y;
sourceClip.x1 = sourceClipping->LowerRightCorner.X;
sourceClip.y1 = sourceClipping->LowerRightCorner.Y;
}
else
{
sourceClip.x0 = 0;
sourceClip.y0 = 0;
sourceClip.x1 = source ? source->getDimension().Width : 0;
sourceClip.y1 = source ? source->getDimension().Height : 0;
}
if ( destClipping )
{
destClip.x0 = destClipping->UpperLeftCorner.X;
destClip.y0 = destClipping->UpperLeftCorner.Y;
destClip.x1 = destClipping->LowerRightCorner.X;
destClip.y1 = destClipping->LowerRightCorner.Y;
}
else
{
destClip.x0 = 0;
destClip.y0 = 0;
destClip.x1 = dest ? dest->getDimension().Width : 0;
destClip.y1 = dest ? dest->getDimension().Height : 0;
}
v.x0 = destPos ? destPos->X : 0;
v.y0 = destPos ? destPos->Y : 0;
v.x1 = v.x0 + ( sourceClip.x1 - sourceClip.x0 );
v.y1 = v.y0 + ( sourceClip.y1 - sourceClip.y0 );
intersect ( job.Dest, destClip, v );
if ( !isValid ( job.Dest ) )
return 0;
job.width = job.Dest.x1 - job.Dest.x0;
job.height = job.Dest.y1 - job.Dest.y0;
job.Source.x0 = sourceClip.x0 + ( job.Dest.x0 - v.x0 );
job.Source.x1 = job.Source.x0 + job.width;
job.Source.y0 = sourceClip.y0 + ( job.Dest.y0 - v.y0 );
job.Source.y1 = job.Source.y0 + job.height;
job.argb = argb;
if ( source )
{
job.srcPitch = source->getPitch();
job.srcPixelMul = source->getBytesPerPixel();
job.src = (void*) ( (u8*) source->lock() + ( job.Source.y0 * job.srcPitch ) + ( job.Source.x0 * job.srcPixelMul ) );
}
else
{
// use srcPitch for color operation on dest
job.srcPitch = job.width * dest->getBytesPerPixel();
}
job.dstPitch = dest->getPitch();
job.dstPixelMul = dest->getBytesPerPixel();
job.dst = (void*) ( (u8*) dest->lock() + ( job.Dest.y0 * job.dstPitch ) + ( job.Dest.x0 * job.dstPixelMul ) );
blitter ( &job );
if ( source )
source->unlock ();
if ( dest )
dest->unlock();
return 1;
}
}
namespace irr
{
namespace video
{
//! constructor
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<s32>& size)
:Data(0), Size(size), Format(format), DeleteMemory(true)
{
initData();
}
//! constructor
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<s32>& size, void* data,
bool ownForeignMemory, bool deleteForeignMemory)
: Data(0), Size(size), Format(format), DeleteMemory(deleteForeignMemory)
{
if (ownForeignMemory)
{
Data = (void*)0xbadf00d;
initData();
Data = data;
}
else
{
Data = 0;
initData();
memcpy(Data, data, Size.Height * Pitch);
}
}
//! constructor
CImage::CImage(ECOLOR_FORMAT format, IImage* imageToCopy)
: Data(0), Format(format), DeleteMemory(true)
{
if (!imageToCopy)
return;
Size = imageToCopy->getDimension();
initData();
// now copy data from other image
Blit ( BLITTER_TEXTURE, this, 0, 0, imageToCopy, 0,0 );
}
//! constructor
CImage::CImage(IImage* imageToCopy, const core::position2d<s32>& pos,
const core::dimension2d<s32>& size)
: Data(0), Size(0,0), DeleteMemory(true)
{
if (!imageToCopy)
return;
Format = imageToCopy->getColorFormat();
Size = size;
initData();
core::rect<s32> sClip( pos.X, pos.Y, pos.X + size.Width,pos.Y + size.Height );
Blit ( BLITTER_TEXTURE, this, 0, 0, imageToCopy, &sClip,0 );
}
//! assumes format and size has been set and creates the rest
void CImage::initData()
{
setBitMasks();
BitsPerPixel = getBitsPerPixelFromFormat(Format);
BytesPerPixel = BitsPerPixel / 8;
// Pitch should be aligned...
Pitch = BytesPerPixel * Size.Width;
if (!Data)
Data = new s8[Size.Height * Pitch];
}
//! destructor
CImage::~CImage()
{
if ( DeleteMemory )
delete [] (s8*)Data;
}
//! Returns width and height of image data.
const core::dimension2d<s32>& CImage::getDimension() const
{
return Size;
}
//! Returns bits per pixel.
u32 CImage::getBitsPerPixel() const
{
return BitsPerPixel;
}
//! Returns bytes per pixel
u32 CImage::getBytesPerPixel() const
{
return BytesPerPixel;
}
//! Returns image data size in bytes
u32 CImage::getImageDataSizeInBytes() const
{
return Pitch * Size.Height;
}
//! Returns image data size in pixels
u32 CImage::getImageDataSizeInPixels() const
{
return Size.Width * Size.Height;
}
//! returns mask for red value of a pixel
u32 CImage::getRedMask() const
{
return RedMask;
}
//! returns mask for green value of a pixel
u32 CImage::getGreenMask() const
{
return GreenMask;
}
//! returns mask for blue value of a pixel
u32 CImage::getBlueMask() const
{
return BlueMask;
}
//! returns mask for alpha value of a pixel
u32 CImage::getAlphaMask() const
{
return AlphaMask;
}
void CImage::setBitMasks()
{
switch(Format)
{
case ECF_A1R5G5B5:
AlphaMask = 0x1<<15;
RedMask = 0x1F<<10;
GreenMask = 0x1F<<5;
BlueMask = 0x1F;
break;
case ECF_R5G6B5:
AlphaMask = 0x0;
RedMask = 0x1F<<11;
GreenMask = 0x3F<<5;
BlueMask = 0x1F;
break;
case ECF_R8G8B8:
AlphaMask = 0x0;
RedMask = 0x00FF0000;
GreenMask = 0x0000FF00;
BlueMask = 0x000000FF;
break;
case ECF_A8R8G8B8:
AlphaMask = 0xFF000000;
RedMask = 0x00FF0000;
GreenMask = 0x0000FF00;
BlueMask = 0x000000FF;
break;
}
}
u32 CImage::getBitsPerPixelFromFormat(ECOLOR_FORMAT format)
{
switch(format)
{
case ECF_A1R5G5B5:
return 16;
case ECF_R5G6B5:
return 16;
case ECF_R8G8B8:
return 24;
case ECF_A8R8G8B8:
return 32;
}
return 0;
}
//! sets a pixel
void CImage::setPixel(u32 x, u32 y, const SColor &color )
{
if (x >= (u32)Size.Width || y >= (u32)Size.Height)
return;
switch(Format)
{
case ECF_A1R5G5B5:
{
u16 * dest = (u16*) ((u8*) Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toA1R5G5B5 ( color.color );
} break;
case ECF_R5G6B5:
{
u16 * dest = (u16*) ((u8*) Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toR5G6B5 ( color.color );
} break;
case ECF_R8G8B8:
{
u8* dest = (u8*) Data + ( y * Pitch ) + ( x * 3 );
dest[0] = color.getRed();
dest[1] = color.getGreen();
dest[2] = color.getBlue();
} break;
case ECF_A8R8G8B8:
{
u32 * dest = (u32*) ((u8*) Data + ( y * Pitch ) + ( x << 2 ));
*dest = color.color;
} break;
}
}
//! returns a pixel
SColor CImage::getPixel(u32 x, u32 y) const
{
if (x >= (u32)Size.Width || y >= (u32)Size.Height)
return SColor(0);
switch(Format)
{
case ECF_A1R5G5B5:
return A1R5G5B5toA8R8G8B8(((u16*)Data)[y*Size.Width + x]);
case ECF_R5G6B5:
return R5G6B5toA8R8G8B8(((u16*)Data)[y*Size.Width + x]);
case ECF_A8R8G8B8:
return ((u32*)Data)[y*Size.Width + x];
case ECF_R8G8B8:
{
u8* p = &((u8*)Data)[(y*3)*Size.Width + (x*3)];
return SColor(255,p[0],p[1],p[2]);
}
}
return SColor(0);
}
//! returns the color format
ECOLOR_FORMAT CImage::getColorFormat() const
{
return Format;
}
//! draws a rectangle
void CImage::drawRectangle(const core::rect<s32>& rect, const SColor &color)
{
Blit ( color.getAlpha() == 0xFF ? BLITTER_COLOR : BLITTER_COLOR_ALPHA,
this, 0, &rect.UpperLeftCorner, 0, &rect, color.color );
}
//! copies this surface into another
void CImage::copyTo(IImage* target, const core::position2d<s32>& pos)
{
Blit ( BLITTER_TEXTURE, target, 0, &pos, this, 0, 0 );
}
//! copies this surface into another
void CImage::copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect)
{
Blit ( BLITTER_TEXTURE, target, clipRect, &pos, this, &sourceRect, 0 );
}
//! copies this surface into another, using the alpha mask, an cliprect and a color to add with
void CImage::copyToWithAlpha(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const SColor &color, const core::rect<s32>* clipRect)
{
// color blend only necessary on not full spectrum aka. color.color != 0xFFFFFFFF
Blit ( color.color == 0xFFFFFFFF ? BLITTER_TEXTURE_ALPHA_BLEND: BLITTER_TEXTURE_ALPHA_COLOR_BLEND,
target, clipRect, &pos, this, &sourceRect, color.color );
}
//! draws a line from to with color
void CImage::drawLine(const core::position2d<s32>& from, const core::position2d<s32>& to, const SColor &color)
{
AbsRectangle clip;
GetClip ( clip, this );
core::position2d<s32> p[2];
if ( ClipLine ( clip, p[0], p[1], from, to ) )
{
u32 alpha = extractAlpha ( color.color );
switch ( Format )
{
case ECF_A1R5G5B5:
if ( alpha == 256 )
{
RenderLine16_Decal ( this, p[0], p[1], video::A8R8G8B8toA1R5G5B5 ( color.color ) );
}
else
{
RenderLine16_Blend ( this, p[0], p[1], video::A8R8G8B8toA1R5G5B5 ( color.color ), alpha >> 3 );
}
break;
case ECF_A8R8G8B8:
if ( alpha == 256 )
{
RenderLine32_Decal ( this, p[0], p[1], color.color );
}
else
{
RenderLine32_Blend ( this, p[0], p[1], color.color, alpha );
}
break;
}
}
}
//! copies this surface into another, scaling it to the target image size
// note: this is very very slow. (i didn't want to write a fast version.
// but hopefully, nobody wants to scale surfaces every frame.
void CImage::copyToScaling(void* target, s32 width, s32 height, ECOLOR_FORMAT format, u32 pitch)
{
if (!target || !width || !height)
return;
const u32 bpp=getBitsPerPixelFromFormat(format)/8;
if (0==pitch)
pitch = width*bpp;
if (Format==format && Size.Width==width && Size.Height==height)
{
if (pitch==Pitch)
{
memcpy(target, Data, height*pitch);
return;
}
else
{
u8* tgtpos = (u8*) target;
u8* dstpos = (u8*) Data;
const u32 bwidth = width*bpp;
for (s32 y=0; y<height; ++y)
{
memcpy(target, Data, height*pitch);
memset(tgtpos+width, 0, pitch-bwidth);
tgtpos += pitch;
dstpos += Pitch;
}
return;
}
}
const f32 sourceXStep = (f32)Size.Width / (f32)width;
const f32 sourceYStep = (f32)Size.Height / (f32)height;
s32 yval=0, syval=0;
f32 sy = 0.0f;
for (s32 y=0; y<height; ++y)
{
f32 sx = 0.0f;
for (s32 x=0; x<width; ++x)
{
CColorConverter::convert_viaFormat(((u8*)Data)+ syval + ((s32)sx)*BytesPerPixel, Format, 1, ((u8*)target)+ yval + (x*bpp), format);
sx+=sourceXStep;
}
sy+=sourceYStep;
syval=((s32)sy)*Pitch;
yval+=pitch;
}
}
//! copies this surface into another, scaling it to the target image size
// note: this is very very slow. (i didn't want to write a fast version.
// but hopefully, nobody wants to scale surfaces every frame.
void CImage::copyToScaling(IImage* target)
{
if (!target)
return;
const core::dimension2d<s32>& targetSize = target->getDimension();
if (targetSize==Size)
{
copyTo(target);
return;
}
copyToScaling(target->lock(), targetSize.Width, targetSize.Height, target->getColorFormat());
target->unlock();
}
//! copies this surface into another, scaling it to fit it.
void CImage::copyToScalingBoxFilter(IImage* target, s32 bias)
{
const core::dimension2d<s32> destSize = target->getDimension();
const f32 sourceXStep = (f32) Size.Width / (f32) destSize.Width;
const f32 sourceYStep = (f32) Size.Height / (f32) destSize.Height;
target->lock();
s32 fx = core::ceil32 ( sourceXStep );
s32 fy = core::ceil32 ( sourceYStep );
f32 sx;
f32 sy;
sy = 0.f;
for ( s32 y = 0; y != destSize.Height; ++y )
{
sx = 0.f;
for ( s32 x = 0; x != destSize.Width; ++x )
{
target->setPixel ( x, y, getPixelBox( core::floor32 ( sx ), core::floor32 ( sy ), fx, fy, bias ) );
sx += sourceXStep;
}
sy += sourceYStep;
}
target->unlock ();
}
//! fills the surface with given color
void CImage::fill(const SColor &color)
{
u32 c;
switch ( Format )
{
case ECF_A1R5G5B5:
c = video::A8R8G8B8toA1R5G5B5 ( color.color );
c |= c << 16;
break;
case ECF_R5G6B5:
c = video::A8R8G8B8toR5G6B5 ( color.color );
c |= c << 16;
break;
case ECF_A8R8G8B8:
c = color.color;
break;
default:
// os::Printer::log("CImage::Format not supported", ELL_ERROR);
return;
}
memset32 ( Data, c, getImageDataSizeInBytes () );
}
//! get a filtered pixel
inline SColor CImage::getPixelBox ( s32 x, s32 y, s32 fx, s32 fy, s32 bias ) const
{
SColor c;
s32 a = 0, r = 0, g = 0, b = 0;
for ( s32 dx = 0; dx != fx; ++dx )
{
for ( s32 dy = 0; dy != fy; ++dy )
{
c = getPixel ( x + dx , y + dy );
a += c.getAlpha ();
r += c.getRed();
g += c.getGreen();
b += c.getBlue();
}
}
s32 sdiv = s32_log2_s32(fx * fy);
a = core::s32_clamp ( ( a >> sdiv ) + bias, 0, 255 );
r = core::s32_clamp ( ( r >> sdiv ) + bias, 0, 255 );
g = core::s32_clamp ( ( g >> sdiv ) + bias, 0, 255 );
b = core::s32_clamp ( ( b >> sdiv ) + bias, 0, 255 );
c.set ( a, r, g, b );
return c;
}
} // end namespace video
} // end namespace irr