void Sprite::remapImages(FrameNumber frameFrom, FrameNumber frameTo, const std::vector<uint8_t>& mapping)
{
ASSERT(m_format == IMAGE_INDEXED);
ASSERT(mapping.size() == 256);
CelList cels;
getCels(cels);
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
// Remap this Cel because is inside the specified range
if (cel->getFrame() >= frameFrom &&
cel->getFrame() <= frameTo) {
Image* image = getStock()->getImage(cel->getImage());
LockImageBits<IndexedTraits> bits(image);
LockImageBits<IndexedTraits>::iterator
it = bits.begin(),
end = bits.end();
for (; it != end; ++it)
*it = mapping[*it];
}
}
}
void RotateCommand::onExecute(Context* context)
{
ContextReader reader(context);
{
CelList cels;
bool rotateSprite = false;
// Flip the mask or current cel
if (m_flipMask) {
DocumentRange range = App::instance()->getMainWindow()->getTimeline()->range();
if (range.enabled())
cels = get_unique_cels(reader.sprite(), range);
else if (reader.cel())
cels.push_back(reader.cel());
}
// Flip the whole sprite
else if (reader.sprite()) {
for (Cel* cel : reader.sprite()->uniqueCels())
cels.push_back(cel);
rotateSprite = true;
}
if (cels.empty()) // Nothing to do
return;
RotateJob job(reader, m_angle, cels, rotateSprite);
job.startJob();
job.waitJob();
}
reader.document()->generateMaskBoundaries();
update_screen_for_document(reader.document());
}
size_t Sprite::getImageRefs(int imageIndex) const
{
CelList cels;
getCels(cels);
size_t refs = 0;
for (CelList::iterator it=cels.begin(), end=cels.end(); it != end; ++it)
if ((*it)->getImage() == imageIndex)
++refs;
return refs;
}
void RotateCommand::onExecute(Context* context)
{
{
Site site = context->activeSite();
CelList cels;
bool rotateSprite = false;
// Flip the mask or current cel
if (m_flipMask) {
auto range = App::instance()->timeline()->range();
if (range.enabled())
cels = get_unique_cels(site.sprite(), range);
else if (site.cel()) {
// If we want to rotate the visible mask for the current cel,
// we can go to MovingPixelsState.
if (static_cast<app::Document*>(site.document())->isMaskVisible()) {
// Select marquee tool
if (tools::Tool* tool = App::instance()->toolBox()
->getToolById(tools::WellKnownTools::RectangularMarquee)) {
ToolBar::instance()->selectTool(tool);
current_editor->startSelectionTransformation(gfx::Point(0, 0), m_angle);
return;
}
}
cels.push_back(site.cel());
}
}
// Flip the whole sprite
else if (site.sprite()) {
for (Cel* cel : site.sprite()->uniqueCels())
cels.push_back(cel);
rotateSprite = true;
}
if (cels.empty()) // Nothing to do
return;
ContextReader reader(context);
{
RotateJob job(reader, m_angle, cels, rotateSprite);
job.startJob();
job.waitJob();
}
reader.document()->generateMaskBoundaries();
update_screen_for_document(reader.document());
}
}
void LayerImage::getCels(CelList& cels) const
{
CelConstIterator it = getCelBegin();
CelConstIterator end = getCelEnd();
for (; it != end; ++it)
cels.push_back(*it);
}
// TODO the DocumentRange should be "iteratable" to replace this function
CelList get_cels_in_range(Sprite* sprite, const DocumentRange& range)
{
CelList cels;
for (LayerIndex layerIdx = range.layerBegin(); layerIdx <= range.layerEnd(); ++layerIdx) {
Layer* layer = sprite->indexToLayer(layerIdx);
if (!layer->isImage())
continue;
LayerImage* layerImage = static_cast<LayerImage*>(layer);
for (FrameNumber frame = range.frameEnd(),
begin = range.frameBegin().previous();
frame != begin;
frame = frame.previous()) {
Cel* cel = layerImage->getCel(frame);
if (cel)
cels.push_back(cel);
}
}
return cels;
}
void Sprite::remapImages(FrameNumber frameFrom, FrameNumber frameTo, const std::vector<uint8_t>& mapping)
{
ASSERT(m_format == IMAGE_INDEXED);
ASSERT(mapping.size() == 256);
CelList cels;
getCels(cels);
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
// Remap this Cel because is inside the specified range
if (cel->getFrame() >= frameFrom &&
cel->getFrame() <= frameTo) {
Image* image = getStock()->getImage(cel->getImage());
for (int y=0; y<image->h; ++y) {
IndexedTraits::address_t ptr = image_address_fast<IndexedTraits>(image, 0, y);
for (int x=0; x<image->w; ++x, ++ptr)
*ptr = mapping[*ptr];
}
}
}
}
void Sprite::pickCels(int x, int y, frame_t frame, int opacityThreshold, CelList& cels) const
{
std::vector<Layer*> layers;
getLayersList(layers);
for (int i=(int)layers.size()-1; i>=0; --i) {
Layer* layer = layers[i];
if (!layer->isImage() || !layer->isVisible())
continue;
Cel* cel = layer->cel(frame);
if (!cel)
continue;
Image* image = cel->image();
if (!image)
continue;
if (!cel->bounds().contains(gfx::Point(x, y)))
continue;
color_t color = get_pixel(image,
x - cel->x(),
y - cel->y());
bool isOpaque = true;
switch (image->pixelFormat()) {
case IMAGE_RGB:
isOpaque = (rgba_geta(color) >= opacityThreshold);
break;
case IMAGE_INDEXED:
isOpaque = (color != image->maskColor());
break;
case IMAGE_GRAYSCALE:
isOpaque = (graya_geta(color) >= opacityThreshold);
break;
}
if (!isOpaque)
continue;
cels.push_back(cel);
}
fflush(stdout);
}
void FlipCommand::onExecute(Context* context)
{
ContextWriter writer(context);
Document* document = writer.document();
Sprite* sprite = writer.sprite();
{
Transaction transaction(writer.context(),
m_flipMask ?
(m_flipType == doc::algorithm::FlipHorizontal ?
"Flip Horizontal":
"Flip Vertical"):
(m_flipType == doc::algorithm::FlipHorizontal ?
"Flip Canvas Horizontal":
"Flip Canvas Vertical"));
DocumentApi api = document->getApi(transaction);
CelList cels;
if (m_flipMask) {
auto range = App::instance()->timeline()->range();
if (range.enabled())
cels = get_unique_cels(sprite, range);
else if (writer.cel())
cels.push_back(writer.cel());
}
else {
for (Cel* cel : sprite->uniqueCels())
cels.push_back(cel);
}
Mask* mask = document->mask();
if (m_flipMask && document->isMaskVisible()) {
Site site = *writer.site();
for (Cel* cel : cels) {
site.frame(cel->frame());
site.layer(cel->layer());
int x, y;
Image* image = site.image(&x, &y);
if (!image)
continue;
// When the mask is inside the cel, we can try to flip the
// pixels inside the image.
if (cel->bounds().contains(mask->bounds())) {
gfx::Rect flipBounds = mask->bounds();
flipBounds.offset(-x, -y);
flipBounds &= image->bounds();
if (flipBounds.isEmpty())
continue;
if (mask->bitmap() && !mask->isRectangular())
transaction.execute(new cmd::FlipMaskedCel(cel, m_flipType));
else
api.flipImage(image, flipBounds, m_flipType);
if (cel->layer()->isTransparent())
transaction.execute(new cmd::TrimCel(cel));
}
// When the mask is bigger than the cel bounds, we have to
// expand the cel, make the flip, and shrink it again.
else {
gfx::Rect flipBounds = (sprite->bounds() & mask->bounds());
if (flipBounds.isEmpty())
continue;
ExpandCelCanvas expand(
site, cel->layer(),
TiledMode::NONE, transaction,
ExpandCelCanvas::None);
expand.validateDestCanvas(gfx::Region(flipBounds));
if (mask->bitmap() && !mask->isRectangular())
doc::algorithm::flip_image_with_mask(
expand.getDestCanvas(), mask, m_flipType,
document->bgColor(cel->layer()));
else
doc::algorithm::flip_image(
expand.getDestCanvas(),
flipBounds, m_flipType);
expand.commit();
}
}
}
else {
for (Cel* cel : cels) {
Image* image = cel->image();
api.setCelPosition
(sprite, cel,
(m_flipType == doc::algorithm::FlipHorizontal ?
sprite->width() - image->width() - cel->x():
cel->x()),
(m_flipType == doc::algorithm::FlipVertical ?
sprite->height() - image->height() - cel->y():
cel->y()));
api.flipImage(image, image->bounds(), m_flipType);
}
}
// Flip the mask.
Image* maskBitmap = mask->bitmap();
if (maskBitmap) {
transaction.execute(new cmd::FlipMask(document, m_flipType));
// Flip the mask position because the
if (!m_flipMask)
transaction.execute(
new cmd::SetMaskPosition(
document,
gfx::Point(
(m_flipType == doc::algorithm::FlipHorizontal ?
sprite->width() - mask->bounds().x2():
mask->bounds().x),
(m_flipType == doc::algorithm::FlipVertical ?
sprite->height() - mask->bounds().y2():
mask->bounds().y))));
document->generateMaskBoundaries();
}
transaction.commit();
}
update_screen_for_document(document);
}
/**
* [working thread]
*/
virtual void onJob()
{
UndoTransaction undoTransaction(m_writer.context(), "Rotate Canvas");
DocumentApi api = m_document->getApi();
// get all sprite cels
CelList cels;
m_sprite->getCels(cels);
// for each cel...
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
Image* image = m_sprite->getStock()->getImage(cel->getImage());
// change it location
switch (m_angle) {
case 180:
api.setCelPosition(m_sprite, cel,
m_sprite->getWidth() - cel->getX() - image->getWidth(),
m_sprite->getHeight() - cel->getY() - image->getHeight());
break;
case 90:
api.setCelPosition(m_sprite, cel,
m_sprite->getHeight() - cel->getY() - image->getHeight(),
cel->getX());
break;
case -90:
api.setCelPosition(m_sprite, cel,
cel->getY(),
m_sprite->getWidth() - cel->getX() - image->getWidth());
break;
}
}
// for each stock's image
for (int i=0; i<m_sprite->getStock()->size(); ++i) {
Image* image = m_sprite->getStock()->getImage(i);
if (!image)
continue;
// rotate the image
Image* new_image = Image::create(image->getPixelFormat(),
m_angle == 180 ? image->getWidth(): image->getHeight(),
m_angle == 180 ? image->getHeight(): image->getWidth());
raster::rotate_image(image, new_image, m_angle);
api.replaceStockImage(m_sprite, i, new_image);
jobProgress((float)i / m_sprite->getStock()->size());
// cancel all the operation?
if (isCanceled())
return; // UndoTransaction destructor will undo all operations
}
// rotate mask
if (m_document->isMaskVisible()) {
Mask* origMask = m_document->getMask();
base::UniquePtr<Mask> new_mask(new Mask());
const gfx::Rect& origBounds = origMask->getBounds();
int x = 0, y = 0;
switch (m_angle) {
case 180:
x = m_sprite->getWidth() - origBounds.x - origBounds.w;
y = m_sprite->getHeight() - origBounds.y - origBounds.h;
break;
case 90:
x = m_sprite->getHeight() - origBounds.y - origBounds.h;
y = origBounds.x;
break;
case -90:
x = origBounds.y;
y = m_sprite->getWidth() - origBounds.x - origBounds.w;
break;
}
// create the new rotated mask
new_mask->replace(x, y,
m_angle == 180 ? origBounds.w: origBounds.h,
m_angle == 180 ? origBounds.h: origBounds.w);
raster::rotate_image(origMask->getBitmap(), new_mask->getBitmap(), m_angle);
// Copy new mask
api.copyToCurrentMask(new_mask);
// Regenerate mask
m_document->resetTransformation();
m_document->generateMaskBoundaries();
}
// change the sprite's size
if (m_angle != 180)
api.setSpriteSize(m_sprite, m_sprite->getHeight(), m_sprite->getWidth());
// commit changes
undoTransaction.commit();
}
/**
* [working thread]
*/
virtual void onJob()
{
UndoTransaction undoTransaction(m_document, "Rotate Canvas");
// get all sprite cels
CelList cels;
m_sprite->getCels(cels);
// for each cel...
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
Image* image = m_sprite->getStock()->getImage(cel->getImage());
// change it location
switch (m_angle) {
case 180:
undoTransaction.setCelPosition(cel,
m_sprite->getWidth() - cel->getX() - image->w,
m_sprite->getHeight() - cel->getY() - image->h);
break;
case 90:
undoTransaction.setCelPosition(cel, m_sprite->getHeight() - cel->getY() - image->h, cel->getX());
break;
case -90:
undoTransaction.setCelPosition(cel, cel->getY(), m_sprite->getWidth() - cel->getX() - image->w);
break;
}
}
// for each stock's image
for (int i=0; i<m_sprite->getStock()->size(); ++i) {
Image* image = m_sprite->getStock()->getImage(i);
if (!image)
continue;
// rotate the image
Image* new_image = image_new(image->imgtype,
m_angle == 180 ? image->w: image->h,
m_angle == 180 ? image->h: image->w);
image_rotate(image, new_image, m_angle);
undoTransaction.replaceStockImage(i, new_image);
jobProgress((float)i / m_sprite->getStock()->size());
// cancel all the operation?
if (isCanceled())
return; // UndoTransaction destructor will undo all operations
}
// rotate mask
if (m_document->isMaskVisible()) {
Mask* origMask = m_document->getMask();
Mask* new_mask = mask_new();
int x = 0, y = 0;
switch (m_angle) {
case 180:
x = m_sprite->getWidth() - origMask->x - origMask->w;
y = m_sprite->getHeight() - origMask->y - origMask->h;
break;
case 90:
x = m_sprite->getHeight() - origMask->y - origMask->h;
y = origMask->x;
break;
case -90:
x = origMask->y;
y = m_sprite->getWidth() - origMask->x - origMask->w;
break;
}
// create the new rotated mask
mask_replace(new_mask, x, y,
m_angle == 180 ? origMask->w: origMask->h,
m_angle == 180 ? origMask->h: origMask->w);
image_rotate(origMask->bitmap, new_mask->bitmap, m_angle);
// copy new mask
undoTransaction.copyToCurrentMask(new_mask);
mask_free(new_mask);
// regenerate mask
m_document->generateMaskBoundaries();
}
// change the sprite's size
if (m_angle != 180)
undoTransaction.setSpriteSize(m_sprite->getHeight(), m_sprite->getWidth());
// commit changes
undoTransaction.commit();
}
void FlipCommand::onExecute(Context* context)
{
ContextWriter writer(context);
Document* document = writer.document();
Sprite* sprite = writer.sprite();
DocumentApi api = document->getApi();
{
UndoTransaction undoTransaction(writer.context(),
m_flipMask ?
(m_flipType == raster::algorithm::FlipHorizontal ?
"Flip Horizontal":
"Flip Vertical"):
(m_flipType == raster::algorithm::FlipHorizontal ?
"Flip Canvas Horizontal":
"Flip Canvas Vertical"));
if (m_flipMask) {
int x, y;
Image* image = writer.image(&x, &y);
if (!image)
return;
Mask* mask = NULL;
bool alreadyFlipped = false;
// This variable will be the area to be flipped inside the image.
gfx::Rect bounds(image->getBounds());
// If there is some portion of sprite selected, we flip the
// selected region only. If the mask isn't visible, we flip the
// whole image.
if (document->isMaskVisible()) {
mask = document->getMask();
// Intersect the full area of the image with the mask's
// bounds, so we don't request to flip an area outside the
// image's bounds.
bounds = bounds.createIntersect(gfx::Rect(mask->getBounds()).offset(-x, -y));
// If the mask isn't a rectangular area, we've to flip the mask too.
if (mask->getBitmap() != NULL && !mask->isRectangular()) {
int bgcolor = app_get_color_to_clear_layer(writer.layer());
// Flip the portion of image specified by the mask.
mask->offsetOrigin(-x, -y);
api.flipImageWithMask(image, mask, m_flipType, bgcolor);
mask->offsetOrigin(x, y);
alreadyFlipped = true;
// Flip the mask.
Image* maskBitmap = mask->getBitmap();
if (maskBitmap != NULL) {
// Create a flipped copy of the current mask.
base::UniquePtr<Mask> newMask(new Mask(*mask));
newMask->freeze();
raster::algorithm::flip_image(newMask->getBitmap(),
maskBitmap->getBounds(), m_flipType);
newMask->unfreeze();
// Change the current mask and generate the new boundaries.
api.copyToCurrentMask(newMask);
document->generateMaskBoundaries();
}
}
}
// Flip the portion of image specified by "bounds" variable.
if (!alreadyFlipped) {
api.flipImage(image, bounds, m_flipType);
}
}
else {
// get all sprite cels
CelList cels;
sprite->getCels(cels);
// for each cel...
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
Image* image = sprite->getStock()->getImage(cel->getImage());
api.setCelPosition
(sprite, cel,
(m_flipType == raster::algorithm::FlipHorizontal ?
sprite->getWidth() - image->getWidth() - cel->getX():
cel->getX()),
(m_flipType == raster::algorithm::FlipVertical ?
sprite->getHeight() - image->getHeight() - cel->getY():
cel->getY()));
api.flipImage(image, image->getBounds(), m_flipType);
}
}
undoTransaction.commit();
}
update_screen_for_document(document);
}
/**
* [working thread]
*/
virtual void onJob()
{
UndoTransaction undoTransaction(m_writer.context(), "Sprite Size");
DocumentApi api = m_writer.document()->getApi();
// Get all sprite cels
CelList cels;
m_sprite->getCels(cels);
// For each cel...
int progress = 0;
for (CelIterator it = cels.begin(); it != cels.end(); ++it, ++progress) {
Cel* cel = *it;
// Change its location
api.setCelPosition(m_sprite, cel, scale_x(cel->x()), scale_y(cel->y()));
// Get cel's image
Image* image = cel->image();
if (!image)
continue;
// Resize the image
int w = scale_x(image->width());
int h = scale_y(image->height());
Image* new_image = Image::create(image->pixelFormat(), MAX(1, w), MAX(1, h));
doc::algorithm::fixup_image_transparent_colors(image);
doc::algorithm::resize_image(image, new_image,
m_resize_method,
m_sprite->getPalette(cel->frame()),
m_sprite->getRgbMap(cel->frame()));
api.replaceStockImage(m_sprite, cel->imageIndex(), new_image);
jobProgress((float)progress / cels.size());
// cancel all the operation?
if (isCanceled())
return; // UndoTransaction destructor will undo all operations
}
// Resize mask
if (m_document->isMaskVisible()) {
base::UniquePtr<Image> old_bitmap
(crop_image(m_document->mask()->bitmap(), -1, -1,
m_document->mask()->bitmap()->width()+2,
m_document->mask()->bitmap()->height()+2, 0));
int w = scale_x(old_bitmap->width());
int h = scale_y(old_bitmap->height());
base::UniquePtr<Mask> new_mask(new Mask);
new_mask->replace(scale_x(m_document->mask()->bounds().x-1),
scale_y(m_document->mask()->bounds().y-1), MAX(1, w), MAX(1, h));
algorithm::resize_image(old_bitmap, new_mask->bitmap(),
m_resize_method,
m_sprite->getPalette(FrameNumber(0)), // Ignored
m_sprite->getRgbMap(FrameNumber(0))); // Ignored
// Reshrink
new_mask->intersect(new_mask->bounds());
// Copy new mask
api.copyToCurrentMask(new_mask);
// Regenerate mask
m_document->resetTransformation();
m_document->generateMaskBoundaries();
}
// resize sprite
api.setSpriteSize(m_sprite, m_new_width, m_new_height);
// commit changes
undoTransaction.commit();
}
// [working thread]
virtual void onJob()
{
Transaction transaction(m_writer.context(), "Rotate Canvas");
DocumentApi api = m_document->getApi(transaction);
// 1) Rotate cel positions
for (Cel* cel : m_cels) {
Image* image = cel->image();
if (!image)
continue;
switch (m_angle) {
case 180:
api.setCelPosition(m_sprite, cel,
m_sprite->width() - cel->x() - image->width(),
m_sprite->height() - cel->y() - image->height());
break;
case 90:
api.setCelPosition(m_sprite, cel,
m_sprite->height() - cel->y() - image->height(),
cel->x());
break;
case -90:
api.setCelPosition(m_sprite, cel,
cel->y(),
m_sprite->width() - cel->x() - image->width());
break;
}
}
// 2) Rotate images
int i = 0;
for (Cel* cel : m_cels) {
Image* image = cel->image();
if (image) {
ImageRef new_image(Image::create(image->pixelFormat(),
m_angle == 180 ? image->width(): image->height(),
m_angle == 180 ? image->height(): image->width()));
doc::rotate_image(image, new_image.get(), m_angle);
api.replaceImage(m_sprite, cel->imageRef(), new_image);
}
jobProgress((float)i / m_cels.size());
++i;
// cancel all the operation?
if (isCanceled())
return; // Transaction destructor will undo all operations
}
// rotate mask
if (m_document->isMaskVisible()) {
Mask* origMask = m_document->mask();
base::UniquePtr<Mask> new_mask(new Mask());
const gfx::Rect& origBounds = origMask->bounds();
int x = 0, y = 0;
switch (m_angle) {
case 180:
x = m_sprite->width() - origBounds.x - origBounds.w;
y = m_sprite->height() - origBounds.y - origBounds.h;
break;
case 90:
x = m_sprite->height() - origBounds.y - origBounds.h;
y = origBounds.x;
break;
case -90:
x = origBounds.y;
y = m_sprite->width() - origBounds.x - origBounds.w;
break;
}
// create the new rotated mask
new_mask->replace(
gfx::Rect(x, y,
m_angle == 180 ? origBounds.w: origBounds.h,
m_angle == 180 ? origBounds.h: origBounds.w));
doc::rotate_image(origMask->bitmap(), new_mask->bitmap(), m_angle);
// Copy new mask
api.copyToCurrentMask(new_mask);
// Regenerate mask
m_document->resetTransformation();
m_document->generateMaskBoundaries();
}
// change the sprite's size
if (m_rotateSprite && m_angle != 180)
api.setSpriteSize(m_sprite, m_sprite->height(), m_sprite->width());
// commit changes
transaction.commit();
}
void FilterManagerImpl::applyToTarget()
{
const bool paletteChange = paletteHasChanged();
bool cancelled = false;
CelList cels;
switch (m_celsTarget) {
case CelsTarget::Selected: {
auto range = App::instance()->timeline()->range();
if (range.enabled())
cels = get_unlocked_unique_cels(m_site.sprite(), range);
else if (m_site.cel() &&
m_site.layer() &&
m_site.layer()->isEditable()) {
cels.push_back(m_site.cel());
}
break;
}
case CelsTarget::All: {
for (Cel* cel : m_site.sprite()->uniqueCels()) {
if (cel->layer()->isEditable())
cels.push_back(cel);
}
break;
}
}
if (cels.empty() && !paletteChange) {
// We don't have images/palette changes to do (there will not be a
// transaction).
return;
}
// Initialize writting operation
ContextReader reader(m_context);
ContextWriter writer(reader);
m_transaction.reset(new Transaction(writer.context(), m_filter->getName(), ModifyDocument));
m_progressBase = 0.0f;
m_progressWidth = (cels.size() > 0 ? 1.0f / cels.size(): 1.0f);
std::set<ObjectId> visited;
// Palette change
if (paletteChange) {
Palette newPalette = *getNewPalette();
restoreSpritePalette();
m_transaction->execute(
new cmd::SetPalette(m_site.sprite(),
m_site.frame(), &newPalette));
}
// For each target image
for (auto it = cels.begin();
it != cels.end() && !cancelled;
++it) {
Image* image = (*it)->image();
// Avoid applying the filter two times to the same image
if (visited.find(image->id()) == visited.end()) {
visited.insert(image->id());
applyToCel(*it);
}
// Is there a delegate to know if the process was cancelled by the user?
if (m_progressDelegate)
cancelled = m_progressDelegate->isCancelled();
// Make progress
m_progressBase += m_progressWidth;
}
// Reset m_oldPalette to avoid restoring the color palette
m_oldPalette.reset(nullptr);
}