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<<tsrc->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)
ITextureSource *tsrc = m_gamedef->getTextureSource();
std::ostringstream os;
os<<basename<<crack;
- buf->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<u32, TileSpec>::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;
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);
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
<<std::endl;*/
/*
- [crackN
+ [crack:N:P
+ [cracko:N:P
Adds a cracking texture
+ N = animation frame count, P = crack progression
*/
if(part_of_name.substr(0,6) == "[crack")
{
<<"\", cancelling."<<std::endl;
return false;
}
-
+
// Crack image number and overlay option
- s32 progression = 0;
- bool use_overlay = false;
- if(part_of_name.substr(6,1) == "o")
- {
- progression = stoi(part_of_name.substr(7));
- use_overlay = true;
- }
- else
- {
- progression = stoi(part_of_name.substr(6));
- use_overlay = false;
- }
+ 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(":"));
- // Size of the base image
- core::dimension2d<u32> dim_base = baseimg->getDimension();
-
/*
Load crack image.
*/
video::IImage *img_crack = m_sourcecache.getOrLoad(
"crack_anylength.png", m_device);
-
+
if(img_crack && progression >= 0)
{
- // Dimension of original image
- core::dimension2d<u32> 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<u32> 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<s32>(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<s32>(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();
}
}
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<u32> dim = image->getDimension();
- core::dimension2d<u32> dim_overlay = overlay->getDimension();
- assert(dim == dim_overlay);
-
- for(u32 y=0; y<dim.Height; y++)
- for(u32 x=0; x<dim.Width; x++)
- {
- video::SColor c1 = image->getPixel(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
}
}
+/*
+ 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; y0<size.Y; y0++)
+ for(u32 x0=0; x0<size.X; x0++)
+ {
+ s32 src_x = src_pos.X + x0;
+ s32 src_y = src_pos.Y + y0;
+ s32 dst_x = dst_pos.X + x0;
+ s32 dst_y = dst_pos.Y + y0;
+ video::SColor src_c = src->getPixel(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<u32> dim_dst = dst->getDimension();
+ // Dimension of original image
+ core::dimension2d<u32> 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<u32> 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<u32> 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<s32>(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)
projects / oweals / minetest.git / commitdiff