[gimp/gimp-2-10] plug-ins: a lot of coding style cleanup in file-dds.
- From: Jehan <jehanp src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp/gimp-2-10] plug-ins: a lot of coding style cleanup in file-dds.
- Date: Wed, 2 Jan 2019 20:50:18 +0000 (UTC)
commit d75a4615bda54e15b534a4ea74eaa2a22d17dec9
Author: Jehan <jehan girinstud io>
Date: Wed Jan 2 21:32:17 2019 +0100
plug-ins: a lot of coding style cleanup in file-dds.
Still a lot more to do but pushing WIP to not have it wasted if more
commits come in from others.
Also got rid of some global variables.
(cherry picked from commit ff2d22d915b9a94c491bde33fa2fa14f8cb740e2)
plug-ins/file-dds/dds.c | 450 +++---
plug-ins/file-dds/dds.h | 40 +-
plug-ins/file-dds/ddsplugin.h | 93 +-
plug-ins/file-dds/ddsread.c | 2171 +++++++++++++-------------
plug-ins/file-dds/ddswrite.c | 3374 +++++++++++++++++++++--------------------
5 files changed, 3143 insertions(+), 2985 deletions(-)
---
diff --git a/plug-ins/file-dds/dds.c b/plug-ins/file-dds/dds.c
index b4cc217364..ea8a943fe9 100644
--- a/plug-ins/file-dds/dds.c
+++ b/plug-ins/file-dds/dds.c
@@ -1,24 +1,24 @@
/*
- DDS GIMP plugin
-
- Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
- with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not, write to
- the Free Software Foundation, 51 Franklin Street, Fifth Floor
- Boston, MA 02110-1301, USA.
-*/
+ * DDS GIMP plugin
+ *
+ * Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
+ * with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301, USA.
+ */
#include "config.h"
@@ -37,32 +37,44 @@
#include "dds.h"
#include "misc.h"
-FILE *errFile;
-gchar *prog_name = "dds";
-gchar *filename;
-gint interactive_dds;
-
-static void query(void);
-static void run(const gchar *name, gint nparams, const GimpParam *param,
- gint *nreturn_vals, GimpParam **return_vals);
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
GimpPlugInInfo PLUG_IN_INFO =
{
- 0, 0, query, run
+ 0,
+ 0,
+ query,
+ run
};
DDSWriteVals dds_write_vals =
{
- DDS_COMPRESS_NONE, DDS_MIPMAP_NONE, DDS_SAVE_SELECTED_LAYER,
- DDS_FORMAT_DEFAULT, -1, DDS_MIPMAP_FILTER_DEFAULT, DDS_MIPMAP_WRAP_DEFAULT,
- 0, 0, 0.0, 0, 0,
- 0, 0.5
+ DDS_COMPRESS_NONE,
+ DDS_MIPMAP_NONE,
+ DDS_SAVE_SELECTED_LAYER,
+ DDS_FORMAT_DEFAULT,
+ -1,
+ DDS_MIPMAP_FILTER_DEFAULT,
+ DDS_MIPMAP_WRAP_DEFAULT,
+ 0,
+ 0,
+ 0.0,
+ 0,
+ 0,
+ 0,
+ 0.5
};
DDSReadVals dds_read_vals =
{
- 1, 1
+ 1,
+ 1
};
static GimpParamDef load_args[] =
@@ -73,6 +85,7 @@ static GimpParamDef load_args[] =
{GIMP_PDB_INT32, "load_mipmaps", "Load mipmaps if present"},
{GIMP_PDB_INT32, "decode_images", "Decode YCoCg/AExp images when detected"}
};
+
static GimpParamDef load_return_vals[] =
{
{GIMP_PDB_IMAGE, "image", "Output image"}
@@ -107,9 +120,10 @@ static GimpParamDef decode_args[] =
{GIMP_PDB_DRAWABLE, "drawable", "Drawable to save"}
};
-MAIN()
+MAIN ()
-static void query(void)
+static void
+query (void)
{
gimp_install_procedure (LOAD_PROC,
"Loads files in DDS image format",
@@ -120,8 +134,8 @@ static void query(void)
N_("DDS image"),
0,
GIMP_PLUGIN,
- G_N_ELEMENTS(load_args),
- G_N_ELEMENTS(load_return_vals),
+ G_N_ELEMENTS (load_args),
+ G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/dds");
@@ -139,7 +153,7 @@ static void query(void)
N_("DDS image"),
"INDEXED, GRAY, RGB",
GIMP_PLUGIN,
- G_N_ELEMENTS(save_args), 0,
+ G_N_ELEMENTS (save_args), 0,
save_args, 0);
gimp_register_file_handler_mime (SAVE_PROC, "image/dds");
@@ -156,7 +170,7 @@ static void query(void)
N_("Decode YCoCg"),
"RGBA",
GIMP_PLUGIN,
- G_N_ELEMENTS(decode_args), 0,
+ G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_YCOCG_PROC, "<Image>/Filters/Colors");*/
@@ -169,7 +183,7 @@ static void query(void)
N_("Decode YCoCg (scaled)"),
"RGBA",
GIMP_PLUGIN,
- G_N_ELEMENTS(decode_args), 0,
+ G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_YCOCG_SCALED_PROC, "<Image>/Filters/Colors");*/
@@ -182,201 +196,201 @@ static void query(void)
N_("Decode Alpha exponent"),
"RGBA",
GIMP_PLUGIN,
- G_N_ELEMENTS(decode_args), 0,
+ G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_ALPHA_EXP_PROC, "<Image>/Filters/Colors");*/
}
-static void run(const gchar *name, gint nparams, const GimpParam *param,
- gint *nreturn_vals, GimpParam **return_vals)
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
{
- static GimpParam values[2];
- GimpRunMode run_mode;
- GimpPDBStatusType status = GIMP_PDB_SUCCESS;
- gint32 imageID;
- gint32 drawableID;
- GimpExportReturn export = GIMP_EXPORT_CANCEL;
-
- gegl_init(NULL, NULL);
-
- run_mode = param[0].data.d_int32;
-
- *nreturn_vals = 1;
- *return_vals = values;
-
- values[0].type = GIMP_PDB_STATUS;
- values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
-
- if(!strcmp(name, LOAD_PROC))
- {
- switch(run_mode)
- {
- case GIMP_RUN_INTERACTIVE:
- gimp_ui_init("dds", 0);
- interactive_dds = 1;
- gimp_get_data(LOAD_PROC, &dds_read_vals);
- break;
- case GIMP_RUN_NONINTERACTIVE:
- interactive_dds = 0;
- dds_read_vals.mipmaps = param[3].data.d_int32;
- dds_read_vals.decode_images = param[4].data.d_int32;
- if(nparams != G_N_ELEMENTS(load_args))
- status = GIMP_PDB_CALLING_ERROR;
- break;
- default:
- break;
- }
-
- if(status == GIMP_PDB_SUCCESS)
- {
- status = read_dds(param[1].data.d_string, &imageID);
- if(status == GIMP_PDB_SUCCESS && imageID != -1)
- {
- *nreturn_vals = 2;
- values[1].type = GIMP_PDB_IMAGE;
- values[1].data.d_image = imageID;
- if(interactive_dds)
- gimp_set_data(LOAD_PROC, &dds_read_vals, sizeof(dds_read_vals));
- }
- else if(status != GIMP_PDB_CANCEL)
- status = GIMP_PDB_EXECUTION_ERROR;
- }
- }
- else if(!strcmp(name, SAVE_PROC))
- {
- imageID = param[1].data.d_int32;
- drawableID = param[2].data.d_int32;
-
- switch(run_mode)
- {
- case GIMP_RUN_INTERACTIVE:
- case GIMP_RUN_WITH_LAST_VALS:
- gimp_ui_init("dds", 0);
- export = gimp_export_image(&imageID, &drawableID, "DDS",
- (GIMP_EXPORT_CAN_HANDLE_RGB |
- GIMP_EXPORT_CAN_HANDLE_GRAY |
- GIMP_EXPORT_CAN_HANDLE_INDEXED |
- GIMP_EXPORT_CAN_HANDLE_ALPHA |
- GIMP_EXPORT_CAN_HANDLE_LAYERS));
- if(export == GIMP_EXPORT_CANCEL)
- {
- values[0].data.d_status = GIMP_PDB_CANCEL;
- return;
- }
- default:
- break;
- }
-
- switch(run_mode)
- {
- case GIMP_RUN_INTERACTIVE:
- gimp_get_data(SAVE_PROC, &dds_write_vals);
- interactive_dds = 1;
- break;
- case GIMP_RUN_NONINTERACTIVE:
- interactive_dds = 0;
- if(nparams != G_N_ELEMENTS(save_args))
- status = GIMP_PDB_CALLING_ERROR;
- else
- {
- dds_write_vals.compression = param[5].data.d_int32;
- dds_write_vals.mipmaps = param[6].data.d_int32;
- dds_write_vals.savetype = param[7].data.d_int32;
- dds_write_vals.format = param[8].data.d_int32;
- dds_write_vals.transindex = param[9].data.d_int32;
- dds_write_vals.mipmap_filter = param[10].data.d_int32;
- dds_write_vals.mipmap_wrap = param[11].data.d_int32;
- dds_write_vals.gamma_correct = param[12].data.d_int32;
- dds_write_vals.srgb = param[13].data.d_int32;
- dds_write_vals.gamma = param[14].data.d_float;
- dds_write_vals.perceptual_metric = param[15].data.d_int32;
- dds_write_vals.preserve_alpha_coverage = param[16].data.d_int32;
- dds_write_vals.alpha_test_threshold = param[17].data.d_float;
-
- if((dds_write_vals.compression < DDS_COMPRESS_NONE) ||
- (dds_write_vals.compression >= DDS_COMPRESS_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- if((dds_write_vals.mipmaps < DDS_MIPMAP_NONE) ||
- (dds_write_vals.mipmaps >= DDS_MIPMAP_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- if((dds_write_vals.savetype < DDS_SAVE_SELECTED_LAYER) ||
- (dds_write_vals.savetype >= DDS_SAVE_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- if((dds_write_vals.format < DDS_FORMAT_DEFAULT) ||
- (dds_write_vals.format >= DDS_FORMAT_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- if((dds_write_vals.mipmap_filter < DDS_MIPMAP_FILTER_DEFAULT) ||
- (dds_write_vals.mipmap_filter >= DDS_MIPMAP_FILTER_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- if((dds_write_vals.mipmap_wrap < DDS_MIPMAP_WRAP_DEFAULT) ||
- (dds_write_vals.mipmap_wrap >= DDS_MIPMAP_WRAP_MAX))
- status = GIMP_PDB_CALLING_ERROR;
- }
- break;
- case GIMP_RUN_WITH_LAST_VALS:
- gimp_get_data(SAVE_PROC, &dds_write_vals);
- interactive_dds = 0;
- break;
- default:
- break;
- }
-
- if(dds_write_vals.gamma < 1e-04f)
- /* gimp_gamma() got removed and was always returning 2.2 anyway.
+ static GimpParam values[2];
+ GimpRunMode run_mode;
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+ gint32 imageID;
+ gint32 drawableID;
+ GimpExportReturn export = GIMP_EXPORT_CANCEL;
+
+ gegl_init (NULL, NULL);
+
+ run_mode = param[0].data.d_int32;
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+ if (!strcmp (name, LOAD_PROC))
+ {
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ gimp_ui_init ("dds", 0);
+ gimp_get_data (LOAD_PROC, &dds_read_vals);
+ break;
+ case GIMP_RUN_NONINTERACTIVE:
+ dds_read_vals.mipmaps = param[3].data.d_int32;
+ dds_read_vals.decode_images = param[4].data.d_int32;
+ if (nparams != G_N_ELEMENTS (load_args))
+ status = GIMP_PDB_CALLING_ERROR;
+ break;
+ default:
+ break;
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ status = read_dds (param[1].data.d_string, &imageID,
+ run_mode == GIMP_RUN_INTERACTIVE);
+ if (status == GIMP_PDB_SUCCESS && imageID != -1)
+ {
+ *nreturn_vals = 2;
+ values[1].type = GIMP_PDB_IMAGE;
+ values[1].data.d_image = imageID;
+ if (run_mode == GIMP_RUN_INTERACTIVE)
+ gimp_set_data (LOAD_PROC, &dds_read_vals, sizeof (dds_read_vals));
+ }
+ else if (status != GIMP_PDB_CANCEL)
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+ }
+ else if (!strcmp (name, SAVE_PROC))
+ {
+ imageID = param[1].data.d_int32;
+ drawableID = param[2].data.d_int32;
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_ui_init ("dds", 0);
+ export = gimp_export_image (&imageID, &drawableID, "DDS",
+ (GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_GRAY |
+ GIMP_EXPORT_CAN_HANDLE_INDEXED |
+ GIMP_EXPORT_CAN_HANDLE_ALPHA |
+ GIMP_EXPORT_CAN_HANDLE_LAYERS));
+ if (export == GIMP_EXPORT_CANCEL)
+ {
+ values[0].data.d_status = GIMP_PDB_CANCEL;
+ return;
+ }
+ default:
+ break;
+ }
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ gimp_get_data (SAVE_PROC, &dds_write_vals);
+ break;
+ case GIMP_RUN_NONINTERACTIVE:
+ if (nparams != G_N_ELEMENTS (save_args))
+ status = GIMP_PDB_CALLING_ERROR;
+ else
+ {
+ dds_write_vals.compression = param[5].data.d_int32;
+ dds_write_vals.mipmaps = param[6].data.d_int32;
+ dds_write_vals.savetype = param[7].data.d_int32;
+ dds_write_vals.format = param[8].data.d_int32;
+ dds_write_vals.transindex = param[9].data.d_int32;
+ dds_write_vals.mipmap_filter = param[10].data.d_int32;
+ dds_write_vals.mipmap_wrap = param[11].data.d_int32;
+ dds_write_vals.gamma_correct = param[12].data.d_int32;
+ dds_write_vals.srgb = param[13].data.d_int32;
+ dds_write_vals.gamma = param[14].data.d_float;
+ dds_write_vals.perceptual_metric = param[15].data.d_int32;
+ dds_write_vals.preserve_alpha_coverage = param[16].data.d_int32;
+ dds_write_vals.alpha_test_threshold = param[17].data.d_float;
+
+ if ((dds_write_vals.compression < DDS_COMPRESS_NONE) ||
+ (dds_write_vals.compression >= DDS_COMPRESS_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ if ((dds_write_vals.mipmaps < DDS_MIPMAP_NONE) ||
+ (dds_write_vals.mipmaps >= DDS_MIPMAP_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ if ((dds_write_vals.savetype < DDS_SAVE_SELECTED_LAYER) ||
+ (dds_write_vals.savetype >= DDS_SAVE_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ if ((dds_write_vals.format < DDS_FORMAT_DEFAULT) ||
+ (dds_write_vals.format >= DDS_FORMAT_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ if ((dds_write_vals.mipmap_filter < DDS_MIPMAP_FILTER_DEFAULT) ||
+ (dds_write_vals.mipmap_filter >= DDS_MIPMAP_FILTER_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ if ((dds_write_vals.mipmap_wrap < DDS_MIPMAP_WRAP_DEFAULT) ||
+ (dds_write_vals.mipmap_wrap >= DDS_MIPMAP_WRAP_MAX))
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ break;
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_get_data (SAVE_PROC, &dds_write_vals);
+ break;
+ default:
+ break;
+ }
+
+ if (dds_write_vals.gamma < 1e-04f)
+ /* gimp_gamma () got removed and was always returning 2.2 anyway.
* XXX Review this piece of code if we expect gamma value could
* be parameterized.
*/
- dds_write_vals.gamma = 2.2;
-
- if(status == GIMP_PDB_SUCCESS)
- {
- status = write_dds(param[3].data.d_string, imageID, drawableID);
- if(status == GIMP_PDB_SUCCESS)
- gimp_set_data(SAVE_PROC, &dds_write_vals, sizeof(dds_write_vals));
- }
-
- if(export == GIMP_EXPORT_EXPORT)
- gimp_image_delete(imageID);
- }
- else if(!strcmp(name, DECODE_YCOCG_PROC))
- {
- imageID = param[1].data.d_int32;
- drawableID = param[2].data.d_int32;
-
- decode_ycocg_image(drawableID, TRUE);
+ dds_write_vals.gamma = 2.2;
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ status = write_dds (param[3].data.d_string, imageID, drawableID,
+ run_mode == GIMP_RUN_INTERACTIVE);
+ if (status == GIMP_PDB_SUCCESS)
+ gimp_set_data (SAVE_PROC, &dds_write_vals, sizeof (dds_write_vals));
+ }
+
+ if (export == GIMP_EXPORT_EXPORT)
+ gimp_image_delete (imageID);
+ }
+ else if (!strcmp (name, DECODE_YCOCG_PROC))
+ {
+ imageID = param[1].data.d_int32;
+ drawableID = param[2].data.d_int32;
+
+ decode_ycocg_image (drawableID, TRUE);
status = GIMP_PDB_SUCCESS;
- if(run_mode != GIMP_RUN_NONINTERACTIVE)
- gimp_displays_flush();
- }
- else if(!strcmp(name, DECODE_YCOCG_SCALED_PROC))
- {
- imageID = param[1].data.d_int32;
- drawableID = param[2].data.d_int32;
+ if (run_mode != GIMP_RUN_NONINTERACTIVE)
+ gimp_displays_flush ();
+ }
+ else if (!strcmp (name, DECODE_YCOCG_SCALED_PROC))
+ {
+ imageID = param[1].data.d_int32;
+ drawableID = param[2].data.d_int32;
- decode_ycocg_scaled_image(drawableID, TRUE);
+ decode_ycocg_scaled_image (drawableID, TRUE);
status = GIMP_PDB_SUCCESS;
- if(run_mode != GIMP_RUN_NONINTERACTIVE)
- gimp_displays_flush();
- }
- else if(!strcmp(name, DECODE_ALPHA_EXP_PROC))
- {
- imageID = param[1].data.d_int32;
- drawableID = param[2].data.d_int32;
+ if (run_mode != GIMP_RUN_NONINTERACTIVE)
+ gimp_displays_flush ();
+ }
+ else if (!strcmp (name, DECODE_ALPHA_EXP_PROC))
+ {
+ imageID = param[1].data.d_int32;
+ drawableID = param[2].data.d_int32;
- decode_alpha_exp_image(drawableID, TRUE);
+ decode_alpha_exp_image (drawableID, TRUE);
status = GIMP_PDB_SUCCESS;
- if(run_mode != GIMP_RUN_NONINTERACTIVE)
- gimp_displays_flush();
- }
- else
- status = GIMP_PDB_CALLING_ERROR;
+ if (run_mode != GIMP_RUN_NONINTERACTIVE)
+ gimp_displays_flush ();
+ }
+ else
+ status = GIMP_PDB_CALLING_ERROR;
- values[0].data.d_status = status;
+ values[0].data.d_status = status;
}
-
diff --git a/plug-ins/file-dds/dds.h b/plug-ins/file-dds/dds.h
index 6affc41a5c..5e2086aeed 100644
--- a/plug-ins/file-dds/dds.h
+++ b/plug-ins/file-dds/dds.h
@@ -1,24 +1,24 @@
/*
- DDS GIMP plugin
-
- Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
- with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not, write to
- the Free Software Foundation, 51 Franklin Street, Fifth Floor
- Boston, MA 02110-1301, USA.
-*/
+ * DDS GIMP plugin
+ *
+ * Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
+ * with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301, USA.
+ */
#ifndef DDS_H
#define DDS_H
diff --git a/plug-ins/file-dds/ddsplugin.h b/plug-ins/file-dds/ddsplugin.h
index 6306ec6922..ecb250b4b9 100644
--- a/plug-ins/file-dds/ddsplugin.h
+++ b/plug-ins/file-dds/ddsplugin.h
@@ -1,24 +1,24 @@
/*
- DDS GIMP plugin
-
- Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
- with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not, write to
- the Free Software Foundation, 51 Franklin Street, Fifth Floor
- Boston, MA 02110-1301, USA.
-*/
+ * DDS GIMP plugin
+ *
+ * Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
+ * with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301, USA.
+ */
#ifndef __DDSPLUGIN_H
#define __DDSPLUGIN_H
@@ -34,44 +34,45 @@
typedef struct
{
- int compression;
- int mipmaps;
- int savetype;
- int format;
- int transindex;
- int mipmap_filter;
- int mipmap_wrap;
- int gamma_correct;
- int srgb;
- float gamma;
- int perceptual_metric;
- int show_adv_opt;
- int preserve_alpha_coverage;
- float alpha_test_threshold;
+ int compression;
+ int mipmaps;
+ int savetype;
+ int format;
+ int transindex;
+ int mipmap_filter;
+ int mipmap_wrap;
+ int gamma_correct;
+ int srgb;
+ float gamma;
+ int perceptual_metric;
+ int show_adv_opt;
+ int preserve_alpha_coverage;
+ float alpha_test_threshold;
} DDSWriteVals;
typedef struct
{
- int mipmaps;
- int decode_images;
+ int mipmaps;
+ int decode_images;
} DDSReadVals;
extern DDSWriteVals dds_write_vals;
extern DDSReadVals dds_read_vals;
-extern GimpPDBStatusType read_dds(gchar *filename, gint32 *imageID);
-extern GimpPDBStatusType write_dds(gchar *, gint32, gint32);
+extern GimpPDBStatusType read_dds (gchar *filename,
+ gint32 *imageID,
+ gboolean interactive_dds);
+extern GimpPDBStatusType write_dds (gchar *filename,
+ gint32 image_id,
+ gint32 drawable_id,
+ gboolean interactive_dds);
-extern gint interactive_dds;
-extern gchar *prog_name;
-extern gchar *filename;
-extern FILE *errorFile;
-#define LOAD_PROC "file-dds-load"
-#define SAVE_PROC "file-dds-save"
+#define LOAD_PROC "file-dds-load"
+#define SAVE_PROC "file-dds-save"
-#define DECODE_YCOCG_PROC "color-decode-ycocg"
+#define DECODE_YCOCG_PROC "color-decode-ycocg"
#define DECODE_YCOCG_SCALED_PROC "color-decode-ycocg-scaled"
-#define DECODE_ALPHA_EXP_PROC "color-decode-alpha-exp"
+#define DECODE_ALPHA_EXP_PROC "color-decode-alpha-exp"
#endif
diff --git a/plug-ins/file-dds/ddsread.c b/plug-ins/file-dds/ddsread.c
index 0be3a5660e..d263897d9c 100644
--- a/plug-ins/file-dds/ddsread.c
+++ b/plug-ins/file-dds/ddsread.c
@@ -1,32 +1,32 @@
/*
- DDS GIMP plugin
-
- Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
- with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not, write to
- the Free Software Foundation, 51 Franklin Street, Fifth Floor
- Boston, MA 02110-1301, USA.
-*/
+ * DDS GIMP plugin
+ *
+ * Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
+ * with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301, USA.
+ */
/*
-** !!! COPYRIGHT NOTICE !!!
-**
-** The following is based on code (C) 2003 Arne Reuter <homepage arnereuter de>
-** URL: http://www.dr-reuter.de/arne/dds.html
-**
-*/
+ ** !!! COPYRIGHT NOTICE !!!
+ **
+ ** The following is based on code (C) 2003 Arne Reuter <homepage arnereuter de>
+ ** URL: http://www.dr-reuter.de/arne/dds.html
+ **
+ */
#include "config.h"
@@ -51,758 +51,787 @@
typedef struct
{
- unsigned char rshift, gshift, bshift, ashift;
- unsigned char rbits, gbits, bbits, abits;
- unsigned int rmask, gmask, bmask, amask;
- unsigned int bpp, gimp_bpp;
- int tile_height;
- unsigned char *palette;
+ unsigned char rshift, gshift, bshift, ashift;
+ unsigned char rbits, gbits, bbits, abits;
+ unsigned int rmask, gmask, bmask, amask;
+ unsigned int bpp, gimp_bpp;
+ int tile_height;
+ unsigned char *palette;
} dds_load_info_t;
-static int read_header(dds_header_t *hdr, FILE *fp);
-static int read_header_dx10(dds_header_dx10_t *hdr, FILE *fp);
-static int validate_header(dds_header_t *hdr);
-static int setup_dxgi_format(dds_header_t *hdr, dds_header_dx10_t *dx10hdr);
-static int load_layer(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, unsigned int level, char *prefix,
- unsigned int *l, guchar *pixels, unsigned char *buf);
-static int load_mipmaps(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, char *prefix, unsigned int *l,
- guchar *pixels, unsigned char *buf);
-static int load_face(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, char *prefix, unsigned int *l,
- guchar *pixels, unsigned char *buf);
-static unsigned char color_bits(unsigned int mask);
-static unsigned char color_shift(unsigned int mask);
-static int load_dialog(void);
+static int read_header (dds_header_t *hdr,
+ FILE *fp);
+static int read_header_dx10 (dds_header_dx10_t *hdr,
+ FILE *fp);
+static int validate_header (dds_header_t *hdr);
+static int setup_dxgi_format (dds_header_t *hdr,
+ dds_header_dx10_t *dx10hdr);
+static int load_layer (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ unsigned int level,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf);
+static int load_mipmaps (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf);
+static int load_face (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf);
+static unsigned char color_bits (unsigned int mask);
+static unsigned char color_shift (unsigned int mask);
+static int load_dialog (void);
static int runme = 0;
-GimpPDBStatusType read_dds(gchar *filename, gint32 *imageID)
+GimpPDBStatusType
+read_dds (gchar *filename,
+ gint32 *imageID,
+ gboolean interactive_dds)
{
- gint32 image = 0;
- unsigned char *buf;
- unsigned int l = 0;
- guchar *pixels;
- gchar *tmp;
- FILE *fp;
- dds_header_t hdr;
- dds_header_dx10_t dx10hdr;
- dds_load_info_t d;
- gint *layers, layer_count;
- GimpImageBaseType type;
- int i, j;
-
- if (interactive_dds)
- {
- if(!load_dialog())
- return(GIMP_PDB_CANCEL);
- }
-
- fp = g_fopen(filename, "rb");
- if(fp == 0)
- {
- g_message("Error opening file.\n");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- if(strrchr(filename, '/'))
- tmp = g_strdup_printf("Loading %s:", strrchr(filename, '/') + 1);
- else
- tmp = g_strdup_printf("Loading %s:", filename);
- gimp_progress_init(tmp);
- g_free(tmp);
-
- /* read header */
- read_header(&hdr, fp);
-
- memset(&dx10hdr, 0, sizeof(dds_header_dx10_t));
-
- /* read DX10 header if necessary */
- if(GETL32(hdr.pixelfmt.fourcc) == FOURCC('D','X','1','0'))
- {
+ gint32 image = 0;
+ unsigned char *buf;
+ unsigned int l = 0;
+ guchar *pixels;
+ gchar *tmp;
+ FILE *fp;
+ dds_header_t hdr;
+ dds_header_dx10_t dx10hdr;
+ dds_load_info_t d;
+ gint *layers, layer_count;
+ GimpImageBaseType type;
+ int i, j;
+
+ if (interactive_dds)
+ {
+ if (!load_dialog ())
+ return (GIMP_PDB_CANCEL);
+ }
+
+ fp = g_fopen (filename, "rb");
+ if (fp == 0)
+ {
+ g_message ("Error opening file.\n");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ if (strrchr (filename, '/'))
+ tmp = g_strdup_printf ("Loading %s:", strrchr (filename, '/') + 1);
+ else
+ tmp = g_strdup_printf ("Loading %s:", filename);
+ gimp_progress_init (tmp);
+ g_free (tmp);
+
+ /* read header */
+ read_header (&hdr, fp);
+
+ memset (&dx10hdr, 0, sizeof (dds_header_dx10_t));
+
+ /* read DX10 header if necessary */
+ if (GETL32(hdr.pixelfmt.fourcc) == FOURCC ('D','X','1','0'))
+ {
read_header_dx10(&dx10hdr, fp);
- if(!setup_dxgi_format(&hdr, &dx10hdr))
- {
- fclose(fp);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- }
-
- if(!validate_header(&hdr))
- {
- fclose(fp);
- g_message("Invalid DDS header!\n");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- /* a lot of DDS images out there don't have this for some reason -_- */
- if(hdr.pitch_or_linsize == 0)
- {
- if(hdr.pixelfmt.flags & DDPF_FOURCC) /* assume linear size */
- {
- hdr.pitch_or_linsize = ((hdr.width + 3) >> 2) * ((hdr.height + 3) >> 2);
- switch(GETL32(hdr.pixelfmt.fourcc))
- {
- case FOURCC('D','X','T','1'):
- case FOURCC('A','T','I','1'):
- case FOURCC('B','C','4','U'):
- case FOURCC('B','C','4','S'):
- hdr.pitch_or_linsize *= 8;
- break;
+ if (!setup_dxgi_format (&hdr, &dx10hdr))
+ {
+ fclose (fp);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ }
+
+ if (!validate_header (&hdr))
+ {
+ fclose (fp);
+ g_message ("Invalid DDS header!\n");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ /* a lot of DDS images out there don't have this for some reason -_- */
+ if (hdr.pitch_or_linsize == 0)
+ {
+ if (hdr.pixelfmt.flags & DDPF_FOURCC) /* assume linear size */
+ {
+ hdr.pitch_or_linsize = ((hdr.width + 3) >> 2) * ((hdr.height + 3) >> 2);
+ switch (GETL32(hdr.pixelfmt.fourcc))
+ {
+ case FOURCC ('D','X','T','1'):
+ case FOURCC ('A','T','I','1'):
+ case FOURCC ('B','C','4','U'):
+ case FOURCC ('B','C','4','S'):
+ hdr.pitch_or_linsize *= 8;
+ break;
default:
- hdr.pitch_or_linsize *= 16;
- break;
- }
- }
+ hdr.pitch_or_linsize *= 16;
+ break;
+ }
+ }
else /* assume pitch */
- {
- hdr.pitch_or_linsize = hdr.height * hdr.width * (hdr.pixelfmt.bpp >> 3);
- }
- }
+ {
+ hdr.pitch_or_linsize = hdr.height * hdr.width * (hdr.pixelfmt.bpp >> 3);
+ }
+ }
- if(hdr.pixelfmt.flags & DDPF_FOURCC)
- {
+ if (hdr.pixelfmt.flags & DDPF_FOURCC)
+ {
/* fourcc is dXt* or rXgb */
- if(hdr.pixelfmt.fourcc[1] == 'X')
- hdr.pixelfmt.flags |= DDPF_ALPHAPIXELS;
- }
-
- if(hdr.pixelfmt.flags & DDPF_FOURCC)
- {
- switch(GETL32(hdr.pixelfmt.fourcc))
- {
- case FOURCC('A','T','I','1'):
- case FOURCC('B','C','4','U'):
- case FOURCC('B','C','4','S'):
- d.bpp = d.gimp_bpp = 1;
- type = GIMP_GRAY;
- break;
- case FOURCC('A','T','I','2'):
- case FOURCC('B','C','5','U'):
- case FOURCC('B','C','5','S'):
- d.bpp = d.gimp_bpp = 3;
- type = GIMP_RGB;
- break;
- default:
- d.bpp = d.gimp_bpp = 4;
- type = GIMP_RGB;
- break;
- }
- }
- else
- {
+ if (hdr.pixelfmt.fourcc[1] == 'X')
+ hdr.pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ }
+
+ if (hdr.pixelfmt.flags & DDPF_FOURCC)
+ {
+ switch (GETL32(hdr.pixelfmt.fourcc))
+ {
+ case FOURCC ('A','T','I','1'):
+ case FOURCC ('B','C','4','U'):
+ case FOURCC ('B','C','4','S'):
+ d.bpp = d.gimp_bpp = 1;
+ type = GIMP_GRAY;
+ break;
+ case FOURCC ('A','T','I','2'):
+ case FOURCC ('B','C','5','U'):
+ case FOURCC ('B','C','5','S'):
+ d.bpp = d.gimp_bpp = 3;
+ type = GIMP_RGB;
+ break;
+ default:
+ d.bpp = d.gimp_bpp = 4;
+ type = GIMP_RGB;
+ break;
+ }
+ }
+ else
+ {
d.bpp = hdr.pixelfmt.bpp >> 3;
- if(d.bpp == 2)
- {
- if(hdr.pixelfmt.amask == 0xf000) // RGBA4
- {
- d.gimp_bpp = 4;
- type = GIMP_RGB;
- }
- else if(hdr.pixelfmt.amask == 0xff00) //L8A8
- {
- d.gimp_bpp = 2;
- type = GIMP_GRAY;
- }
- else if(hdr.pixelfmt.bmask == 0x1f) //R5G6B5 or RGB5A1
- {
- if(hdr.pixelfmt.amask == 0x8000) // RGB5A1
- d.gimp_bpp = 4;
- else
- d.gimp_bpp = 3;
-
- type = GIMP_RGB;
- }
- else //L16
- {
- d.gimp_bpp = 1;
- type = GIMP_GRAY;
- }
- }
+ if (d.bpp == 2)
+ {
+ if (hdr.pixelfmt.amask == 0xf000) // RGBA4
+ {
+ d.gimp_bpp = 4;
+ type = GIMP_RGB;
+ }
+ else if (hdr.pixelfmt.amask == 0xff00) //L8A8
+ {
+ d.gimp_bpp = 2;
+ type = GIMP_GRAY;
+ }
+ else if (hdr.pixelfmt.bmask == 0x1f) //R5G6B5 or RGB5A1
+ {
+ if (hdr.pixelfmt.amask == 0x8000) // RGB5A1
+ d.gimp_bpp = 4;
+ else
+ d.gimp_bpp = 3;
+
+ type = GIMP_RGB;
+ }
+ else //L16
+ {
+ d.gimp_bpp = 1;
+ type = GIMP_GRAY;
+ }
+ }
else
- {
- if(hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
- {
- type = GIMP_INDEXED;
- d.gimp_bpp = 1;
- }
- else if(hdr.pixelfmt.rmask == 0xe0) // R3G3B2
- {
- type = GIMP_RGB;
- d.gimp_bpp = 3;
- }
- else
- {
- /* test alpha only image */
- if(d.bpp == 1 && (hdr.pixelfmt.flags & DDPF_ALPHA))
+ {
+ if (hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ {
+ type = GIMP_INDEXED;
+ d.gimp_bpp = 1;
+ }
+ else if (hdr.pixelfmt.rmask == 0xe0) // R3G3B2
{
- d.gimp_bpp = 2;
- type = GIMP_GRAY;
+ type = GIMP_RGB;
+ d.gimp_bpp = 3;
}
- else
+ else
{
- d.gimp_bpp = d.bpp;
- type = (d.bpp == 1) ? GIMP_GRAY : GIMP_RGB;
+ /* test alpha only image */
+ if (d.bpp == 1 && (hdr.pixelfmt.flags & DDPF_ALPHA))
+ {
+ d.gimp_bpp = 2;
+ type = GIMP_GRAY;
+ }
+ else
+ {
+ d.gimp_bpp = d.bpp;
+ type = (d.bpp == 1) ? GIMP_GRAY : GIMP_RGB;
+ }
}
- }
- }
- }
-
- image = gimp_image_new(hdr.width, hdr.height, type);
-
- if(image == -1)
- {
- g_message("Can't allocate new image.\n");
- fclose(fp);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- gimp_image_set_filename(image, filename);
-
- if(hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
- {
- d.palette = g_malloc(256 * 4);
- if(fread(d.palette, 1, 1024, fp) != 1024)
- {
- g_message("Error reading palette.\n");
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- for(i = j = 0; i < 768; i += 3, j += 4)
- {
- d.palette[i + 0] = d.palette[j + 0];
- d.palette[i + 1] = d.palette[j + 1];
- d.palette[i + 2] = d.palette[j + 2];
- }
- gimp_image_set_colormap(image, d.palette, 256);
- }
-
- d.tile_height = gimp_tile_height();
-
- pixels = g_new(guchar, d.tile_height * hdr.width * d.gimp_bpp);
- buf = g_malloc(hdr.pitch_or_linsize);
-
- d.rshift = color_shift(hdr.pixelfmt.rmask);
- d.gshift = color_shift(hdr.pixelfmt.gmask);
- d.bshift = color_shift(hdr.pixelfmt.bmask);
- d.ashift = color_shift(hdr.pixelfmt.amask);
- d.rbits = color_bits(hdr.pixelfmt.rmask);
- d.gbits = color_bits(hdr.pixelfmt.gmask);
- d.bbits = color_bits(hdr.pixelfmt.bmask);
- d.abits = color_bits(hdr.pixelfmt.amask);
- d.rmask = (hdr.pixelfmt.rmask >> d.rshift) << (8 - d.rbits);
- d.gmask = (hdr.pixelfmt.gmask >> d.gshift) << (8 - d.gbits);
- d.bmask = (hdr.pixelfmt.bmask >> d.bshift) << (8 - d.bbits);
- d.amask = (hdr.pixelfmt.amask >> d.ashift) << (8 - d.abits);
-
- if(!(hdr.caps.caps2 & DDSCAPS2_CUBEMAP) &&
+ }
+ }
+
+ image = gimp_image_new (hdr.width, hdr.height, type);
+
+ if (image == -1)
+ {
+ g_message ("Can't allocate new image.\n");
+ fclose (fp);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ gimp_image_set_filename (image, filename);
+
+ if (hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ {
+ d.palette = g_malloc (256 * 4);
+ if (fread (d.palette, 1, 1024, fp) != 1024)
+ {
+ g_message ("Error reading palette.\n");
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ for (i = j = 0; i < 768; i += 3, j += 4)
+ {
+ d.palette[i + 0] = d.palette[j + 0];
+ d.palette[i + 1] = d.palette[j + 1];
+ d.palette[i + 2] = d.palette[j + 2];
+ }
+ gimp_image_set_colormap (image, d.palette, 256);
+ }
+
+ d.tile_height = gimp_tile_height ();
+
+ pixels = g_new (guchar, d.tile_height * hdr.width * d.gimp_bpp);
+ buf = g_malloc (hdr.pitch_or_linsize);
+
+ d.rshift = color_shift (hdr.pixelfmt.rmask);
+ d.gshift = color_shift (hdr.pixelfmt.gmask);
+ d.bshift = color_shift (hdr.pixelfmt.bmask);
+ d.ashift = color_shift (hdr.pixelfmt.amask);
+ d.rbits = color_bits (hdr.pixelfmt.rmask);
+ d.gbits = color_bits (hdr.pixelfmt.gmask);
+ d.bbits = color_bits (hdr.pixelfmt.bmask);
+ d.abits = color_bits (hdr.pixelfmt.amask);
+ d.rmask = (hdr.pixelfmt.rmask >> d.rshift) << (8 - d.rbits);
+ d.gmask = (hdr.pixelfmt.gmask >> d.gshift) << (8 - d.gbits);
+ d.bmask = (hdr.pixelfmt.bmask >> d.bshift) << (8 - d.bbits);
+ d.amask = (hdr.pixelfmt.amask >> d.ashift) << (8 - d.abits);
+
+ if (!(hdr.caps.caps2 & DDSCAPS2_CUBEMAP) &&
!(hdr.caps.caps2 & DDSCAPS2_VOLUME) &&
dx10hdr.arraySize == 0)
- {
- if(!load_layer(fp, &hdr, &d, image, 0, "", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if(!load_mipmaps(fp, &hdr, &d, image, "", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- }
- else if(hdr.caps.caps2 & DDSCAPS2_CUBEMAP)
- {
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) &&
- !load_face(fp, &hdr, &d, image, "(positive x)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) &&
- !load_face(fp, &hdr, &d, image, "(negative x)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) &&
- !load_face(fp, &hdr, &d, image, "(positive y)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) &&
- !load_face(fp, &hdr, &d, image, "(negative y)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) &&
- !load_face(fp, &hdr, &d, image, "(positive z)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ) &&
- !load_face(fp, &hdr, &d, image, "(negative z)", &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- }
- else if((hdr.caps.caps2 & DDSCAPS2_VOLUME) &&
- (hdr.flags & DDSD_DEPTH))
- {
+ {
+ if (!load_layer (fp, &hdr, &d, image, 0, "", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if (!load_mipmaps (fp, &hdr, &d, image, "", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ }
+ else if (hdr.caps.caps2 & DDSCAPS2_CUBEMAP)
+ {
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) &&
+ !load_face (fp, &hdr, &d, image, "(positive x)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) &&
+ !load_face (fp, &hdr, &d, image, "(negative x)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) &&
+ !load_face (fp, &hdr, &d, image, "(positive y)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) &&
+ !load_face (fp, &hdr, &d, image, "(negative y)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) &&
+ !load_face (fp, &hdr, &d, image, "(positive z)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if ((hdr.caps.caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ) &&
+ !load_face (fp, &hdr, &d, image, "(negative z)", &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ }
+ else if ((hdr.caps.caps2 & DDSCAPS2_VOLUME) &&
+ (hdr.flags & DDSD_DEPTH))
+ {
unsigned int i, level;
char *plane;
- for(i = 0; i < hdr.depth; ++i)
- {
- plane = g_strdup_printf("(z = %d)", i);
- if(!load_layer(fp, &hdr, &d, image, 0, plane, &l, pixels, buf))
- {
- g_free(plane);
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- g_free(plane);
- }
-
- if((hdr.flags & DDSD_MIPMAPCOUNT) &&
- (hdr.caps.caps1 & DDSCAPS_MIPMAP) &&
- (dds_read_vals.mipmaps != 0))
- {
- for(level = 1; level < hdr.num_mipmaps; ++level)
- {
- int n = hdr.depth >> level;
- if(n < 1) n = 1;
- for(i = 0; i < n; ++i)
+ for (i = 0; i < hdr.depth; ++i)
+ {
+ plane = g_strdup_printf ("(z = %d)", i);
+ if (!load_layer (fp, &hdr, &d, image, 0, plane, &l, pixels, buf))
{
- plane = g_strdup_printf("(z = %d)", i);
- if(!load_layer(fp, &hdr, &d, image, level, plane, &l, pixels, buf))
- {
- g_free(plane);
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- g_free(plane);
+ g_free (plane);
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
}
- }
- }
- }
- else if(dx10hdr.arraySize > 0)
- {
+ g_free (plane);
+ }
+
+ if ((hdr.flags & DDSD_MIPMAPCOUNT) &&
+ (hdr.caps.caps1 & DDSCAPS_MIPMAP) &&
+ (dds_read_vals.mipmaps != 0))
+ {
+ for (level = 1; level < hdr.num_mipmaps; ++level)
+ {
+ int n = hdr.depth >> level;
+ if (n < 1) n = 1;
+ for (i = 0; i < n; ++i)
+ {
+ plane = g_strdup_printf ("(z = %d)", i);
+ if (!load_layer (fp, &hdr, &d, image, level, plane, &l, pixels, buf))
+ {
+ g_free (plane);
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ g_free (plane);
+ }
+ }
+ }
+ }
+ else if (dx10hdr.arraySize > 0)
+ {
unsigned int i;
char *elem;
- for(i = 0; i < dx10hdr.arraySize; ++i)
- {
- elem = g_strdup_printf("(array element %d)", i);
- if(!load_layer(fp, &hdr, &d, image, 0, elem, &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- if(!load_mipmaps(fp, &hdr, &d, image, elem, &l, pixels, buf))
- {
- fclose(fp);
- gimp_image_delete(image);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- g_free(elem);
- }
- }
-
- gimp_progress_update(1.0);
-
- if(hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
- g_free(d.palette);
-
- g_free(buf);
- g_free(pixels);
- fclose(fp);
-
- layers = gimp_image_get_layers(image, &layer_count);
-
- if(layers == NULL || layer_count == 0)
- {
- g_message("Oops! NULL image read! Please report this!");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- gimp_image_set_active_layer(image, layers[0]);
- g_free (layers);
-
- *imageID = image;
-
- return(GIMP_PDB_SUCCESS);
+ for (i = 0; i < dx10hdr.arraySize; ++i)
+ {
+ elem = g_strdup_printf ("(array element %d)", i);
+ if (!load_layer (fp, &hdr, &d, image, 0, elem, &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ if (!load_mipmaps (fp, &hdr, &d, image, elem, &l, pixels, buf))
+ {
+ fclose (fp);
+ gimp_image_delete (image);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ g_free (elem);
+ }
+ }
+
+ gimp_progress_update (1.0);
+
+ if (hdr.pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ g_free (d.palette);
+
+ g_free (buf);
+ g_free (pixels);
+ fclose (fp);
+
+ layers = gimp_image_get_layers (image, &layer_count);
+
+ if (layers == NULL || layer_count == 0)
+ {
+ g_message ("Oops! NULL image read! Please report this!");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ gimp_image_set_active_layer (image, layers[0]);
+ g_free (layers);
+
+ *imageID = image;
+
+ return (GIMP_PDB_SUCCESS);
}
-static int read_header(dds_header_t *hdr, FILE *fp)
+static int
+read_header (dds_header_t *hdr,
+ FILE *fp)
{
- unsigned char buf[DDS_HEADERSIZE];
-
- memset(hdr, 0, sizeof(dds_header_t));
-
- if(fread(buf, 1, DDS_HEADERSIZE, fp) != DDS_HEADERSIZE)
- return(0);
-
- hdr->magic = GETL32(buf);
-
- hdr->size = GETL32(buf + 4);
- hdr->flags = GETL32(buf + 8);
- hdr->height = GETL32(buf + 12);
- hdr->width = GETL32(buf + 16);
- hdr->pitch_or_linsize = GETL32(buf + 20);
- hdr->depth = GETL32(buf + 24);
- hdr->num_mipmaps = GETL32(buf + 28);
-
- hdr->pixelfmt.size = GETL32(buf + 76);
- hdr->pixelfmt.flags = GETL32(buf + 80);
- hdr->pixelfmt.fourcc[0] = buf[84];
- hdr->pixelfmt.fourcc[1] = buf[85];
- hdr->pixelfmt.fourcc[2] = buf[86];
- hdr->pixelfmt.fourcc[3] = buf[87];
- hdr->pixelfmt.bpp = GETL32(buf + 88);
- hdr->pixelfmt.rmask = GETL32(buf + 92);
- hdr->pixelfmt.gmask = GETL32(buf + 96);
- hdr->pixelfmt.bmask = GETL32(buf + 100);
- hdr->pixelfmt.amask = GETL32(buf + 104);
-
- hdr->caps.caps1 = GETL32(buf + 108);
- hdr->caps.caps2 = GETL32(buf + 112);
-
- /* GIMP-DDS special info */
- if(GETL32(buf + 32) == FOURCC('G','I','M','P') &&
- GETL32(buf + 36) == FOURCC('-','D','D','S'))
- {
+ unsigned char buf[DDS_HEADERSIZE];
+
+ memset (hdr, 0, sizeof (dds_header_t));
+
+ if (fread (buf, 1, DDS_HEADERSIZE, fp) != DDS_HEADERSIZE)
+ return (0);
+
+ hdr->magic = GETL32(buf);
+
+ hdr->size = GETL32(buf + 4);
+ hdr->flags = GETL32(buf + 8);
+ hdr->height = GETL32(buf + 12);
+ hdr->width = GETL32(buf + 16);
+ hdr->pitch_or_linsize = GETL32(buf + 20);
+ hdr->depth = GETL32(buf + 24);
+ hdr->num_mipmaps = GETL32(buf + 28);
+
+ hdr->pixelfmt.size = GETL32(buf + 76);
+ hdr->pixelfmt.flags = GETL32(buf + 80);
+ hdr->pixelfmt.fourcc[0] = buf[84];
+ hdr->pixelfmt.fourcc[1] = buf[85];
+ hdr->pixelfmt.fourcc[2] = buf[86];
+ hdr->pixelfmt.fourcc[3] = buf[87];
+ hdr->pixelfmt.bpp = GETL32(buf + 88);
+ hdr->pixelfmt.rmask = GETL32(buf + 92);
+ hdr->pixelfmt.gmask = GETL32(buf + 96);
+ hdr->pixelfmt.bmask = GETL32(buf + 100);
+ hdr->pixelfmt.amask = GETL32(buf + 104);
+
+ hdr->caps.caps1 = GETL32(buf + 108);
+ hdr->caps.caps2 = GETL32(buf + 112);
+
+ /* GIMP-DDS special info */
+ if (GETL32(buf + 32) == FOURCC ('G','I','M','P') &&
+ GETL32(buf + 36) == FOURCC ('-','D','D','S'))
+ {
hdr->reserved.gimp_dds_special.magic1 = GETL32(buf + 32);
hdr->reserved.gimp_dds_special.magic2 = GETL32(buf + 36);
hdr->reserved.gimp_dds_special.version = GETL32(buf + 40);
hdr->reserved.gimp_dds_special.extra_fourcc = GETL32(buf + 44);
- }
+ }
- return(1);
+ return (1);
}
-static int read_header_dx10(dds_header_dx10_t *hdr, FILE *fp)
+static int
+read_header_dx10(dds_header_dx10_t *hdr,
+ FILE *fp)
{
- char buf[DDS_HEADERSIZE_DX10];
+ char buf[DDS_HEADERSIZE_DX10];
- memset(hdr, 0, sizeof(dds_header_dx10_t));
+ memset (hdr, 0, sizeof (dds_header_dx10_t));
- if(fread(buf, 1, DDS_HEADERSIZE_DX10, fp) != DDS_HEADERSIZE_DX10)
- return(0);
+ if (fread (buf, 1, DDS_HEADERSIZE_DX10, fp) != DDS_HEADERSIZE_DX10)
+ return (0);
- hdr->dxgiFormat = GETL32(buf);
- hdr->resourceDimension = GETL32(buf + 4);
- hdr->miscFlag = GETL32(buf + 8);
- hdr->arraySize = GETL32(buf + 12);
- hdr->reserved = GETL32(buf + 16);
+ hdr->dxgiFormat = GETL32(buf);
+ hdr->resourceDimension = GETL32(buf + 4);
+ hdr->miscFlag = GETL32(buf + 8);
+ hdr->arraySize = GETL32(buf + 12);
+ hdr->reserved = GETL32(buf + 16);
- return(1);
+ return (1);
}
-static int validate_header(dds_header_t *hdr)
+static int
+validate_header (dds_header_t *hdr)
{
- unsigned int fourcc;
-
- if(hdr->magic != FOURCC('D','D','S',' '))
- {
- g_message("Invalid DDS file.\n");
- return(0);
- }
-
- if((hdr->flags & DDSD_PITCH) == (hdr->flags & DDSD_LINEARSIZE))
- {
- //g_message("Warning: DDSD_PITCH or DDSD_LINEARSIZE is not set.\n");
- if(hdr->pixelfmt.flags & DDPF_FOURCC)
- hdr->flags |= DDSD_LINEARSIZE;
+ unsigned int fourcc;
+
+ if (hdr->magic != FOURCC ('D','D','S',' '))
+ {
+ g_message ("Invalid DDS file.\n");
+ return (0);
+ }
+
+ if ((hdr->flags & DDSD_PITCH) == (hdr->flags & DDSD_LINEARSIZE))
+ {
+ //g_message ("Warning: DDSD_PITCH or DDSD_LINEARSIZE is not set.\n");
+ if (hdr->pixelfmt.flags & DDPF_FOURCC)
+ hdr->flags |= DDSD_LINEARSIZE;
else
- hdr->flags |= DDSD_PITCH;
- }
-/*
- if((hdr->pixelfmt.flags & DDPF_FOURCC) ==
- (hdr->pixelfmt.flags & DDPF_RGB))
- {
- g_message("Invalid pixel format.\n");
- return(0);
- }
-*/
- fourcc = GETL32(hdr->pixelfmt.fourcc);
-
- if((hdr->pixelfmt.flags & DDPF_FOURCC) &&
- fourcc != FOURCC('D','X','T','1') &&
- fourcc != FOURCC('D','X','T','2') &&
- fourcc != FOURCC('D','X','T','3') &&
- fourcc != FOURCC('D','X','T','4') &&
- fourcc != FOURCC('D','X','T','5') &&
- fourcc != FOURCC('R','X','G','B') &&
- fourcc != FOURCC('A','T','I','1') &&
- fourcc != FOURCC('B','C','4','U') &&
- fourcc != FOURCC('B','C','4','S') &&
- fourcc != FOURCC('A','T','I','2') &&
- fourcc != FOURCC('B','C','5','U') &&
- fourcc != FOURCC('B','C','5','S') &&
- fourcc != FOURCC('D','X','1','0'))
- {
- g_message("Unsupported format (FOURCC: %c%c%c%c, hex: %08x).\n",
- hdr->pixelfmt.fourcc[0],
- hdr->pixelfmt.fourcc[1],
- hdr->pixelfmt.fourcc[2],
- hdr->pixelfmt.fourcc[3],
- GETL32(hdr->pixelfmt.fourcc));
- return(0);
- }
-
- if(hdr->pixelfmt.flags & DDPF_RGB)
- {
- if((hdr->pixelfmt.bpp != 8) &&
- (hdr->pixelfmt.bpp != 16) &&
- (hdr->pixelfmt.bpp != 24) &&
- (hdr->pixelfmt.bpp != 32))
- {
- g_message("Invalid BPP.\n");
- return(0);
- }
- }
- else if(hdr->pixelfmt.flags & DDPF_LUMINANCE)
- {
- if((hdr->pixelfmt.bpp != 8) &&
- (hdr->pixelfmt.bpp != 16))
- {
- g_message("Invalid BPP.\n");
- return(0);
- }
+ hdr->flags |= DDSD_PITCH;
+ }
+ /*
+ if ((hdr->pixelfmt.flags & DDPF_FOURCC) ==
+ (hdr->pixelfmt.flags & DDPF_RGB))
+ {
+ g_message ("Invalid pixel format.\n");
+ return (0);
+ }
+ */
+ fourcc = GETL32(hdr->pixelfmt.fourcc);
+
+ if ((hdr->pixelfmt.flags & DDPF_FOURCC) &&
+ fourcc != FOURCC ('D','X','T','1') &&
+ fourcc != FOURCC ('D','X','T','2') &&
+ fourcc != FOURCC ('D','X','T','3') &&
+ fourcc != FOURCC ('D','X','T','4') &&
+ fourcc != FOURCC ('D','X','T','5') &&
+ fourcc != FOURCC ('R','X','G','B') &&
+ fourcc != FOURCC ('A','T','I','1') &&
+ fourcc != FOURCC ('B','C','4','U') &&
+ fourcc != FOURCC ('B','C','4','S') &&
+ fourcc != FOURCC ('A','T','I','2') &&
+ fourcc != FOURCC ('B','C','5','U') &&
+ fourcc != FOURCC ('B','C','5','S') &&
+ fourcc != FOURCC ('D','X','1','0'))
+ {
+ g_message ("Unsupported format (FOURCC: %c%c%c%c, hex: %08x).\n",
+ hdr->pixelfmt.fourcc[0],
+ hdr->pixelfmt.fourcc[1],
+ hdr->pixelfmt.fourcc[2],
+ hdr->pixelfmt.fourcc[3],
+ GETL32(hdr->pixelfmt.fourcc));
+ return (0);
+ }
+
+ if (hdr->pixelfmt.flags & DDPF_RGB)
+ {
+ if ((hdr->pixelfmt.bpp != 8) &&
+ (hdr->pixelfmt.bpp != 16) &&
+ (hdr->pixelfmt.bpp != 24) &&
+ (hdr->pixelfmt.bpp != 32))
+ {
+ g_message ("Invalid BPP.\n");
+ return (0);
+ }
+ }
+ else if (hdr->pixelfmt.flags & DDPF_LUMINANCE)
+ {
+ if ((hdr->pixelfmt.bpp != 8) &&
+ (hdr->pixelfmt.bpp != 16))
+ {
+ g_message ("Invalid BPP.\n");
+ return (0);
+ }
hdr->pixelfmt.flags |= DDPF_RGB;
- }
- else if(hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
- {
+ }
+ else if (hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ {
hdr->pixelfmt.flags |= DDPF_RGB;
- }
+ }
- if(!(hdr->pixelfmt.flags & DDPF_RGB) &&
+ if (!(hdr->pixelfmt.flags & DDPF_RGB) &&
!(hdr->pixelfmt.flags & DDPF_ALPHA) &&
!(hdr->pixelfmt.flags & DDPF_FOURCC) &&
!(hdr->pixelfmt.flags & DDPF_LUMINANCE))
- {
- g_message("Unknown pixel format! Taking a guess, expect trouble!");
- switch(fourcc)
- {
- case FOURCC('D','X','T','1'):
- case FOURCC('D','X','T','2'):
- case FOURCC('D','X','T','3'):
- case FOURCC('D','X','T','4'):
- case FOURCC('D','X','T','5'):
- case FOURCC('R','X','G','B'):
- case FOURCC('A','T','I','1'):
- case FOURCC('B','C','4','U'):
- case FOURCC('B','C','4','S'):
- case FOURCC('A','T','I','2'):
- case FOURCC('B','C','5','U'):
- case FOURCC('B','C','5','S'):
- hdr->pixelfmt.flags |= DDPF_FOURCC;
- break;
- default:
- switch(hdr->pixelfmt.bpp)
+ {
+ g_message ("Unknown pixel format! Taking a guess, expect trouble!");
+ switch (fourcc)
+ {
+ case FOURCC ('D','X','T','1'):
+ case FOURCC ('D','X','T','2'):
+ case FOURCC ('D','X','T','3'):
+ case FOURCC ('D','X','T','4'):
+ case FOURCC ('D','X','T','5'):
+ case FOURCC ('R','X','G','B'):
+ case FOURCC ('A','T','I','1'):
+ case FOURCC ('B','C','4','U'):
+ case FOURCC ('B','C','4','S'):
+ case FOURCC ('A','T','I','2'):
+ case FOURCC ('B','C','5','U'):
+ case FOURCC ('B','C','5','S'):
+ hdr->pixelfmt.flags |= DDPF_FOURCC;
+ break;
+ default:
+ switch (hdr->pixelfmt.bpp)
{
- case 8:
- if(hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
- hdr->pixelfmt.flags |= DDPF_ALPHA;
- else
- hdr->pixelfmt.flags |= DDPF_LUMINANCE;
- break;
- case 16:
- case 24:
- case 32:
- hdr->pixelfmt.flags |= DDPF_RGB;
- break;
- default:
- g_message("Invalid pixel format.");
- return(0);
+ case 8:
+ if (hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
+ hdr->pixelfmt.flags |= DDPF_ALPHA;
+ else
+ hdr->pixelfmt.flags |= DDPF_LUMINANCE;
+ break;
+ case 16:
+ case 24:
+ case 32:
+ hdr->pixelfmt.flags |= DDPF_RGB;
+ break;
+ default:
+ g_message ("Invalid pixel format.");
+ return (0);
}
- break;
- }
- }
+ break;
+ }
+ }
- return(1);
+ return (1);
}
/*
* This function will set the necessary flags and attributes in the standard
* dds header using the information found in the DX10 header.
*/
-static int setup_dxgi_format(dds_header_t *hdr, dds_header_dx10_t *dx10hdr)
+static int
+setup_dxgi_format (dds_header_t *hdr,
+ dds_header_dx10_t *dx10hdr)
{
- if((dx10hdr->resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE2D) &&
+ if ((dx10hdr->resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE2D) &&
(dx10hdr->miscFlag & D3D10_RESOURCE_MISC_TEXTURECUBE))
- {
+ {
hdr->caps.caps2 |= DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALL_FACES;
- }
- else if(dx10hdr->resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D)
- {
+ }
+ else if (dx10hdr->resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D)
+ {
hdr->flags |= DDSD_DEPTH;
hdr->caps.caps2 |= DDSCAPS2_VOLUME;
- }
+ }
- if((dx10hdr->resourceDimension != D3D10_RESOURCE_DIMENSION_TEXTURE1D) &&
+ if ((dx10hdr->resourceDimension != D3D10_RESOURCE_DIMENSION_TEXTURE1D) &&
(dx10hdr->resourceDimension != D3D10_RESOURCE_DIMENSION_TEXTURE2D) &&
(dx10hdr->resourceDimension != D3D10_RESOURCE_DIMENSION_TEXTURE3D))
- return(0);
+ return (0);
- // check for a compressed DXGI format
- if((dx10hdr->dxgiFormat >= DXGI_FORMAT_BC1_TYPELESS) &&
+ // check for a compressed DXGI format
+ if ((dx10hdr->dxgiFormat >= DXGI_FORMAT_BC1_TYPELESS) &&
(dx10hdr->dxgiFormat <= DXGI_FORMAT_BC5_SNORM))
- {
+ {
// set flag and replace FOURCC
hdr->pixelfmt.flags |= DDPF_FOURCC;
- switch(dx10hdr->dxgiFormat)
- {
- case DXGI_FORMAT_BC1_TYPELESS:
- case DXGI_FORMAT_BC1_UNORM:
- case DXGI_FORMAT_BC1_UNORM_SRGB:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('D','X','T','1'));
- break;
- case DXGI_FORMAT_BC2_TYPELESS:
- case DXGI_FORMAT_BC2_UNORM:
- case DXGI_FORMAT_BC2_UNORM_SRGB:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('D','X','T','3'));
- break;
- case DXGI_FORMAT_BC3_TYPELESS:
- case DXGI_FORMAT_BC3_UNORM:
- case DXGI_FORMAT_BC3_UNORM_SRGB:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('D','X','T','5'));
- break;
- case DXGI_FORMAT_BC4_TYPELESS:
- case DXGI_FORMAT_BC4_UNORM:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('A','T','I','1'));
- break;
- case DXGI_FORMAT_BC4_SNORM:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('B','C','4','S'));
- break;
- case DXGI_FORMAT_BC5_TYPELESS:
- case DXGI_FORMAT_BC5_UNORM:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('A','T','I','2'));
- break;
- case DXGI_FORMAT_BC5_SNORM:
- PUTL32(hdr->pixelfmt.fourcc, FOURCC('B','C','5','S'));
- break;
- default:
- break;
- }
- }
- else
- {
+ switch (dx10hdr->dxgiFormat)
+ {
+ case DXGI_FORMAT_BC1_TYPELESS:
+ case DXGI_FORMAT_BC1_UNORM:
+ case DXGI_FORMAT_BC1_UNORM_SRGB:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('D','X','T','1'));
+ break;
+ case DXGI_FORMAT_BC2_TYPELESS:
+ case DXGI_FORMAT_BC2_UNORM:
+ case DXGI_FORMAT_BC2_UNORM_SRGB:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('D','X','T','3'));
+ break;
+ case DXGI_FORMAT_BC3_TYPELESS:
+ case DXGI_FORMAT_BC3_UNORM:
+ case DXGI_FORMAT_BC3_UNORM_SRGB:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('D','X','T','5'));
+ break;
+ case DXGI_FORMAT_BC4_TYPELESS:
+ case DXGI_FORMAT_BC4_UNORM:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('A','T','I','1'));
+ break;
+ case DXGI_FORMAT_BC4_SNORM:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('B','C','4','S'));
+ break;
+ case DXGI_FORMAT_BC5_TYPELESS:
+ case DXGI_FORMAT_BC5_UNORM:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('A','T','I','2'));
+ break;
+ case DXGI_FORMAT_BC5_SNORM:
+ PUTL32(hdr->pixelfmt.fourcc, FOURCC ('B','C','5','S'));
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
/* unset the FOURCC flag */
hdr->pixelfmt.flags &= ~DDPF_FOURCC;
- switch(dx10hdr->dxgiFormat)
- {
- case DXGI_FORMAT_B8G8R8A8_TYPELESS:
- case DXGI_FORMAT_B8G8R8A8_UNORM:
- case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
- hdr->pixelfmt.bpp = 32;
- hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = 0x00ff0000;
- hdr->pixelfmt.gmask = 0x0000ff00;
- hdr->pixelfmt.bmask = 0x000000ff;
- hdr->pixelfmt.amask = 0xff000000;
- break;
- case DXGI_FORMAT_B8G8R8X8_TYPELESS:
- case DXGI_FORMAT_B8G8R8X8_UNORM:
- case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
- hdr->pixelfmt.bpp = 32;
- hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = 0x00ff0000;
- hdr->pixelfmt.gmask = 0x0000ff00;
- hdr->pixelfmt.bmask = 0x000000ff;
- hdr->pixelfmt.amask = 0x00000000;
- break;
- case DXGI_FORMAT_R8G8B8A8_TYPELESS:
- case DXGI_FORMAT_R8G8B8A8_UNORM:
- case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
- case DXGI_FORMAT_R8G8B8A8_UINT:
- case DXGI_FORMAT_R8G8B8A8_SNORM:
- case DXGI_FORMAT_R8G8B8A8_SINT:
- hdr->pixelfmt.bpp = 32;
- hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = 0x000000ff;
- hdr->pixelfmt.gmask = 0x0000ff00;
- hdr->pixelfmt.bmask = 0x00ff0000;
- hdr->pixelfmt.amask = 0xff000000;
- break;
- case DXGI_FORMAT_B5G6R5_UNORM:
- hdr->pixelfmt.bpp = 16;
- hdr->pixelfmt.rmask = 0x0000f800;
- hdr->pixelfmt.gmask = 0x000007e0;
- hdr->pixelfmt.bmask = 0x0000001f;
- hdr->pixelfmt.amask = 0x00000000;
- break;
- case DXGI_FORMAT_B5G5R5A1_UNORM:
- hdr->pixelfmt.bpp = 16;
- hdr->pixelfmt.rmask = 0x00007c00;
- hdr->pixelfmt.gmask = 0x000003e0;
- hdr->pixelfmt.bmask = 0x0000001f;
- hdr->pixelfmt.amask = 0x00008000;
- break;
- case DXGI_FORMAT_R10G10B10A2_TYPELESS:
- case DXGI_FORMAT_R10G10B10A2_UNORM:
- case DXGI_FORMAT_R10G10B10A2_UINT:
- hdr->pixelfmt.bpp = 32;
- hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = 0x000003ff;
- hdr->pixelfmt.gmask = 0x000ffc00;
- hdr->pixelfmt.bmask = 0x3ff00000;
- hdr->pixelfmt.amask = 0xc0000000;
- break;
- case DXGI_FORMAT_A8_UNORM:
- hdr->pixelfmt.bpp = 8;
- hdr->pixelfmt.flags |= DDPF_ALPHA | DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = hdr->pixelfmt.gmask = hdr->pixelfmt.bmask = 0;
- hdr->pixelfmt.amask = 0x000000ff;
- break;
- case DXGI_FORMAT_R8_TYPELESS:
- case DXGI_FORMAT_R8_UNORM:
- case DXGI_FORMAT_R8_UINT:
- case DXGI_FORMAT_R8_SNORM:
- case DXGI_FORMAT_R8_SINT:
- hdr->pixelfmt.bpp = 8;
- hdr->pixelfmt.rmask = 0x000000ff;
- hdr->pixelfmt.gmask = hdr->pixelfmt.bmask = hdr->pixelfmt.amask = 0;
- break;
- case DXGI_FORMAT_B4G4R4A4_UNORM:
- hdr->pixelfmt.bpp = 16;
- hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
- hdr->pixelfmt.rmask = 0x00000f00;
- hdr->pixelfmt.gmask = 0x000000f0;
- hdr->pixelfmt.bmask = 0x0000000f;
- hdr->pixelfmt.amask = 0x0000f000;
- break;
- case DXGI_FORMAT_UNKNOWN:
- g_message("Unknown DXGI format. Expect problems...");
- break;
- default: /* unsupported DXGI format */
- g_message("Unsupported DXGI format (%d)", dx10hdr->dxgiFormat);
- return(0);
- }
- }
-
- return(1);
+ switch (dx10hdr->dxgiFormat)
+ {
+ case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+ case DXGI_FORMAT_B8G8R8A8_UNORM:
+ case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+ hdr->pixelfmt.bpp = 32;
+ hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = 0x00ff0000;
+ hdr->pixelfmt.gmask = 0x0000ff00;
+ hdr->pixelfmt.bmask = 0x000000ff;
+ hdr->pixelfmt.amask = 0xff000000;
+ break;
+ case DXGI_FORMAT_B8G8R8X8_TYPELESS:
+ case DXGI_FORMAT_B8G8R8X8_UNORM:
+ case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+ hdr->pixelfmt.bpp = 32;
+ hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = 0x00ff0000;
+ hdr->pixelfmt.gmask = 0x0000ff00;
+ hdr->pixelfmt.bmask = 0x000000ff;
+ hdr->pixelfmt.amask = 0x00000000;
+ break;
+ case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+ case DXGI_FORMAT_R8G8B8A8_UNORM:
+ case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+ case DXGI_FORMAT_R8G8B8A8_UINT:
+ case DXGI_FORMAT_R8G8B8A8_SNORM:
+ case DXGI_FORMAT_R8G8B8A8_SINT:
+ hdr->pixelfmt.bpp = 32;
+ hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = 0x000000ff;
+ hdr->pixelfmt.gmask = 0x0000ff00;
+ hdr->pixelfmt.bmask = 0x00ff0000;
+ hdr->pixelfmt.amask = 0xff000000;
+ break;
+ case DXGI_FORMAT_B5G6R5_UNORM:
+ hdr->pixelfmt.bpp = 16;
+ hdr->pixelfmt.rmask = 0x0000f800;
+ hdr->pixelfmt.gmask = 0x000007e0;
+ hdr->pixelfmt.bmask = 0x0000001f;
+ hdr->pixelfmt.amask = 0x00000000;
+ break;
+ case DXGI_FORMAT_B5G5R5A1_UNORM:
+ hdr->pixelfmt.bpp = 16;
+ hdr->pixelfmt.rmask = 0x00007c00;
+ hdr->pixelfmt.gmask = 0x000003e0;
+ hdr->pixelfmt.bmask = 0x0000001f;
+ hdr->pixelfmt.amask = 0x00008000;
+ break;
+ case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+ case DXGI_FORMAT_R10G10B10A2_UNORM:
+ case DXGI_FORMAT_R10G10B10A2_UINT:
+ hdr->pixelfmt.bpp = 32;
+ hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = 0x000003ff;
+ hdr->pixelfmt.gmask = 0x000ffc00;
+ hdr->pixelfmt.bmask = 0x3ff00000;
+ hdr->pixelfmt.amask = 0xc0000000;
+ break;
+ case DXGI_FORMAT_A8_UNORM:
+ hdr->pixelfmt.bpp = 8;
+ hdr->pixelfmt.flags |= DDPF_ALPHA | DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = hdr->pixelfmt.gmask = hdr->pixelfmt.bmask = 0;
+ hdr->pixelfmt.amask = 0x000000ff;
+ break;
+ case DXGI_FORMAT_R8_TYPELESS:
+ case DXGI_FORMAT_R8_UNORM:
+ case DXGI_FORMAT_R8_UINT:
+ case DXGI_FORMAT_R8_SNORM:
+ case DXGI_FORMAT_R8_SINT:
+ hdr->pixelfmt.bpp = 8;
+ hdr->pixelfmt.rmask = 0x000000ff;
+ hdr->pixelfmt.gmask = hdr->pixelfmt.bmask = hdr->pixelfmt.amask = 0;
+ break;
+ case DXGI_FORMAT_B4G4R4A4_UNORM:
+ hdr->pixelfmt.bpp = 16;
+ hdr->pixelfmt.flags |= DDPF_ALPHAPIXELS;
+ hdr->pixelfmt.rmask = 0x00000f00;
+ hdr->pixelfmt.gmask = 0x000000f0;
+ hdr->pixelfmt.bmask = 0x0000000f;
+ hdr->pixelfmt.amask = 0x0000f000;
+ break;
+ case DXGI_FORMAT_UNKNOWN:
+ g_message ("Unknown DXGI format. Expect problems...");
+ break;
+ default: /* unsupported DXGI format */
+ g_message ("Unsupported DXGI format (%d)", dx10hdr->dxgiFormat);
+ return (0);
+ }
+ }
+
+ return (1);
}
@@ -812,440 +841,466 @@ premultiplied_variant (const Babl* format)
if (format == babl_format ("R'G'B'A u8"))
return babl_format ("R'aG'aB'aA u8");
else
- g_printerr ("Add format %s to premultiplied_variant() %s: %d\n", babl_get_name (format), __FILE__,
__LINE__);
+ g_printerr ("Add format %s to premultiplied_variant () %s: %d\n", babl_get_name (format), __FILE__,
__LINE__);
return format;
}
-static int load_layer(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, unsigned int level, char *prefix,
- unsigned int *l, guchar *pixels, unsigned char *buf)
+static int
+load_layer (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ unsigned int level,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf)
{
- GeglBuffer *buffer;
- const Babl *bablfmt = NULL;
- GimpImageType type = GIMP_RGBA_IMAGE;
- gchar *layer_name;
- gint x, y, z, n;
- gint32 layer;
- unsigned int width = hdr->width >> level;
- unsigned int height = hdr->height >> level;
- unsigned int size = hdr->pitch_or_linsize >> (2 * level);
- unsigned int layerw;
- int format = DDS_COMPRESS_NONE;
-
- if(width < 1) width = 1;
- if(height < 1) height = 1;
-
- switch(d->bpp)
- {
- case 1:
- if(hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
- {
- type = GIMP_INDEXED_IMAGE;
- bablfmt = babl_format("R'G'B' u8");
- }
- else if(hdr->pixelfmt.rmask == 0xe0)
- {
- type = GIMP_RGB_IMAGE;
- bablfmt = babl_format("R'G'B' u8");
- }
- else if(hdr->pixelfmt.flags & DDPF_ALPHA)
- {
- type = GIMP_GRAYA_IMAGE;
- bablfmt = babl_format("Y'A u8");
- }
- else
- {
- type = GIMP_GRAY_IMAGE;
- bablfmt = babl_format("Y' u8");
- }
- break;
- case 2:
- if(hdr->pixelfmt.amask == 0xf000) //RGBA4
- {
- type = GIMP_RGBA_IMAGE;
- bablfmt = babl_format("R'G'B'A u8");
- }
- else if(hdr->pixelfmt.amask == 0xff00) //L8A8
- {
- type = GIMP_GRAYA_IMAGE;
- bablfmt = babl_format("Y'A u8");
- }
- else if(hdr->pixelfmt.bmask == 0x1f) //R5G6B5 or RGB5A1
- {
- type = (hdr->pixelfmt.amask == 0x8000) ? GIMP_RGBA_IMAGE : GIMP_RGB_IMAGE;
- bablfmt = (hdr->pixelfmt.amask == 0x8000) ? babl_format("R'G'B'A u8") : babl_format("R'G'B' u8");
- }
- else //L16
- {
- type = GIMP_GRAY_IMAGE;
- bablfmt = babl_format("Y' u8");
- }
- break;
- case 3: type = GIMP_RGB_IMAGE; bablfmt = babl_format("R'G'B' u8"); break;
- case 4: type = GIMP_RGBA_IMAGE; bablfmt = babl_format("R'G'B'A u8"); break;
- }
-
- layer_name = (level) ? g_strdup_printf("mipmap %d %s", level, prefix) :
- g_strdup_printf("main surface %s", prefix);
-
- layer = gimp_layer_new(image, layer_name, width, height, type, 100,
+ GeglBuffer *buffer;
+ const Babl *bablfmt = NULL;
+ GimpImageType type = GIMP_RGBA_IMAGE;
+ gchar *layer_name;
+ gint x, y, z, n;
+ gint32 layer;
+ unsigned int width = hdr->width >> level;
+ unsigned int height = hdr->height >> level;
+ unsigned int size = hdr->pitch_or_linsize >> (2 * level);
+ unsigned int layerw;
+ int format = DDS_COMPRESS_NONE;
+
+ if (width < 1) width = 1;
+ if (height < 1) height = 1;
+
+ switch (d->bpp)
+ {
+ case 1:
+ if (hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ {
+ type = GIMP_INDEXED_IMAGE;
+ bablfmt = babl_format ("R'G'B' u8");
+ }
+ else if (hdr->pixelfmt.rmask == 0xe0)
+ {
+ type = GIMP_RGB_IMAGE;
+ bablfmt = babl_format ("R'G'B' u8");
+ }
+ else if (hdr->pixelfmt.flags & DDPF_ALPHA)
+ {
+ type = GIMP_GRAYA_IMAGE;
+ bablfmt = babl_format ("Y'A u8");
+ }
+ else
+ {
+ type = GIMP_GRAY_IMAGE;
+ bablfmt = babl_format ("Y' u8");
+ }
+ break;
+ case 2:
+ if (hdr->pixelfmt.amask == 0xf000) /* RGBA4 */
+ {
+ type = GIMP_RGBA_IMAGE;
+ bablfmt = babl_format ("R'G'B'A u8");
+ }
+ else if (hdr->pixelfmt.amask == 0xff00) /* L8A8 */
+ {
+ type = GIMP_GRAYA_IMAGE;
+ bablfmt = babl_format ("Y'A u8");
+ }
+ else if (hdr->pixelfmt.bmask == 0x1f) /* R5G6B5 or RGB5A1 */
+ {
+ type = (hdr->pixelfmt.amask == 0x8000) ? GIMP_RGBA_IMAGE : GIMP_RGB_IMAGE;
+ bablfmt = (hdr->pixelfmt.amask == 0x8000) ? babl_format ("R'G'B'A u8") : babl_format ("R'G'B' u8");
+ }
+ else /* L16 */
+ {
+ type = GIMP_GRAY_IMAGE;
+ bablfmt = babl_format ("Y' u8");
+ }
+ break;
+ case 3: type = GIMP_RGB_IMAGE; bablfmt = babl_format ("R'G'B' u8"); break;
+ case 4: type = GIMP_RGBA_IMAGE; bablfmt = babl_format ("R'G'B'A u8"); break;
+ }
+
+ layer_name = (level) ? g_strdup_printf ("mipmap %d %s", level, prefix) :
+ g_strdup_printf ("main surface %s", prefix);
+
+ layer = gimp_layer_new (image, layer_name, width, height, type, 100,
GIMP_LAYER_MODE_NORMAL);
- g_free(layer_name);
+ g_free (layer_name);
+
+ gimp_image_insert_layer (image, layer, 0, *l);
- gimp_image_insert_layer(image, layer, 0, *l);
+ if ((*l)++) gimp_item_set_visible (layer, FALSE);
- if((*l)++) gimp_item_set_visible(layer, FALSE);
+ buffer = gimp_drawable_get_buffer (layer);
- buffer = gimp_drawable_get_buffer(layer);
-
- layerw = gegl_buffer_get_width(buffer);
+ layerw = gegl_buffer_get_width (buffer);
- if(hdr->pixelfmt.flags & DDPF_FOURCC)
- {
+ if (hdr->pixelfmt.flags & DDPF_FOURCC)
+ {
unsigned int w = (width + 3) >> 2;
unsigned int h = (height + 3) >> 2;
- switch(GETL32(hdr->pixelfmt.fourcc))
- {
- case FOURCC('D','X','T','1'): format = DDS_COMPRESS_BC1; break;
- case FOURCC('D','X','T','2'): bablfmt = premultiplied_variant (bablfmt);
- case FOURCC('D','X','T','3'): format = DDS_COMPRESS_BC2; break;
- case FOURCC('D','X','T','4'): bablfmt = premultiplied_variant (bablfmt);
- case FOURCC('D','X','T','5'): format = DDS_COMPRESS_BC3; break;
- case FOURCC('R','X','G','B'): format = DDS_COMPRESS_BC3; break;
- case FOURCC('A','T','I','1'):
- case FOURCC('B','C','4','U'):
- case FOURCC('B','C','4','S'): format = DDS_COMPRESS_BC4; break;
- case FOURCC('A','T','I','2'):
- case FOURCC('B','C','5','U'):
- case FOURCC('B','C','5','S'): format = DDS_COMPRESS_BC5; break;
- }
+ switch (GETL32(hdr->pixelfmt.fourcc))
+ {
+ case FOURCC ('D','X','T','1'): format = DDS_COMPRESS_BC1; break;
+ case FOURCC ('D','X','T','2'): bablfmt = premultiplied_variant (bablfmt);
+ case FOURCC ('D','X','T','3'): format = DDS_COMPRESS_BC2; break;
+ case FOURCC ('D','X','T','4'): bablfmt = premultiplied_variant (bablfmt);
+ case FOURCC ('D','X','T','5'): format = DDS_COMPRESS_BC3; break;
+ case FOURCC ('R','X','G','B'): format = DDS_COMPRESS_BC3; break;
+ case FOURCC ('A','T','I','1'):
+ case FOURCC ('B','C','4','U'):
+ case FOURCC ('B','C','4','S'): format = DDS_COMPRESS_BC4; break;
+ case FOURCC ('A','T','I','2'):
+ case FOURCC ('B','C','5','U'):
+ case FOURCC ('B','C','5','S'): format = DDS_COMPRESS_BC5; break;
+ }
size = w * h;
- if((format == DDS_COMPRESS_BC1) || (format == DDS_COMPRESS_BC4))
- size *= 8;
+ if ((format == DDS_COMPRESS_BC1) || (format == DDS_COMPRESS_BC4))
+ size *= 8;
else
- size *= 16;
- }
-
- if((hdr->flags & DDSD_LINEARSIZE) &&
- !fread(buf, size, 1, fp))
- {
- g_message("Unexpected EOF.\n");
- return(0);
- }
-
- if((hdr->pixelfmt.flags & DDPF_RGB) || (hdr->pixelfmt.flags & DDPF_ALPHA))
- {
+ size *= 16;
+ }
+
+ if ((hdr->flags & DDSD_LINEARSIZE) &&
+ !fread (buf, size, 1, fp))
+ {
+ g_message ("Unexpected EOF.\n");
+ return (0);
+ }
+
+ if ((hdr->pixelfmt.flags & DDPF_RGB) || (hdr->pixelfmt.flags & DDPF_ALPHA))
+ {
z = 0;
- for(y = 0, n = 0; y < height; ++y, ++n)
- {
- if(n >= d->tile_height)
- {
- gegl_buffer_set(buffer, GEGL_RECTANGLE(0, y - n, layerw, n), 0,
- bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
- n = 0;
- gimp_progress_update((double)y / (double)hdr->height);
- }
-
- if((hdr->flags & DDSD_PITCH) &&
- !fread(buf, width * d->bpp, 1, fp))
- {
- g_message("Unexpected EOF.\n");
- return(0);
- }
-
- if(!(hdr->flags & DDSD_LINEARSIZE)) z = 0;
-
- for(x = 0; x < layerw; ++x)
- {
- unsigned int pixel = buf[z];
- unsigned int pos = (n * layerw + x) * d->gimp_bpp;
-
- if(d->bpp > 1) pixel += ((unsigned int)buf[z + 1] << 8);
- if(d->bpp > 2) pixel += ((unsigned int)buf[z + 2] << 16);
- if(d->bpp > 3) pixel += ((unsigned int)buf[z + 3] << 24);
-
- if(d->bpp >= 3)
+ for (y = 0, n = 0; y < height; ++y, ++n)
+ {
+ if (n >= d->tile_height)
{
- if(hdr->pixelfmt.amask == 0xc0000000) // handle RGB10A2
- {
- pixels[pos + 0] = (pixel >> d->bshift) >> 2;
- pixels[pos + 1] = (pixel >> d->gshift) >> 2;
- pixels[pos + 2] = (pixel >> d->rshift) >> 2;
- if(hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
- pixels[pos + 3] = (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
- }
- else
- {
- pixels[pos] =
- (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
- pixels[pos + 1] =
- (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
- pixels[pos + 2] =
- (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
- if(hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
- {
- pixels[pos + 3] =
- (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
- }
- }
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y - n, layerw, n), 0,
+ bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
+ n = 0;
+ gimp_progress_update ((double)y / (double)hdr->height);
}
- else if(d->bpp == 2)
+
+ if ((hdr->flags & DDSD_PITCH) &&
+ !fread (buf, width * d->bpp, 1, fp))
{
- if(hdr->pixelfmt.amask == 0xf000) //RGBA4
- {
- pixels[pos] =
- (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
- pixels[pos + 1] =
- (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
- pixels[pos + 2] =
- (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
- pixels[pos + 3] =
- (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
- }
- else if(hdr->pixelfmt.amask == 0xff00) //L8A8
- {
- pixels[pos] =
- (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
- pixels[pos + 1] =
- (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
- }
- else if(hdr->pixelfmt.bmask == 0x1f) //R5G6B5 or RGB5A1
- {
- pixels[pos] =
- (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
- pixels[pos + 1] =
- (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
- pixels[pos + 2] =
- (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
- if(hdr->pixelfmt.amask == 0x8000)
- {
- pixels[pos + 3] =
- (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
- }
- }
- else //L16
- pixels[pos] = (unsigned char)(255 * ((float)(pixel & 0xffff) / 65535.0f));
+ g_message ("Unexpected EOF.\n");
+ return (0);
}
- else
+
+ if (!(hdr->flags & DDSD_LINEARSIZE)) z = 0;
+
+ for (x = 0; x < layerw; ++x)
{
- if(hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
- {
- pixels[pos] = pixel & 0xff;
- }
- else if(hdr->pixelfmt.rmask == 0xe0) // R3G3B2
- {
- pixels[pos] =
- (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
- pixels[pos + 1] =
- (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
- pixels[pos + 2] =
- (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
- }
- else if(hdr->pixelfmt.flags & DDPF_ALPHA)
- {
- pixels[pos + 0] = 255;
- pixels[pos + 1] = pixel & 0xff;
- }
- else // LUMINANCE
- {
- pixels[pos] = pixel & 0xff;
- }
+ unsigned int pixel = buf[z];
+ unsigned int pos = (n * layerw + x) * d->gimp_bpp;
+
+ if (d->bpp > 1) pixel += ((unsigned int)buf[z + 1] << 8);
+ if (d->bpp > 2) pixel += ((unsigned int)buf[z + 2] << 16);
+ if (d->bpp > 3) pixel += ((unsigned int)buf[z + 3] << 24);
+
+ if (d->bpp >= 3)
+ {
+ if (hdr->pixelfmt.amask == 0xc0000000) // handle RGB10A2
+ {
+ pixels[pos + 0] = (pixel >> d->bshift) >> 2;
+ pixels[pos + 1] = (pixel >> d->gshift) >> 2;
+ pixels[pos + 2] = (pixel >> d->rshift) >> 2;
+ if (hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
+ pixels[pos + 3] = (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
+ }
+ else
+ {
+ pixels[pos] =
+ (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
+ pixels[pos + 1] =
+ (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
+ pixels[pos + 2] =
+ (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
+ if (hdr->pixelfmt.flags & DDPF_ALPHAPIXELS)
+ {
+ pixels[pos + 3] =
+ (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
+ }
+ }
+ }
+ else if (d->bpp == 2)
+ {
+ if (hdr->pixelfmt.amask == 0xf000) //RGBA4
+ {
+ pixels[pos] =
+ (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
+ pixels[pos + 1] =
+ (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
+ pixels[pos + 2] =
+ (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
+ pixels[pos + 3] =
+ (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
+ }
+ else if (hdr->pixelfmt.amask == 0xff00) //L8A8
+ {
+ pixels[pos] =
+ (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
+ pixels[pos + 1] =
+ (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
+ }
+ else if (hdr->pixelfmt.bmask == 0x1f) //R5G6B5 or RGB5A1
+ {
+ pixels[pos] =
+ (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
+ pixels[pos + 1] =
+ (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
+ pixels[pos + 2] =
+ (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
+ if (hdr->pixelfmt.amask == 0x8000)
+ {
+ pixels[pos + 3] =
+ (pixel >> d->ashift << (8 - d->abits) & d->amask) * 255 / d->amask;
+ }
+ }
+ else //L16
+ pixels[pos] = (unsigned char)(255 * ((float)(pixel & 0xffff) / 65535.0f));
+ }
+ else
+ {
+ if (hdr->pixelfmt.flags & DDPF_PALETTEINDEXED8)
+ {
+ pixels[pos] = pixel & 0xff;
+ }
+ else if (hdr->pixelfmt.rmask == 0xe0) // R3G3B2
+ {
+ pixels[pos] =
+ (pixel >> d->rshift << (8 - d->rbits) & d->rmask) * 255 / d->rmask;
+ pixels[pos + 1] =
+ (pixel >> d->gshift << (8 - d->gbits) & d->gmask) * 255 / d->gmask;
+ pixels[pos + 2] =
+ (pixel >> d->bshift << (8 - d->bbits) & d->bmask) * 255 / d->bmask;
+ }
+ else if (hdr->pixelfmt.flags & DDPF_ALPHA)
+ {
+ pixels[pos + 0] = 255;
+ pixels[pos + 1] = pixel & 0xff;
+ }
+ else // LUMINANCE
+ {
+ pixels[pos] = pixel & 0xff;
+ }
+ }
+
+ z += d->bpp;
}
+ }
- z += d->bpp;
- }
- }
-
- gegl_buffer_set(buffer, GEGL_RECTANGLE(0, y - n, layerw, n), 0,
- bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
- }
- else if(hdr->pixelfmt.flags & DDPF_FOURCC)
- {
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y - n, layerw, n), 0,
+ bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
+ }
+ else if (hdr->pixelfmt.flags & DDPF_FOURCC)
+ {
unsigned char *dst;
- if(!(hdr->flags & DDSD_LINEARSIZE))
- {
- g_message("Image marked as compressed, but DDSD_LINEARSIZE is not set.\n");
- return(0);
- }
+ if (!(hdr->flags & DDSD_LINEARSIZE))
+ {
+ g_message ("Image marked as compressed, but DDSD_LINEARSIZE is not set.\n");
+ return (0);
+ }
- dst = g_malloc(width * height * d->gimp_bpp);
- memset(dst, 0, width * height * d->gimp_bpp);
+ dst = g_malloc (width * height * d->gimp_bpp);
+ memset (dst, 0, width * height * d->gimp_bpp);
- if(d->gimp_bpp == 4)
- {
- for(y = 0; y < height; ++y)
- for(x = 0; x < width; ++x)
- dst[y * (width * 4) + (x * 4) + 3] = 255;
- }
+ if (d->gimp_bpp == 4)
+ {
+ for (y = 0; y < height; ++y)
+ for (x = 0; x < width; ++x)
+ dst[y * (width * 4) + (x * 4) + 3] = 255;
+ }
- dxt_decompress(dst, buf, format, size, width, height, d->gimp_bpp,
- hdr->pixelfmt.flags & DDPF_NORMAL);
+ dxt_decompress (dst, buf, format, size, width, height, d->gimp_bpp,
+ hdr->pixelfmt.flags & DDPF_NORMAL);
z = 0;
- for(y = 0, n = 0; y < height; ++y, ++n)
- {
- if(n >= d->tile_height)
- {
- gegl_buffer_set(buffer, GEGL_RECTANGLE(0, y - n, layerw, n), 0,
- bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
- n = 0;
- gimp_progress_update((double)y / (double)hdr->height);
- }
-
- memcpy(pixels + n * layerw * d->gimp_bpp,
- dst + y * layerw * d->gimp_bpp,
- width * d->gimp_bpp);
- }
-
- gegl_buffer_set(buffer, GEGL_RECTANGLE(0, y - n, layerw, n), 0,
- bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
-
- g_free(dst);
- }
-
- gegl_buffer_flush(buffer);
-
- g_object_unref(buffer);
-
- /* gimp dds specific. decode encoded images */
- if(dds_read_vals.decode_images &&
- hdr->reserved.gimp_dds_special.magic1 == FOURCC('G','I','M','P') &&
- hdr->reserved.gimp_dds_special.magic2 == FOURCC('-','D','D','S'))
- {
- switch(hdr->reserved.gimp_dds_special.extra_fourcc)
- {
- case FOURCC('A','E','X','P'):
- decode_alpha_exp_image(layer, FALSE);
- break;
- case FOURCC('Y','C','G','1'):
- decode_ycocg_image(layer, FALSE);
- break;
- case FOURCC('Y','C','G','2'):
- decode_ycocg_scaled_image(layer, FALSE);
- break;
- default:
- break;
- }
- }
-
- return(1);
+ for (y = 0, n = 0; y < height; ++y, ++n)
+ {
+ if (n >= d->tile_height)
+ {
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y - n, layerw, n), 0,
+ bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
+ n = 0;
+ gimp_progress_update ((double)y / (double)hdr->height);
+ }
+
+ memcpy (pixels + n * layerw * d->gimp_bpp,
+ dst + y * layerw * d->gimp_bpp,
+ width * d->gimp_bpp);
+ }
+
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y - n, layerw, n), 0,
+ bablfmt, pixels, GEGL_AUTO_ROWSTRIDE);
+
+ g_free (dst);
+ }
+
+ gegl_buffer_flush (buffer);
+
+ g_object_unref (buffer);
+
+ /* gimp dds specific. decode encoded images */
+ if (dds_read_vals.decode_images &&
+ hdr->reserved.gimp_dds_special.magic1 == FOURCC ('G','I','M','P') &&
+ hdr->reserved.gimp_dds_special.magic2 == FOURCC ('-','D','D','S'))
+ {
+ switch (hdr->reserved.gimp_dds_special.extra_fourcc)
+ {
+ case FOURCC ('A','E','X','P'):
+ decode_alpha_exp_image (layer, FALSE);
+ break;
+ case FOURCC ('Y','C','G','1'):
+ decode_ycocg_image (layer, FALSE);
+ break;
+ case FOURCC ('Y','C','G','2'):
+ decode_ycocg_scaled_image (layer, FALSE);
+ break;
+ default:
+ break;
+ }
+ }
+
+ return (1);
}
-static int load_mipmaps(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, char *prefix, unsigned int *l,
- guchar *pixels, unsigned char *buf)
+static int
+load_mipmaps (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf)
{
- unsigned int level;
+ unsigned int level;
- if((hdr->flags & DDSD_MIPMAPCOUNT) &&
+ if ((hdr->flags & DDSD_MIPMAPCOUNT) &&
(hdr->caps.caps1 & DDSCAPS_MIPMAP) &&
(dds_read_vals.mipmaps != 0))
- {
- for(level = 1; level < hdr->num_mipmaps; ++level)
- {
- if(!load_layer(fp, hdr, d, image, level, prefix, l, pixels, buf))
- return(0);
- }
- }
- return(1);
+ {
+ for (level = 1; level < hdr->num_mipmaps; ++level)
+ {
+ if (!load_layer (fp, hdr, d, image, level, prefix, l, pixels, buf))
+ return (0);
+ }
+ }
+ return (1);
}
-static int load_face(FILE *fp, dds_header_t *hdr, dds_load_info_t *d,
- gint32 image, char *prefix, unsigned int *l,
- guchar *pixels, unsigned char *buf)
+static int
+load_face (FILE *fp,
+ dds_header_t *hdr,
+ dds_load_info_t *d,
+ gint32 image,
+ char *prefix,
+ unsigned int *l,
+ guchar *pixels,
+ unsigned char *buf)
{
- if(!load_layer(fp, hdr, d, image, 0, prefix, l, pixels, buf))
- return(0);
- return(load_mipmaps(fp, hdr, d, image, prefix, l, pixels, buf));
+ if (!load_layer (fp, hdr, d, image, 0, prefix, l, pixels, buf))
+ return (0);
+ return (load_mipmaps (fp, hdr, d, image, prefix, l, pixels, buf));
}
-static unsigned char color_bits(unsigned int mask)
+static unsigned char
+color_bits (unsigned int mask)
{
- unsigned char i = 0;
+ unsigned char i = 0;
- while(mask)
- {
- if(mask & 1) ++i;
+ while (mask)
+ {
+ if (mask & 1) ++i;
mask >>= 1;
- }
- return(i);
+ }
+ return (i);
}
-static unsigned char color_shift(unsigned int mask)
+static unsigned char
+color_shift (unsigned int mask)
{
- unsigned char i = 0;
+ unsigned char i = 0;
- if(!mask) return(0);
- while(!((mask >> i) & 1)) ++i;
- return(i);
+ if (!mask) return (0);
+ while (!((mask >> i) & 1)) ++i;
+ return (i);
}
-static void load_dialog_response(GtkWidget *widget, gint response_id,
- gpointer data)
+static void
+load_dialog_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data)
{
- switch(response_id)
- {
- case GTK_RESPONSE_OK:
- runme = 1;
- default:
- gtk_widget_destroy(widget);
- break;
- }
+ switch (response_id)
+ {
+ case GTK_RESPONSE_OK:
+ runme = 1;
+ default:
+ gtk_widget_destroy (widget);
+ break;
+ }
}
-static void toggle_clicked(GtkWidget *widget, gpointer data)
+static void
+toggle_clicked (GtkWidget *widget,
+ gpointer data)
{
- int *flag = (int*)data;
- (*flag) = !(*flag);
+ int *flag = (int*) data;
+ (*flag) = !(*flag);
}
-static int load_dialog(void)
+static int
+load_dialog (void)
{
- GtkWidget *dlg;
- GtkWidget *vbox;
- GtkWidget *check;
+ GtkWidget *dlg;
+ GtkWidget *vbox;
+ GtkWidget *check;
- dlg = gimp_dialog_new(_("Load DDS"), "dds", NULL, GTK_WIN_POS_MOUSE,
+ dlg = gimp_dialog_new (_("Load DDS"), "dds", NULL, GTK_WIN_POS_MOUSE,
gimp_standard_help_func, LOAD_PROC,
_("Cancel"), GTK_RESPONSE_CANCEL,
_("OK"), GTK_RESPONSE_OK,
NULL);
- g_signal_connect(dlg, "response",
+ g_signal_connect (dlg, "response",
G_CALLBACK (load_dialog_response),
0);
- g_signal_connect(dlg, "destroy",
+ g_signal_connect (dlg, "destroy",
G_CALLBACK (gtk_main_quit),
0);
- vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
- gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dlg))),
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
vbox, 1, 1, 0);
- gtk_widget_show(vbox);
+ gtk_widget_show (vbox);
- check = gtk_check_button_new_with_label(_("Load mipmaps"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_read_vals.mipmaps);
- g_signal_connect(check, "clicked",
+ check = gtk_check_button_new_with_label (_("Load mipmaps"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_read_vals.mipmaps);
+ g_signal_connect (check, "clicked",
G_CALLBACK (toggle_clicked), &dds_read_vals.mipmaps);
- gtk_box_pack_start(GTK_BOX(vbox), check, 1, 1, 0);
- gtk_widget_show(check);
+ gtk_box_pack_start (GTK_BOX (vbox), check, 1, 1, 0);
+ gtk_widget_show (check);
- check = gtk_check_button_new_with_label(_("Automatically decode YCoCg/AExp images when detected"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_read_vals.decode_images);
- g_signal_connect(check, "clicked",
+ check = gtk_check_button_new_with_label (_("Automatically decode YCoCg/AExp images when detected"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_read_vals.decode_images);
+ g_signal_connect (check, "clicked",
G_CALLBACK (toggle_clicked), &dds_read_vals.decode_images);
- gtk_box_pack_start(GTK_BOX(vbox), check, 1, 1, 0);
- gtk_widget_show(check);
+ gtk_box_pack_start (GTK_BOX (vbox), check, 1, 1, 0);
+ gtk_widget_show (check);
- gtk_widget_show(dlg);
+ gtk_widget_show (dlg);
- runme = 0;
+ runme = 0;
- gtk_main();
+ gtk_main ();
- return(runme);
+ return (runme);
}
diff --git a/plug-ins/file-dds/ddswrite.c b/plug-ins/file-dds/ddswrite.c
index b5a297c7e5..b19b3c6cc5 100644
--- a/plug-ins/file-dds/ddswrite.c
+++ b/plug-ins/file-dds/ddswrite.c
@@ -1,24 +1,24 @@
/*
- DDS GIMP plugin
-
- Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
- with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not, write to
- the Free Software Foundation, 51 Franklin Street, Fifth Floor
- Boston, MA 02110-1301, USA.
-*/
+ * DDS GIMP plugin
+ *
+ * Copyright (C) 2004-2012 Shawn Kirst <skirst gmail com>,
+ * with parts (C) 2003 Arne Reuter <homepage arnereuter de> where specified.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301, USA.
+ */
#include "config.h"
@@ -43,39 +43,46 @@
#include "imath.h"
#include "color.h"
-static gint save_dialog(gint32 image_id, gint32 drawable);
-static void save_dialog_response(GtkWidget *widget, gint response_id, gpointer data);
-static int write_image(FILE *fp, gint32 image_id, gint32 drawable_id);
+static gint save_dialog (gint32 image_id,
+ gint32 drawable);
+static void save_dialog_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data);
+static int write_image (FILE *fp,
+ gint32 image_id,
+ gint32 drawable_id);
static int runme = 0;
enum
{
- COMBO_VALUE, COMBO_STRING, COMBO_SENSITIVE
+ COMBO_VALUE,
+ COMBO_STRING,
+ COMBO_SENSITIVE
};
static const char *cubemap_face_names[4][6] =
{
- {
+ {
"positive x", "negative x",
"positive y", "negative y",
"positive z", "negative z"
- },
- {
+ },
+ {
"pos x", "neg x",
"pos y", "neg y",
"pos z", "neg z",
- },
- {
+ },
+ {
"+x", "-x",
"+y", "-y",
"+z", "-z"
- },
- {
+ },
+ {
"right", "left",
"top", "bottom",
"back", "front"
- }
+ }
};
static gint cubemap_faces[6];
@@ -98,1187 +105,1234 @@ static GtkWidget *alpha_test_threshold_spin;
typedef struct string_value_s
{
- int value;
- char *string;
+ int value;
+ char *string;
} string_value_t;
static string_value_t compression_strings[] =
{
- {DDS_COMPRESS_NONE, "None"},
- {DDS_COMPRESS_BC1, "BC1 / DXT1"},
- {DDS_COMPRESS_BC2, "BC2 / DXT3"},
- {DDS_COMPRESS_BC3, "BC3 / DXT5"},
- {DDS_COMPRESS_BC3N, "BC3nm / DXT5nm"},
- {DDS_COMPRESS_BC4, "BC4 / ATI1 (3Dc+)"},
- {DDS_COMPRESS_BC5, "BC5 / ATI2 (3Dc)"},
- {DDS_COMPRESS_RXGB, "RXGB (DXT5)"},
- {DDS_COMPRESS_AEXP, "Alpha Exponent (DXT5)"},
- {DDS_COMPRESS_YCOCG, "YCoCg (DXT5)"},
- {DDS_COMPRESS_YCOCGS, "YCoCg scaled (DXT5)"},
- {-1, 0}
+ {DDS_COMPRESS_NONE, "None"},
+ {DDS_COMPRESS_BC1, "BC1 / DXT1"},
+ {DDS_COMPRESS_BC2, "BC2 / DXT3"},
+ {DDS_COMPRESS_BC3, "BC3 / DXT5"},
+ {DDS_COMPRESS_BC3N, "BC3nm / DXT5nm"},
+ {DDS_COMPRESS_BC4, "BC4 / ATI1 (3Dc+)"},
+ {DDS_COMPRESS_BC5, "BC5 / ATI2 (3Dc)"},
+ {DDS_COMPRESS_RXGB, "RXGB (DXT5)"},
+ {DDS_COMPRESS_AEXP, "Alpha Exponent (DXT5)"},
+ {DDS_COMPRESS_YCOCG, "YCoCg (DXT5)"},
+ {DDS_COMPRESS_YCOCGS, "YCoCg scaled (DXT5)"},
+ {-1, 0}
};
static string_value_t format_strings[] =
{
- {DDS_FORMAT_DEFAULT, "Default"},
- {DDS_FORMAT_RGB8, "RGB8"},
- {DDS_FORMAT_RGBA8, "RGBA8"},
- {DDS_FORMAT_BGR8, "BGR8"},
- {DDS_FORMAT_ABGR8, "ABGR8"},
- {DDS_FORMAT_R5G6B5, "R5G6B5"},
- {DDS_FORMAT_RGBA4, "RGBA4"},
- {DDS_FORMAT_RGB5A1, "RGB5A1"},
- {DDS_FORMAT_RGB10A2, "RGB10A2"},
- {DDS_FORMAT_R3G3B2, "R3G3B2"},
- {DDS_FORMAT_A8, "A8"},
- {DDS_FORMAT_L8, "L8"},
- {DDS_FORMAT_L8A8, "L8A8"},
- {DDS_FORMAT_AEXP, "AExp"},
- {DDS_FORMAT_YCOCG, "YCoCg"},
- {-1, 0}
+ {DDS_FORMAT_DEFAULT, "Default"},
+ {DDS_FORMAT_RGB8, "RGB8"},
+ {DDS_FORMAT_RGBA8, "RGBA8"},
+ {DDS_FORMAT_BGR8, "BGR8"},
+ {DDS_FORMAT_ABGR8, "ABGR8"},
+ {DDS_FORMAT_R5G6B5, "R5G6B5"},
+ {DDS_FORMAT_RGBA4, "RGBA4"},
+ {DDS_FORMAT_RGB5A1, "RGB5A1"},
+ {DDS_FORMAT_RGB10A2, "RGB10A2"},
+ {DDS_FORMAT_R3G3B2, "R3G3B2"},
+ {DDS_FORMAT_A8, "A8"},
+ {DDS_FORMAT_L8, "L8"},
+ {DDS_FORMAT_L8A8, "L8A8"},
+ {DDS_FORMAT_AEXP, "AExp"},
+ {DDS_FORMAT_YCOCG, "YCoCg"},
+ {-1, 0}
};
static string_value_t mipmap_strings[] =
{
- {DDS_MIPMAP_NONE, "No mipmaps"},
- {DDS_MIPMAP_GENERATE, "Generate mipmaps"},
- {DDS_MIPMAP_EXISTING, "Use existing mipmaps"},
- {-1, 0}
+ {DDS_MIPMAP_NONE, "No mipmaps"},
+ {DDS_MIPMAP_GENERATE, "Generate mipmaps"},
+ {DDS_MIPMAP_EXISTING, "Use existing mipmaps"},
+ {-1, 0}
};
static string_value_t mipmap_filter_strings[] =
{
- {DDS_MIPMAP_FILTER_DEFAULT, "Default"},
- {DDS_MIPMAP_FILTER_NEAREST, "Nearest"},
- {DDS_MIPMAP_FILTER_BOX, "Box"},
- {DDS_MIPMAP_FILTER_TRIANGLE, "Triangle"},
- {DDS_MIPMAP_FILTER_QUADRATIC, "Quadratic"},
- {DDS_MIPMAP_FILTER_BSPLINE, "B-Spline"},
- {DDS_MIPMAP_FILTER_MITCHELL, "Mitchell"},
- {DDS_MIPMAP_FILTER_LANCZOS, "Lanczos"},
- {DDS_MIPMAP_FILTER_KAISER, "Kaiser"},
- {-1, 0}
+ {DDS_MIPMAP_FILTER_DEFAULT, "Default"},
+ {DDS_MIPMAP_FILTER_NEAREST, "Nearest"},
+ {DDS_MIPMAP_FILTER_BOX, "Box"},
+ {DDS_MIPMAP_FILTER_TRIANGLE, "Triangle"},
+ {DDS_MIPMAP_FILTER_QUADRATIC, "Quadratic"},
+ {DDS_MIPMAP_FILTER_BSPLINE, "B-Spline"},
+ {DDS_MIPMAP_FILTER_MITCHELL, "Mitchell"},
+ {DDS_MIPMAP_FILTER_LANCZOS, "Lanczos"},
+ {DDS_MIPMAP_FILTER_KAISER, "Kaiser"},
+ {-1, 0}
};
static string_value_t mipmap_wrap_strings[] =
{
- {DDS_MIPMAP_WRAP_DEFAULT, "Default"},
- {DDS_MIPMAP_WRAP_MIRROR, "Mirror"},
- {DDS_MIPMAP_WRAP_REPEAT, "Repeat"},
- {DDS_MIPMAP_WRAP_CLAMP, "Clamp"},
- {-1, 0}
+ {DDS_MIPMAP_WRAP_DEFAULT, "Default"},
+ {DDS_MIPMAP_WRAP_MIRROR, "Mirror"},
+ {DDS_MIPMAP_WRAP_REPEAT, "Repeat"},
+ {DDS_MIPMAP_WRAP_CLAMP, "Clamp"},
+ {-1, 0}
};
static string_value_t save_type_strings[] =
{
- {DDS_SAVE_SELECTED_LAYER, "Image / Selected layer"},
- {DDS_SAVE_CUBEMAP, "As cube map"},
- {DDS_SAVE_VOLUMEMAP, "As volume map"},
- {DDS_SAVE_ARRAY, "As texture array"},
- {-1, 0}
+ {DDS_SAVE_SELECTED_LAYER, "Image / Selected layer"},
+ {DDS_SAVE_CUBEMAP, "As cube map"},
+ {DDS_SAVE_VOLUMEMAP, "As volume map"},
+ {DDS_SAVE_ARRAY, "As texture array"},
+ {-1, 0}
};
static struct
{
- int format;
- DXGI_FORMAT dxgi_format;
- int bpp;
- int alpha;
- unsigned int rmask;
- unsigned int gmask;
- unsigned int bmask;
- unsigned int amask;
+ int format;
+ DXGI_FORMAT dxgi_format;
+ int bpp;
+ int alpha;
+ unsigned int rmask;
+ unsigned int gmask;
+ unsigned int bmask;
+ unsigned int amask;
} format_info[] =
{
- {DDS_FORMAT_RGB8, DXGI_FORMAT_UNKNOWN, 3, 0, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000},
- {DDS_FORMAT_RGBA8, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000},
- {DDS_FORMAT_BGR8, DXGI_FORMAT_UNKNOWN, 3, 0, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000},
- {DDS_FORMAT_ABGR8, DXGI_FORMAT_R8G8B8A8_UNORM, 4, 1, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000},
- {DDS_FORMAT_R5G6B5, DXGI_FORMAT_B5G6R5_UNORM, 2, 0, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000},
- {DDS_FORMAT_RGBA4, DXGI_FORMAT_B4G4R4A4_UNORM, 2, 1, 0x00000f00, 0x000000f0, 0x0000000f, 0x0000f000},
- {DDS_FORMAT_RGB5A1, DXGI_FORMAT_B5G5R5A1_UNORM, 2, 1, 0x00007c00, 0x000003e0, 0x0000001f, 0x00008000},
- {DDS_FORMAT_RGB10A2, DXGI_FORMAT_R10G10B10A2_UNORM, 4, 1, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000},
- {DDS_FORMAT_R3G3B2, DXGI_FORMAT_UNKNOWN, 1, 0, 0x000000e0, 0x0000001c, 0x00000003, 0x00000000},
- {DDS_FORMAT_A8, DXGI_FORMAT_A8_UNORM, 1, 0, 0x00000000, 0x00000000, 0x00000000, 0x000000ff},
- {DDS_FORMAT_L8, DXGI_FORMAT_R8_UNORM, 1, 0, 0x000000ff, 0x000000ff, 0x000000ff, 0x00000000},
- {DDS_FORMAT_L8A8, DXGI_FORMAT_UNKNOWN, 2, 1, 0x000000ff, 0x000000ff, 0x000000ff, 0x0000ff00},
- {DDS_FORMAT_AEXP, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000},
- {DDS_FORMAT_YCOCG, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000}
+ {DDS_FORMAT_RGB8, DXGI_FORMAT_UNKNOWN, 3, 0, 0x00ff0000, 0x0000ff00, 0x000000ff,
0x00000000},
+ {DDS_FORMAT_RGBA8, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff,
0xff000000},
+ {DDS_FORMAT_BGR8, DXGI_FORMAT_UNKNOWN, 3, 0, 0x000000ff, 0x0000ff00, 0x00ff0000,
0x00000000},
+ {DDS_FORMAT_ABGR8, DXGI_FORMAT_R8G8B8A8_UNORM, 4, 1, 0x000000ff, 0x0000ff00, 0x00ff0000,
0xff000000},
+ {DDS_FORMAT_R5G6B5, DXGI_FORMAT_B5G6R5_UNORM, 2, 0, 0x0000f800, 0x000007e0, 0x0000001f,
0x00000000},
+ {DDS_FORMAT_RGBA4, DXGI_FORMAT_B4G4R4A4_UNORM, 2, 1, 0x00000f00, 0x000000f0, 0x0000000f,
0x0000f000},
+ {DDS_FORMAT_RGB5A1, DXGI_FORMAT_B5G5R5A1_UNORM, 2, 1, 0x00007c00, 0x000003e0, 0x0000001f,
0x00008000},
+ {DDS_FORMAT_RGB10A2, DXGI_FORMAT_R10G10B10A2_UNORM, 4, 1, 0x000003ff, 0x000ffc00, 0x3ff00000,
0xc0000000},
+ {DDS_FORMAT_R3G3B2, DXGI_FORMAT_UNKNOWN, 1, 0, 0x000000e0, 0x0000001c, 0x00000003,
0x00000000},
+ {DDS_FORMAT_A8, DXGI_FORMAT_A8_UNORM, 1, 0, 0x00000000, 0x00000000, 0x00000000,
0x000000ff},
+ {DDS_FORMAT_L8, DXGI_FORMAT_R8_UNORM, 1, 0, 0x000000ff, 0x000000ff, 0x000000ff,
0x00000000},
+ {DDS_FORMAT_L8A8, DXGI_FORMAT_UNKNOWN, 2, 1, 0x000000ff, 0x000000ff, 0x000000ff,
0x0000ff00},
+ {DDS_FORMAT_AEXP, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff,
0xff000000},
+ {DDS_FORMAT_YCOCG, DXGI_FORMAT_B8G8R8A8_UNORM, 4, 1, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000}
};
-static int check_mipmaps(gint32 image_id, int savetype)
+static int
+check_mipmaps (gint32 image_id,
+ int savetype)
{
- gint *layers, num_layers;
- int i, j, w, h, mipw, miph, num_mipmaps, num_surfaces = 0;
- int min_surfaces = 1, max_surfaces = 1;
- int valid = 1;
- GimpImageType type;
-
- /* not handling volume maps for the moment... */
- if(savetype == DDS_SAVE_VOLUMEMAP)
- return(0);
-
- if(savetype == DDS_SAVE_CUBEMAP)
- {
+ gint *layers, num_layers;
+ int i, j, w, h, mipw, miph, num_mipmaps, num_surfaces = 0;
+ int min_surfaces = 1, max_surfaces = 1;
+ int valid = 1;
+ GimpImageType type;
+
+ /* not handling volume maps for the moment... */
+ if (savetype == DDS_SAVE_VOLUMEMAP)
+ return (0);
+
+ if (savetype == DDS_SAVE_CUBEMAP)
+ {
min_surfaces = 6;
max_surfaces = 6;
- }
- else if(savetype == DDS_SAVE_ARRAY)
- {
+ }
+ else if (savetype == DDS_SAVE_ARRAY)
+ {
min_surfaces = 2;
max_surfaces = INT_MAX;
- }
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- w = gimp_image_width(image_id);
- h = gimp_image_height(image_id);
-
- num_mipmaps = get_num_mipmaps(w, h);
-
- type = gimp_drawable_type(layers[0]);
-
- for(i = 0; i < num_layers; ++i)
- {
- if(type != gimp_drawable_type(layers[i]))
- return(0);
-
- if((gimp_drawable_width(layers[i]) == w) &&
- (gimp_drawable_height(layers[i]) == h))
- ++num_surfaces;
- }
-
- if((num_surfaces < min_surfaces) ||
+ }
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ w = gimp_image_width (image_id);
+ h = gimp_image_height (image_id);
+
+ num_mipmaps = get_num_mipmaps (w, h);
+
+ type = gimp_drawable_type (layers[0]);
+
+ for (i = 0; i < num_layers; ++i)
+ {
+ if (type != gimp_drawable_type (layers[i]))
+ return (0);
+
+ if ((gimp_drawable_width (layers[i]) == w) &&
+ (gimp_drawable_height (layers[i]) == h))
+ ++num_surfaces;
+ }
+
+ if ((num_surfaces < min_surfaces) ||
(num_surfaces > max_surfaces) ||
(num_layers != (num_surfaces * num_mipmaps)))
- return(0);
-
- for(i = 0; valid && i < num_layers; i += num_mipmaps)
- {
- if((gimp_drawable_width(layers[i]) != w) ||
- (gimp_drawable_height(layers[i]) != h))
- {
- valid = 0;
- break;
- }
-
- for(j = 1; j < num_mipmaps; ++j)
- {
- mipw = w >> j;
- miph = h >> j;
- if(mipw < 1) mipw = 1;
- if(miph < 1) miph = 1;
- if((gimp_drawable_width(layers[i + j]) != mipw) ||
- (gimp_drawable_height(layers[i + j]) != miph))
- {
- valid = 0;
- break;
- }
- }
- }
-
- return(valid);
+ return (0);
+
+ for (i = 0; valid && i < num_layers; i += num_mipmaps)
+ {
+ if ((gimp_drawable_width (layers[i]) != w) ||
+ (gimp_drawable_height (layers[i]) != h))
+ {
+ valid = 0;
+ break;
+ }
+
+ for (j = 1; j < num_mipmaps; ++j)
+ {
+ mipw = w >> j;
+ miph = h >> j;
+ if (mipw < 1) mipw = 1;
+ if (miph < 1) miph = 1;
+ if ((gimp_drawable_width (layers[i + j]) != mipw) ||
+ (gimp_drawable_height (layers[i + j]) != miph))
+ {
+ valid = 0;
+ break;
+ }
+ }
+ }
+
+ return (valid);
}
-static int check_cubemap(gint32 image_id)
+static int
+check_cubemap (gint32 image_id)
{
- gint *layers, num_layers;
- int cubemap = 1, i, j, k, w, h;
- char *layer_name;
- GimpImageType type;
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- if(num_layers < 6) return(0);
-
- /* check for a valid cubemap with mipmap layers */
- if(num_layers > 6)
- {
+ gint *layers, num_layers;
+ int cubemap = 1, i, j, k, w, h;
+ char *layer_name;
+ GimpImageType type;
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ if (num_layers < 6) return (0);
+
+ /* check for a valid cubemap with mipmap layers */
+ if (num_layers > 6)
+ {
/* check that mipmap layers are in order for a cubemap */
- if(!check_mipmaps(image_id, DDS_SAVE_CUBEMAP))
- return(0);
-
+ if (!check_mipmaps (image_id, DDS_SAVE_CUBEMAP))
+ return (0);
+
/* invalidate cubemap faces */
- for(i = 0; i < 6; ++i)
- cubemap_faces[i] = -1;
-
+ for (i = 0; i < 6; ++i)
+ cubemap_faces[i] = -1;
+
/* find the mipmap level 0 layers */
- w = gimp_image_width(image_id);
- h = gimp_image_height(image_id);
-
- for(i = 0; i < num_layers; ++i)
- {
- if((gimp_drawable_width(layers[i]) != w) ||
- (gimp_drawable_height(layers[i]) != h))
+ w = gimp_image_width (image_id);
+ h = gimp_image_height (image_id);
+
+ for (i = 0; i < num_layers; ++i)
+ {
+ if ((gimp_drawable_width (layers[i]) != w) ||
+ (gimp_drawable_height (layers[i]) != h))
continue;
-
- layer_name = (char*)gimp_item_get_name(layers[i]);
- for(j = 0; j < 6; ++j)
- {
- for(k = 0; k < 4; ++k)
+
+ layer_name = (char*)gimp_item_get_name (layers[i]);
+ for (j = 0; j < 6; ++j)
{
- if(strstr(layer_name, cubemap_face_names[k][j]))
- {
- if(cubemap_faces[j] == -1)
- {
- cubemap_faces[j] = layers[i];
- break;
- }
- }
+ for (k = 0; k < 4; ++k)
+ {
+ if (strstr (layer_name, cubemap_face_names[k][j]))
+ {
+ if (cubemap_faces[j] == -1)
+ {
+ cubemap_faces[j] = layers[i];
+ break;
+ }
+ }
+ }
}
- }
- }
-
+ }
+
/* check for 6 valid faces */
- for(i = 0; i < 6; ++i)
- {
- if(cubemap_faces[i] == -1)
- {
- cubemap = 0;
- break;
- }
- }
-
+ for (i = 0; i < 6; ++i)
+ {
+ if (cubemap_faces[i] == -1)
+ {
+ cubemap = 0;
+ break;
+ }
+ }
+
/* make sure they are all the same type */
- if(cubemap)
- {
- type = gimp_drawable_type(cubemap_faces[0]);
- for(i = 1; i < 6 && cubemap; ++i)
- {
- if(gimp_drawable_type(cubemap_faces[i]) != type)
- cubemap = 0;
- }
- }
- }
-
- if(num_layers == 6)
- {
+ if (cubemap)
+ {
+ type = gimp_drawable_type (cubemap_faces[0]);
+ for (i = 1; i < 6 && cubemap; ++i)
+ {
+ if (gimp_drawable_type (cubemap_faces[i]) != type)
+ cubemap = 0;
+ }
+ }
+ }
+
+ if (num_layers == 6)
+ {
/* invalidate cubemap faces */
- for(i = 0; i < 6; ++i)
- cubemap_faces[i] = -1;
-
- for(i = 0; i < 6; ++i)
- {
- layer_name = (char*)gimp_item_get_name(layers[i]);
- for(j = 0; j < 6; ++j)
- {
- for(k = 0; k < 4; ++k)
+ for (i = 0; i < 6; ++i)
+ cubemap_faces[i] = -1;
+
+ for (i = 0; i < 6; ++i)
+ {
+ layer_name = (char*)gimp_item_get_name (layers[i]);
+ for (j = 0; j < 6; ++j)
{
- if(strstr(layer_name, cubemap_face_names[k][j]))
- {
- if(cubemap_faces[j] == -1)
- {
- cubemap_faces[j] = layers[i];
- break;
- }
- }
+ for (k = 0; k < 4; ++k)
+ {
+ if (strstr (layer_name, cubemap_face_names[k][j]))
+ {
+ if (cubemap_faces[j] == -1)
+ {
+ cubemap_faces[j] = layers[i];
+ break;
+ }
+ }
+ }
}
- }
- }
-
+ }
+
/* check for 6 valid faces */
- for(i = 0; i < 6; ++i)
- {
- if(cubemap_faces[i] == -1)
- {
- cubemap = 0;
- break;
- }
- }
-
+ for (i = 0; i < 6; ++i)
+ {
+ if (cubemap_faces[i] == -1)
+ {
+ cubemap = 0;
+ break;
+ }
+ }
+
/* make sure they are all the same size */
- if(cubemap)
- {
- w = gimp_drawable_width(cubemap_faces[0]);
- h = gimp_drawable_height(cubemap_faces[0]);
-
- for(i = 1; i < 6 && cubemap; ++i)
- {
- if((gimp_drawable_width(cubemap_faces[i]) != w) ||
- (gimp_drawable_height(cubemap_faces[i]) != h))
- cubemap = 0;
- }
- }
-
+ if (cubemap)
+ {
+ w = gimp_drawable_width (cubemap_faces[0]);
+ h = gimp_drawable_height (cubemap_faces[0]);
+
+ for (i = 1; i < 6 && cubemap; ++i)
+ {
+ if ((gimp_drawable_width (cubemap_faces[i]) != w) ||
+ (gimp_drawable_height (cubemap_faces[i]) != h))
+ cubemap = 0;
+ }
+ }
+
/* make sure they are all the same type */
- if(cubemap)
- {
- type = gimp_drawable_type(cubemap_faces[0]);
- for(i = 1; i < 6 && cubemap; ++i)
- {
- if(gimp_drawable_type(cubemap_faces[i]) != type)
- cubemap = 0;
- }
- }
- }
-
- return(cubemap);
+ if (cubemap)
+ {
+ type = gimp_drawable_type (cubemap_faces[0]);
+ for (i = 1; i < 6 && cubemap; ++i)
+ {
+ if (gimp_drawable_type (cubemap_faces[i]) != type)
+ cubemap = 0;
+ }
+ }
+ }
+
+ return (cubemap);
}
-static int check_volume(gint32 image_id)
+static int
+check_volume (gint32 image_id)
{
- gint *layers, num_layers;
- int volume = 0, i, w, h;
- GimpImageType type;
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- if(num_layers > 1)
- {
+ gint *layers, num_layers;
+ int volume = 0, i, w, h;
+ GimpImageType type;
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ if (num_layers > 1)
+ {
volume = 1;
-
+
/* make sure all layers are the same size */
- w = gimp_drawable_width(layers[0]);
- h = gimp_drawable_height(layers[0]);
-
- for(i = 1; i < num_layers && volume; ++i)
- {
- if((gimp_drawable_width(layers[i]) != w) ||
- (gimp_drawable_height(layers[i]) != h))
+ w = gimp_drawable_width (layers[0]);
+ h = gimp_drawable_height (layers[0]);
+
+ for (i = 1; i < num_layers && volume; ++i)
+ {
+ if ((gimp_drawable_width (layers[i]) != w) ||
+ (gimp_drawable_height (layers[i]) != h))
volume = 0;
- }
-
- if(volume)
- {
- /* make sure all layers are the same type */
- type = gimp_drawable_type(layers[0]);
- for(i = 1; i < num_layers && volume; ++i)
- {
- if(gimp_drawable_type(layers[i]) != type)
- volume = 0;
- }
- }
- }
-
- return(volume);
+ }
+
+ if (volume)
+ {
+ /* make sure all layers are the same type */
+ type = gimp_drawable_type (layers[0]);
+ for (i = 1; i < num_layers && volume; ++i)
+ {
+ if (gimp_drawable_type (layers[i]) != type)
+ volume = 0;
+ }
+ }
+ }
+
+ return (volume);
}
-static int check_array(gint32 image_id)
+static int
+check_array (gint32 image_id)
{
- gint *layers, num_layers;
- int array = 0, i, w, h;
- GimpImageType type;
-
- if(check_mipmaps(image_id, DDS_SAVE_ARRAY))
- return(1);
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- if(num_layers > 1)
- {
+ gint *layers, num_layers;
+ int array = 0, i, w, h;
+ GimpImageType type;
+
+ if (check_mipmaps (image_id, DDS_SAVE_ARRAY))
+ return (1);
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ if (num_layers > 1)
+ {
array = 1;
-
+
/* make sure all layers are the same size */
- w = gimp_drawable_width(layers[0]);
- h = gimp_drawable_height(layers[0]);
-
- for(i = 1; i < num_layers && array; ++i)
- {
- if((gimp_drawable_width(layers[i]) != w) ||
- (gimp_drawable_height(layers[i]) != h))
+ w = gimp_drawable_width (layers[0]);
+ h = gimp_drawable_height (layers[0]);
+
+ for (i = 1; i < num_layers && array; ++i)
+ {
+ if ((gimp_drawable_width (layers[i]) != w) ||
+ (gimp_drawable_height (layers[i]) != h))
array = 0;
- }
-
- if(array)
- {
- /* make sure all layers are the same type */
- type = gimp_drawable_type(layers[0]);
- for(i = 1; i < num_layers; ++i)
- {
- if(gimp_drawable_type(layers[i]) != type)
+ }
+
+ if (array)
+ {
+ /* make sure all layers are the same type */
+ type = gimp_drawable_type (layers[0]);
+ for (i = 1; i < num_layers; ++i)
{
- array = 0;
- break;
+ if (gimp_drawable_type (layers[i]) != type)
+ {
+ array = 0;
+ break;
+ }
}
- }
- }
- }
-
- return(array);
+ }
+ }
+
+ return (array);
}
-static int get_array_size(gint32 image_id)
+static int
+get_array_size (gint32 image_id)
{
- gint *layers, num_layers;
- int i, w, h, elements = 0;
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- w = gimp_image_width(image_id);
- h = gimp_image_height(image_id);
-
- for(i = 0; i < num_layers; ++i)
- {
- if((gimp_drawable_width(layers[i]) == w) && (gimp_drawable_height(layers[i]) == h))
- ++elements;
- }
-
- return(elements);
+ gint *layers, num_layers;
+ int i, w, h, elements = 0;
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ w = gimp_image_width (image_id);
+ h = gimp_image_height (image_id);
+
+ for (i = 0; i < num_layers; ++i)
+ {
+ if ((gimp_drawable_width (layers[i]) == w) && (gimp_drawable_height (layers[i]) == h))
+ ++elements;
+ }
+
+ return (elements);
}
-GimpPDBStatusType write_dds(gchar *filename, gint32 image_id, gint32 drawable_id)
+GimpPDBStatusType
+write_dds (gchar *filename,
+ gint32 image_id,
+ gint32 drawable_id,
+ gboolean interactive_dds)
{
- FILE *fp;
- gchar *tmp;
- int rc = 0;
-
- is_mipmap_chain_valid = check_mipmaps(image_id, dds_write_vals.savetype);
-
- is_cubemap = check_cubemap(image_id);
- is_volume = check_volume(image_id);
- is_array = check_array(image_id);
-
- if(interactive_dds)
- {
- if(!is_mipmap_chain_valid &&
- dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING)
- dds_write_vals.mipmaps = DDS_MIPMAP_NONE;
-
- if(!save_dialog(image_id, drawable_id))
- return(GIMP_PDB_CANCEL);
- }
- else
- {
- if(dds_write_vals.savetype == DDS_SAVE_CUBEMAP && !is_cubemap)
- {
- g_message("DDS: Cannot save image as cube map");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- if(dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP && !is_volume)
- {
- g_message("DDS: Cannot save image as volume map");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- if(dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP &&
- dds_write_vals.compression != DDS_COMPRESS_NONE)
- {
- g_message("DDS: Cannot save volume map with compression");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- if(dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING &&
- !is_mipmap_chain_valid)
- {
- g_message("DDS: Cannot save with existing mipmaps as the mipmap chain is incomplete");
- return(GIMP_PDB_EXECUTION_ERROR);
- }
- }
-
- fp = g_fopen(filename, "wb");
- if(fp == 0)
- {
- g_message("Error opening %s", filename);
- return(GIMP_PDB_EXECUTION_ERROR);
- }
-
- if(strrchr(filename, '/'))
- tmp = g_strdup_printf("Saving %s:", strrchr(filename, '/') + 1);
- else
- tmp = g_strdup_printf("Saving %s:", filename);
- gimp_progress_init(tmp);
- g_free(tmp);
-
- rc = write_image(fp, image_id, drawable_id);
-
- fclose(fp);
-
- return(rc ? GIMP_PDB_SUCCESS : GIMP_PDB_EXECUTION_ERROR);
+ FILE *fp;
+ gchar *tmp;
+ int rc = 0;
+
+ is_mipmap_chain_valid = check_mipmaps (image_id, dds_write_vals.savetype);
+
+ is_cubemap = check_cubemap (image_id);
+ is_volume = check_volume (image_id);
+ is_array = check_array (image_id);
+
+ if (interactive_dds)
+ {
+ if (!is_mipmap_chain_valid &&
+ dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING)
+ dds_write_vals.mipmaps = DDS_MIPMAP_NONE;
+
+ if (!save_dialog (image_id, drawable_id))
+ return (GIMP_PDB_CANCEL);
+ }
+ else
+ {
+ if (dds_write_vals.savetype == DDS_SAVE_CUBEMAP && !is_cubemap)
+ {
+ g_message ("DDS: Cannot save image as cube map");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ if (dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP && !is_volume)
+ {
+ g_message ("DDS: Cannot save image as volume map");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ if (dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP &&
+ dds_write_vals.compression != DDS_COMPRESS_NONE)
+ {
+ g_message ("DDS: Cannot save volume map with compression");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ if (dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING &&
+ !is_mipmap_chain_valid)
+ {
+ g_message ("DDS: Cannot save with existing mipmaps as the mipmap chain is incomplete");
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+ }
+
+ fp = g_fopen (filename, "wb");
+ if (fp == 0)
+ {
+ g_message ("Error opening %s", filename);
+ return (GIMP_PDB_EXECUTION_ERROR);
+ }
+
+ if (strrchr (filename, '/'))
+ tmp = g_strdup_printf ("Saving %s:", strrchr (filename, '/') + 1);
+ else
+ tmp = g_strdup_printf ("Saving %s:", filename);
+ gimp_progress_init (tmp);
+ g_free (tmp);
+
+ rc = write_image (fp, image_id, drawable_id);
+
+ fclose (fp);
+
+ return (rc ? GIMP_PDB_SUCCESS : GIMP_PDB_EXECUTION_ERROR);
}
-static void swap_rb(unsigned char *pixels, unsigned int n, int bpp)
+static void
+swap_rb (unsigned char *pixels,
+ unsigned int n,
+ int bpp)
{
- unsigned int i;
- unsigned char t;
+ unsigned int i;
+ unsigned char t;
- for(i = 0; i < n; ++i)
- {
+ for (i = 0; i < n; ++i)
+ {
t = pixels[bpp * i + 0];
pixels[bpp * i + 0] = pixels[bpp * i + 2];
pixels[bpp * i + 2] = t;
- }
+ }
}
-static void alpha_exp(unsigned char *dst, int r, int g, int b, int a)
+static void
+alpha_exp (unsigned char *dst,
+ int r,
+ int g,
+ int b,
+ int a)
{
- float ar, ag, ab, aa;
+ float ar, ag, ab, aa;
- ar = (float)r / 255.0f;
- ag = (float)g / 255.0f;
- ab = (float)b / 255.0f;
+ ar = (float)r / 255.0f;
+ ag = (float)g / 255.0f;
+ ab = (float)b / 255.0f;
- aa = MAX(ar, MAX(ag, ab));
+ aa = MAX (ar, MAX (ag, ab));
- if(aa < 1e-04f)
- {
+ if (aa < 1e-04f)
+ {
dst[0] = b;
dst[1] = g;
dst[2] = r;
dst[3] = 255;
return;
- }
+ }
- ar /= aa;
- ag /= aa;
- ab /= aa;
+ ar /= aa;
+ ag /= aa;
+ ab /= aa;
- r = (int)floorf(255.0f * ar + 0.5f);
- g = (int)floorf(255.0f * ag + 0.5f);
- b = (int)floorf(255.0f * ab + 0.5f);
- a = (int)floorf(255.0f * aa + 0.5f);
+ r = (int)floorf (255.0f * ar + 0.5f);
+ g = (int)floorf (255.0f * ag + 0.5f);
+ b = (int)floorf (255.0f * ab + 0.5f);
+ a = (int)floorf (255.0f * aa + 0.5f);
- dst[0] = MAX(0, MIN(255, b));
- dst[1] = MAX(0, MIN(255, g));
- dst[2] = MAX(0, MIN(255, r));
- dst[3] = MAX(0, MIN(255, a));
+ dst[0] = MAX (0, MIN (255, b));
+ dst[1] = MAX (0, MIN (255, g));
+ dst[2] = MAX (0, MIN (255, r));
+ dst[3] = MAX (0, MIN (255, a));
}
-static void convert_pixels(unsigned char *dst, unsigned char *src,
- int format, int w, int h, int d, int bpp,
- unsigned char *palette, int mipmaps)
+static void
+convert_pixels (unsigned char *dst,
+ unsigned char *src,
+ int format,
+ int w,
+ int h,
+ int d,
+ int bpp,
+ unsigned char *palette,
+ int mipmaps)
{
- unsigned int i, num_pixels;
- unsigned char r, g, b, a;
-
- if(d > 0)
- num_pixels = get_volume_mipmapped_size(w, h, d, 1, 0, mipmaps, DDS_COMPRESS_NONE);
- else
- num_pixels = get_mipmapped_size(w, h, 1, 0, mipmaps, DDS_COMPRESS_NONE);
-
- for(i = 0; i < num_pixels; ++i)
- {
- if(bpp == 1)
- {
- if(palette)
- {
- r = palette[3 * src[i] + 0];
- g = palette[3 * src[i] + 1];
- b = palette[3 * src[i] + 2];
- }
- else
+ unsigned int i, num_pixels;
+ unsigned char r, g, b, a;
+
+ if (d > 0)
+ num_pixels = get_volume_mipmapped_size (w, h, d, 1, 0, mipmaps, DDS_COMPRESS_NONE);
+ else
+ num_pixels = get_mipmapped_size (w, h, 1, 0, mipmaps, DDS_COMPRESS_NONE);
+
+ for (i = 0; i < num_pixels; ++i)
+ {
+ if (bpp == 1)
+ {
+ if (palette)
+ {
+ r = palette[3 * src[i] + 0];
+ g = palette[3 * src[i] + 1];
+ b = palette[3 * src[i] + 2];
+ }
+ else
r = g = b = src[i];
- if(format == DDS_FORMAT_A8)
+ if (format == DDS_FORMAT_A8)
a = src[i];
- else
+ else
a = 255;
- }
- else if(bpp == 2)
- {
- r = g = b = src[2 * i];
- a = src[2 * i + 1];
- }
- else if(bpp == 3)
- {
- b = src[3 * i + 0];
- g = src[3 * i + 1];
- r = src[3 * i + 2];
- a = 255;
- }
+ }
+ else if (bpp == 2)
+ {
+ r = g = b = src[2 * i];
+ a = src[2 * i + 1];
+ }
+ else if (bpp == 3)
+ {
+ b = src[3 * i + 0];
+ g = src[3 * i + 1];
+ r = src[3 * i + 2];
+ a = 255;
+ }
else
- {
- b = src[4 * i + 0];
- g = src[4 * i + 1];
- r = src[4 * i + 2];
- a = src[4 * i + 3];
- }
-
- switch(format)
- {
- case DDS_FORMAT_RGB8:
- dst[3 * i + 0] = b;
- dst[3 * i + 1] = g;
- dst[3 * i + 2] = r;
- break;
- case DDS_FORMAT_RGBA8:
- dst[4 * i + 0] = b;
- dst[4 * i + 1] = g;
- dst[4 * i + 2] = r;
- dst[4 * i + 3] = a;
- break;
- case DDS_FORMAT_BGR8:
- dst[3 * i + 0] = r;
- dst[3 * i + 1] = g;
- dst[3 * i + 2] = b;
- break;
- case DDS_FORMAT_ABGR8:
- dst[4 * i + 0] = r;
- dst[4 * i + 1] = g;
- dst[4 * i + 2] = b;
- dst[4 * i + 3] = a;
- break;
- case DDS_FORMAT_R5G6B5:
- PUTL16(&dst[2 * i], pack_r5g6b5(r, g, b));
- break;
- case DDS_FORMAT_RGBA4:
- PUTL16(&dst[2 * i], pack_rgba4(r, g, b, a));
- break;
- case DDS_FORMAT_RGB5A1:
- PUTL16(&dst[2 * i], pack_rgb5a1(r, g, b, a));
- break;
- case DDS_FORMAT_RGB10A2:
- PUTL32(&dst[4 * i], pack_rgb10a2(r, g, b, a));
- break;
- case DDS_FORMAT_R3G3B2:
- dst[i] = pack_r3g3b2(r, g, b);
- break;
- case DDS_FORMAT_A8:
- dst[i] = a;
- break;
- case DDS_FORMAT_L8:
- dst[i] = rgb_to_luminance(r, g, b);
- break;
- case DDS_FORMAT_L8A8:
- dst[2 * i + 0] = rgb_to_luminance(r, g, b);
- dst[2 * i + 1] = a;
- break;
- case DDS_FORMAT_YCOCG:
- dst[4 * i] = a;
- RGB_to_YCoCg(&dst[4 * i], r, g, b);
- break;
- case DDS_FORMAT_AEXP:
- alpha_exp(&dst[4 * i], r, g, b, a);
- break;
- default:
- break;
- }
- }
+ {
+ b = src[4 * i + 0];
+ g = src[4 * i + 1];
+ r = src[4 * i + 2];
+ a = src[4 * i + 3];
+ }
+
+ switch (format)
+ {
+ case DDS_FORMAT_RGB8:
+ dst[3 * i + 0] = b;
+ dst[3 * i + 1] = g;
+ dst[3 * i + 2] = r;
+ break;
+ case DDS_FORMAT_RGBA8:
+ dst[4 * i + 0] = b;
+ dst[4 * i + 1] = g;
+ dst[4 * i + 2] = r;
+ dst[4 * i + 3] = a;
+ break;
+ case DDS_FORMAT_BGR8:
+ dst[3 * i + 0] = r;
+ dst[3 * i + 1] = g;
+ dst[3 * i + 2] = b;
+ break;
+ case DDS_FORMAT_ABGR8:
+ dst[4 * i + 0] = r;
+ dst[4 * i + 1] = g;
+ dst[4 * i + 2] = b;
+ dst[4 * i + 3] = a;
+ break;
+ case DDS_FORMAT_R5G6B5:
+ PUTL16(&dst[2 * i], pack_r5g6b5(r, g, b));
+ break;
+ case DDS_FORMAT_RGBA4:
+ PUTL16(&dst[2 * i], pack_rgba4(r, g, b, a));
+ break;
+ case DDS_FORMAT_RGB5A1:
+ PUTL16(&dst[2 * i], pack_rgb5a1(r, g, b, a));
+ break;
+ case DDS_FORMAT_RGB10A2:
+ PUTL32(&dst[4 * i], pack_rgb10a2(r, g, b, a));
+ break;
+ case DDS_FORMAT_R3G3B2:
+ dst[i] = pack_r3g3b2(r, g, b);
+ break;
+ case DDS_FORMAT_A8:
+ dst[i] = a;
+ break;
+ case DDS_FORMAT_L8:
+ dst[i] = rgb_to_luminance (r, g, b);
+ break;
+ case DDS_FORMAT_L8A8:
+ dst[2 * i + 0] = rgb_to_luminance (r, g, b);
+ dst[2 * i + 1] = a;
+ break;
+ case DDS_FORMAT_YCOCG:
+ dst[4 * i] = a;
+ RGB_to_YCoCg (&dst[4 * i], r, g, b);
+ break;
+ case DDS_FORMAT_AEXP:
+ alpha_exp (&dst[4 * i], r, g, b, a);
+ break;
+ default:
+ break;
+ }
+ }
}
-static void get_mipmap_chain(unsigned char *dst, int w, int h, int bpp,
- gint32 image_id, gint drawable_id)
+static void
+get_mipmap_chain (unsigned char *dst,
+ int w,
+ int h,
+ int bpp,
+ gint32 image_id,
+ gint drawable_id)
{
- gint *layers, num_layers;
- GeglBuffer *buffer;
- const Babl *format = 0;
- int i, idx = 0, offset, mipw, miph;
-
- if(bpp == 1)
- format = babl_format("Y' u8");
- else if(bpp == 2)
- format = babl_format("Y'A u8");
- else if(bpp == 3)
- format = babl_format("R'G'B' u8");
- else
- format = babl_format("R'G'B'A u8");
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- for(i = 0; i < num_layers; ++i)
- {
- if(layers[i] == drawable_id)
- {
- idx = i;
- break;
- }
- }
-
- if(i == num_layers) return;
-
- offset = 0;
-
- while(get_next_mipmap_dimensions(&mipw, &miph, w, h))
- {
- buffer = gimp_drawable_get_buffer(layers[++idx]);
-
- if((gegl_buffer_get_width(buffer) != mipw) ||
- (gegl_buffer_get_height(buffer) != miph))
- {
- g_object_unref(buffer);
- return;
- }
-
- gegl_buffer_get(buffer, GEGL_RECTANGLE(0, 0, mipw, miph), 1.0, format,
- dst + offset, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
- g_object_unref(buffer);
+ gint *layers, num_layers;
+ GeglBuffer *buffer;
+ const Babl *format = 0;
+ int i, idx = 0, offset, mipw, miph;
+
+ if (bpp == 1)
+ format = babl_format ("Y' u8");
+ else if (bpp == 2)
+ format = babl_format ("Y'A u8");
+ else if (bpp == 3)
+ format = babl_format ("R'G'B' u8");
+ else
+ format = babl_format ("R'G'B'A u8");
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ for (i = 0; i < num_layers; ++i)
+ {
+ if (layers[i] == drawable_id)
+ {
+ idx = i;
+ break;
+ }
+ }
+
+ if (i == num_layers) return;
+
+ offset = 0;
+
+ while (get_next_mipmap_dimensions (&mipw, &miph, w, h))
+ {
+ buffer = gimp_drawable_get_buffer (layers[++idx]);
+
+ if ((gegl_buffer_get_width (buffer) != mipw) ||
+ (gegl_buffer_get_height (buffer) != miph))
+ {
+ g_object_unref (buffer);
+ return;
+ }
+
+ gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, mipw, miph), 1.0, format,
+ dst + offset, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+ g_object_unref (buffer);
/* we need BGRX or BGRA */
- if(bpp >= 3)
- swap_rb(dst + offset, mipw * miph, bpp);
+ if (bpp >= 3)
+ swap_rb (dst + offset, mipw * miph, bpp);
offset += (mipw * miph * bpp);
w = mipw;
h = miph;
- }
+ }
}
-static void write_layer(FILE *fp, gint32 image_id, gint32 drawable_id,
- int w, int h, int bpp, int fmtbpp, int mipmaps)
+static void
+write_layer (FILE *fp,
+ gint32 image_id,
+ gint32 drawable_id,
+ int w,
+ int h,
+ int bpp,
+ int fmtbpp,
+ int mipmaps)
{
- GeglBuffer *buffer;
- const Babl *format = 0;
- GimpImageBaseType basetype;
- GimpImageType type;
- unsigned char *src, *dst, *fmtdst, *tmp;
- unsigned char *palette = NULL;
- int i, c, x, y, size, fmtsize, offset, colors;
- int compression = dds_write_vals.compression;
- int flags = 0;
-
- basetype = gimp_image_base_type(image_id);
- type = gimp_drawable_type(drawable_id);
-
- buffer = gimp_drawable_get_buffer(drawable_id);
-
- src = g_malloc(w * h * bpp);
-
- if(bpp == 1)
- format = babl_format("Y' u8");
- else if(bpp == 2)
- format = babl_format("Y'A u8");
- else if(bpp == 3)
- format = babl_format("R'G'B' u8");
- else
- format = babl_format("R'G'B'A u8");
-
- gegl_buffer_get(buffer, GEGL_RECTANGLE(0, 0, w, h), 1.0, format, src,
+ GeglBuffer *buffer;
+ const Babl *format = 0;
+ GimpImageBaseType basetype;
+ GimpImageType type;
+ unsigned char *src, *dst, *fmtdst, *tmp;
+ unsigned char *palette = NULL;
+ int i, c, x, y, size, fmtsize, offset, colors;
+ int compression = dds_write_vals.compression;
+ int flags = 0;
+
+ basetype = gimp_image_base_type (image_id);
+ type = gimp_drawable_type (drawable_id);
+
+ buffer = gimp_drawable_get_buffer (drawable_id);
+
+ src = g_malloc (w * h * bpp);
+
+ if (bpp == 1)
+ format = babl_format ("Y' u8");
+ else if (bpp == 2)
+ format = babl_format ("Y'A u8");
+ else if (bpp == 3)
+ format = babl_format ("R'G'B' u8");
+ else
+ format = babl_format ("R'G'B'A u8");
+
+ gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0, format, src,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
- if(basetype == GIMP_INDEXED)
- {
- palette = gimp_image_get_colormap(image_id, &colors);
+ if (basetype == GIMP_INDEXED)
+ {
+ palette = gimp_image_get_colormap (image_id, &colors);
- if(type == GIMP_INDEXEDA_IMAGE)
- {
- tmp = g_malloc(w * h);
- for(i = 0; i < w * h; ++i)
+ if (type == GIMP_INDEXEDA_IMAGE)
+ {
+ tmp = g_malloc (w * h);
+ for (i = 0; i < w * h; ++i)
tmp[i] = src[2 * i];
- g_free(src);
- src = tmp;
- bpp = 1;
- }
- }
-
- /* we want and assume BGRA ordered pixels for bpp >= 3 from here and
- onwards */
- if(bpp >= 3)
- swap_rb(src, w * h, bpp);
-
- if(compression == DDS_COMPRESS_BC3N)
- {
- if(bpp != 4)
- {
- fmtsize = w * h * 4;
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_RGBA8, w, h, 0, bpp,
- palette, 1);
- g_free(src);
- src = fmtdst;
- bpp = 4;
- }
-
- for(y = 0; y < h; ++y)
- {
- for(x = 0; x < w; ++x)
- {
- /* set alpha to red (x) */
- src[y * (w * 4) + (x * 4) + 3] =
- src[y * (w * 4) + (x * 4) + 2];
- /* set red to 1 */
- src[y * (w * 4) + (x * 4) + 2] = 255;
- }
- }
- }
-
- /* RXGB (Doom3) */
- if(compression == DDS_COMPRESS_RXGB)
- {
- if(bpp != 4)
- {
- fmtsize = w * h * 4;
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_RGBA8, w, h, 0, bpp,
- palette, 1);
- g_free(src);
- src = fmtdst;
- bpp = 4;
- }
-
- for(y = 0; y < h; ++y)
- {
- for(x = 0; x < w; ++x)
- {
- /* swap red and alpha */
- c = src[y * (w * 4) + (x * 4) + 3];
- src[y * (w * 4) + (x * 4) + 3] =
- src[y * (w * 4) + (x * 4) + 2];
- src[y * (w * 4) + (x * 4) + 2] = c;
- }
- }
- }
-
- if(compression == DDS_COMPRESS_YCOCG ||
+ g_free (src);
+ src = tmp;
+ bpp = 1;
+ }
+ }
+
+ /* we want and assume BGRA ordered pixels for bpp >= 3 from here and
+ onwards */
+ if (bpp >= 3)
+ swap_rb (src, w * h, bpp);
+
+ if (compression == DDS_COMPRESS_BC3N)
+ {
+ if (bpp != 4)
+ {
+ fmtsize = w * h * 4;
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_RGBA8, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
+ src = fmtdst;
+ bpp = 4;
+ }
+
+ for (y = 0; y < h; ++y)
+ {
+ for (x = 0; x < w; ++x)
+ {
+ /* set alpha to red (x) */
+ src[y * (w * 4) + (x * 4) + 3] =
+ src[y * (w * 4) + (x * 4) + 2];
+ /* set red to 1 */
+ src[y * (w * 4) + (x * 4) + 2] = 255;
+ }
+ }
+ }
+
+ /* RXGB (Doom3) */
+ if (compression == DDS_COMPRESS_RXGB)
+ {
+ if (bpp != 4)
+ {
+ fmtsize = w * h * 4;
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_RGBA8, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
+ src = fmtdst;
+ bpp = 4;
+ }
+
+ for (y = 0; y < h; ++y)
+ {
+ for (x = 0; x < w; ++x)
+ {
+ /* swap red and alpha */
+ c = src[y * (w * 4) + (x * 4) + 3];
+ src[y * (w * 4) + (x * 4) + 3] =
+ src[y * (w * 4) + (x * 4) + 2];
+ src[y * (w * 4) + (x * 4) + 2] = c;
+ }
+ }
+ }
+
+ if (compression == DDS_COMPRESS_YCOCG ||
compression == DDS_COMPRESS_YCOCGS) /* convert to YCoCG */
- {
+ {
fmtsize = w * h * 4;
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_YCOCG, w, h, 0, bpp,
- palette, 1);
- g_free(src);
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_YCOCG, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
src = fmtdst;
bpp = 4;
- }
+ }
- if(compression == DDS_COMPRESS_AEXP)
- {
+ if (compression == DDS_COMPRESS_AEXP)
+ {
fmtsize = w * h * 4;
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_AEXP, w, h, 0, bpp,
- palette, 1);
- g_free(src);
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_AEXP, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
src = fmtdst;
bpp = 4;
- }
-
- if(compression == DDS_COMPRESS_NONE)
- {
- if(mipmaps > 1)
- {
- /* pre-convert indexed images to RGB for better quality mipmaps
- if a pixel format conversion is requested */
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT && basetype == GIMP_INDEXED)
- {
- fmtsize = get_mipmapped_size(w, h, 3, 0, mipmaps, DDS_COMPRESS_NONE);
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_RGB8, w, h, 0, bpp,
- palette, 1);
- g_free(src);
- src = fmtdst;
- bpp = 3;
- palette = NULL;
- }
-
- size = get_mipmapped_size(w, h, bpp, 0, mipmaps, DDS_COMPRESS_NONE);
- dst = g_malloc(size);
- if(dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE)
- {
- generate_mipmaps(dst, src, w, h, bpp, palette != NULL,
- mipmaps,
- dds_write_vals.mipmap_filter,
- dds_write_vals.mipmap_wrap,
- dds_write_vals.gamma_correct + dds_write_vals.srgb,
- dds_write_vals.gamma,
- dds_write_vals.preserve_alpha_coverage,
- dds_write_vals.alpha_test_threshold);
- }
- else
- {
- memcpy(dst, src, w * h * bpp);
- get_mipmap_chain(dst + (w * h * bpp), w, h, bpp, image_id, drawable_id);
- }
-
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT)
- {
- fmtsize = get_mipmapped_size(w, h, fmtbpp, 0, mipmaps,
- DDS_COMPRESS_NONE);
- fmtdst = g_malloc(fmtsize);
-
- convert_pixels(fmtdst, dst, dds_write_vals.format, w, h, 0, bpp,
- palette, mipmaps);
-
- g_free(dst);
- dst = fmtdst;
- bpp = fmtbpp;
- }
-
- offset = 0;
-
- for(i = 0; i < mipmaps; ++i)
- {
- size = get_mipmapped_size(w, h, bpp, i, 1, DDS_COMPRESS_NONE);
- fwrite(dst + offset, 1, size, fp);
- offset += size;
- }
-
- g_free(dst);
- }
+ }
+
+ if (compression == DDS_COMPRESS_NONE)
+ {
+ if (mipmaps > 1)
+ {
+ /* pre-convert indexed images to RGB for better quality mipmaps
+ if a pixel format conversion is requested */
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT && basetype == GIMP_INDEXED)
+ {
+ fmtsize = get_mipmapped_size (w, h, 3, 0, mipmaps, DDS_COMPRESS_NONE);
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_RGB8, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
+ src = fmtdst;
+ bpp = 3;
+ palette = NULL;
+ }
+
+ size = get_mipmapped_size (w, h, bpp, 0, mipmaps, DDS_COMPRESS_NONE);
+ dst = g_malloc (size);
+ if (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE)
+ {
+ generate_mipmaps (dst, src, w, h, bpp, palette != NULL,
+ mipmaps,
+ dds_write_vals.mipmap_filter,
+ dds_write_vals.mipmap_wrap,
+ dds_write_vals.gamma_correct + dds_write_vals.srgb,
+ dds_write_vals.gamma,
+ dds_write_vals.preserve_alpha_coverage,
+ dds_write_vals.alpha_test_threshold);
+ }
+ else
+ {
+ memcpy (dst, src, w * h * bpp);
+ get_mipmap_chain (dst + (w * h * bpp), w, h, bpp, image_id, drawable_id);
+ }
+
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT)
+ {
+ fmtsize = get_mipmapped_size (w, h, fmtbpp, 0, mipmaps,
+ DDS_COMPRESS_NONE);
+ fmtdst = g_malloc (fmtsize);
+
+ convert_pixels (fmtdst, dst, dds_write_vals.format, w, h, 0, bpp,
+ palette, mipmaps);
+
+ g_free (dst);
+ dst = fmtdst;
+ bpp = fmtbpp;
+ }
+
+ offset = 0;
+
+ for (i = 0; i < mipmaps; ++i)
+ {
+ size = get_mipmapped_size (w, h, bpp, i, 1, DDS_COMPRESS_NONE);
+ fwrite (dst + offset, 1, size, fp);
+ offset += size;
+ }
+
+ g_free (dst);
+ }
else
- {
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT)
- {
- fmtdst = g_malloc(h * w * fmtbpp);
- convert_pixels(fmtdst, src, dds_write_vals.format, w, h, 0, bpp,
- palette, 1);
- g_free(src);
- src = fmtdst;
- bpp = fmtbpp;
- }
-
- fwrite(src, 1, h * w * bpp, fp);
- }
- }
- else
- {
- size = get_mipmapped_size(w, h, bpp, 0, mipmaps, compression);
-
- dst = g_malloc(size);
-
- if(basetype == GIMP_INDEXED)
- {
- fmtsize = get_mipmapped_size(w, h, 3, 0, mipmaps,
- DDS_COMPRESS_NONE);
- fmtdst = g_malloc(fmtsize);
- convert_pixels(fmtdst, src, DDS_FORMAT_RGB8, w, h, 0, bpp,
- palette, mipmaps);
- g_free(src);
- src = fmtdst;
- bpp = 3;
- }
-
- if(mipmaps > 1)
- {
- fmtsize = get_mipmapped_size(w, h, bpp, 0, mipmaps,
- DDS_COMPRESS_NONE);
- fmtdst = g_malloc(fmtsize);
- if(dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE)
- {
- generate_mipmaps(fmtdst, src, w, h, bpp, 0, mipmaps,
- dds_write_vals.mipmap_filter,
- dds_write_vals.mipmap_wrap,
- dds_write_vals.gamma_correct + dds_write_vals.srgb,
- dds_write_vals.gamma,
- dds_write_vals.preserve_alpha_coverage,
- dds_write_vals.alpha_test_threshold);
- }
- else
- {
- memcpy(fmtdst, src, w * h * bpp);
- get_mipmap_chain(fmtdst + (w * h * bpp), w, h, bpp, image_id, drawable_id);
- }
-
- g_free(src);
- src = fmtdst;
- }
+ {
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT)
+ {
+ fmtdst = g_malloc (h * w * fmtbpp);
+ convert_pixels (fmtdst, src, dds_write_vals.format, w, h, 0, bpp,
+ palette, 1);
+ g_free (src);
+ src = fmtdst;
+ bpp = fmtbpp;
+ }
+
+ fwrite (src, 1, h * w * bpp, fp);
+ }
+ }
+ else
+ {
+ size = get_mipmapped_size (w, h, bpp, 0, mipmaps, compression);
+
+ dst = g_malloc (size);
+
+ if (basetype == GIMP_INDEXED)
+ {
+ fmtsize = get_mipmapped_size (w, h, 3, 0, mipmaps,
+ DDS_COMPRESS_NONE);
+ fmtdst = g_malloc (fmtsize);
+ convert_pixels (fmtdst, src, DDS_FORMAT_RGB8, w, h, 0, bpp,
+ palette, mipmaps);
+ g_free (src);
+ src = fmtdst;
+ bpp = 3;
+ }
+
+ if (mipmaps > 1)
+ {
+ fmtsize = get_mipmapped_size (w, h, bpp, 0, mipmaps,
+ DDS_COMPRESS_NONE);
+ fmtdst = g_malloc (fmtsize);
+ if (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE)
+ {
+ generate_mipmaps (fmtdst, src, w, h, bpp, 0, mipmaps,
+ dds_write_vals.mipmap_filter,
+ dds_write_vals.mipmap_wrap,
+ dds_write_vals.gamma_correct + dds_write_vals.srgb,
+ dds_write_vals.gamma,
+ dds_write_vals.preserve_alpha_coverage,
+ dds_write_vals.alpha_test_threshold);
+ }
+ else
+ {
+ memcpy (fmtdst, src, w * h * bpp);
+ get_mipmap_chain (fmtdst + (w * h * bpp), w, h, bpp, image_id, drawable_id);
+ }
+
+ g_free (src);
+ src = fmtdst;
+ }
flags = 0;
- if(dds_write_vals.perceptual_metric) flags |= DXT_PERCEPTUAL;
+ if (dds_write_vals.perceptual_metric) flags |= DXT_PERCEPTUAL;
- dxt_compress(dst, src, compression, w, h, bpp, mipmaps, flags);
+ dxt_compress (dst, src, compression, w, h, bpp, mipmaps, flags);
- fwrite(dst, 1, size, fp);
+ fwrite (dst, 1, size, fp);
- g_free(dst);
- }
+ g_free (dst);
+ }
- g_free(src);
+ g_free (src);
- g_object_unref(buffer);
+ g_object_unref (buffer);
}
-static void write_volume_mipmaps(FILE *fp, gint32 image_id, gint32 *layers,
- int w, int h, int d, int bpp, int fmtbpp,
- int mipmaps)
+static void
+write_volume_mipmaps (FILE *fp,
+ gint32 image_id,
+ gint32 *layers,
+ int w,
+ int h,
+ int d,
+ int bpp,
+ int fmtbpp,
+ int mipmaps)
{
- int i, size, offset, colors;
- unsigned char *src, *dst, *tmp, *fmtdst;
- unsigned char *palette = 0;
- GeglBuffer *buffer;
- const Babl *format;
- GimpImageBaseType type;
-
- type = gimp_image_base_type(image_id);
-
- if(dds_write_vals.compression != DDS_COMPRESS_NONE) return;
-
- src = g_malloc(w * h * bpp * d);
-
- if(bpp == 1)
- format = babl_format("Y' u8");
- else if(bpp == 2)
- format = babl_format("Y'A u8");
- else if(bpp == 3)
- format = babl_format("R'G'B' u8");
- else
- format = babl_format("R'G'B'A u8");
-
- if(gimp_image_base_type(image_id) == GIMP_INDEXED)
- palette = gimp_image_get_colormap(image_id, &colors);
-
- offset = 0;
- for(i = 0; i < d; ++i)
- {
- buffer = gimp_drawable_get_buffer(layers[i]);
- gegl_buffer_get(buffer, GEGL_RECTANGLE(0, 0, w, h), 1.0, format,
- src + offset, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+ int i, size, offset, colors;
+ unsigned char *src, *dst, *tmp, *fmtdst;
+ unsigned char *palette = 0;
+ GeglBuffer *buffer;
+ const Babl *format;
+ GimpImageBaseType type;
+
+ type = gimp_image_base_type (image_id);
+
+ if (dds_write_vals.compression != DDS_COMPRESS_NONE) return;
+
+ src = g_malloc (w * h * bpp * d);
+
+ if (bpp == 1)
+ format = babl_format ("Y' u8");
+ else if (bpp == 2)
+ format = babl_format ("Y'A u8");
+ else if (bpp == 3)
+ format = babl_format ("R'G'B' u8");
+ else
+ format = babl_format ("R'G'B'A u8");
+
+ if (gimp_image_base_type (image_id) == GIMP_INDEXED)
+ palette = gimp_image_get_colormap (image_id, &colors);
+
+ offset = 0;
+ for (i = 0; i < d; ++i)
+ {
+ buffer = gimp_drawable_get_buffer (layers[i]);
+ gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0, format,
+ src + offset, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
offset += (w * h * bpp);
- g_object_unref(buffer);
- }
-
- if(gimp_drawable_type(layers[0]) == GIMP_INDEXEDA_IMAGE)
- {
- tmp = g_malloc(w * h * d);
- for(i = 0; i < w * h * d; ++i)
- tmp[i] = src[2 * i];
- g_free(src);
+ g_object_unref (buffer);
+ }
+
+ if (gimp_drawable_type (layers[0]) == GIMP_INDEXEDA_IMAGE)
+ {
+ tmp = g_malloc (w * h * d);
+ for (i = 0; i < w * h * d; ++i)
+ tmp[i] = src[2 * i];
+ g_free (src);
src = tmp;
bpp = 1;
- }
-
- /* we want and assume BGRA ordered pixels for bpp >= 3 from here and
- onwards */
- if(bpp >= 3)
- swap_rb(src, w * h * d, bpp);
-
- /* pre-convert indexed images to RGB for better mipmaps if a
- pixel format conversion is requested */
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT && type == GIMP_INDEXED)
- {
- size = get_volume_mipmapped_size(w, h, d, 3, 0, mipmaps,
- DDS_COMPRESS_NONE);
- dst = g_malloc(size);
- convert_pixels(dst, src, DDS_FORMAT_RGB8, w, h, d, bpp, palette, 1);
- g_free(src);
+ }
+
+ /* we want and assume BGRA ordered pixels for bpp >= 3 from here and
+ onwards */
+ if (bpp >= 3)
+ swap_rb (src, w * h * d, bpp);
+
+ /* pre-convert indexed images to RGB for better mipmaps if a
+ pixel format conversion is requested */
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT && type == GIMP_INDEXED)
+ {
+ size = get_volume_mipmapped_size (w, h, d, 3, 0, mipmaps,
+ DDS_COMPRESS_NONE);
+ dst = g_malloc (size);
+ convert_pixels (dst, src, DDS_FORMAT_RGB8, w, h, d, bpp, palette, 1);
+ g_free (src);
src = dst;
bpp = 3;
palette = NULL;
- }
+ }
- size = get_volume_mipmapped_size(w, h, d, bpp, 0, mipmaps,
+ size = get_volume_mipmapped_size (w, h, d, bpp, 0, mipmaps,
dds_write_vals.compression);
- dst = g_malloc(size);
+ dst = g_malloc (size);
- offset = get_volume_mipmapped_size(w, h, d, bpp, 0, 1,
+ offset = get_volume_mipmapped_size (w, h, d, bpp, 0, 1,
dds_write_vals.compression);
- generate_volume_mipmaps(dst, src, w, h, d, bpp,
+ generate_volume_mipmaps (dst, src, w, h, d, bpp,
palette != NULL, mipmaps,
dds_write_vals.mipmap_filter,
dds_write_vals.mipmap_wrap,
dds_write_vals.gamma_correct + dds_write_vals.srgb,
dds_write_vals.gamma);
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT)
- {
- size = get_volume_mipmapped_size(w, h, d, fmtbpp, 0, mipmaps,
- dds_write_vals.compression);
- offset = get_volume_mipmapped_size(w, h, d, fmtbpp, 0, 1,
- dds_write_vals.compression);
- fmtdst = g_malloc(size);
-
- convert_pixels(fmtdst, dst, dds_write_vals.format, w, h, d, bpp,
- palette, mipmaps);
- g_free(dst);
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT)
+ {
+ size = get_volume_mipmapped_size (w, h, d, fmtbpp, 0, mipmaps,
+ dds_write_vals.compression);
+ offset = get_volume_mipmapped_size (w, h, d, fmtbpp, 0, 1,
+ dds_write_vals.compression);
+ fmtdst = g_malloc (size);
+
+ convert_pixels (fmtdst, dst, dds_write_vals.format, w, h, d, bpp,
+ palette, mipmaps);
+ g_free (dst);
dst = fmtdst;
- }
+ }
- fwrite(dst + offset, 1, size, fp);
+ fwrite (dst + offset, 1, size, fp);
- g_free(src);
- g_free(dst);
+ g_free (src);
+ g_free (dst);
}
-static int write_image(FILE *fp, gint32 image_id, gint32 drawable_id)
+static int
+write_image (FILE *fp,
+ gint32 image_id,
+ gint32 drawable_id)
{
- GimpImageType drawable_type;
- GimpImageBaseType basetype;
- int i, w, h, bpp = 0, fmtbpp = 0, has_alpha = 0;
- int num_mipmaps;
- unsigned char hdr[DDS_HEADERSIZE], hdr10[DDS_HEADERSIZE_DX10];
- unsigned int flags = 0, pflags = 0, caps = 0, caps2 = 0, size = 0;
- unsigned int rmask = 0, gmask = 0, bmask = 0, amask = 0;
- unsigned int fourcc = 0;
- DXGI_FORMAT dxgi_format = DXGI_FORMAT_UNKNOWN;
- gint32 num_layers, *layers;
- guchar *cmap;
- gint colors;
- unsigned char zero[4] = {0, 0, 0, 0};
- int is_dx10 = 0, array_size = 1;
-
- layers = gimp_image_get_layers(image_id, &num_layers);
-
- if(dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING)
- drawable_id = layers[0];
-
- if(dds_write_vals.savetype == DDS_SAVE_SELECTED_LAYER)
- {
- w = gimp_drawable_width(drawable_id);
- h = gimp_drawable_height(drawable_id);
- }
- else
- {
- w = gimp_image_width(image_id);
- h = gimp_image_height(image_id);
- }
-
- basetype = gimp_image_base_type(image_id);
- drawable_type = gimp_drawable_type(drawable_id);
-
- switch(drawable_type)
- {
- case GIMP_RGB_IMAGE: bpp = 3; break;
- case GIMP_RGBA_IMAGE: bpp = 4; break;
- case GIMP_GRAY_IMAGE: bpp = 1; break;
- case GIMP_GRAYA_IMAGE: bpp = 2; break;
- case GIMP_INDEXED_IMAGE: bpp = 1; break;
- case GIMP_INDEXEDA_IMAGE: bpp = 2; break;
- default:
- break;
- }
-
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT)
- {
- for(i = 0; ; ++i)
- {
- if(format_info[i].format == dds_write_vals.format)
- {
- fmtbpp = format_info[i].bpp;
- has_alpha = format_info[i].alpha;
- rmask = format_info[i].rmask;
- gmask = format_info[i].gmask;
- bmask = format_info[i].bmask;
- amask = format_info[i].amask;
- dxgi_format = format_info[i].dxgi_format;
- break;
- }
- }
- }
- else if(bpp == 1)
- {
- if(basetype == GIMP_INDEXED)
- {
- fmtbpp = 1;
- has_alpha = 0;
- rmask = bmask = gmask = amask = 0;
- }
+ GimpImageType drawable_type;
+ GimpImageBaseType basetype;
+ int i, w, h, bpp = 0, fmtbpp = 0, has_alpha = 0;
+ int num_mipmaps;
+ unsigned char hdr[DDS_HEADERSIZE], hdr10[DDS_HEADERSIZE_DX10];
+ unsigned int flags = 0, pflags = 0, caps = 0, caps2 = 0, size = 0;
+ unsigned int rmask = 0, gmask = 0, bmask = 0, amask = 0;
+ unsigned int fourcc = 0;
+ DXGI_FORMAT dxgi_format = DXGI_FORMAT_UNKNOWN;
+ gint32 num_layers, *layers;
+ guchar *cmap;
+ gint colors;
+ unsigned char zero[4] = {0, 0, 0, 0};
+ int is_dx10 = 0, array_size = 1;
+
+ layers = gimp_image_get_layers (image_id, &num_layers);
+
+ if (dds_write_vals.mipmaps == DDS_MIPMAP_EXISTING)
+ drawable_id = layers[0];
+
+ if (dds_write_vals.savetype == DDS_SAVE_SELECTED_LAYER)
+ {
+ w = gimp_drawable_width (drawable_id);
+ h = gimp_drawable_height (drawable_id);
+ }
+ else
+ {
+ w = gimp_image_width (image_id);
+ h = gimp_image_height (image_id);
+ }
+
+ basetype = gimp_image_base_type (image_id);
+ drawable_type = gimp_drawable_type (drawable_id);
+
+ switch (drawable_type)
+ {
+ case GIMP_RGB_IMAGE: bpp = 3; break;
+ case GIMP_RGBA_IMAGE: bpp = 4; break;
+ case GIMP_GRAY_IMAGE: bpp = 1; break;
+ case GIMP_GRAYA_IMAGE: bpp = 2; break;
+ case GIMP_INDEXED_IMAGE: bpp = 1; break;
+ case GIMP_INDEXEDA_IMAGE: bpp = 2; break;
+ default:
+ break;
+ }
+
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT)
+ {
+ for (i = 0; ; ++i)
+ {
+ if (format_info[i].format == dds_write_vals.format)
+ {
+ fmtbpp = format_info[i].bpp;
+ has_alpha = format_info[i].alpha;
+ rmask = format_info[i].rmask;
+ gmask = format_info[i].gmask;
+ bmask = format_info[i].bmask;
+ amask = format_info[i].amask;
+ dxgi_format = format_info[i].dxgi_format;
+ break;
+ }
+ }
+ }
+ else if (bpp == 1)
+ {
+ if (basetype == GIMP_INDEXED)
+ {
+ fmtbpp = 1;
+ has_alpha = 0;
+ rmask = bmask = gmask = amask = 0;
+ }
else
- {
- fmtbpp = 1;
- has_alpha = 0;
- rmask = 0x000000ff;
- gmask = bmask = amask = 0;
- dxgi_format = DXGI_FORMAT_R8_UNORM;
- }
- }
- else if(bpp == 2)
- {
- if(basetype == GIMP_INDEXED)
- {
- fmtbpp = 1;
- has_alpha = 0;
- rmask = gmask = bmask = amask = 0;
- }
+ {
+ fmtbpp = 1;
+ has_alpha = 0;
+ rmask = 0x000000ff;
+ gmask = bmask = amask = 0;
+ dxgi_format = DXGI_FORMAT_R8_UNORM;
+ }
+ }
+ else if (bpp == 2)
+ {
+ if (basetype == GIMP_INDEXED)
+ {
+ fmtbpp = 1;
+ has_alpha = 0;
+ rmask = gmask = bmask = amask = 0;
+ }
else
- {
- fmtbpp = 2;
- has_alpha = 1;
- rmask = 0x000000ff;
- gmask = 0x000000ff;
- bmask = 0x000000ff;
- amask = 0x0000ff00;
- }
- }
- else if(bpp == 3)
- {
+ {
+ fmtbpp = 2;
+ has_alpha = 1;
+ rmask = 0x000000ff;
+ gmask = 0x000000ff;
+ bmask = 0x000000ff;
+ amask = 0x0000ff00;
+ }
+ }
+ else if (bpp == 3)
+ {
fmtbpp = 3;
rmask = 0x00ff0000;
gmask = 0x0000ff00;
bmask = 0x000000ff;
amask = 0x00000000;
- }
- else
- {
+ }
+ else
+ {
fmtbpp = 4;
has_alpha = 1;
rmask = 0x00ff0000;
@@ -1286,196 +1340,196 @@ static int write_image(FILE *fp, gint32 image_id, gint32 drawable_id)
bmask = 0x000000ff;
amask = 0xff000000;
dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;
- }
+ }
- memset(hdr, 0, DDS_HEADERSIZE);
+ memset (hdr, 0, DDS_HEADERSIZE);
- PUTL32(hdr, FOURCC('D','D','S',' '));
- PUTL32(hdr + 4, 124);
- PUTL32(hdr + 12, h);
- PUTL32(hdr + 16, w);
- PUTL32(hdr + 76, 32);
+ PUTL32(hdr, FOURCC ('D','D','S',' '));
+ PUTL32(hdr + 4, 124);
+ PUTL32(hdr + 12, h);
+ PUTL32(hdr + 16, w);
+ PUTL32(hdr + 76, 32);
- if(dds_write_vals.compression == DDS_COMPRESS_NONE)
- {
+ if (dds_write_vals.compression == DDS_COMPRESS_NONE)
+ {
PUTL32(hdr + 88, fmtbpp << 3);
PUTL32(hdr + 92, rmask);
PUTL32(hdr + 96, gmask);
PUTL32(hdr + 100, bmask);
PUTL32(hdr + 104, amask);
- }
+ }
- /*
- put some information in the reserved area to identify the origin
- of the image
- */
- PUTL32(hdr + 32, FOURCC('G','I','M','P'));
- PUTL32(hdr + 36, FOURCC('-','D','D','S'));
- PUTL32(hdr + 40, DDS_PLUGIN_VERSION);
+ /*
+ put some information in the reserved area to identify the origin
+ of the image
+ */
+ PUTL32(hdr + 32, FOURCC ('G','I','M','P'));
+ PUTL32(hdr + 36, FOURCC ('-','D','D','S'));
+ PUTL32(hdr + 40, DDS_PLUGIN_VERSION);
- flags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT;
+ flags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT;
- caps = DDSCAPS_TEXTURE;
- if(dds_write_vals.mipmaps)
- {
+ caps = DDSCAPS_TEXTURE;
+ if (dds_write_vals.mipmaps)
+ {
flags |= DDSD_MIPMAPCOUNT;
caps |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
- num_mipmaps = get_num_mipmaps(w, h);
- }
- else
- num_mipmaps = 1;
+ num_mipmaps = get_num_mipmaps (w, h);
+ }
+ else
+ num_mipmaps = 1;
- if((dds_write_vals.savetype == DDS_SAVE_CUBEMAP) && is_cubemap)
- {
+ if ((dds_write_vals.savetype == DDS_SAVE_CUBEMAP) && is_cubemap)
+ {
caps |= DDSCAPS_COMPLEX;
caps2 |= (DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALL_FACES);
- }
- else if((dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP) && is_volume)
- {
+ }
+ else if ((dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP) && is_volume)
+ {
PUTL32(hdr + 24, num_layers); /* depth */
flags |= DDSD_DEPTH;
caps |= DDSCAPS_COMPLEX;
caps2 |= DDSCAPS2_VOLUME;
- }
+ }
- PUTL32(hdr + 28, num_mipmaps);
- PUTL32(hdr + 108, caps);
- PUTL32(hdr + 112, caps2);
+ PUTL32(hdr + 28, num_mipmaps);
+ PUTL32(hdr + 108, caps);
+ PUTL32(hdr + 112, caps2);
- if(dds_write_vals.compression == DDS_COMPRESS_NONE)
- {
+ if (dds_write_vals.compression == DDS_COMPRESS_NONE)
+ {
flags |= DDSD_PITCH;
- if(dds_write_vals.format > DDS_FORMAT_DEFAULT)
- {
- if(dds_write_vals.format == DDS_FORMAT_A8)
+ if (dds_write_vals.format > DDS_FORMAT_DEFAULT)
+ {
+ if (dds_write_vals.format == DDS_FORMAT_A8)
pflags |= DDPF_ALPHA;
- else
- {
- if(((fmtbpp == 1) || (dds_write_vals.format == DDS_FORMAT_L8A8)) &&
- (dds_write_vals.format != DDS_FORMAT_R3G3B2))
- pflags |= DDPF_LUMINANCE;
- else
- pflags |= DDPF_RGB;
- }
- }
+ else
+ {
+ if (((fmtbpp == 1) || (dds_write_vals.format == DDS_FORMAT_L8A8)) &&
+ (dds_write_vals.format != DDS_FORMAT_R3G3B2))
+ pflags |= DDPF_LUMINANCE;
+ else
+ pflags |= DDPF_RGB;
+ }
+ }
else
- {
- if(bpp == 1)
- {
- if(basetype == GIMP_INDEXED)
- pflags |= DDPF_PALETTEINDEXED8;
- else
- pflags |= DDPF_LUMINANCE;
- }
- else if((bpp == 2) && (basetype == GIMP_INDEXED))
+ {
+ if (bpp == 1)
+ {
+ if (basetype == GIMP_INDEXED)
+ pflags |= DDPF_PALETTEINDEXED8;
+ else
+ pflags |= DDPF_LUMINANCE;
+ }
+ else if ((bpp == 2) && (basetype == GIMP_INDEXED))
pflags |= DDPF_PALETTEINDEXED8;
- else
+ else
pflags |= DDPF_RGB;
- }
+ }
- if(has_alpha) pflags |= DDPF_ALPHAPIXELS;
+ if (has_alpha) pflags |= DDPF_ALPHAPIXELS;
PUTL32(hdr + 8, flags);
PUTL32(hdr + 20, w * fmtbpp); /* pitch */
PUTL32(hdr + 80, pflags);
/*
- write extra fourcc info - this is special to GIMP DDS. When the image
- is read by the plugin, we can detect the added information to decode
- the pixels
- */
- if(dds_write_vals.format == DDS_FORMAT_AEXP)
- {
- PUTL32(hdr + 44, FOURCC('A','E','X','P'));
- }
- else if(dds_write_vals.format == DDS_FORMAT_YCOCG)
- {
- PUTL32(hdr + 44, FOURCC('Y','C','G','1'));
- }
- }
- else
- {
+ write extra fourcc info - this is special to GIMP DDS. When the image
+ is read by the plugin, we can detect the added information to decode
+ the pixels
+ */
+ if (dds_write_vals.format == DDS_FORMAT_AEXP)
+ {
+ PUTL32(hdr + 44, FOURCC ('A','E','X','P'));
+ }
+ else if (dds_write_vals.format == DDS_FORMAT_YCOCG)
+ {
+ PUTL32(hdr + 44, FOURCC ('Y','C','G','1'));
+ }
+ }
+ else
+ {
flags |= DDSD_LINEARSIZE;
pflags = DDPF_FOURCC;
- switch(dds_write_vals.compression)
- {
- case DDS_COMPRESS_BC1:
- fourcc = FOURCC('D','X','T','1');
- dxgi_format = DXGI_FORMAT_BC1_UNORM;
- break;
- case DDS_COMPRESS_BC2:
- fourcc = FOURCC('D','X','T','3');
- dxgi_format = DXGI_FORMAT_BC2_UNORM;
- break;
- case DDS_COMPRESS_BC3:
- case DDS_COMPRESS_BC3N:
- case DDS_COMPRESS_YCOCG:
- case DDS_COMPRESS_YCOCGS:
- case DDS_COMPRESS_AEXP:
- fourcc = FOURCC('D','X','T','5');
- dxgi_format = DXGI_FORMAT_BC3_UNORM;
- break;
- case DDS_COMPRESS_RXGB:
- fourcc = FOURCC('R','X','G','B');
- dxgi_format = DXGI_FORMAT_BC3_UNORM;
- break;
- case DDS_COMPRESS_BC4:
- fourcc = FOURCC('A','T','I','1');
- dxgi_format = DXGI_FORMAT_BC4_UNORM;
- //is_dx10 = 1;
- break;
- case DDS_COMPRESS_BC5:
- fourcc = FOURCC('A','T','I','2');
- dxgi_format = DXGI_FORMAT_BC5_UNORM;
- //is_dx10 = 1;
- break;
- }
-
- if((dds_write_vals.compression == DDS_COMPRESS_BC3N) ||
- (dds_write_vals.compression == DDS_COMPRESS_RXGB))
- pflags |= DDPF_NORMAL;
+ switch (dds_write_vals.compression)
+ {
+ case DDS_COMPRESS_BC1:
+ fourcc = FOURCC ('D','X','T','1');
+ dxgi_format = DXGI_FORMAT_BC1_UNORM;
+ break;
+ case DDS_COMPRESS_BC2:
+ fourcc = FOURCC ('D','X','T','3');
+ dxgi_format = DXGI_FORMAT_BC2_UNORM;
+ break;
+ case DDS_COMPRESS_BC3:
+ case DDS_COMPRESS_BC3N:
+ case DDS_COMPRESS_YCOCG:
+ case DDS_COMPRESS_YCOCGS:
+ case DDS_COMPRESS_AEXP:
+ fourcc = FOURCC ('D','X','T','5');
+ dxgi_format = DXGI_FORMAT_BC3_UNORM;
+ break;
+ case DDS_COMPRESS_RXGB:
+ fourcc = FOURCC ('R','X','G','B');
+ dxgi_format = DXGI_FORMAT_BC3_UNORM;
+ break;
+ case DDS_COMPRESS_BC4:
+ fourcc = FOURCC ('A','T','I','1');
+ dxgi_format = DXGI_FORMAT_BC4_UNORM;
+ //is_dx10 = 1;
+ break;
+ case DDS_COMPRESS_BC5:
+ fourcc = FOURCC ('A','T','I','2');
+ dxgi_format = DXGI_FORMAT_BC5_UNORM;
+ //is_dx10 = 1;
+ break;
+ }
+
+ if ((dds_write_vals.compression == DDS_COMPRESS_BC3N) ||
+ (dds_write_vals.compression == DDS_COMPRESS_RXGB))
+ pflags |= DDPF_NORMAL;
PUTL32(hdr + 8, flags);
PUTL32(hdr + 80, pflags);
PUTL32(hdr + 84, fourcc);
size = ((w + 3) >> 2) * ((h + 3) >> 2);
- if((dds_write_vals.compression == DDS_COMPRESS_BC1) ||
- (dds_write_vals.compression == DDS_COMPRESS_BC4))
- size *= 8;
+ if ((dds_write_vals.compression == DDS_COMPRESS_BC1) ||
+ (dds_write_vals.compression == DDS_COMPRESS_BC4))
+ size *= 8;
else
- size *= 16;
+ size *= 16;
PUTL32(hdr + 20, size); /* linear size */
/*
- write extra fourcc info - this is special to GIMP DDS. When the image
- is read by the plugin, we can detect the added information to decode
- the pixels
- */
- if(dds_write_vals.compression == DDS_COMPRESS_AEXP)
- {
- PUTL32(hdr + 44, FOURCC('A','E','X','P'));
- }
- else if(dds_write_vals.compression == DDS_COMPRESS_YCOCG)
- {
- PUTL32(hdr + 44, FOURCC('Y','C','G','1'));
- }
- else if(dds_write_vals.compression == DDS_COMPRESS_YCOCGS)
- {
- PUTL32(hdr + 44, FOURCC('Y','C','G','2'));
- }
- }
-
- /* texture arrays require a DX10 header */
- if(dds_write_vals.savetype == DDS_SAVE_ARRAY)
- is_dx10 = 1;
-
- if(is_dx10)
- {
- array_size = (dds_write_vals.savetype == DDS_SAVE_SELECTED_LAYER) ? 1 : get_array_size(image_id);
+ write extra fourcc info - this is special to GIMP DDS. When the image
+ is read by the plugin, we can detect the added information to decode
+ the pixels
+ */
+ if (dds_write_vals.compression == DDS_COMPRESS_AEXP)
+ {
+ PUTL32(hdr + 44, FOURCC ('A','E','X','P'));
+ }
+ else if (dds_write_vals.compression == DDS_COMPRESS_YCOCG)
+ {
+ PUTL32(hdr + 44, FOURCC ('Y','C','G','1'));
+ }
+ else if (dds_write_vals.compression == DDS_COMPRESS_YCOCGS)
+ {
+ PUTL32(hdr + 44, FOURCC ('Y','C','G','2'));
+ }
+ }
+
+ /* texture arrays require a DX10 header */
+ if (dds_write_vals.savetype == DDS_SAVE_ARRAY)
+ is_dx10 = 1;
+
+ if (is_dx10)
+ {
+ array_size = (dds_write_vals.savetype == DDS_SAVE_SELECTED_LAYER) ? 1 : get_array_size (image_id);
PUTL32(hdr10 + 0, dxgi_format);
PUTL32(hdr10 + 4, D3D10_RESOURCE_DIMENSION_TEXTURE2D);
@@ -1485,643 +1539,677 @@ static int write_image(FILE *fp, gint32 image_id, gint32 drawable_id)
/* update main header accordingly */
PUTL32(hdr + 80, pflags | DDPF_FOURCC);
- PUTL32(hdr + 84, FOURCC('D','X','1','0'));
- }
+ PUTL32(hdr + 84, FOURCC ('D','X','1','0'));
+ }
- fwrite(hdr, DDS_HEADERSIZE, 1, fp);
+ fwrite (hdr, DDS_HEADERSIZE, 1, fp);
- if(is_dx10)
- fwrite(hdr10, DDS_HEADERSIZE_DX10, 1, fp);
+ if (is_dx10)
+ fwrite (hdr10, DDS_HEADERSIZE_DX10, 1, fp);
- /* write palette for indexed images */
- if((basetype == GIMP_INDEXED) &&
+ /* write palette for indexed images */
+ if ((basetype == GIMP_INDEXED) &&
(dds_write_vals.format == DDS_FORMAT_DEFAULT) &&
(dds_write_vals.compression == DDS_COMPRESS_NONE))
- {
- cmap = gimp_image_get_colormap(image_id, &colors);
- for(i = 0; i < colors; ++i)
- {
- fwrite(&cmap[3 * i], 1, 3, fp);
- if(i == dds_write_vals.transindex)
- fputc(0, fp);
- else
- fputc(255, fp);
- }
- for(; i < 256; ++i)
- fwrite(zero, 1, 4, fp);
- }
-
- if(dds_write_vals.savetype == DDS_SAVE_CUBEMAP)
- {
- for(i = 0; i < 6; ++i)
- {
- write_layer(fp, image_id, cubemap_faces[i], w, h, bpp, fmtbpp,
- num_mipmaps);
- gimp_progress_update((float)(i + 1) / 6.0);
- }
- }
- else if(dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP)
- {
- for(i = 0; i < num_layers; ++i)
- {
- write_layer(fp, image_id, layers[i], w, h, bpp, fmtbpp, 1);
- gimp_progress_update((float)i / (float)num_layers);
- }
-
- if(num_mipmaps > 1)
- write_volume_mipmaps(fp, image_id, layers, w, h, num_layers,
+ {
+ cmap = gimp_image_get_colormap (image_id, &colors);
+ for (i = 0; i < colors; ++i)
+ {
+ fwrite (&cmap[3 * i], 1, 3, fp);
+ if (i == dds_write_vals.transindex)
+ fputc (0, fp);
+ else
+ fputc (255, fp);
+ }
+ for (; i < 256; ++i)
+ fwrite (zero, 1, 4, fp);
+ }
+
+ if (dds_write_vals.savetype == DDS_SAVE_CUBEMAP)
+ {
+ for (i = 0; i < 6; ++i)
+ {
+ write_layer (fp, image_id, cubemap_faces[i], w, h, bpp, fmtbpp,
+ num_mipmaps);
+ gimp_progress_update ((float)(i + 1) / 6.0);
+ }
+ }
+ else if (dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP)
+ {
+ for (i = 0; i < num_layers; ++i)
+ {
+ write_layer (fp, image_id, layers[i], w, h, bpp, fmtbpp, 1);
+ gimp_progress_update ((float)i / (float)num_layers);
+ }
+
+ if (num_mipmaps > 1)
+ write_volume_mipmaps (fp, image_id, layers, w, h, num_layers,
bpp, fmtbpp, num_mipmaps);
- }
- else if(dds_write_vals.savetype == DDS_SAVE_ARRAY)
- {
- for(i = 0; i < num_layers; ++i)
- {
- if((gimp_drawable_width(layers[i]) == w) && (gimp_drawable_height(layers[i]) == h))
- write_layer(fp, image_id, layers[i], w, h, bpp, fmtbpp, num_mipmaps);
-
- gimp_progress_update((float)i / (float)num_layers);
- }
- }
- else
- {
- write_layer(fp, image_id, drawable_id, w, h, bpp, fmtbpp, num_mipmaps);
- }
-
- gimp_progress_update(1.0);
-
- return(1);
+ }
+ else if (dds_write_vals.savetype == DDS_SAVE_ARRAY)
+ {
+ for (i = 0; i < num_layers; ++i)
+ {
+ if ((gimp_drawable_width (layers[i]) == w) && (gimp_drawable_height (layers[i]) == h))
+ write_layer (fp, image_id, layers[i], w, h, bpp, fmtbpp, num_mipmaps);
+
+ gimp_progress_update ((float)i / (float)num_layers);
+ }
+ }
+ else
+ {
+ write_layer (fp, image_id, drawable_id, w, h, bpp, fmtbpp, num_mipmaps);
+ }
+
+ gimp_progress_update (1.0);
+
+ return (1);
}
-static GtkWidget *string_value_combo_new(string_value_t *strings,
- int active_value)
+static GtkWidget *
+string_value_combo_new (string_value_t *strings,
+ int active_value)
{
- GtkWidget *opt;
- GtkCellRenderer *renderer;
- GtkListStore *store;
- GtkTreeIter iter;
- int i, active = 0;
-
- store = gtk_list_store_new(3, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN);
- for(i = 0; strings[i].string; ++i)
- {
- if(strings[i].value == active_value) active = i;
- gtk_list_store_append(store, &iter);
- gtk_list_store_set(store, &iter,
- 0, strings[i].value,
- 1, strings[i].string,
- 2, 1,
- -1);
- }
-
- renderer = gtk_cell_renderer_text_new();
-
- opt = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
- gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(opt), renderer, 1);
- gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(opt), renderer,
+ GtkWidget *opt;
+ GtkCellRenderer *renderer;
+ GtkListStore *store;
+ GtkTreeIter iter;
+ int i, active = 0;
+
+ store = gtk_list_store_new (3, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN);
+ for (i = 0; strings[i].string; ++i)
+ {
+ if (strings[i].value == active_value) active = i;
+ gtk_list_store_append (store, &iter);
+ gtk_list_store_set (store, &iter,
+ 0, strings[i].value,
+ 1, strings[i].string,
+ 2, 1,
+ -1);
+ }
+
+ renderer = gtk_cell_renderer_text_new ();
+
+ opt = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (opt), renderer, 1);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (opt), renderer,
"text", COMBO_STRING,
"sensitive", COMBO_SENSITIVE,
NULL);
- gtk_combo_box_set_active(GTK_COMBO_BOX(opt), active);
+ gtk_combo_box_set_active (GTK_COMBO_BOX (opt), active);
- g_object_unref(store);
+ g_object_unref (store);
- return(opt);
+ return (opt);
}
-static void string_value_combo_selected(GtkWidget *widget, gpointer data)
+static void
+string_value_combo_selected (GtkWidget *widget,
+ gpointer data)
{
- int value;
- GtkTreeIter iter;
- GtkTreeModel *model;
+ int value;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
- gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter);
- gtk_tree_model_get(model, &iter, COMBO_VALUE, &value, -1);
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
+ gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
+ gtk_tree_model_get (model, &iter, COMBO_VALUE, &value, -1);
- *((int *)data) = value;
+ *((int *)data) = value;
}
-static void string_value_combo_set_item_sensitive(GtkWidget *widget,
- int value, int sensitive)
+static void
+string_value_combo_set_item_sensitive (GtkWidget *widget,
+ int value,
+ int sensitive)
{
- GtkTreeIter iter;
- GtkTreeModel *model;
- int val;
-
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
- gtk_tree_model_get_iter_first(model, &iter);
- do
- {
- gtk_tree_model_get(model, &iter, COMBO_VALUE, &val, -1);
- if(val == value)
- {
- gtk_list_store_set(GTK_LIST_STORE(model), &iter,
- COMBO_SENSITIVE, sensitive, -1);
- break;
- }
- } while(gtk_tree_model_iter_next(model, &iter));
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ int val;
+
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
+ gtk_tree_model_get_iter_first (model, &iter);
+ do
+ {
+ gtk_tree_model_get (model, &iter, COMBO_VALUE, &val, -1);
+ if (val == value)
+ {
+ gtk_list_store_set (GTK_LIST_STORE (model), &iter,
+ COMBO_SENSITIVE, sensitive, -1);
+ break;
+ }
+ } while (gtk_tree_model_iter_next (model, &iter));
}
-static void string_value_combo_set_active(GtkWidget *widget,
- int value)
+static void
+string_value_combo_set_active (GtkWidget *widget,
+ int value)
{
- GtkTreeIter iter;
- GtkTreeModel *model;
- int val;
-
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
- gtk_tree_model_get_iter_first(model, &iter);
- do
- {
- gtk_tree_model_get(model, &iter, COMBO_VALUE, &val, -1);
- if(val == value)
- {
- gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &iter);
- break;
- }
- } while(gtk_tree_model_iter_next(model, &iter));
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ int val;
+
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
+ gtk_tree_model_get_iter_first (model, &iter);
+ do
+ {
+ gtk_tree_model_get (model, &iter, COMBO_VALUE, &val, -1);
+ if (val == value)
+ {
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
+ break;
+ }
+ } while (gtk_tree_model_iter_next (model, &iter));
}
-static void save_dialog_response(GtkWidget *widget, gint response_id,
- gpointer data)
+static void
+save_dialog_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data)
{
- switch(response_id)
- {
- case GTK_RESPONSE_OK:
- runme = 1;
- default:
- gtk_widget_destroy(widget);
- break;
- }
+ switch (response_id)
+ {
+ case GTK_RESPONSE_OK:
+ runme = 1;
+ default:
+ gtk_widget_destroy (widget);
+ break;
+ }
}
-static void compression_selected(GtkWidget *widget, gpointer data)
+static void
+compression_selected (GtkWidget *widget,
+ gpointer data)
{
- GtkTreeIter iter;
- GtkTreeModel *model;
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
- gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter);
- gtk_tree_model_get(model, &iter, COMBO_VALUE,
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
+ gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
+ gtk_tree_model_get (model, &iter, COMBO_VALUE,
&dds_write_vals.compression, -1);
- gtk_widget_set_sensitive(format_opt, dds_write_vals.compression == DDS_COMPRESS_NONE);
- gtk_widget_set_sensitive(pm_chk, dds_write_vals.compression != DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (format_opt, dds_write_vals.compression == DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (pm_chk, dds_write_vals.compression != DDS_COMPRESS_NONE);
}
-static void savetype_selected(GtkWidget *widget, gpointer data)
+static void
+savetype_selected (GtkWidget *widget,
+ gpointer data)
{
- gint32 image_id = *((gint32 *)data);
-
- dds_write_vals.savetype = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
-
- switch(dds_write_vals.savetype)
- {
- case DDS_SAVE_SELECTED_LAYER:
- case DDS_SAVE_CUBEMAP:
- case DDS_SAVE_ARRAY:
- gtk_widget_set_sensitive(compress_opt, 1);
- break;
- case DDS_SAVE_VOLUMEMAP:
- dds_write_vals.compression = DDS_COMPRESS_NONE;
- gtk_combo_box_set_active(GTK_COMBO_BOX(compress_opt),
- DDS_COMPRESS_NONE);
- gtk_widget_set_sensitive(compress_opt, 0);
- break;
- }
-
- string_value_combo_set_item_sensitive(mipmap_opt, DDS_MIPMAP_EXISTING,
- check_mipmaps(image_id, dds_write_vals.savetype));
+ gint32 image_id = *((gint32 *)data);
+
+ dds_write_vals.savetype = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
+
+ switch (dds_write_vals.savetype)
+ {
+ case DDS_SAVE_SELECTED_LAYER:
+ case DDS_SAVE_CUBEMAP:
+ case DDS_SAVE_ARRAY:
+ gtk_widget_set_sensitive (compress_opt, 1);
+ break;
+ case DDS_SAVE_VOLUMEMAP:
+ dds_write_vals.compression = DDS_COMPRESS_NONE;
+ gtk_combo_box_set_active (GTK_COMBO_BOX (compress_opt),
+ DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (compress_opt, 0);
+ break;
+ }
+
+ string_value_combo_set_item_sensitive (mipmap_opt, DDS_MIPMAP_EXISTING,
+ check_mipmaps (image_id, dds_write_vals.savetype));
}
-static void mipmaps_selected(GtkWidget *widget, gpointer data)
+static void
+mipmaps_selected (GtkWidget *widget,
+ gpointer data)
{
- GtkTreeIter iter;
- GtkTreeModel *model;
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
- gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter);
- gtk_tree_model_get(model, &iter, COMBO_VALUE,
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
+ gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
+ gtk_tree_model_get (model, &iter, COMBO_VALUE,
&dds_write_vals.mipmaps, -1);
- gtk_widget_set_sensitive(mipmap_filter_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(mipmap_wrap_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(gamma_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(srgb_chk, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct);
- gtk_widget_set_sensitive(gamma_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
+ gtk_widget_set_sensitive (mipmap_filter_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (mipmap_wrap_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (gamma_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (srgb_chk, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct);
+ gtk_widget_set_sensitive (gamma_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct && !dds_write_vals.srgb);
- gtk_widget_set_sensitive(alpha_coverage_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(alpha_test_threshold_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
+ gtk_widget_set_sensitive (alpha_coverage_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (alpha_test_threshold_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.preserve_alpha_coverage);
}
-static void toggle_clicked(GtkWidget *widget, gpointer data)
+static void
+toggle_clicked (GtkWidget *widget,
+ gpointer data)
{
- int *flag = (int *)data;
- (*flag) = !(*flag);
+ int *flag = (int *)data;
+ (*flag) = !(*flag);
}
-static void transindex_clicked(GtkWidget *widget, gpointer data)
+static void
+transindex_clicked (GtkWidget *widget,
+ gpointer data)
{
- GtkWidget *spin = GTK_WIDGET(g_object_get_data(G_OBJECT(widget), "spin"));
+ GtkWidget *spin = GTK_WIDGET (g_object_get_data (G_OBJECT (widget), "spin"));
- if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
- {
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+ {
dds_write_vals.transindex = 0;
- gtk_widget_set_sensitive(spin, 1);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
- }
- else
- {
- gtk_widget_set_sensitive(spin, 0);
+ gtk_widget_set_sensitive (spin, 1);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), 0);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (spin, 0);
dds_write_vals.transindex = -1;
- }
+ }
}
-static void transindex_changed(GtkWidget *widget, gpointer data)
+static void
+transindex_changed (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.transindex = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
+ dds_write_vals.transindex = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
}
-static void adv_opt_expanded(GtkWidget *widget, gpointer data)
+static void
+adv_opt_expanded (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.show_adv_opt = !gtk_expander_get_expanded(GTK_EXPANDER(widget));
+ dds_write_vals.show_adv_opt = !gtk_expander_get_expanded (GTK_EXPANDER (widget));
}
-static void gamma_correct_clicked(GtkWidget *widget, gpointer data)
+static void
+gamma_correct_clicked (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.gamma_correct = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
- gtk_widget_set_sensitive(srgb_chk, dds_write_vals.gamma_correct);
- gtk_widget_set_sensitive(gamma_spin, dds_write_vals.gamma_correct && !dds_write_vals.srgb);
+ dds_write_vals.gamma_correct = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+ gtk_widget_set_sensitive (srgb_chk, dds_write_vals.gamma_correct);
+ gtk_widget_set_sensitive (gamma_spin, dds_write_vals.gamma_correct && !dds_write_vals.srgb);
}
-static void srgb_clicked(GtkWidget *widget, gpointer data)
+static void
+srgb_clicked (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.srgb = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
- gtk_widget_set_sensitive(gamma_spin, !dds_write_vals.srgb);
+ dds_write_vals.srgb = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+ gtk_widget_set_sensitive (gamma_spin, !dds_write_vals.srgb);
}
-static void gamma_changed(GtkWidget *widget, gpointer data)
+static void
+gamma_changed (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.gamma = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
+ dds_write_vals.gamma = gtk_spin_button_get_value (GTK_SPIN_BUTTON (widget));
}
-static void alpha_coverage_clicked(GtkWidget *widget, gpointer data)
+static void
+alpha_coverage_clicked (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.preserve_alpha_coverage = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
- gtk_widget_set_sensitive(alpha_test_threshold_spin, dds_write_vals.preserve_alpha_coverage);
+ dds_write_vals.preserve_alpha_coverage = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+ gtk_widget_set_sensitive (alpha_test_threshold_spin, dds_write_vals.preserve_alpha_coverage);
}
-static void alpha_test_threshold_changed(GtkWidget *widget, gpointer data)
+static void
+alpha_test_threshold_changed (GtkWidget *widget,
+ gpointer data)
{
- dds_write_vals.alpha_test_threshold = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
+ dds_write_vals.alpha_test_threshold = gtk_spin_button_get_value (GTK_SPIN_BUTTON (widget));
}
-static gint save_dialog(gint32 image_id, gint32 drawable_id)
+static gint
+save_dialog (gint32 image_id,
+ gint32 drawable_id)
{
- GtkWidget *dlg;
- GtkWidget *vbox, *vbox2, *hbox;
- GtkWidget *table;
- GtkWidget *label;
- GtkWidget *opt;
- GtkWidget *check;
- GtkWidget *spin;
- GtkWidget *expander;
- GtkWidget *frame;
- GimpImageBaseType basetype;
-
- if(is_cubemap || is_volume || is_array)
- dds_write_vals.savetype = DDS_SAVE_SELECTED_LAYER;
-
- basetype = gimp_image_base_type(image_id);
-
- dlg = gimp_dialog_new (_("Export as DDS"), "dds", NULL, GTK_WIN_POS_MOUSE,
- gimp_standard_help_func, SAVE_PROC,
+ GtkWidget *dlg;
+ GtkWidget *vbox, *vbox2, *hbox;
+ GtkWidget *table;
+ GtkWidget *label;
+ GtkWidget *opt;
+ GtkWidget *check;
+ GtkWidget *spin;
+ GtkWidget *expander;
+ GtkWidget *frame;
+ GimpImageBaseType basetype;
+
+ if (is_cubemap || is_volume || is_array)
+ dds_write_vals.savetype = DDS_SAVE_SELECTED_LAYER;
+
+ basetype = gimp_image_base_type (image_id);
+
+ dlg = gimp_dialog_new (_("Export as DDS"), "dds", NULL, GTK_WIN_POS_MOUSE,
+ gimp_standard_help_func, SAVE_PROC,
_("Cancel"), GTK_RESPONSE_CANCEL,
_("OK"), GTK_RESPONSE_OK,
- NULL);
+ NULL);
- g_signal_connect(dlg, "response",
- G_CALLBACK(save_dialog_response),
- 0);
- g_signal_connect(dlg, "destroy",
- G_CALLBACK(gtk_main_quit),
- 0);
+ g_signal_connect (dlg, "response",
+ G_CALLBACK (save_dialog_response),
+ 0);
+ g_signal_connect (dlg, "destroy",
+ G_CALLBACK (gtk_main_quit),
+ 0);
- gtk_window_set_resizable(GTK_WINDOW(dlg), 0);
+ gtk_window_set_resizable (GTK_WINDOW (dlg), 0);
- vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
- gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
- gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dlg))),
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
vbox, 1, 1, 0);
- gtk_widget_show(vbox);
+ gtk_widget_show (vbox);
- table = gtk_table_new(4, 2, 0);
- gtk_widget_show(table);
- gtk_box_pack_start(GTK_BOX(vbox), table, 1, 1, 0);
- gtk_table_set_row_spacings(GTK_TABLE(table), 4);
- gtk_table_set_col_spacings(GTK_TABLE(table), 8);
+ table = gtk_table_new (4, 2, 0);
+ gtk_widget_show (table);
+ gtk_box_pack_start (GTK_BOX (vbox), table, 1, 1, 0);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 4);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 8);
- label = gtk_label_new(_("Compression:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
+ label = gtk_label_new (_("Compression:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(compression_strings,
+ opt = string_value_combo_new (compression_strings,
dds_write_vals.compression);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 0, 1,
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(compression_selected), 0);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (compression_selected), 0);
- compress_opt = opt;
+ compress_opt = opt;
- label = gtk_label_new(_("Format:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
+ label = gtk_label_new (_("Format:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(format_strings, dds_write_vals.format);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 1, 2,
+ opt = string_value_combo_new (format_strings, dds_write_vals.format);
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(string_value_combo_selected),
- &dds_write_vals.format);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (string_value_combo_selected),
+ &dds_write_vals.format);
- gtk_widget_set_sensitive(opt, dds_write_vals.compression == DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (opt, dds_write_vals.compression == DDS_COMPRESS_NONE);
- format_opt = opt;
+ format_opt = opt;
- label = gtk_label_new(_("Save:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
+ label = gtk_label_new (_("Save:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(save_type_strings, dds_write_vals.savetype);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 2, 3,
+ opt = string_value_combo_new (save_type_strings, dds_write_vals.savetype);
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(savetype_selected), &image_id);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (savetype_selected), &image_id);
- string_value_combo_set_item_sensitive(opt, DDS_SAVE_CUBEMAP, is_cubemap);
- string_value_combo_set_item_sensitive(opt, DDS_SAVE_VOLUMEMAP, is_volume);
- string_value_combo_set_item_sensitive(opt, DDS_SAVE_ARRAY, is_array);
+ string_value_combo_set_item_sensitive (opt, DDS_SAVE_CUBEMAP, is_cubemap);
+ string_value_combo_set_item_sensitive (opt, DDS_SAVE_VOLUMEMAP, is_volume);
+ string_value_combo_set_item_sensitive (opt, DDS_SAVE_ARRAY, is_array);
- label = gtk_label_new(_("Mipmaps:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
+ label = gtk_label_new (_("Mipmaps:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(mipmap_strings,
+ opt = string_value_combo_new (mipmap_strings,
dds_write_vals.mipmaps);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 3, 4,
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 3, 4,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(mipmaps_selected), &image_id);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (mipmaps_selected), &image_id);
- string_value_combo_set_item_sensitive(opt, DDS_MIPMAP_EXISTING,
- check_mipmaps(image_id, dds_write_vals.savetype));
+ string_value_combo_set_item_sensitive (opt, DDS_MIPMAP_EXISTING,
+ check_mipmaps (image_id, dds_write_vals.savetype));
- mipmap_opt = opt;
+ mipmap_opt = opt;
- string_value_combo_set_item_sensitive(opt, DDS_MIPMAP_EXISTING,
+ string_value_combo_set_item_sensitive (opt, DDS_MIPMAP_EXISTING,
!(is_volume || is_cubemap) &&
is_mipmap_chain_valid);
- hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_box_pack_start(GTK_BOX(vbox), hbox, 1, 1, 0);
- gtk_widget_show(hbox);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, 1, 1, 0);
+ gtk_widget_show (hbox);
- check = gtk_check_button_new_with_label(_("Transparent index:"));
- gtk_box_pack_start(GTK_BOX(hbox), check, 0, 0, 0);
- g_signal_connect(check, "clicked",
- G_CALLBACK(transindex_clicked), 0);
- gtk_widget_show(check);
+ check = gtk_check_button_new_with_label (_("Transparent index:"));
+ gtk_box_pack_start (GTK_BOX (hbox), check, 0, 0, 0);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (transindex_clicked), 0);
+ gtk_widget_show (check);
- spin = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 255, 1, 1, 0)), 1, 0);
- gtk_box_pack_start(GTK_BOX(hbox), spin, 1, 1, 0);
- gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin),
+ spin = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)), 1, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), spin, 1, 1, 0);
+ gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spin),
GTK_UPDATE_IF_VALID);
- g_signal_connect(spin, "value_changed",
- G_CALLBACK(transindex_changed), 0);
- gtk_widget_show(spin);
-
- g_object_set_data(G_OBJECT(check), "spin", spin);
-
- if(basetype != GIMP_INDEXED)
- {
- gtk_widget_set_sensitive(check, 0);
- gtk_widget_set_sensitive(spin, 0);
- }
- else if(dds_write_vals.transindex < 0)
- {
- gtk_widget_set_sensitive(spin, 0);
- }
- else if(dds_write_vals.transindex >= 0)
- {
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), 1);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), dds_write_vals.transindex);
- }
-
- if(is_volume && dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP)
- {
+ g_signal_connect (spin, "value_changed",
+ G_CALLBACK (transindex_changed), 0);
+ gtk_widget_show (spin);
+
+ g_object_set_data (G_OBJECT (check), "spin", spin);
+
+ if (basetype != GIMP_INDEXED)
+ {
+ gtk_widget_set_sensitive (check, 0);
+ gtk_widget_set_sensitive (spin, 0);
+ }
+ else if (dds_write_vals.transindex < 0)
+ {
+ gtk_widget_set_sensitive (spin, 0);
+ }
+ else if (dds_write_vals.transindex >= 0)
+ {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), 1);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), dds_write_vals.transindex);
+ }
+
+ if (is_volume && dds_write_vals.savetype == DDS_SAVE_VOLUMEMAP)
+ {
dds_write_vals.compression = DDS_COMPRESS_NONE;
- string_value_combo_set_active(compress_opt, DDS_COMPRESS_NONE);
- gtk_widget_set_sensitive(compress_opt, 0);
- }
-
- expander = gtk_expander_new(_("<b>Advanced Options</b>"));
- gtk_expander_set_use_markup(GTK_EXPANDER(expander), 1);
- gtk_expander_set_expanded(GTK_EXPANDER(expander), dds_write_vals.show_adv_opt);
- gtk_expander_set_spacing(GTK_EXPANDER(expander), 8);
- g_signal_connect(expander, "activate",
- G_CALLBACK(adv_opt_expanded), 0);
- gtk_box_pack_start(GTK_BOX(vbox), expander, 1, 1, 0);
- gtk_widget_show(expander);
-
-
- vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
- gtk_container_add(GTK_CONTAINER(expander), vbox2);
- gtk_widget_show(vbox2);
-
- frame = gtk_frame_new(_("Compression"));
- gtk_box_pack_start(GTK_BOX(vbox2), frame, 1, 1, 0);
- gtk_widget_show(frame);
-
- table = gtk_table_new(1, 2, 0);
- gtk_table_set_row_spacings(GTK_TABLE(table), 4);
- gtk_table_set_col_spacings(GTK_TABLE(table), 8);
- gtk_container_set_border_width(GTK_CONTAINER(table), 8);
- gtk_container_add(GTK_CONTAINER(frame), table);
- gtk_widget_show(table);
-
- check = gtk_check_button_new_with_label(_("Use perceptual error metric"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_write_vals.perceptual_metric);
- gtk_table_attach(GTK_TABLE(table), check, 0, 2, 0, 1,
+ string_value_combo_set_active (compress_opt, DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (compress_opt, 0);
+ }
+
+ expander = gtk_expander_new (_("<b>Advanced Options</b>"));
+ gtk_expander_set_use_markup (GTK_EXPANDER (expander), 1);
+ gtk_expander_set_expanded (GTK_EXPANDER (expander), dds_write_vals.show_adv_opt);
+ gtk_expander_set_spacing (GTK_EXPANDER (expander), 8);
+ g_signal_connect (expander, "activate",
+ G_CALLBACK (adv_opt_expanded), 0);
+ gtk_box_pack_start (GTK_BOX (vbox), expander, 1, 1, 0);
+ gtk_widget_show (expander);
+
+
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
+ gtk_container_add (GTK_CONTAINER (expander), vbox2);
+ gtk_widget_show (vbox2);
+
+ frame = gtk_frame_new (_("Compression"));
+ gtk_box_pack_start (GTK_BOX (vbox2), frame, 1, 1, 0);
+ gtk_widget_show (frame);
+
+ table = gtk_table_new (1, 2, 0);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 4);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 8);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 8);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+ gtk_widget_show (table);
+
+ check = gtk_check_button_new_with_label (_("Use perceptual error metric"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_write_vals.perceptual_metric);
+ gtk_table_attach (GTK_TABLE (table), check, 0, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- g_signal_connect(check, "clicked",
- G_CALLBACK(toggle_clicked), &dds_write_vals.perceptual_metric);
- gtk_widget_show(check);
-
- pm_chk = check;
-
- frame = gtk_frame_new(_("Mipmaps"));
- gtk_box_pack_start(GTK_BOX(vbox2), frame, 1, 1, 0);
- gtk_widget_show(frame);
-
- table = gtk_table_new(7, 2, 0);
- gtk_table_set_row_spacings(GTK_TABLE(table), 4);
- gtk_table_set_col_spacings(GTK_TABLE(table), 8);
- gtk_container_set_border_width(GTK_CONTAINER(table), 8);
- gtk_container_add(GTK_CONTAINER(frame), table);
- gtk_widget_show(table);
-
- label = gtk_label_new(_("Filter:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (toggle_clicked), &dds_write_vals.perceptual_metric);
+ gtk_widget_show (check);
+
+ pm_chk = check;
+
+ frame = gtk_frame_new (_("Mipmaps"));
+ gtk_box_pack_start (GTK_BOX (vbox2), frame, 1, 1, 0);
+ gtk_widget_show (frame);
+
+ table = gtk_table_new (7, 2, 0);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 4);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 8);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 8);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+ gtk_widget_show (table);
+
+ label = gtk_label_new (_("Filter:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(mipmap_filter_strings,
+ opt = string_value_combo_new (mipmap_filter_strings,
dds_write_vals.mipmap_filter);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 0, 1,
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(string_value_combo_selected),
- &dds_write_vals.mipmap_filter);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (string_value_combo_selected),
+ &dds_write_vals.mipmap_filter);
- mipmap_filter_opt = opt;
+ mipmap_filter_opt = opt;
- label = gtk_label_new(_("Wrap mode:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
+ label = gtk_label_new (_("Wrap mode:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- opt = string_value_combo_new(mipmap_wrap_strings,
+ opt = string_value_combo_new (mipmap_wrap_strings,
dds_write_vals.mipmap_wrap);
- gtk_widget_show(opt);
- gtk_table_attach(GTK_TABLE(table), opt, 1, 2, 1, 2,
+ gtk_widget_show (opt);
+ gtk_table_attach (GTK_TABLE (table), opt, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- g_signal_connect(opt, "changed",
- G_CALLBACK(string_value_combo_selected),
- &dds_write_vals.mipmap_wrap);
+ g_signal_connect (opt, "changed",
+ G_CALLBACK (string_value_combo_selected),
+ &dds_write_vals.mipmap_wrap);
- mipmap_wrap_opt = opt;
+ mipmap_wrap_opt = opt;
- check = gtk_check_button_new_with_label(_("Apply gamma correction"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_write_vals.gamma_correct &&
dds_write_vals.mipmaps);
- gtk_table_attach(GTK_TABLE(table), check, 1, 2, 2, 3,
+ check = gtk_check_button_new_with_label (_("Apply gamma correction"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_write_vals.gamma_correct &&
dds_write_vals.mipmaps);
+ gtk_table_attach (GTK_TABLE (table), check, 1, 2, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- g_signal_connect(check, "clicked",
- G_CALLBACK(gamma_correct_clicked), NULL);
- gtk_widget_show(check);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (gamma_correct_clicked), NULL);
+ gtk_widget_show (check);
- gamma_chk = check;
+ gamma_chk = check;
- check = gtk_check_button_new_with_label(_("Use sRGB colorspace"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_write_vals.gamma_correct &&
dds_write_vals.srgb);
- gtk_table_attach(GTK_TABLE(table), check, 1, 2, 3, 4,
+ check = gtk_check_button_new_with_label (_("Use sRGB colorspace"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_write_vals.gamma_correct &&
dds_write_vals.srgb);
+ gtk_table_attach (GTK_TABLE (table), check, 1, 2, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- g_signal_connect(check, "clicked",
- G_CALLBACK(srgb_clicked), NULL);
- gtk_widget_show(check);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (srgb_clicked), NULL);
+ gtk_widget_show (check);
- srgb_chk = check;
+ srgb_chk = check;
- label = gtk_label_new(_("Gamma:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,
+ label = gtk_label_new (_("Gamma:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- spin = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(dds_write_vals.gamma, 1e-05, 100, 0.1, 0.5,
0)), 1, 1);
- gtk_table_attach(GTK_TABLE(table), spin, 1, 2, 4, 5,
+ spin = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (dds_write_vals.gamma, 1e-05, 100, 0.1,
0.5, 0)), 1, 1);
+ gtk_table_attach (GTK_TABLE (table), spin, 1, 2, 4, 5,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_IF_VALID);
- g_signal_connect(spin, "value_changed",
- G_CALLBACK(gamma_changed), 0);
- gtk_widget_show(spin);
+ gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spin), GTK_UPDATE_IF_VALID);
+ g_signal_connect (spin, "value_changed",
+ G_CALLBACK (gamma_changed), 0);
+ gtk_widget_show (spin);
- gamma_spin = spin;
+ gamma_spin = spin;
- check = gtk_check_button_new_with_label(_("Preserve alpha test coverage"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), dds_write_vals.preserve_alpha_coverage &&
dds_write_vals.mipmaps);
- gtk_table_attach(GTK_TABLE(table), check, 1, 2, 5, 6,
+ check = gtk_check_button_new_with_label (_("Preserve alpha test coverage"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), dds_write_vals.preserve_alpha_coverage &&
dds_write_vals.mipmaps);
+ gtk_table_attach (GTK_TABLE (table), check, 1, 2, 5, 6,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- g_signal_connect(check, "clicked",
- G_CALLBACK(alpha_coverage_clicked), NULL);
- gtk_widget_show(check);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (alpha_coverage_clicked), NULL);
+ gtk_widget_show (check);
- alpha_coverage_chk = check;
+ alpha_coverage_chk = check;
- label = gtk_label_new(_("Alpha test threshold:"));
- gtk_widget_show(label);
- gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7,
+ label = gtk_label_new (_("Alpha test threshold:"));
+ gtk_widget_show (label);
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
- gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
+ gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
- spin = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(dds_write_vals.alpha_test_threshold, 0, 1,
0.01, 0.1, 0)), 1, 2);
- gtk_table_attach(GTK_TABLE(table), spin, 1, 2, 6, 7,
+ spin = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (dds_write_vals.alpha_test_threshold, 0, 1,
0.01, 0.1, 0)), 1, 2);
+ gtk_table_attach (GTK_TABLE (table), spin, 1, 2, 6, 7,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND), 0, 0);
- gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_IF_VALID);
- g_signal_connect(spin, "value_changed",
- G_CALLBACK(alpha_test_threshold_changed), 0);
- gtk_widget_show(spin);
-
- alpha_test_threshold_spin = spin;
-
- gtk_widget_set_sensitive(mipmap_filter_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(mipmap_wrap_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(gamma_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(srgb_chk, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct);
- gtk_widget_set_sensitive(gamma_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
+ gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spin), GTK_UPDATE_IF_VALID);
+ g_signal_connect (spin, "value_changed",
+ G_CALLBACK (alpha_test_threshold_changed), 0);
+ gtk_widget_show (spin);
+
+ alpha_test_threshold_spin = spin;
+
+ gtk_widget_set_sensitive (mipmap_filter_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (mipmap_wrap_opt, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (gamma_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (srgb_chk, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct);
+ gtk_widget_set_sensitive (gamma_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.gamma_correct && !dds_write_vals.srgb);
- gtk_widget_set_sensitive(pm_chk, dds_write_vals.compression != DDS_COMPRESS_NONE);
- gtk_widget_set_sensitive(alpha_coverage_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
- gtk_widget_set_sensitive(alpha_test_threshold_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
+ gtk_widget_set_sensitive (pm_chk, dds_write_vals.compression != DDS_COMPRESS_NONE);
+ gtk_widget_set_sensitive (alpha_coverage_chk, dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE);
+ gtk_widget_set_sensitive (alpha_test_threshold_spin, (dds_write_vals.mipmaps == DDS_MIPMAP_GENERATE) &&
dds_write_vals.preserve_alpha_coverage);
- gtk_widget_show(dlg);
+ gtk_widget_show (dlg);
- runme = 0;
+ runme = 0;
- gtk_main();
+ gtk_main ();
- return(runme);
+ return (runme);
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
