void
floating_sel_activate_drawable (GimpLayer *layer)
{
GimpImage *image;
GimpDrawable *drawable;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
image = gimp_item_get_image (GIMP_ITEM (layer));
drawable = gimp_layer_get_floating_sel_drawable (layer);
/* set the underlying drawable to active */
if (GIMP_IS_LAYER_MASK (drawable))
{
GimpLayerMask *mask = GIMP_LAYER_MASK (drawable);
gimp_image_set_active_layer (image, gimp_layer_mask_get_layer (mask));
}
else if (GIMP_IS_CHANNEL (drawable))
{
gimp_image_set_active_channel (image, GIMP_CHANNEL (drawable));
}
else
{
gimp_image_set_active_layer (image, GIMP_LAYER (drawable));
}
}
void
callback_edit_mask_button (GtkWidget * button, gpointer data)
{
NewLayerData *nl_data = NEW_LAYER_DATA (data);
PreviewData *p_data = nl_data->preview_data;
gint32 layer_ID = *(nl_data->layer_ID);
IMAGE_CHECK_ACTION(p_data->image_ID, gtk_dialog_response (GTK_DIALOG (dlg), RESPONSE_FATAL), );
LAYER_CHECK_ACTION(layer_ID, gtk_dialog_response (GTK_DIALOG (dlg), RESPONSE_REFRESH), );
if (*(nl_data->status) != TRUE)
{
g_message ("You just found a bug!");
return;
}
gimp_image_undo_group_start (p_data->image_ID);
gimp_image_set_active_layer(p_data->image_ID, layer_ID);
gimp_image_undo_group_end (p_data->image_ID);
nl_data->preview_data->ui_vals->layer_on_edit_ID = layer_ID;
nl_data->preview_data->ui_vals->layer_on_edit_type = nl_data->layer_type;
nl_data->preview_data->ui_vals->layer_on_edit_is_new = FALSE;
gtk_dialog_response (GTK_DIALOG(dlg), RESPONSE_WORK_ON_AUX_LAYER);
}
static void
layer_select_advance (LayerSelect *layer_select,
gint move)
{
GimpLayer *active_layer;
GimpLayer *next_layer;
GList *layers;
gint n_layers;
gint index;
if (move == 0)
return;
/* If there is a floating selection, allow no advancement */
if (gimp_image_get_floating_selection (layer_select->image))
return;
active_layer = gimp_image_get_active_layer (layer_select->image);
layers = gimp_image_get_layer_list (layer_select->image);
n_layers = g_list_length (layers);
index = g_list_index (layers, active_layer);
index += move;
if (index < 0)
index = n_layers - 1;
else if (index >= n_layers)
index = 0;
next_layer = g_list_nth_data (layers, index);
g_list_free (layers);
if (next_layer && next_layer != active_layer)
{
active_layer = gimp_image_set_active_layer (layer_select->image,
next_layer);
if (active_layer)
{
gimp_view_set_viewable (GIMP_VIEW (layer_select->view),
GIMP_VIEWABLE (active_layer));
gtk_label_set_text (GTK_LABEL (layer_select->label),
gimp_object_get_name (active_layer));
}
}
}
static void
gimp_floating_sel_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpFloatingSelUndo *floating_sel_undo = GIMP_FLOATING_SEL_UNDO (undo);
GimpLayer *floating_layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_FS_TO_LAYER:
if (undo_mode == GIMP_UNDO_MODE_UNDO)
{
/* Update the preview for the floating sel */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (floating_layer));
gimp_layer_set_floating_sel_drawable (floating_layer,
floating_sel_undo->drawable);
gimp_image_set_active_layer (undo->image, floating_layer);
gimp_drawable_attach_floating_sel (gimp_layer_get_floating_sel_drawable (floating_layer),
floating_layer);
}
else
{
gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (floating_layer));
gimp_layer_set_floating_sel_drawable (floating_layer, NULL);
}
/* When the floating selection is converted to/from a normal
* layer it does something resembling a name change, so emit the
* "name-changed" signal
*/
gimp_object_name_changed (GIMP_OBJECT (floating_layer));
gimp_drawable_update (GIMP_DRAWABLE (floating_layer),
0, 0,
gimp_item_get_width (GIMP_ITEM (floating_layer)),
gimp_item_get_height (GIMP_ITEM (floating_layer)));
break;
default:
g_assert_not_reached ();
}
}
void removeAllLayersExceptMain(void) {
gint *pnLayers = NULL;
gint numLayers = 0 ;
gint nIndex = 0 ;
gimp_image_set_active_layer(local_vals.image_ID, drawableBeginActiveLayer);
pnLayers = gimp_image_get_layers(local_vals.image_ID, &numLayers);
for (nIndex=0;nIndex< numLayers;nIndex++) {
if (pnLayers[nIndex] != drawableBeginActiveLayer) {
if (gimp_layer_is_floating_sel(pnLayers[nIndex]))
{
gimp_floating_sel_remove(pnLayers[nIndex]);
} else {
gimp_image_remove_layer(local_vals.image_ID, pnLayers[nIndex]);
}
}
}
gimp_drawable_set_visible(drawableBeginActiveLayer, TRUE);
}
static void preview_ambient_occlusion_only(gint32 image_ID) {
gint32 drawable_ID = -1;
gint32 drawableAO_ID = -1;
gtk_label_set_text(GTK_LABEL(progress_label), "Mixing Colors");
// preview_diffuse_only(image_ID);
preview_normal_only(image_ID);
// if (preview_normal_only(image_ID) != NULL) return NULL;
drawable_ID = gimp_image_get_active_layer(image_ID);
/** Copy active layer. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
drawableAO_ID = gimp_layer_copy (drawable_ID);
/** Add new layer to image. */
gimp_image_add_layer(image_ID, drawableAO_ID, -1);
/** Set new layer as active. */
gimp_image_set_active_layer(image_ID, drawableAO_ID);
/**
* Colors -> Components -> "Channel Mixer" applied
* Standard plug-in. Source code ships with GIMP.
*
* Add the "f" here to signify float in c language.
* Removed 0.0 on first param and changed to 0 because boolean.
*/
/** Explained on line ~1300 of InsaneBump.c */
// if (plug_in_colors_channel_mixer_connector(image_ID, drawableAO_ID, 0, -200.0f, 0.0f, 0.0f, 0.0f, -200.0f, 0.0f, 0.0f, 0.0f, 1.0f) != 1) return;
if (plug_in_colors_channel_mixer_connector(image_ID, drawableAO_ID, 0, -1.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.87);
gimp_desaturate(drawableAO_ID);
gimp_levels_stretch(drawableAO_ID);
pDrawables.drawable_ao = gimp_drawable_get(drawableAO_ID);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.90);
}
GimpImage *
gimp_image_duplicate (GimpImage *image)
{
GimpImage *new_image;
GimpLayer *active_layer;
GimpChannel *active_channel;
GimpVectors *active_vectors;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
gimp_set_busy_until_idle (image->gimp);
/* Create a new image */
new_image = gimp_create_image (image->gimp,
gimp_image_get_width (image),
gimp_image_get_height (image),
gimp_image_get_base_type (image),
gimp_image_get_precision (image),
FALSE);
gimp_image_undo_disable (new_image);
/* Store the source uri to be used by the save dialog */
gimp_image_duplicate_save_source_uri (image, new_image);
/* Copy the colormap if necessary */
gimp_image_duplicate_colormap (image, new_image);
/* Copy resolution information */
gimp_image_duplicate_resolution (image, new_image);
/* Copy the layers */
active_layer = gimp_image_duplicate_layers (image, new_image);
/* Copy the channels */
active_channel = gimp_image_duplicate_channels (image, new_image);
/* Copy any vectors */
active_vectors = gimp_image_duplicate_vectors (image, new_image);
/* Copy floating layer */
gimp_image_duplicate_floating_sel (image, new_image);
/* Copy the selection mask */
gimp_image_duplicate_mask (image, new_image);
/* Set active layer, active channel, active vectors */
if (active_layer)
gimp_image_set_active_layer (new_image, active_layer);
if (active_channel)
gimp_image_set_active_channel (new_image, active_channel);
if (active_vectors)
gimp_image_set_active_vectors (new_image, active_vectors);
/* Copy state of all color components */
gimp_image_duplicate_components (image, new_image);
/* Copy any guides */
gimp_image_duplicate_guides (image, new_image);
/* Copy any sample points */
gimp_image_duplicate_sample_points (image, new_image);
/* Copy the grid */
gimp_image_duplicate_grid (image, new_image);
/* Copy the quick mask info */
gimp_image_duplicate_quick_mask (image, new_image);
/* Copy parasites */
gimp_image_duplicate_parasites (image, new_image);
gimp_image_undo_enable (new_image);
return new_image;
}
static void
gimp_move_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
if (move->moving_guide)
{
gboolean delete_guide = FALSE;
gint x, y, width, height;
gimp_tool_pop_status (tool, display);
gimp_tool_control_set_scroll_lock (tool->control, FALSE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_CENTER);
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
gimp_display_shell_selection_resume (shell);
return;
}
gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
if ((move->guide_position < y) ||
(move->guide_position > (y + height)))
delete_guide = TRUE;
break;
case GIMP_ORIENTATION_VERTICAL:
if ((move->guide_position < x) ||
(move->guide_position > (x + width)))
delete_guide = TRUE;
break;
default:
break;
}
if (delete_guide)
{
if (move->guide)
{
gimp_image_remove_guide (image, move->guide, TRUE);
move->guide = NULL;
}
}
else
{
if (move->guide)
{
gimp_image_move_guide (image, move->guide,
move->guide_position, TRUE);
}
else
{
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
move->guide = gimp_image_add_hguide (image,
move->guide_position,
TRUE);
break;
case GIMP_ORIENTATION_VERTICAL:
move->guide = gimp_image_add_vguide (image,
move->guide_position,
TRUE);
break;
default:
g_assert_not_reached ();
}
}
}
gimp_display_shell_selection_resume (shell);
gimp_image_flush (image);
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
if (move->guide)
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
else
{
gboolean flush = FALSE;
if (! config->move_tool_changes_active ||
(release_type == GIMP_BUTTON_RELEASE_CANCEL))
{
if (move->old_active_layer)
{
gimp_image_set_active_layer (image, move->old_active_layer);
move->old_active_layer = NULL;
flush = TRUE;
}
if (move->old_active_vectors)
{
gimp_image_set_active_vectors (image, move->old_active_vectors);
move->old_active_vectors = NULL;
flush = TRUE;
}
}
if (release_type != GIMP_BUTTON_RELEASE_CANCEL)
{
if (move->floating_layer)
{
floating_sel_anchor (move->floating_layer);
flush = TRUE;
}
}
if (flush)
gimp_image_flush (image);
}
}
static void
gimp_move_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
tool->display = display;
move->floating_layer = NULL;
move->guide = NULL;
move->moving_guide = FALSE;
move->old_active_layer = NULL;
move->old_active_vectors = NULL;
if (! options->move_current)
{
if (options->move_type == GIMP_TRANSFORM_TYPE_PATH)
{
GimpVectors *vectors;
if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display,
coords, 7, 7,
NULL, NULL, NULL, NULL, NULL,
&vectors))
{
move->old_active_vectors =
gimp_image_get_active_vectors (image);
gimp_image_set_active_vectors (image, vectors);
}
else
{
/* no path picked */
return;
}
}
else if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER)
{
GimpGuide *guide;
GimpLayer *layer;
const gint snap_distance = display->config->snap_distance;
if (gimp_display_shell_get_show_guides (shell) &&
(guide = gimp_image_find_guide (image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance))))
{
move->guide = guide;
move->moving_guide = TRUE;
move->guide_position = gimp_guide_get_position (guide);
move->guide_orientation = gimp_guide_get_orientation (guide);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_BORDER);
gimp_tool_control_activate (tool->control);
gimp_display_shell_selection_pause (shell);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_tool_push_status_length (tool, display,
_("Move Guide: "),
SWAP_ORIENT (move->guide_orientation),
move->guide_position,
NULL);
return;
}
else if ((layer = gimp_image_pick_layer (image,
coords->x,
coords->y)))
{
if (gimp_image_get_floating_selection (image) &&
! gimp_layer_is_floating_sel (layer))
{
/* If there is a floating selection, and this aint it,
* use the move tool to anchor it.
*/
move->floating_layer =
gimp_image_get_floating_selection (image);
gimp_tool_control_activate (tool->control);
return;
}
else
{
move->old_active_layer = gimp_image_get_active_layer (image);
gimp_image_set_active_layer (image, layer);
}
}
else
{
/* no guide and no layer picked */
return;
}
}
}
switch (options->move_type)
{
case GIMP_TRANSFORM_TYPE_PATH:
if (gimp_image_get_active_vectors (image))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_VECTORS, TRUE);
break;
case GIMP_TRANSFORM_TYPE_SELECTION:
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_MASK, TRUE);
break;
case GIMP_TRANSFORM_TYPE_LAYER:
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (GIMP_IS_LAYER_MASK (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_LAYER_MASK, TRUE);
else if (GIMP_IS_CHANNEL (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_CHANNEL, TRUE);
else if (GIMP_IS_LAYER (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_LAYER, TRUE);
}
break;
}
}
GimpImage *
gimp_image_duplicate (GimpImage *image)
{
GimpImage *new_image;
GimpLayer *floating_layer;
GList *list;
GimpLayer *active_layer = NULL;
GimpChannel *active_channel = NULL;
GimpVectors *active_vectors = NULL;
GimpDrawable *new_floating_sel_drawable = NULL;
GimpDrawable *floating_sel_drawable = NULL;
gchar *filename;
gint count;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
gimp_set_busy_until_idle (image->gimp);
/* Create a new image */
new_image = gimp_create_image (image->gimp,
image->width, image->height,
image->base_type,
FALSE);
gimp_image_undo_disable (new_image);
/* Store the folder to be used by the save dialog */
filename = gimp_image_get_filename (image);
if (filename)
{
g_object_set_data_full (G_OBJECT (new_image), "gimp-image-dirname",
g_path_get_dirname (filename),
(GDestroyNotify) g_free);
g_free (filename);
}
/* Copy the colormap if necessary */
if (new_image->base_type == GIMP_INDEXED)
gimp_image_set_colormap (new_image,
gimp_image_get_colormap (image),
gimp_image_get_colormap_size (image),
FALSE);
/* Copy resolution information */
new_image->xresolution = image->xresolution;
new_image->yresolution = image->yresolution;
new_image->resolution_unit = image->resolution_unit;
/* Copy floating layer */
floating_layer = gimp_image_floating_sel (image);
if (floating_layer)
{
floating_sel_relax (floating_layer, FALSE);
floating_sel_drawable = floating_layer->fs.drawable;
floating_layer = NULL;
}
/* Copy the layers */
for (list = GIMP_LIST (image->layers)->list, count = 0;
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
GimpLayer *new_layer;
new_layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer),
new_image,
G_TYPE_FROM_INSTANCE (layer),
FALSE));
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (GIMP_OBJECT (layer)));
/* Make sure that if the layer has a layer mask,
* its name isn't screwed up
*/
if (new_layer->mask)
gimp_object_set_name (GIMP_OBJECT (new_layer->mask),
gimp_object_get_name (GIMP_OBJECT (layer->mask)));
if (gimp_image_get_active_layer (image) == layer)
active_layer = new_layer;
if (image->floating_sel == layer)
floating_layer = new_layer;
if (floating_sel_drawable == GIMP_DRAWABLE (layer))
new_floating_sel_drawable = GIMP_DRAWABLE (new_layer);
if (floating_layer != new_layer)
gimp_image_add_layer (new_image, new_layer, count++);
}
/* Copy the channels */
for (list = GIMP_LIST (image->channels)->list, count = 0;
list;
list = g_list_next (list))
{
GimpChannel *channel = list->data;
GimpChannel *new_channel;
new_channel =
GIMP_CHANNEL (gimp_item_convert (GIMP_ITEM (channel),
new_image,
G_TYPE_FROM_INSTANCE (channel),
FALSE));
/* Make sure the copied channel doesn't say: "<old channel> copy" */
gimp_object_set_name (GIMP_OBJECT (new_channel),
gimp_object_get_name (GIMP_OBJECT (channel)));
if (gimp_image_get_active_channel (image) == channel)
active_channel = (new_channel);
if (floating_sel_drawable == GIMP_DRAWABLE (channel))
new_floating_sel_drawable = GIMP_DRAWABLE (new_channel);
gimp_image_add_channel (new_image, new_channel, count++);
}
/* Copy any vectors */
for (list = GIMP_LIST (image->vectors)->list, count = 0;
list;
list = g_list_next (list))
{
GimpVectors *vectors = list->data;
GimpVectors *new_vectors;
new_vectors =
GIMP_VECTORS (gimp_item_convert (GIMP_ITEM (vectors),
new_image,
G_TYPE_FROM_INSTANCE (vectors),
FALSE));
/* Make sure the copied vectors doesn't say: "<old vectors> copy" */
gimp_object_set_name (GIMP_OBJECT (new_vectors),
gimp_object_get_name (GIMP_OBJECT (vectors)));
if (gimp_image_get_active_vectors (image) == vectors)
active_vectors = new_vectors;
gimp_image_add_vectors (new_image, new_vectors, count++);
}
/* Copy the selection mask */
{
TileManager *src_tiles;
TileManager *dest_tiles;
PixelRegion srcPR, destPR;
src_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (image->selection_mask));
dest_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (new_image->selection_mask));
pixel_region_init (&srcPR, src_tiles,
0, 0, image->width, image->height, FALSE);
pixel_region_init (&destPR, dest_tiles,
0, 0, image->width, image->height, TRUE);
copy_region (&srcPR, &destPR);
new_image->selection_mask->bounds_known = FALSE;
new_image->selection_mask->boundary_known = FALSE;
}
if (floating_layer)
floating_sel_attach (floating_layer, new_floating_sel_drawable);
/* Set active layer, active channel, active vectors */
if (active_layer)
gimp_image_set_active_layer (new_image, active_layer);
if (active_channel)
gimp_image_set_active_channel (new_image, active_channel);
if (active_vectors)
gimp_image_set_active_vectors (new_image, active_vectors);
/* Copy state of all color channels */
for (count = 0; count < MAX_CHANNELS; count++)
{
new_image->visible[count] = image->visible[count];
new_image->active[count] = image->active[count];
}
/* Copy any guides */
for (list = image->guides; list; list = g_list_next (list))
{
GimpGuide *guide = list->data;
gint position = gimp_guide_get_position (guide);
switch (gimp_guide_get_orientation (guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
gimp_image_add_hguide (new_image, position, FALSE);
break;
case GIMP_ORIENTATION_VERTICAL:
gimp_image_add_vguide (new_image, position, FALSE);
break;
default:
g_error ("Unknown guide orientation.\n");
}
}
/* Copy any sample points */
for (list = image->sample_points; list; list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gimp_image_add_sample_point_at_pos (new_image,
sample_point->x,
sample_point->y,
FALSE);
}
/* Copy the grid */
if (image->grid)
gimp_image_set_grid (new_image, image->grid, FALSE);
/* Copy the quick mask info */
new_image->quick_mask_state = image->quick_mask_state;
new_image->quick_mask_inverted = image->quick_mask_inverted;
new_image->quick_mask_color = image->quick_mask_color;
/* Copy parasites */
if (image->parasites)
{
g_object_unref (new_image->parasites);
new_image->parasites = gimp_parasite_list_copy (image->parasites);
}
gimp_image_undo_enable (new_image);
return new_image;
}
static GimpPDBStatusType plt_load(gchar *filename, gint32 *image_id)
{
FILE *stream = 0;
unsigned int i;
// Using uint for guaranteed sizes across all systems
// guint may or may not work (?)
uint8_t plt_version[8];
uint32_t plt_width = 0;
uint32_t plt_height = 0;
uint8_t *buffer;
uint8_t px_value = 0;
uint8_t px_layer = 0;
uint32_t num_px = 0;
gint32 newImgID = -1;
gint32 newLayerID = -1;
gint32 plt_layer_ids[PLT_NUM_LAYERS];
guint8 pixel[2] = {0, 255}; // GRAYA image = 2 Channels: Value + Alpha
stream = fopen(filename, "rb");
if(stream == 0)
{
g_message("Error opening file.\n");
return (GIMP_PDB_EXECUTION_ERROR);
}
gimp_progress_init_printf("Opening %s", filename);
gimp_progress_update(0.0);
// Read header: Version, should be 8x1 bytes = "PLT V1 "
if (fread(plt_version, 1, 8, stream) < 8)
{
g_message("Invalid plt file: Unable to read version information.\n");
fclose(stream);
return (GIMP_PDB_EXECUTION_ERROR);
}
if (g_ascii_strncasecmp(plt_version, PLT_HEADER_VERSION, 8) != 0)
{
g_message("Invalid plt file: Version mismatch.\n");
fclose(stream);
return (GIMP_PDB_EXECUTION_ERROR);
}
// Read header: Next 8 bytes don't matter
fseek(stream, 8, SEEK_CUR);
// Read header: Width
if (fread(&plt_width, 4, 1, stream) < 1)
{
g_message("Invalid plt file: Unable to read width.\n");
fclose(stream);
return (GIMP_PDB_EXECUTION_ERROR);
}
// Read header: Height
if (fread(&plt_height, 4, 1, stream) < 1)
{
g_message("Invalid plt file: Unable to read height.\n");
fclose(stream);
return (GIMP_PDB_EXECUTION_ERROR);
}
// Create a new image
newImgID = gimp_image_new(plt_width, plt_height, GIMP_GRAY);
if(newImgID == -1)
{
g_message("Unable to allocate new image.\n");
fclose(stream);
return (GIMP_PDB_EXECUTION_ERROR);
}
gimp_image_set_filename(newImgID, filename);
// Create the 10 plt layers, add them to the new image and save their ID's
for (i = 0; i < PLT_NUM_LAYERS; i++)
{
newLayerID = gimp_layer_new(newImgID,
plt_layernames[i],
plt_width, plt_height,
GIMP_GRAYA_IMAGE,
100.0,
GIMP_NORMAL_MODE);
gimp_image_insert_layer(newImgID, newLayerID, 0, 0);
plt_layer_ids[i] = newLayerID;
}
// Read image data
// Expecting width*height (value, layer) tuples = 2*width*height bytes
num_px = plt_width * plt_height;
buffer = (uint8_t*) g_malloc(sizeof(uint8_t)*2*num_px);
if (fread(buffer, 1, 2*num_px, stream) < (2*num_px))
{
g_message("Image size mismatch.\n");
fclose(stream);
g_free(buffer);
gimp_image_delete(newImgID);
return (GIMP_PDB_EXECUTION_ERROR);
}
for (i = 0; i < num_px; i++)
{
pixel[0] = buffer[2*i];
px_layer = buffer[2*i+1];
gimp_drawable_set_pixel(plt_layer_ids[px_layer],
i % plt_width,
plt_height - (int)(floor(i / plt_width)) - 1,
2,
pixel);
gimp_progress_update((float) i/ (float) num_px);
}
gimp_progress_update(1.0);
gimp_image_set_active_layer(newImgID, plt_layer_ids[0]);
fclose(stream);
g_free(buffer);
*image_id = newImgID;
return (GIMP_PDB_SUCCESS);
}
static void preview_alt_normal(gint32 image_ID) {
/*******************************************************************************
* Begin H and Normal
******************************************************************************/
gint32 mergedLayer_ID = -1;
gint32 normalmap_ID = -1;
gfloat wsize = (gfloat)gimp_image_width(image_ID);
gfloat hsize = (gfloat)gimp_image_width(image_ID);
/** Get active layer. */
gint32 drawable_temp_ID = gimp_image_get_active_layer(image_ID);
/** Copy active layer. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
gint32 diffuse_ID = gimp_layer_copy (drawable_temp_ID);
/** Add new layer to image. */
gimp_image_add_layer(image_ID, diffuse_ID, -1);
/** Set new layer as active. */
gimp_image_set_active_layer(image_ID, diffuse_ID);
/** Here I should hide previous active layer, make not visible. */
gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing");
/**
* Since copied, don't need this here.
* blur seems to not create an extra layer.
*/
blur(image_ID, diffuse_ID, wsize, hsize, local_vals.LargeDetails, 0, local_vals.ao);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.15);
normalmap_ID = gimp_image_get_active_layer(image_ID);
if(local_vals.smoothstep)
{
gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing");
/**
* Filter "Blur" applied
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.20);
}
else
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.20);
}
if(local_vals.invh)
{
/**
* Colors Menu->Invert
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_vinvert_connector(image_ID, normalmap_ID) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.25);
}
else
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.25);
}
/** Here is _p Displacement drawable. */
pDrawables.drawable_p = gimp_drawable_get(normalmap_ID);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.30);
/** Extra layer here. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
gtk_label_set_text(GTK_LABEL(progress_label), "Base Mapping");
doBaseMap(image_ID, diffuse_ID, local_vals.Depth, local_vals.LargeDetails, local_vals.ao);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.35);
normalmap_ID = gimp_image_get_active_layer(image_ID);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.40);
/** Here is _ln low normal. l l l l l l l l l l l l l l l l */
if (gcNeedNormal == 'l') {
pDrawables.drawable_n = gimp_drawable_get(normalmap_ID);
}
/** Creates an extra layer. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
shapeRecognise(image_ID, normalmap_ID, local_vals.ShapeRecog, local_vals.ao);
if(local_vals.smoothstep)
{
normalmap_ID = gimp_image_get_active_layer(image_ID);
gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing");
/**
* Filter "Blur" applied
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.45);
}
else
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.45);
}
/** Here is _sn super normal. s s s s s s s s s s s s s s s s */
if (gcNeedNormal == 's') {
pDrawables.drawable_n = gimp_drawable_get(normalmap_ID);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.50);
gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen");
/** Creates an extra layer. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
sharpen(image_ID, diffuse_ID, local_vals.Depth, 0, local_vals.SmallDetails);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.55);
normalmap_ID = gimp_image_get_active_layer(image_ID);
gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen more");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.65);
/**
* Filter Enhance "Sharpen" applied
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_sharpen_connector(image_ID, normalmap_ID, 20) != 1) return;
/** Here is _hn high normal. h h h h h h h h h h h h h h h h */
if (gcNeedNormal == 'h') {
pDrawables.drawable_n = gimp_drawable_get(normalmap_ID);
}
gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen again");
/** Creates an extra layer. */
/** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */
sharpen(image_ID, diffuse_ID, local_vals.Depth, 6, local_vals.MediumDetails);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.70);
normalmap_ID = gimp_image_get_active_layer(image_ID);
gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing");
/**
* Filter "Blur" applied
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.75);
/** Here is _mn medium normal m m m m m m m m m m m m m m m m */
if (gcNeedNormal == 'm') {
pDrawables.drawable_n = gimp_drawable_get(normalmap_ID);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.78);
gimp_drawable_set_visible(diffuse_ID, 0);
/**
* Don't do the next line:
*
* gimp_image_merge_visible_layers(image_ID, 0);
*
* Do this instead for preview:
*/
mergedLayer_ID = gimp_layer_new_from_visible(image_ID, image_ID, "temp");
/** Add copied layer to image. */
gimp_image_add_layer(image_ID, mergedLayer_ID, -1);
}
static void preview_diffuse_only(gint32 image_ID) {
gint32 noiselayer_ID = -1;
gint32 drawable_ID = -1;
gint32 drawableDiffuse_ID = -1;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0);
gtk_label_set_text(GTK_LABEL(progress_label), "Begin");
drawableBeginActiveLayer = gimp_image_get_active_layer(image_ID);
drawable_ID = gimp_layer_copy (drawableBeginActiveLayer);
gimp_image_add_layer(image_ID, drawable_ID, -1);
gimp_image_set_active_layer(image_ID, drawable_ID);
/** Here I should hide previous active layer, make not visible. */
gimp_drawable_set_visible(drawableBeginActiveLayer, FALSE);
/**
* For preview do nothing here.
* if(local_vals.Resizie)
* {
* }
*/
if (local_vals.Noise)
{
/** Already have active layer in drawable_ID. */
noiselayer_ID = gimp_layer_copy (drawable_ID);
gimp_image_add_layer(image_ID, noiselayer_ID, -1);
gimp_image_set_active_layer(image_ID, noiselayer_ID);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.03);
gtk_label_set_text(GTK_LABEL(progress_label), "Noise");
/**
* Filter "RGB Noise" applied
* Standard plug-in. Source code ships with GIMP.
*
* Add the "f" here to signify float in c language.
*/
if (plug_in_rgb_noise_connector(image_ID, noiselayer_ID, 1, 1, 0.20f, 0.20f, 0.20f, 0.0f) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04);
gimp_layer_set_mode(noiselayer_ID, GIMP_VALUE_MODE);
gimp_image_merge_down(image_ID, noiselayer_ID, 0);
gtk_label_set_text(GTK_LABEL(gwNormalLabel), "Noise affects every redraw!");
} else {
gtk_label_set_text(GTK_LABEL(gwNormalLabel), "");
gtk_label_set_text(GTK_LABEL(progress_label), "Noise added");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04);
}
if(local_vals.RemoveLighting)
{
gtk_label_set_text(GTK_LABEL(progress_label), "Remove Shading");
removeShadingPreview(image_ID, local_vals.Noise);
/**
* See notes inside of removeShadingPreview
* for explanation of next line.
*/
/**
* If Noise is on, then noiselayer_ID was merged down into drawable_ID.
* You cannot remove drawable_ID in this case, as it is the only
* layer left!
*
* However, if Noise is Yes and RemoveLighting is Yes,
* Then there is an extra layer floating around!
* Delete noiselayer_ID? I thought it was merged!
* No, I was right noiselayer_ID is already gone!
*/
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05);
} else {
gtk_label_set_text(GTK_LABEL(progress_label), "Stretch");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05);
}
drawableDiffuse_ID = gimp_image_get_active_layer(image_ID);
gimp_levels_stretch(drawableDiffuse_ID);
if(local_vals.Tile)
{
gtk_label_set_text(GTK_LABEL(progress_label), "Making Seamless");
/**
* Filter "Tile Seamless" applied
* Standard plug-in. Source code ships with GIMP.
*/
if (plug_in_make_seamless_connector(image_ID, drawableDiffuse_ID) != 1) return;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07);
} else {
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07);
}
/** Here I should un hide previously hidden layer, make visible. */
pDrawables.drawable_d = gimp_drawable_get(drawableDiffuse_ID);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.1);
}
