From 96c34d369e71e25299eccc1527ae5463ea5219e3 Mon Sep 17 00:00:00 2001 From: Kahrl Date: Fri, 2 Aug 2013 21:31:52 +0200 Subject: [PATCH] Fix crack overlay for animated textures --- src/mapblock_mesh.cpp | 33 ++++-- src/tile.cpp | 226 ++++++++++++++++++++++-------------------- 2 files changed, 146 insertions(+), 113 deletions(-) diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp index 40158e1ad..28c52f4b9 100644 --- a/src/mapblock_mesh.cpp +++ b/src/mapblock_mesh.cpp @@ -1133,12 +1133,17 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data): if(p.tile.material_flags & MATERIAL_FLAG_CRACK) { ITextureSource *tsrc = data->m_gamedef->tsrc(); - std::string crack_basename = tsrc->getTextureName(p.tile.texture_id); + // Find the texture name plus ^[crack:N: + std::ostringstream os(std::ios::binary); + os<getTextureName(p.tile.texture_id)<<"^[crack"; if(p.tile.material_flags & MATERIAL_FLAG_CRACK_OVERLAY) - crack_basename += "^[cracko"; - else - crack_basename += "^[crack"; - m_crack_materials.insert(std::make_pair(i, crack_basename)); + os<<"o"; // use ^[cracko + os<<":"<<(u32)p.tile.animation_frame_count<<":"; + m_crack_materials.insert(std::make_pair(i, os.str())); + // Replace tile texture with the cracked one + p.tile.texture = tsrc->getTexture( + os.str()+"0", + &p.tile.texture_id); } // - Texture animation if(p.tile.material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) @@ -1313,8 +1318,22 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat ITextureSource *tsrc = m_gamedef->getTextureSource(); std::ostringstream os; os<getMaterial().setTexture(0, - tsrc->getTexture(os.str())); + u32 new_texture_id = 0; + video::ITexture *new_texture = + tsrc->getTexture(os.str(), &new_texture_id); + buf->getMaterial().setTexture(0, new_texture); + + // If the current material is also animated, + // update animation info + std::map::iterator anim_iter = + m_animation_tiles.find(i->first); + if(anim_iter != m_animation_tiles.end()){ + TileSpec &tile = anim_iter->second; + tile.texture = new_texture; + tile.texture_id = new_texture_id; + // force animation update + m_animation_frames[i->first] = -1; + } } m_last_crack = crack; diff --git a/src/tile.cpp b/src/tile.cpp index 726f7f602..027e3add7 100644 --- a/src/tile.cpp +++ b/src/tile.cpp @@ -379,11 +379,11 @@ public: const TextureFromMeshParams ¶ms); // Generates an image from a full string like - // "stone.png^mineral_coal.png^[crack0". + // "stone.png^mineral_coal.png^[crack:1:0". // Shall be called from the main thread. video::IImage* generateImageFromScratch(std::string name); - // Generate image based on a string like "stone.png" or "[crack0". + // Generate image based on a string like "stone.png" or "[crack:1:0". // if baseimg is NULL, it is created. Otherwise stuff is made on it. // Shall be called from the main thread. bool generateImage(std::string part_of_name, video::IImage *& baseimg); @@ -543,14 +543,21 @@ u32 TextureSource::getTextureId(const std::string &name) return 0; } -// Overlay image on top of another image (used for cracks) -void overlay(video::IImage *image, video::IImage *overlay); - // Draw an image on top of an another one, using the alpha channel of the // source image static void blit_with_alpha(video::IImage *src, video::IImage *dst, v2s32 src_pos, v2s32 dst_pos, v2u32 size); +// Like blit_with_alpha, but only modifies destination pixels that +// are fully opaque +static void blit_with_alpha_overlay(video::IImage *src, video::IImage *dst, + v2s32 src_pos, v2s32 dst_pos, v2u32 size); + +// Draw or overlay a crack +static void draw_crack(video::IImage *crack, video::IImage *dst, + bool use_overlay, u32 frame_count, u32 progression, + video::IVideoDriver *driver); + // Brighten image void brighten(video::IImage *image); // Parse a transform name @@ -1032,8 +1039,10 @@ bool TextureSource::generateImage(std::string part_of_name, video::IImage *& bas < dim_base = baseimg->getDimension(); - + // Crack image number and overlay option + bool use_overlay = (part_of_name[6] == 'o'); + Strfnd sf(part_of_name); + sf.next(":"); + u32 frame_count = stoi(sf.next(":")); + u32 progression = stoi(sf.next(":")); + /* Load crack image. @@ -1070,60 +1069,12 @@ bool TextureSource::generateImage(std::string part_of_name, video::IImage *& bas */ video::IImage *img_crack = m_sourcecache.getOrLoad( "crack_anylength.png", m_device); - + if(img_crack && progression >= 0) { - // Dimension of original image - core::dimension2d dim_crack - = img_crack->getDimension(); - // Count of crack stages - s32 crack_count = dim_crack.Height / dim_crack.Width; - // Limit progression - if(progression > crack_count-1) - progression = crack_count-1; - // Dimension of a single crack stage - core::dimension2d dim_crack_cropped( - dim_crack.Width, - dim_crack.Width - ); - // Create cropped and scaled crack images - video::IImage *img_crack_cropped = driver->createImage( - video::ECF_A8R8G8B8, dim_crack_cropped); - video::IImage *img_crack_scaled = driver->createImage( - video::ECF_A8R8G8B8, dim_base); - - if(img_crack_cropped && img_crack_scaled) - { - // Crop crack image - v2s32 pos_crack(0, progression*dim_crack.Width); - img_crack->copyTo(img_crack_cropped, - v2s32(0,0), - core::rect(pos_crack, dim_crack_cropped)); - // Scale crack image by copying - img_crack_cropped->copyToScaling(img_crack_scaled); - // Copy or overlay crack image - if(use_overlay) - { - overlay(baseimg, img_crack_scaled); - } - else - { - /*img_crack_scaled->copyToWithAlpha( - baseimg, - v2s32(0,0), - core::rect(v2s32(0,0), dim_base), - video::SColor(255,255,255,255));*/ - blit_with_alpha(img_crack_scaled, baseimg, - v2s32(0,0), v2s32(0,0), dim_base); - } - } - - if(img_crack_scaled) - img_crack_scaled->drop(); - - if(img_crack_cropped) - img_crack_cropped->drop(); - + draw_crack(img_crack, baseimg, + use_overlay, frame_count, + progression, driver); img_crack->drop(); } } @@ -1499,37 +1450,6 @@ bool TextureSource::generateImage(std::string part_of_name, video::IImage *& bas return true; } -void overlay(video::IImage *image, video::IImage *overlay) -{ - /* - Copy overlay to image, taking alpha into account. - Where image is transparent, don't copy from overlay. - Images sizes must be identical. - */ - if(image == NULL || overlay == NULL) - return; - - core::dimension2d dim = image->getDimension(); - core::dimension2d dim_overlay = overlay->getDimension(); - assert(dim == dim_overlay); - - for(u32 y=0; ygetPixel(x,y); - video::SColor c2 = overlay->getPixel(x,y); - u32 a1 = c1.getAlpha(); - u32 a2 = c2.getAlpha(); - if(a1 == 255 && a2 != 0) - { - c1.setRed((c1.getRed()*(255-a2) + c2.getRed()*a2)/255); - c1.setGreen((c1.getGreen()*(255-a2) + c2.getGreen()*a2)/255); - c1.setBlue((c1.getBlue()*(255-a2) + c2.getBlue()*a2)/255); - } - image->setPixel(x,y,c1); - } -} - /* Draw an image on top of an another one, using the alpha channel of the source image @@ -1554,6 +1474,100 @@ static void blit_with_alpha(video::IImage *src, video::IImage *dst, } } +/* + Draw an image on top of an another one, using the alpha channel of the + source image; only modify fully opaque pixels in destinaion +*/ +static void blit_with_alpha_overlay(video::IImage *src, video::IImage *dst, + v2s32 src_pos, v2s32 dst_pos, v2u32 size) +{ + for(u32 y0=0; y0getPixel(src_x, src_y); + video::SColor dst_c = dst->getPixel(dst_x, dst_y); + if(dst_c.getAlpha() == 255 && src_c.getAlpha() != 0) + { + dst_c = src_c.getInterpolated(dst_c, (float)src_c.getAlpha()/255.0f); + dst->setPixel(dst_x, dst_y, dst_c); + } + } +} + +static void draw_crack(video::IImage *crack, video::IImage *dst, + bool use_overlay, u32 frame_count, u32 progression, + video::IVideoDriver *driver) +{ + // Dimension of destination image + core::dimension2d dim_dst = dst->getDimension(); + // Dimension of original image + core::dimension2d dim_crack = crack->getDimension(); + // Count of crack stages + u32 crack_count = dim_crack.Height / dim_crack.Width; + // Limit frame_count + if(frame_count > dim_dst.Height) + frame_count = dim_dst.Height; + if(frame_count == 0) + frame_count = 1; + // Limit progression + if(progression > crack_count-1) + progression = crack_count-1; + // Dimension of a single crack stage + core::dimension2d dim_crack_cropped( + dim_crack.Width, + dim_crack.Width + ); + // Dimension of the scaled crack stage, + // which is the same as the dimension of a single destination frame + core::dimension2d dim_crack_scaled( + dim_dst.Width, + dim_dst.Height / frame_count + ); + // Create cropped and scaled crack images + video::IImage *crack_cropped = driver->createImage( + video::ECF_A8R8G8B8, dim_crack_cropped); + video::IImage *crack_scaled = driver->createImage( + video::ECF_A8R8G8B8, dim_crack_scaled); + + if(crack_cropped && crack_scaled) + { + // Crop crack image + v2s32 pos_crack(0, progression*dim_crack.Width); + crack->copyTo(crack_cropped, + v2s32(0,0), + core::rect(pos_crack, dim_crack_cropped)); + // Scale crack image by copying + crack_cropped->copyToScaling(crack_scaled); + // Copy or overlay crack image onto each frame + for(u32 i = 0; i < frame_count; ++i) + { + v2s32 dst_pos(0, dim_crack_scaled.Height * i); + if(use_overlay) + { + blit_with_alpha_overlay(crack_scaled, dst, + v2s32(0,0), dst_pos, + dim_crack_scaled); + } + else + { + blit_with_alpha(crack_scaled, dst, + v2s32(0,0), dst_pos, + dim_crack_scaled); + } + } + } + + if(crack_scaled) + crack_scaled->drop(); + + if(crack_cropped) + crack_cropped->drop(); +} + void brighten(video::IImage *image) { if(image == NULL)