minetest/irrlicht
1
0
Fork 0
mirror of https://github.com/minetest/irrlicht.git synced 2025-07-01 15:50:27 +02:00
Code Issues Projects Releases Wiki Activity

Reformat the code, using:

Browse Source 
find -type f |  # list all regular files
  grep -E '\.(h|cpp|mm)$' |  # filter for source files
  grep -v '/mt_' |  # filter out generated files
  grep -v '/vendor/' | # and vendored GL
  grep -v '/test/image_loader_test.cpp' |  # and this file (has giant literals arrays)
  xargs -n 1 -P $(nproc) clang-format -i  # reformat everything

Co-authored-by: numzero <numzer0@yandex.ru>
This commit is contained in:
Desour
2024-03-20 19:35:52 +01:00
parent eb4dec46c2
commit 2bf1d12353
292 changed files with 37376 additions and 42421 deletions
Download Patch File Download Diff File Expand all files Collapse all files

322
source/Irrlicht/CImage.cpp
View File

@ -15,100 +15,89 @@ namespace video
{
//! Constructor from raw data
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size, void* data,
bool ownForeignMemory, bool deleteMemory) : IImage(format, size, deleteMemory)
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<u32> &size, void *data,
bool ownForeignMemory, bool deleteMemory) :
IImage(format, size, deleteMemory)
{
if (ownForeignMemory)
{
Data = (u8*)data;
}
else
{
if (ownForeignMemory) {
Data = (u8 *)data;
} else {
const u32 dataSize = getDataSizeFromFormat(Format, Size.Width, Size.Height);
const u32 allocSize = align_next(dataSize, 16);
// allocate as u32 to ensure enough alignment when casted
Data = reinterpret_cast<u8*>(new u32[allocSize / 4]);
Data = reinterpret_cast<u8 *>(new u32[allocSize / 4]);
memcpy(Data, data, dataSize);
DeleteMemory = true;
}
}
//! Constructor of empty image
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) : IImage(format, size, true)
CImage::CImage(ECOLOR_FORMAT format, const core::dimension2d<u32> &size) :
IImage(format, size, true)
{
const u32 dataSize = getDataSizeFromFormat(Format, Size.Width, Size.Height);
const u32 allocSize = align_next(dataSize, 16);
Data = reinterpret_cast<u8*>(new u32[allocSize / 4]);
Data = reinterpret_cast<u8 *>(new u32[allocSize / 4]);
DeleteMemory = true;
}
//! sets a pixel
void CImage::setPixel(u32 x, u32 y, const SColor &color, bool blend)
{
if (x >= Size.Width || y >= Size.Height)
return;
switch(Format)
{
case ECF_A1R5G5B5:
{
u16 * dest = (u16*) (Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toA1R5G5B5( color.color );
} break;
switch (Format) {
case ECF_A1R5G5B5: {
u16 *dest = (u16 *)(Data + (y * Pitch) + (x << 1));
*dest = video::A8R8G8B8toA1R5G5B5(color.color);
} break;
case ECF_R5G6B5:
{
u16 * dest = (u16*) (Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toR5G6B5( color.color );
} break;
case ECF_R5G6B5: {
u16 *dest = (u16 *)(Data + (y * Pitch) + (x << 1));
*dest = video::A8R8G8B8toR5G6B5(color.color);
} break;
case ECF_R8G8B8:
{
u8* dest = Data + ( y * Pitch ) + ( x * 3 );
dest[0] = (u8)color.getRed();
dest[1] = (u8)color.getGreen();
dest[2] = (u8)color.getBlue();
} break;
case ECF_R8G8B8: {
u8 *dest = Data + (y * Pitch) + (x * 3);
dest[0] = (u8)color.getRed();
dest[1] = (u8)color.getGreen();
dest[2] = (u8)color.getBlue();
} break;
case ECF_A8R8G8B8:
{
u32 * dest = (u32*) (Data + ( y * Pitch ) + ( x << 2 ));
*dest = blend ? PixelBlend32 ( *dest, color.color ) : color.color;
} break;
case ECF_A8R8G8B8: {
u32 *dest = (u32 *)(Data + (y * Pitch) + (x << 2));
*dest = blend ? PixelBlend32(*dest, color.color) : color.color;
} break;
case ECF_UNKNOWN:
os::Printer::log("IImage::setPixel unknown format.", ELL_WARNING);
return;
case ECF_UNKNOWN:
os::Printer::log("IImage::setPixel unknown format.", ELL_WARNING);
return;
default:
break;
default:
break;
}
}
//! returns a pixel
SColor CImage::getPixel(u32 x, u32 y) const
{
if (x >= Size.Width || y >= Size.Height)
return SColor(0);
switch(Format)
{
switch (Format) {
case ECF_A1R5G5B5:
return A1R5G5B5toA8R8G8B8(((u16*)Data)[y*Size.Width + x]);
return A1R5G5B5toA8R8G8B8(((u16 *)Data)[y * Size.Width + x]);
case ECF_R5G6B5:
return R5G6B5toA8R8G8B8(((u16*)Data)[y*Size.Width + x]);
return R5G6B5toA8R8G8B8(((u16 *)Data)[y * Size.Width + x]);
case ECF_A8R8G8B8:
return ((u32*)Data)[y*Size.Width + x];
case ECF_R8G8B8:
{
u8* p = Data+(y*3)*Size.Width + (x*3);
return SColor(255,p[0],p[1],p[2]);
}
return ((u32 *)Data)[y * Size.Width + x];
case ECF_R8G8B8: {
u8 *p = Data + (y * 3) * Size.Width + (x * 3);
return SColor(255, p[0], p[1], p[2]);
}
case ECF_UNKNOWN:
os::Printer::log("IImage::getPixel unknown format.", ELL_WARNING);
@ -121,32 +110,26 @@ SColor CImage::getPixel(u32 x, u32 y) const
return SColor(0);
}
//! copies this surface into another at given position
void CImage::copyTo(IImage* target, const core::position2d<s32>& pos)
void CImage::copyTo(IImage *target, const core::position2d<s32> &pos)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyTo method doesn't work with compressed images.", ELL_WARNING);
return;
}
if (!Blit(BLITTER_TEXTURE, target, 0, &pos, this, 0, 0)
&& target && pos.X == 0 && pos.Y == 0 &&
CColorConverter::canConvertFormat(Format, target->getColorFormat()))
{
if (!Blit(BLITTER_TEXTURE, target, 0, &pos, this, 0, 0) && target && pos.X == 0 && pos.Y == 0 &&
CColorConverter::canConvertFormat(Format, target->getColorFormat())) {
// No fast blitting, but copyToScaling uses other color conversions and might work
irr::core::dimension2du dim(target->getDimension());
copyToScaling(target->getData(), dim.Width, dim.Height, target->getColorFormat(), target->getPitch());
}
}
//! copies this surface partially into another at given position
void CImage::copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect)
void CImage::copyTo(IImage *target, const core::position2d<s32> &pos, const core::rect<s32> &sourceRect, const core::rect<s32> *clipRect)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyTo method doesn't work with compressed images.", ELL_WARNING);
return;
}
@ -154,27 +137,23 @@ void CImage::copyTo(IImage* target, const core::position2d<s32>& pos, const core
Blit(BLITTER_TEXTURE, target, clipRect, &pos, this, &sourceRect, 0);
}
//! copies this surface into another, using the alpha mask, a 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, bool combineAlpha)
void CImage::copyToWithAlpha(IImage *target, const core::position2d<s32> &pos, const core::rect<s32> &sourceRect, const SColor &color, const core::rect<s32> *clipRect, bool combineAlpha)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyToWithAlpha method doesn't work with compressed images.", ELL_WARNING);
return;
}
eBlitter op = combineAlpha ? BLITTER_TEXTURE_COMBINE_ALPHA :
color.color == 0xFFFFFFFF ? BLITTER_TEXTURE_ALPHA_BLEND : BLITTER_TEXTURE_ALPHA_COLOR_BLEND;
Blit(op,target, clipRect, &pos, this, &sourceRect, color.color);
eBlitter op = combineAlpha ? BLITTER_TEXTURE_COMBINE_ALPHA : color.color == 0xFFFFFFFF ? BLITTER_TEXTURE_ALPHA_BLEND
: BLITTER_TEXTURE_ALPHA_COLOR_BLEND;
Blit(op, target, clipRect, &pos, this, &sourceRect, color.color);
}
//! copies this surface into another, if it has the exact same size and format.
bool CImage::copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format, u32 pitch) const
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyToNoScaling method doesn't work with compressed images.", ELL_WARNING);
return false;
}
@ -182,29 +161,25 @@ bool CImage::copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT
if (!target || !width || !height || !Size.Width || !Size.Height)
return false;
const u32 bpp=getBitsPerPixelFromFormat(format)/8;
if (0==pitch)
pitch = width*bpp;
const u32 bpp = getBitsPerPixelFromFormat(format) / 8;
if (0 == pitch)
pitch = width * bpp;
if (!(Format==format && Size.Width==width && Size.Height==height))
if (!(Format == format && Size.Width == width && Size.Height == height))
return false;
if (pitch==Pitch)
{
memcpy(target, Data, (size_t)height*pitch);
}
else
{
u8* tgtpos = (u8*) target;
u8* srcpos = Data;
const u32 bwidth = width*bpp;
const u32 rest = pitch-bwidth;
for (u32 y=0; y<height; ++y)
{
if (pitch == Pitch) {
memcpy(target, Data, (size_t)height * pitch);
} else {
u8 *tgtpos = (u8 *)target;
u8 *srcpos = Data;
const u32 bwidth = width * bpp;
const u32 rest = pitch - bwidth;
for (u32 y = 0; y < height; ++y) {
// copy scanline
memcpy(tgtpos, srcpos, bwidth);
// clear pitch
memset(tgtpos+bwidth, 0, rest);
memset(tgtpos + bwidth, 0, rest);
tgtpos += pitch;
srcpos += Pitch;
}
@ -213,13 +188,11 @@ bool CImage::copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT
return true;
}
//! copies this surface into another, scaling it to the target image size
// note: this is very very slow.
void CImage::copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format, u32 pitch)
void CImage::copyToScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format, u32 pitch)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyToScaling method doesn't work with compressed images.", ELL_WARNING);
return;
}
@ -227,9 +200,9 @@ void CImage::copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT fo
if (!target || !width || !height || !Size.Width || !Size.Height)
return;
const u32 bpp=getBitsPerPixelFromFormat(format)/8;
if (0==pitch)
pitch = width*bpp;
const u32 bpp = getBitsPerPixelFromFormat(format) / 8;
if (0 == pitch)
pitch = width * bpp;
if (copyToNoScaling(target, width, height, format, pitch))
return;
@ -247,42 +220,36 @@ void CImage::copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT fo
f32 sourceXStart = 0.f, sourceYStart = 0.f;
if (width % Size.Width == 0)
sourceXStep = (f32)(Size.Width) / (f32)(width);
else
{
sourceXStep = width > 1 ? (f32)(Size.Width-1) / (f32)(width-1) : 0.f;
sourceXStart = 0.5f; // for rounding to nearest pixel
else {
sourceXStep = width > 1 ? (f32)(Size.Width - 1) / (f32)(width - 1) : 0.f;
sourceXStart = 0.5f; // for rounding to nearest pixel
}
if (height % Size.Height == 0)
sourceYStep = (f32)(Size.Height) / (f32)(height);
else
{
sourceYStep = height > 1 ? (f32)(Size.Height-1) / (f32)(height-1) : 0.f;
sourceYStart = 0.5f; // for rounding to nearest pixel
else {
sourceYStep = height > 1 ? (f32)(Size.Height - 1) / (f32)(height - 1) : 0.f;
sourceYStart = 0.5f; // for rounding to nearest pixel
}
s32 yval=0, syval=0;
s32 yval = 0, syval = 0;
f32 sy = sourceYStart;
for (u32 y=0; y<height; ++y)
{
for (u32 y = 0; y < height; ++y) {
f32 sx = sourceXStart;
for (u32 x=0; x<width; ++x)
{
CColorConverter::convert_viaFormat(Data+ syval + ((s32)sx)*BytesPerPixel, Format, 1, ((u8*)target)+ yval + (x*bpp), format);
sx+=sourceXStep;
for (u32 x = 0; x < width; ++x) {
CColorConverter::convert_viaFormat(Data + syval + ((s32)sx) * BytesPerPixel, Format, 1, ((u8 *)target) + yval + (x * bpp), format);
sx += sourceXStep;
}
sy+=sourceYStep;
syval=(s32)(sy)*Pitch;
yval+=pitch;
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.
void CImage::copyToScaling(IImage* target)
void CImage::copyToScaling(IImage *target)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyToScaling method doesn't work with compressed images.", ELL_WARNING);
return;
}
@ -290,10 +257,9 @@ void CImage::copyToScaling(IImage* target)
if (!target)
return;
const core::dimension2d<u32>& targetSize = target->getDimension();
const core::dimension2d<u32> &targetSize = target->getDimension();
if (targetSize==Size)
{
if (targetSize == Size) {
copyTo(target);
return;
}
@ -301,90 +267,78 @@ void CImage::copyToScaling(IImage* target)
copyToScaling(target->getData(), targetSize.Width, targetSize.Height, target->getColorFormat());
}
//! copies this surface into another, scaling it to fit it.
void CImage::copyToScalingBoxFilter(IImage* target, s32 bias, bool blend)
void CImage::copyToScalingBoxFilter(IImage *target, s32 bias, bool blend)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::copyToScalingBoxFilter method doesn't work with compressed images.", ELL_WARNING);
return;
}
const core::dimension2d<u32> destSize = target->getDimension();
const f32 sourceXStep = (f32) Size.Width / (f32) destSize.Width;
const f32 sourceYStep = (f32) Size.Height / (f32) destSize.Height;
const f32 sourceXStep = (f32)Size.Width / (f32)destSize.Width;
const f32 sourceYStep = (f32)Size.Height / (f32)destSize.Height;
s32 fx = core::ceil32( sourceXStep );
s32 fy = core::ceil32( sourceYStep );
s32 fx = core::ceil32(sourceXStep);
s32 fy = core::ceil32(sourceYStep);
f32 sx;
f32 sy;
sy = 0.f;
for ( u32 y = 0; y != destSize.Height; ++y )
{
for (u32 y = 0; y != destSize.Height; ++y) {
sx = 0.f;
for ( u32 x = 0; x != destSize.Width; ++x )
{
target->setPixel( x, y,
getPixelBox( core::floor32(sx), core::floor32(sy), fx, fy, bias ), blend );
for (u32 x = 0; x != destSize.Width; ++x) {
target->setPixel(x, y,
getPixelBox(core::floor32(sx), core::floor32(sy), fx, fy, bias), blend);
sx += sourceXStep;
}
sy += sourceYStep;
}
}
//! fills the surface with given color
void CImage::fill(const SColor &color)
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::fill method doesn't work with compressed images.", ELL_WARNING);
return;
}
u32 c;
switch ( Format )
{
case ECF_A1R5G5B5:
c = color.toA1R5G5B5();
c |= c << 16;
break;
case ECF_R5G6B5:
c = video::A8R8G8B8toR5G6B5( color.color );
c |= c << 16;
break;
case ECF_A8R8G8B8:
c = color.color;
break;
case ECF_R8G8B8:
{
u8 rgb[3];
CColorConverter::convert_A8R8G8B8toR8G8B8(&color, 1, rgb);
const u32 size = getImageDataSizeInBytes();
for (u32 i=0; i<size; i+=3)
{
memcpy(Data+i, rgb, 3);
}
return;
}
switch (Format) {
case ECF_A1R5G5B5:
c = color.toA1R5G5B5();
c |= c << 16;
break;
default:
case ECF_R5G6B5:
c = video::A8R8G8B8toR5G6B5(color.color);
c |= c << 16;
break;
case ECF_A8R8G8B8:
c = color.color;
break;
case ECF_R8G8B8: {
u8 rgb[3];
CColorConverter::convert_A8R8G8B8toR8G8B8(&color, 1, rgb);
const u32 size = getImageDataSizeInBytes();
for (u32 i = 0; i < size; i += 3) {
memcpy(Data + i, rgb, 3);
}
return;
} break;
default:
// TODO: Handle other formats
return;
return;
}
memset32( Data, c, getImageDataSizeInBytes() );
memset32(Data, c, getImageDataSizeInBytes());
}
//! get a filtered pixel
inline SColor CImage::getPixelBox( s32 x, s32 y, s32 fx, s32 fy, s32 bias ) const
inline SColor CImage::getPixelBox(s32 x, s32 y, s32 fx, s32 fy, s32 bias) const
{
if (IImage::isCompressedFormat(Format))
{
if (IImage::isCompressedFormat(Format)) {
os::Printer::log("IImage::getPixelBox method doesn't work with compressed images.", ELL_WARNING);
return SColor(0);
}
@ -392,34 +346,28 @@ inline SColor CImage::getPixelBox( s32 x, s32 y, s32 fx, s32 fy, s32 bias ) cons
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( core::s32_min ( x + dx, Size.Width - 1 ) ,
core::s32_min ( y + dy, Size.Height - 1 )
);
for (s32 dx = 0; dx != fx; ++dx) {
for (s32 dy = 0; dy != fy; ++dy) {
c = getPixel(core::s32_min(x + dx, Size.Width - 1),
core::s32_min(y + dy, Size.Height - 1));
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 );
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 );
c.set(a, r, g, b);
return c;
}
} // end namespace video
} // end namespace irr