int key_pressed(int kc, t_env *e)
{
key_pressed_split(kc, e);
key_pressed_splitted_split(kc, e);
if (kc == KEY_ESC)
exit(1);
if (kc == KEY_P || kc == KEY_O)
e->puissance += kc == KEY_P ? 1 : -1;
if (kc == KEY_PLUS || kc == KEY_MOINS)
e->nb_it += kc == KEY_PLUS ? 5 : -5;
if (kc == LEFT || kc == RIGHT)
{
e->re_min += kc == LEFT ? e->pixel_size * 50 : e->pixel_size * (-50);
e->re_max += kc == LEFT ? e->pixel_size * 50 : e->pixel_size * (-50);
}
if (kc == UP || kc == DOWN)
{
e->im_min -= kc == DOWN ? e->pixel_size * 50 : e->pixel_size * (-50);
e->im_max -= kc == DOWN ? e->pixel_size * 50 : e->pixel_size * (-50);
}
if (e->ens == 0)
return (1);
clear_image(&e->img_address);
mlx_clear_window(e->mlx, e->win);
e->draw_fract(e);
return (1);
}
int key_pressed(int kc, t_eve *e)
{
if (kc == 53)
exit(1);
if (kc == 69)
e->zfact *= 1.5;
if (kc == 78)
e->zfact /= e->zfact > 0.005 ? 1.5 : 1;
if (kc == 125 || kc == 126)
e->y0 += kc == 125 ? 20 : -20;
if (kc == 123 || kc == 124)
e->x0 += kc == 123 ? -20 : 20;
if (kc >= 82 && kc <= 92)
rotates(kc, e);
if (kc == 35 || kc == 34 || kc == 8)
change_proj(kc, e);
if (!e->persp)
recalc_coords(e);
else
recalc_persp_coords(e);
clear_image(&e->img_address);
draw_in_im(e);
mlx_clear_window(e->mlx, e->win);
mlx_put_image_to_window(e->mlx, e->win, e->img, 0, 0);
if (kc == 71)
mlx_clear_window(e->mlx, e->win);
return (1);
}
void line_fill(GtkWidget *button, void *user_data)
{
do_the_job = true;
clear_image(button, user_data);
for(int i = 0; i < pixbuf->_width / pixbuf->_scale; i++)
{
pixbuf->point(i, i, 0, 0, 0);
};
points.erase(points.begin(), points.end());
std::shared_ptr<cords> point(new cords);
point->x = (pixbuf->_width / pixbuf->_scale) / 3;
point->y = (pixbuf->_height / pixbuf->_scale) * 3 / 5;
points.push_back(point);
for(int i = 0; i < 101; i++)
for(int l = 0; l < 101; l++)
sprawdzony[i][l] = false;
sprawdzony[point->x][point->y] = true;
g_timeout_add(1, fill_to_line, 0);
};
int expose_hook(t_env *e)
{
clear_image(e);
pos_in_map(e);
wall_dist(e);
mlx_clear_window(e->mlx, e->win);
mlx_put_image_to_window(e->mlx, e->win, e->img.i, 0, 0);
put_visor(e);
return (0);
}
int read_jpg_format (FILE *file, Image *img)
{
clear_image(img);
//fprintf(stderr, "read_jpg_format\n");
if(img->encoding == IMG_COL_TYPE)
return read_jpg_256_colors(file, img);
else
return read_jpg_2_colors(file, img);
}
void cleanup (image *photo, char **argv)
{
int rc = write_image (argv [2], photo);
if (!rc)
{
fprintf (stderr, "Unable to write output file %s\n\n", argv [2]);
}
clear_image (photo);
}
Image* crop_image(const Image* image, int x, int y, int w, int h, color_t bg, const ImageBufferPtr& buffer)
{
if (w < 1) throw std::invalid_argument("image_crop: Width is less than 1");
if (h < 1) throw std::invalid_argument("image_crop: Height is less than 1");
Image* trim = Image::create(image->pixelFormat(), w, h, buffer);
trim->setMaskColor(image->maskColor());
clear_image(trim, bg);
trim->copy(image, 0, 0, x, y, w, h);
return trim;
}
int Sprite::getPixel(int x, int y, FrameNumber frame) const
{
int color = 0;
if ((x >= 0) && (y >= 0) && (x < m_width) && (y < m_height)) {
base::UniquePtr<Image> image(Image::create(m_format, 1, 1));
clear_image(image, (m_format == IMAGE_INDEXED ? getTransparentColor(): 0));
render(image, -x, -y, frame);
color = get_pixel(image, 0, 0);
}
return color;
}
/* **slide\_title\_in()**, **slide\_title\_out()** and
* **bling\_title()** are used by the level
* timeline to animate the title.
*
* We use cosine interpolation to slide the title in
* and out, creating a smoother effect.
*
* **progress** will hold a value between 0 to 1
* based on the event progess/duration, making it ideal
* for use with interpolation functions.
*/
static void* before_title_in(void* data, float elapsed_ms, float progress)
{
struct rectangle c = { 0, 0, 192, 108 };
struct rectangle r = { 0, 0, 64, 64 };
struct level_data* ldata = data;
UNUSED(elapsed_ms);
UNUSED(progress);
clear_image(ldata->title.mask, color_from_RGB(0, 0, 0));
draw_on_image(ldata->title.mask);
draw_image(ldata->title.spot, -15, 40, &r, 0);
draw_on_screen();
draw_image(ldata->title.mask, 0, 0, &c, 0);
return NULL;
}
static void* slide_title_in(void* data, float elapsed_ms, float progress)
{
struct rectangle c = { 0, 0, 192, 108 };
struct rectangle r = { 0, 0, 64, 64 };
struct level_data* ldata = data;
UNUSED(elapsed_ms);
clear_image(ldata->title.mask,
color_from_RGB(255 * progress, 255 * progress, 255 * progress));
draw_on_image(ldata->title.mask);
draw_image(ldata->title.spot, -15, 40, &r, 0);
draw_on_screen();
draw_image(ldata->title.mask, 0, 0, &c, 0);
draw_sprite(ldata->title.sprite,
interpolate(-100, 20, progress, circular_ease_out), 10);
return NULL;
}
void PixelsMovement::drawMask(doc::Mask* mask, bool shrink)
{
gfx::Transformation::Corners corners;
m_currentData.transformBox(corners);
gfx::Rect bounds = corners.bounds();
mask->replace(bounds);
if (shrink)
mask->freeze();
clear_image(mask->bitmap(), 0);
drawParallelogram(mask->bitmap(),
m_initialMask->bitmap(),
nullptr,
corners, bounds.origin());
if (shrink)
mask->unfreeze();
}
int mouse_button(int button, int x, int y, t_eve *e)
{
if (button == 1)
{
e->x0 = x;
e->y0 = y;
}
if (button == 4)
e->ec = ft_round(e->ec * 0.75);
if (button == 5)
e->ec = ft_round(e->ec * 1.25);
if (!e->persp)
recalc_coords(e);
else
recalc_persp_coords(e);
clear_image(&e->img_address);
draw_in_im(e);
mlx_clear_window(e->mlx, e->win);
mlx_put_image_to_window(e->mlx, e->win, e->img, 0, 0);
return (1);
}
void TaskButton::update_image_from_xid(void) {
E_RETURN_IF_FAIL(xid >= 0);
Fl_RGB_Image *img = netwm_window_get_icon(xid, TASKBUTTON_ICON_W);
if(!img) return;
int width = img->w(), height = img->h();
/* some safety, scale it if needed */
if((width > TASKBUTTON_ICON_W) || (height > TASKBUTTON_ICON_H)) {
width = (width > TASKBUTTON_ICON_W) ? TASKBUTTON_ICON_W : width;
height = (height > TASKBUTTON_ICON_H) ? TASKBUTTON_ICON_H : height;
/* safe casting */
Fl_RGB_Image *scaled = (Fl_RGB_Image*)img->copy(width, height);
delete img;
img = scaled;
}
clear_image();
image(img);
image_alloc = true;
}
t_image* load_image(const char* path)
{
t_bitmap_header bmp;
t_image* img;
int fd;
unsigned int i;
unsigned int j;
int ppl;
if ((fd = open (path, 0)) < 0)
return NULL;
/*
* read the BMP header and extract data.
*/
if (read (fd, &bmp, sizeof(t_bitmap_header)) != sizeof(t_bitmap_header) ||
bmp.signature[0] != 'B' || bmp.signature[1] != 'M' ||
!(img = malloc (sizeof (t_image))))
{
close (fd);
return NULL;
}
img->width = bmp.width;
img->height = bmp.height;
/*
* build the image.
*/
if (!(img->data = malloc (img->height * sizeof (unsigned char*))))
{
free (img);
close (fd);
return NULL;
}
for (i = 0; i < img->height; i++)
if (!(img->data[i] = malloc (img->width)))
{
for (j = 0; j < i; j++)
free (img->data[j]);
free (img->data);
free (img);
close (fd);
return NULL;
}
ppl = (bmp.size - (img->width * img->height)) / img->height;
if (seek (fd, bmp.offset, SEEK_SET) == (off_t)-1)
{
clear_image (img);
close (fd);
return NULL;
}
for (i = 0; i < img->height; i++)
{
if (read (fd, img->data[i], img->width) != (int)img->width ||
seek (fd, ppl, SEEK_CUR) == (off_t)-1)
{
clear_image (img);
close (fd);
return NULL;
}
}
close (fd);
return img;
}
void BackgroundFromLayer::onExecute()
{
Layer* layer = this->layer();
Sprite* sprite = layer->sprite();
app::Document* doc = static_cast<app::Document*>(sprite->document());
color_t bgcolor = doc->bgColor();
// create a temporary image to draw each frame of the new
// `Background' layer
ImageRef bg_image(Image::create(sprite->pixelFormat(),
sprite->width(),
sprite->height()));
CelList cels;
layer->getCels(cels);
for (Cel* cel : cels) {
// get the image from the sprite's stock of images
Image* cel_image = cel->image();
ASSERT(cel_image);
clear_image(bg_image.get(), bgcolor);
render::composite_image(
bg_image.get(), cel_image,
sprite->palette(cel->frame()),
cel->x(), cel->y(),
MID(0, cel->opacity(), 255),
static_cast<LayerImage*>(layer)->blendMode());
// now we have to copy the new image (bg_image) to the cel...
executeAndAdd(new cmd::SetCelPosition(cel, 0, 0));
// change opacity to 255
if (cel->opacity() < 255)
executeAndAdd(new cmd::SetCelOpacity(cel, 255));
// same size of cel-image and bg-image
if (bg_image->width() == cel_image->width() &&
bg_image->height() == cel_image->height()) {
executeAndAdd(new CopyRect(cel_image, bg_image.get(),
gfx::Clip(0, 0, cel_image->bounds())));
}
else {
ImageRef bg_image2(Image::createCopy(bg_image.get()));
executeAndAdd(new cmd::ReplaceImage(sprite, cel->imageRef(), bg_image2));
}
}
// Fill all empty cels with a flat-image filled with bgcolor
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
Cel* cel = layer->cel(frame);
if (!cel) {
ImageRef cel_image(Image::create(sprite->pixelFormat(),
sprite->width(), sprite->height()));
clear_image(cel_image.get(), bgcolor);
// Create the new cel and add it to the new background layer
cel = new Cel(frame, cel_image);
executeAndAdd(new cmd::AddCel(layer, cel));
}
}
executeAndAdd(new cmd::ConfigureBackground(layer));
}
void FlattenLayers::onExecute()
{
Sprite* sprite = this->sprite();
auto doc = static_cast<Doc*>(sprite->document());
// Create a temporary image.
ImageRef image(Image::create(sprite->pixelFormat(),
sprite->width(),
sprite->height()));
LayerImage* flatLayer; // The layer onto which everything will be flattened.
color_t bgcolor; // The background color to use for flatLayer.
flatLayer = sprite->backgroundLayer();
if (flatLayer && flatLayer->isVisible()) {
// There exists a visible background layer, so we will flatten onto that.
bgcolor = doc->bgColor(flatLayer);
}
else {
// Create a new transparent layer to flatten everything onto.
flatLayer = new LayerImage(sprite);
ASSERT(flatLayer->isVisible());
executeAndAdd(new cmd::AddLayer(sprite->root(), flatLayer, nullptr));
executeAndAdd(new cmd::SetLayerName(flatLayer, "Flattened"));
bgcolor = sprite->transparentColor();
}
render::Render render;
render.setBgType(render::BgType::NONE);
// Copy all frames to the background.
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
// Clear the image and render this frame.
clear_image(image.get(), bgcolor);
render.renderSprite(image.get(), sprite, frame);
// TODO Keep cel links when possible
ImageRef cel_image;
Cel* cel = flatLayer->cel(frame);
if (cel) {
if (cel->links())
executeAndAdd(new cmd::UnlinkCel(cel));
cel_image = cel->imageRef();
ASSERT(cel_image);
executeAndAdd(new cmd::CopyRect(cel_image.get(), image.get(),
gfx::Clip(0, 0, image->bounds())));
}
else {
cel_image.reset(Image::createCopy(image.get()));
cel = new Cel(frame, cel_image);
flatLayer->addCel(cel);
}
}
// Delete old layers.
LayerList layers = sprite->root()->layers();
for (Layer* layer : layers)
if (layer != flatLayer)
executeAndAdd(new cmd::RemoveLayer(layer));
}
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
AVFilterContext *ctx = inlink->dst;
DrawGraphContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVDictionary *metadata;
AVDictionaryEntry *e;
AVFrame *out = s->out;
int i;
if (!s->out || s->out->width != outlink->w ||
s->out->height != outlink->h) {
av_frame_free(&s->out);
s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
out = s->out;
if (!s->out) {
av_frame_free(&in);
return AVERROR(ENOMEM);
}
clear_image(s, out, outlink);
}
av_frame_copy_props(out, in);
metadata = av_frame_get_metadata(in);
for (i = 0; i < 4; i++) {
double values[VAR_VARS_NB];
int j, y, x, old;
uint32_t fg, bg;
float vf;
e = av_dict_get(metadata, s->key[i], NULL, 0);
if (!e || !e->value)
continue;
if (sscanf(e->value, "%f", &vf) != 1)
continue;
vf = av_clipf(vf, s->min, s->max);
values[VAR_MIN] = s->min;
values[VAR_MAX] = s->max;
values[VAR_VAL] = vf;
fg = av_expr_eval(s->fg_expr[i], values, NULL);
bg = AV_RN32(s->bg);
if (i == 0 && s->x >= outlink->w) {
if (s->slide == 0 || s->slide == 1)
s->x = 0;
if (s->slide == 2) {
s->x = outlink->w - 1;
for (j = 0; j < outlink->h; j++) {
memmove(out->data[0] + j * out->linesize[0] ,
out->data[0] + j * out->linesize[0] + 4,
(outlink->w - 1) * 4);
}
} else if (s->slide == 0) {
clear_image(s, out, outlink);
}
}
x = s->x;
y = (outlink->h - 1) * (1 - ((vf - s->min) / (s->max - s->min)));
switch (s->mode) {
case 0:
if (i == 0 && (s->slide == 1 || s->slide == 2))
for (j = 0; j < outlink->h; j++)
draw_dot(bg, x, j, out);
old = AV_RN32(out->data[0] + y * out->linesize[0] + x * 4);
for (j = y; j < outlink->h; j++) {
if (old != bg &&
(AV_RN32(out->data[0] + j * out->linesize[0] + x * 4) != old) ||
AV_RN32(out->data[0] + FFMIN(j+1, outlink->h - 1) * out->linesize[0] + x * 4) != old) {
draw_dot(fg, x, j, out);
break;
}
draw_dot(fg, x, j, out);
}
break;
case 1:
if (i == 0 && (s->slide == 1 || s->slide == 2))
for (j = 0; j < outlink->h; j++)
draw_dot(bg, x, j, out);
draw_dot(fg, x, y, out);
break;
case 2:
if (s->first) {
s->first = 0;
s->prev_y[i] = y;
}
if (i == 0 && (s->slide == 1 || s->slide == 2)) {
for (j = 0; j < y; j++)
draw_dot(bg, x, j, out);
for (j = outlink->h - 1; j > y; j--)
draw_dot(bg, x, j, out);
}
if (y <= s->prev_y[i]) {
for (j = y; j <= s->prev_y[i]; j++)
draw_dot(fg, x, j, out);
} else {
for (j = s->prev_y[i]; j <= y; j++)
draw_dot(fg, x, j, out);
}
s->prev_y[i] = y;
break;
}
}
s->x++;
av_frame_free(&in);
return ff_filter_frame(outlink, av_frame_clone(s->out));
}
/**
Draws the @a frame of animation of the specified @a sprite
in a new image and return it.
Positions source_x, source_y, width and height must have the
zoom applied (zoom.apply(sorce_x), zoom.apply(source_y), zoom.apply(width), etc.)
*/
Image* RenderEngine::renderSprite(int source_x, int source_y,
int width, int height,
FrameNumber frame, Zoom zoom,
bool draw_tiled_bg,
bool enable_onionskin,
ImageBufferPtr& buffer)
{
void (*zoomed_func)(Image*, const Image*, const Palette*, int, int, int, int, Zoom);
const LayerImage* background = m_sprite->backgroundLayer();
bool need_checked_bg = (background != NULL ? !background->isVisible(): true);
uint32_t bg_color = 0;
Image *image;
switch (m_sprite->pixelFormat()) {
case IMAGE_RGB:
zoomed_func = merge_zoomed_image<RgbTraits, RgbTraits>;
break;
case IMAGE_GRAYSCALE:
zoomed_func = merge_zoomed_image<RgbTraits, GrayscaleTraits>;
break;
case IMAGE_INDEXED:
zoomed_func = merge_zoomed_image<RgbTraits, IndexedTraits>;
if (!need_checked_bg)
bg_color = m_sprite->getPalette(frame)->getEntry(m_sprite->transparentColor());
break;
default:
return NULL;
}
// Create a temporary RGB bitmap to draw all to it
image = Image::create(IMAGE_RGB, width, height, buffer);
if (!image)
return NULL;
// Draw checked background
if (need_checked_bg && draw_tiled_bg)
renderCheckedBackground(image, source_x, source_y, zoom);
else
clear_image(image, bg_color);
// Draw the current frame.
global_opacity = 255;
renderLayer(m_sprite->folder(), image,
source_x, source_y, frame, zoom, zoomed_func, true, true, -1);
// Onion-skin feature: Draw previous/next frames with different
// opacity (<255) (it is the onion-skinning)
IDocumentSettings* docSettings = UIContext::instance()
->settings()->getDocumentSettings(m_document);
if (enable_onionskin & docSettings->getUseOnionskin()) {
int prevs = docSettings->getOnionskinPrevFrames();
int nexts = docSettings->getOnionskinNextFrames();
int opacity_base = docSettings->getOnionskinOpacityBase();
int opacity_step = docSettings->getOnionskinOpacityStep();
for (FrameNumber f=frame.previous(prevs); f <= frame.next(nexts); ++f) {
if (f == frame || f < 0 || f > m_sprite->lastFrame())
continue;
else if (f < frame)
global_opacity = opacity_base - opacity_step * ((frame - f)-1);
else
global_opacity = opacity_base - opacity_step * ((f - frame)-1);
if (global_opacity > 0) {
global_opacity = MID(0, global_opacity, 255);
int blend_mode = -1;
if (docSettings->getOnionskinType() == IDocumentSettings::Onionskin_Merge)
blend_mode = BLEND_MODE_NORMAL;
else if (docSettings->getOnionskinType() == IDocumentSettings::Onionskin_RedBlueTint)
blend_mode = (f < frame ? BLEND_MODE_RED_TINT: BLEND_MODE_BLUE_TINT);
renderLayer(m_sprite->folder(), image,
source_x, source_y, f, zoom, zoomed_func,
true, true, blend_mode);
}
}
}
return image;
}
int welcome_main()
{
int i,j;
int mx,my;
int welcome = true;
int option_screen = false;
int score_screen = false;
int first_run = true;
int credits_screen = false;
SDL_Rect temp;
TTF_Font *MyFont;
SDL_Color GREEN = {0,255,0};
SDL_Color WHITE = {255,255,255};
SDL_Surface *message = NULL;
int option = -1;
init_buttons();
init_images();
draw_image(backk,screen,NULL,0,0);
gameLog("Welcome screen initialized...");
//draw_image(message,screen,NULL,0,0);
//Mix_PlayMusic(background_music,-1);
while(welcome)
{
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_MOUSEMOTION:
for(i=0;i<TOTAL_NO_BUTTON;++i)
{
handle_mouseover(&button[i],event.motion.x,event.motion.y);
}
break;
case SDL_MOUSEBUTTONDOWN:
mx = event.button.x;
my = event.button.y;
for( i = 0; i < TOTAL_NO_BUTTON; ++i)
{
if(check_click(button[i],mx,my)==true)
{
if(sound)Mix_PlayChannel(-1,click_sound,4);
animate_button(button[i],i);
first_run = true;
switch(i)
{
case 0:
option = 1;
welcome = false;
break;
case 1:
option_screen = true;
break;
case 2:
score_screen = true;
break;
case 3:
credits_screen = true;
break;
case 4:
option = -1;
welcome = false;
break;
}
}
}
break;
case SDL_QUIT:
welcome = false;
option = -1;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_p:
animate_button(button[0],0);
welcome = false;
option = 1;
break;
case SDLK_x:
animate_button(button[4],4);
welcome = false;
option = -1;
break;
case SDLK_1:
if(Mix_PlayingMusic() == 0)
{
Mix_PlayMusic(background_music,-1);
}
else
{
if(Mix_PausedMusic() == 1)
{
sound = true;
Mix_ResumeMusic();
}
else
{
sound = false;
Mix_PauseMusic();
}
}
break;
case SDLK_0:
Mix_HaltMusic();
break;
}
}
}
//---=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
while(option_screen == true)
{
if(first_run)
{
draw_image(option_screen_image,screen,NULL,0,0);
draw_image(back_button_image,screen,NULL,back_button.dimension.x, back_button.dimension.y);
first_run = false;
}
draw_image(sound_icon[sound],screen,NULL,sound_button.dimension.x,sound_button.dimension.y);
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_MOUSEBUTTONDOWN:
if(sound)Mix_PlayChannel(-1,click_sound,0);
mx = event.button.x;
my = event.button.y;
if(check_click(sound_button,mx,my) == true)
{
if(sound == 0) sound = 1;
else sound =0;
}
if(check_click(back_button,mx,my)== true)
{
draw_image(backk,screen,NULL,0,0);
option_screen = false;
}
}
}
SDL_Flip(screen);
}
//==========================================================================================
while(score_screen == true)
{
if(first_run)
{
draw_image(score_screen_image,screen,NULL,0,0);
draw_image(back_button_image,screen,NULL,back_button.dimension.x, back_button.dimension.y);
show_scores();
first_run = false;
}
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_MOUSEBUTTONDOWN:
if(sound)Mix_PlayChannel(-1,click_sound,0);
mx = event.button.x;
my = event.button.y;
if(check_click(back_button,mx,my)== true)
{
draw_image(backk,screen,NULL,0,0);
score_screen = false;
}
}
}
SDL_Flip(screen);
}
//==========================================================================================
//==========================================================================================
while(credits_screen == true)
{
if(first_run)
{
temp.x = 0;
temp.y = 0;
temp.w = 1100;
temp.h = 600;
clear_image(temp);
MyFont = TTF_OpenFont("fonts\\lfont.ttf",32);
message = TTF_RenderText_Blended(MyFont,"Developed By:",WHITE);
draw_image(message,screen,NULL,100,100);
SDL_FreeSurface(message);
message = NULL;
TTF_CloseFont(MyFont);
MyFont = TTF_OpenFont("fonts\\sfont.ttf",20);
message = TTF_RenderText_Blended(MyFont,"-> Bishruti Siku",GREEN);
draw_image(message,screen,NULL,100,150);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"-> Nitish Dhaubhadel",GREEN);
draw_image(message,screen,NULL,100,170);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"-> Iksha Gurung",GREEN);
draw_image(message,screen,NULL,100,190);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"-> Pranaya Pradhananga",GREEN);
draw_image(message,screen,NULL,100,210);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"-> Sandip Sahani",GREEN);
draw_image(message,screen,NULL,100,230);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"Computer Engineering",WHITE);
draw_image(message,screen,NULL,100,300);
SDL_FreeSurface(message);
message = NULL;
message = TTF_RenderText_Blended(MyFont,"Kathmandu University",WHITE);
draw_image(message,screen,NULL,100,320);
SDL_FreeSurface(message);
message = NULL;
draw_image(back_button_image,screen,NULL,back_button.dimension.x, back_button.dimension.y);
first_run = false;
}
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_MOUSEBUTTONDOWN:
if(sound)Mix_PlayChannel(-1,click_sound,0);
mx = event.button.x;
my = event.button.y;
if(check_click(back_button,mx,my)== true)
{
draw_image(backk,screen,NULL,0,0);
credits_screen = false;
}
}
}
SDL_Flip(screen);
}
//==========================================================================================
for(i=0;i<TOTAL_NO_BUTTON;++i)
{
draw_image(button_image[i][button[i].state],screen,NULL,button[i].dimension.x,button[i].dimension.y);
}
SDL_Flip(screen);
}
SDL_FreeSurface(option_screen_image);
SDL_FreeSurface(score_screen_image);
SDL_FreeSurface(back_button_image);
SDL_FreeSurface(sound_icon[0]);
SDL_FreeSurface(sound_icon[1]);
SDL_FreeSurface(message);
message = NULL;
SDL_FreeSurface(backk);
for(i=0;i<TOTAL_NO_BUTTON;++i)
{
for(j=0;j<2;++j)
{
SDL_FreeSurface(button_image[i][j]);
}
}
//TTF_CloseFont(font);
gameLog("Welcome screen closed...");
return option;
}
bool FliFormat::onSave(FileOp* fop)
{
Sprite* sprite = fop->document->getSprite();
unsigned char cmap[768];
unsigned char omap[768];
s_fli_header fli_header;
int c, times;
Palette *pal;
/* prepare fli header */
fli_header.filesize = 0;
fli_header.frames = 0;
fli_header.width = sprite->getWidth();
fli_header.height = sprite->getHeight();
if ((fli_header.width == 320) && (fli_header.height == 200))
fli_header.magic = HEADER_FLI;
else
fli_header.magic = HEADER_FLC;
fli_header.depth = 8;
fli_header.flags = 3;
fli_header.speed = get_time_precision(sprite);
fli_header.created = 0;
fli_header.updated = 0;
fli_header.aspect_x = 1;
fli_header.aspect_y = 1;
fli_header.oframe1 = fli_header.oframe2 = 0;
/* open the file to write in binary mode */
FileHandle f(open_file_with_exception(fop->filename, "wb"));
fseek(f, 128, SEEK_SET);
// Create the bitmaps
base::UniquePtr<Image> bmp(Image::create(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight()));
base::UniquePtr<Image> old(Image::create(IMAGE_INDEXED, sprite->getWidth(), sprite->getHeight()));
// Write frame by frame
for (FrameNumber frpos(0);
frpos < sprite->getTotalFrames();
++frpos) {
/* get color map */
pal = sprite->getPalette(frpos);
for (c=0; c<256; c++) {
cmap[3*c ] = rgba_getr(pal->getEntry(c));
cmap[3*c+1] = rgba_getg(pal->getEntry(c));
cmap[3*c+2] = rgba_getb(pal->getEntry(c));
}
/* render the frame in the bitmap */
clear_image(bmp, 0);
layer_render(sprite->getFolder(), bmp, 0, 0, frpos);
/* how many times this frame should be written to get the same
time that it has in the sprite */
times = sprite->getFrameDuration(frpos) / fli_header.speed;
for (c=0; c<times; c++) {
/* write this frame */
if (frpos == 0 && c == 0)
fli_write_frame(f, &fli_header, NULL, NULL,
(unsigned char *)bmp->getPixelAddress(0, 0), cmap, W_ALL);
else
fli_write_frame(f, &fli_header,
(unsigned char *)old->getPixelAddress(0, 0), omap,
(unsigned char *)bmp->getPixelAddress(0, 0), cmap, W_ALL);
/* update the old image and color-map to the new ones to compare later */
copy_image(old, bmp, 0, 0);
memcpy(omap, cmap, 768);
}
/* update progress */
fop_progress(fop, (float)(frpos.next()) / (float)(sprite->getTotalFrames()));
}
// Write the header and close the file
fli_write_header(f, &fli_header);
return true;
}
void BackgroundFromLayer::onExecute()
{
Layer* layer = this->layer();
Sprite* sprite = layer->sprite();
auto doc = static_cast<Doc*>(sprite->document());
color_t bgcolor = doc->bgColor();
// Create a temporary image to draw each cel of the new Background
// layer.
ImageRef bg_image(Image::create(sprite->pixelFormat(),
sprite->width(),
sprite->height()));
CelList cels;
layer->getCels(cels);
for (Cel* cel : cels) {
Image* cel_image = cel->image();
ASSERT(cel_image);
clear_image(bg_image.get(), bgcolor);
render::composite_image(
bg_image.get(), cel_image,
sprite->palette(cel->frame()),
cel->x(), cel->y(),
MID(0, cel->opacity(), 255),
static_cast<LayerImage*>(layer)->blendMode());
// now we have to copy the new image (bg_image) to the cel...
executeAndAdd(new cmd::SetCelPosition(cel, 0, 0));
// change opacity to 255
if (cel->opacity() < 255)
executeAndAdd(new cmd::SetCelOpacity(cel, 255));
// Same size of cel image and background image, we can just
// replace pixels.
if (bg_image->width() == cel_image->width() &&
bg_image->height() == cel_image->height()) {
executeAndAdd(new CopyRect(cel_image, bg_image.get(),
gfx::Clip(0, 0, cel_image->bounds())));
}
// In other case we have to replace the whole image (this is the
// most common case, a smaller transparent cel that is converted
// to a canvas size cel in the background)
else {
ImageRef bg_image2(Image::createCopy(bg_image.get()));
executeAndAdd(new cmd::ReplaceImage(sprite, cel->imageRef(), bg_image2));
}
}
// Fill all empty cels with a flat image filled with bgcolor
for (frame_t frame(0); frame<sprite->totalFrames(); ++frame) {
Cel* cel = layer->cel(frame);
if (!cel) {
ImageRef cel_image(Image::create(sprite->pixelFormat(),
sprite->width(), sprite->height()));
clear_image(cel_image.get(), bgcolor);
// Create the new cel and add it to the new background layer
cel = new Cel(frame, cel_image);
executeAndAdd(new cmd::AddCel(layer, cel));
}
}
executeAndAdd(new cmd::ConfigureBackground(layer));
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
Window *main_window = new Window();
main_window->resize(-1,-1);
VBox *main_vbox = new VBox();
HBox *menu_hbox = new HBox();
pixbuf = new Pixbuf();
pixbuf->set_scale(5);
image = new Image();
image->set_from_pixbuf(pixbuf);
menu_hbox->add(image, 1, 1, 0);
VBox *s_vbox = new VBox();
Label *label = new Label("Sąsiedztwo: ");
s_vbox->add(label, 1, 1, 0);
Table *table = new Table();
s_vbox->add(table, 0, 0, 0);
for(int y = 0; y < 3; y++)
{
for(int x = 0; x < 3; x++)
{
sasiedztwo[x][y] = new ToggleButton();
sasiedztwo[x][y]->set_label(std::to_string(x + (y * 3) + 1));
if(x == 1 && y == 1)
{
table->add(new Label("x"), x, y, x + 1, y + 1);
continue;
};
table->add(sasiedztwo[x][y], x, y, x + 1, y + 1);
};
};
Label *label2 = new Label(" ");
s_vbox->add(label2, 1, 1, 0);
menu_hbox->add(s_vbox, 0, 0, 0);
main_vbox->add(menu_hbox, 1, 1, 0);
Button *start_button = new Button("Start");
start_button->set_on_clicked(line_fill);
main_vbox->add(start_button, 0, 0, 0);
Button *stop_button = new Button("Stop");
stop_button->set_on_clicked(stop);
main_vbox->add(stop_button, 0, 0, 0);
main_window->add(main_vbox);
clear_image(main_window->get_ref(), 0);
main_window->show();
g_timeout_add(50, refresh_screen, 0);
gtk_main();
return 0;
};
TaskButton::~TaskButton() {
clear_image();
}
void move_cel(ContextWriter& writer)
{
Document* document = writer.document();
Sprite* sprite = writer.sprite();
Cel *src_cel, *dst_cel;
ASSERT(src_layer != NULL);
ASSERT(dst_layer != NULL);
ASSERT(src_frame >= 0 && src_frame < sprite->getTotalFrames());
ASSERT(dst_frame >= 0 && dst_frame < sprite->getTotalFrames());
if (src_layer->isBackground()) {
copy_cel(writer);
return;
}
src_cel = static_cast<LayerImage*>(src_layer)->getCel(src_frame);
dst_cel = static_cast<LayerImage*>(dst_layer)->getCel(dst_frame);
UndoTransaction undo(writer.context(), "Move Cel", undo::ModifyDocument);
/* remove the 'dst_cel' (if it exists) because it must be
replaced with 'src_cel' */
if ((dst_cel != NULL) && (!dst_layer->isBackground() || src_cel != NULL))
remove_cel(sprite, undo, static_cast<LayerImage*>(dst_layer), dst_cel);
/* move the cel in the same layer */
if (src_cel != NULL) {
if (src_layer == dst_layer) {
if (undo.isEnabled())
undo.pushUndoer(new undoers::SetCelFrame(undo.getObjects(), src_cel));
src_cel->setFrame(dst_frame);
}
/* move the cel in different layers */
else {
if (undo.isEnabled())
undo.pushUndoer(new undoers::RemoveCel(undo.getObjects(), src_layer, src_cel));
static_cast<LayerImage*>(src_layer)->removeCel(src_cel);
src_cel->setFrame(dst_frame);
/* if we are moving a cel from a transparent layer to the
background layer, we have to clear the background of the
image */
if (!src_layer->isBackground() &&
dst_layer->isBackground()) {
Image* src_image = sprite->getStock()->getImage(src_cel->getImage());
Image* dst_image = crop_image(src_image,
-src_cel->getX(),
-src_cel->getY(),
sprite->getWidth(),
sprite->getHeight(), 0);
if (undo.isEnabled()) {
undo.pushUndoer(new undoers::ReplaceImage(undo.getObjects(),
sprite->getStock(), src_cel->getImage()));
undo.pushUndoer(new undoers::SetCelPosition(undo.getObjects(), src_cel));
undo.pushUndoer(new undoers::SetCelOpacity(undo.getObjects(), src_cel));
}
clear_image(dst_image, app_get_color_to_clear_layer(dst_layer));
composite_image(dst_image, src_image, src_cel->getX(), src_cel->getY(), 255, BLEND_MODE_NORMAL);
src_cel->setPosition(0, 0);
src_cel->setOpacity(255);
sprite->getStock()->replaceImage(src_cel->getImage(), dst_image);
delete src_image;
}
if (undo.isEnabled())
undo.pushUndoer(new undoers::AddCel(undo.getObjects(), dst_layer, src_cel));
static_cast<LayerImage*>(dst_layer)->addCel(src_cel);
}
}
undo.commit();
document->notifyCelMoved(src_layer, src_frame, dst_layer, dst_frame);
set_frame_to_handle(NULL, FrameNumber(0), NULL, FrameNumber(0));
}
void copy_cel(ContextWriter& writer)
{
Document* document = writer.document();
Sprite* sprite = writer.sprite();
UndoTransaction undo(writer.context(), "Move Cel", undo::ModifyDocument);
Cel *src_cel, *dst_cel;
ASSERT(src_layer != NULL);
ASSERT(dst_layer != NULL);
ASSERT(src_frame >= 0 && src_frame < sprite->getTotalFrames());
ASSERT(dst_frame >= 0 && dst_frame < sprite->getTotalFrames());
src_cel = static_cast<LayerImage*>(src_layer)->getCel(src_frame);
dst_cel = static_cast<LayerImage*>(dst_layer)->getCel(dst_frame);
// Remove the 'dst_cel' (if it exists) because it must be replaced
// with 'src_cel'
if ((dst_cel != NULL) && (!dst_layer->isBackground() || src_cel != NULL))
remove_cel(sprite, undo, static_cast<LayerImage*>(dst_layer), dst_cel);
// Move the cel in the same layer.
if (src_cel != NULL) {
Image *src_image = sprite->getStock()->getImage(src_cel->getImage());
Image *dst_image;
int image_index;
int dst_cel_x;
int dst_cel_y;
int dst_cel_opacity;
// If we are moving a cel from a transparent layer to the
// background layer, we have to clear the background of the image.
if (!src_layer->isBackground() &&
dst_layer->isBackground()) {
dst_image = crop_image(src_image,
-src_cel->getX(),
-src_cel->getY(),
sprite->getWidth(),
sprite->getHeight(), 0);
clear_image(dst_image, app_get_color_to_clear_layer(dst_layer));
composite_image(dst_image, src_image, src_cel->getX(), src_cel->getY(), 255, BLEND_MODE_NORMAL);
dst_cel_x = 0;
dst_cel_y = 0;
dst_cel_opacity = 255;
}
else {
dst_image = Image::createCopy(src_image);
dst_cel_x = src_cel->getX();
dst_cel_y = src_cel->getY();
dst_cel_opacity = src_cel->getOpacity();
}
// Add the image in the stock
image_index = sprite->getStock()->addImage(dst_image);
if (undo.isEnabled())
undo.pushUndoer(new undoers::AddImage(undo.getObjects(),
sprite->getStock(), image_index));
// Create the new cel
dst_cel = new Cel(dst_frame, image_index);
dst_cel->setPosition(dst_cel_x, dst_cel_y);
dst_cel->setOpacity(dst_cel_opacity);
if (undo.isEnabled())
undo.pushUndoer(new undoers::AddCel(undo.getObjects(), dst_layer, dst_cel));
static_cast<LayerImage*>(dst_layer)->addCel(dst_cel);
}
undo.commit();
document->notifyCelCopied(src_layer, src_frame, dst_layer, dst_frame);
set_frame_to_handle(NULL, FrameNumber(0), NULL, FrameNumber(0));
}
ExpandCelCanvas::ExpandCelCanvas(Context* context, TiledMode tiledMode, UndoTransaction& undo)
: m_cel(NULL)
, m_celImage(NULL)
, m_celCreated(false)
, m_closed(false)
, m_committed(false)
, m_undo(undo)
{
create_buffers();
DocumentLocation location = context->getActiveLocation();
m_document = location.document();
m_sprite = location.sprite();
m_layer = location.layer();
if (m_layer->isImage()) {
m_cel = static_cast<LayerImage*>(m_layer)->getCel(location.frame());
if (m_cel)
m_celImage = m_sprite->getStock()->getImage(m_cel->getImage());
}
// If there is no Cel
if (m_cel == NULL) {
// Create the image
m_celImage = Image::create(m_sprite->getPixelFormat(), m_sprite->getWidth(),
m_sprite->getHeight());
clear_image(m_celImage, m_sprite->getTransparentColor());
// Create the cel
m_cel = new Cel(location.frame(), 0);
static_cast<LayerImage*>(m_layer)->addCel(m_cel);
m_celCreated = true;
}
m_originalCelX = m_cel->getX();
m_originalCelY = m_cel->getY();
// Region to draw
int x1, y1, x2, y2;
if (tiledMode == TILED_NONE) { // Non-tiled
x1 = MIN(m_cel->getX(), 0);
y1 = MIN(m_cel->getY(), 0);
x2 = MAX(m_cel->getX()+m_celImage->getWidth(), m_sprite->getWidth());
y2 = MAX(m_cel->getY()+m_celImage->getHeight(), m_sprite->getHeight());
}
else { // Tiled
x1 = 0;
y1 = 0;
x2 = m_sprite->getWidth();
y2 = m_sprite->getHeight();
}
// create two copies of the image region which we'll modify with the tool
m_srcImage = crop_image(m_celImage,
x1-m_cel->getX(),
y1-m_cel->getY(), x2-x1, y2-y1,
m_sprite->getTransparentColor(),
src_buffer);
m_dstImage = Image::createCopy(m_srcImage, dst_buffer);
// We have to adjust the cel position to match the m_dstImage
// position (the new m_dstImage will be used in RenderEngine to
// draw this cel).
m_cel->setPosition(x1, y1);
}
