commit 66900a7d91cd84b0b6c8737e9c0417d7892ea1c3
parent 9808a29fabc49121e470c8438405b08fd422ace1
Author: vaplv <vaplv@free.fr>
Date: Sat, 19 Jul 2014 17:34:28 +0200
Internally use the public material types
Diffstat:
| M | src/aw.h | | | 41 | ++++++++++++++++++++++++++++++++++++++--- |
| M | src/aw_mtl.c | | | 275 | ++++++++++++++++++++++++++++++++++++++----------------------------------------- |
| M | src/test_aw_mtl.c | | | 70 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------- |
3 files changed, 226 insertions(+), 160 deletions(-)
diff --git a/src/aw.h b/src/aw.h
@@ -31,6 +31,22 @@ enum aw_color_space {
AW_COLOR_XYZ
};
+enum aw_map_flag {
+ AW_MAP_BLEND_U = BIT(0),
+ AW_MAP_BLEND_V = BIT(1),
+ AW_MAP_COLOR_CORRECTION = BIT(2),
+ AW_MAP_CLAMP = BIT(3)
+};
+
+enum aw_map_channel {
+ AW_MAP_CHANNEL_RED,
+ AW_MAP_CHANNEL_GREEN,
+ AW_MAP_CHANNEL_BLUE,
+ AW_MAP_CHANNEL_MATTE,
+ AW_MAP_CHANNEL_LUMINANCE,
+ AW_MAP_CHANNEL_DEPTH
+};
+
struct aw_obj_desc {
size_t faces_count;
size_t groups_count;
@@ -76,14 +92,33 @@ struct aw_color {
enum aw_color_space color_space;
};
+struct aw_map {
+ char* filename; /* NULL <=> Not defined */
+ int options_mask;
+ float image_bias; /* Scalar to add to the image pixels */
+ float image_scale; /* Scalar to multiply to the image pixels */
+ float texcoord_bias[3];
+ float texcoord_scale[3];
+ float texcoord_turbulence[3];
+ size_t resolution; /* image size = resolution x resolution */
+ enum aw_map_channel scalar; /* Channel used to create a scalar texture */
+ float bump_multiplier; /* Only available on bump maps */
+};
+
struct aw_material {
- const char* name;
+ char* name;
struct aw_color ambient;
struct aw_color diffuse;
struct aw_color specular;
struct aw_color transmission;
float specular_exponent;
float refraction_index;
+ size_t illumination_model; /* In [0, 10] */
+ struct aw_map ambient_map;
+ struct aw_map diffuse_map;
+ struct aw_map specular_map;
+ struct aw_map specular_exponent_map; /* Scalar texture */
+ struct aw_map bump_map; /* Scalar texture with valid bump multiplier */
};
struct aw_obj;
@@ -172,13 +207,13 @@ aw_mtl_load
AW_API enum aw_result
aw_mtl_materials_count_get
(struct aw_mtl* mtl,
- size_t* materials_count);
+ size_t* materials_count);
AW_API enum aw_result
aw_mtl_material_get
(struct aw_mtl* mtl,
const size_t imaterial,
- struct aw_material* material);
+ const struct aw_material** material);
END_DECLS
diff --git a/src/aw_mtl.c b/src/aw_mtl.c
@@ -19,140 +19,120 @@ enum map_type {
MAP_BUMP = MAP_SCALAR | BIT(2)
};
-enum map_flag {
- MAP_BLEND_U = BIT(0),
- MAP_BLEND_V = BIT(1),
- MAP_COLOR_CORRECTION = BIT(2),
- MAP_CLAMP = BIT(3)
-};
-
-enum map_channel {
- MAP_CHANNEL_RED,
- MAP_CHANNEL_GREEN,
- MAP_CHANNEL_BLUE,
- MAP_CHANNEL_MATTE,
- MAP_CHANNEL_LUMINANCE,
- MAP_CHANNEL_DEPTH
-};
-
-struct map {
- struct str filename;
- int mask_options; /* Combination of map_flag */
- enum map_channel channel; /* Channel used to create a scalar/bump texture */
- float texture_bias; /* Scalar to add to the image */
- float texture_scale; /* Scale to multiply to the image */
- float origin[3]; /* Texcoord offset */
- float scale[3]; /* Texcoord scale */
- float turbulence[3]; /* Texcoord turbulence */
- size_t resolution;
- float bump_multiplier;
-};
-
static FINLINE void
-map_init(struct mem_allocator* allocator, struct map* map)
+map_init(struct mem_allocator* allocator, struct aw_map* map)
{
+ (void)allocator;
ASSERT(map);
- memset(map, 0, sizeof(struct map));
- str_init(allocator, &map->filename);
+ map->filename = NULL;
+ map->options_mask = 0;
+ map->image_bias = 0.f;
+ map->image_scale = 1.f;
+ f3_splat(map->texcoord_bias, 0.f);
+ f3_splat(map->texcoord_scale, 1.f);
+ f3_splat(map->texcoord_turbulence, 0.f);
+ map->resolution = 0;
+ map->scalar = AW_MAP_CHANNEL_LUMINANCE;
+ map->bump_multiplier = 1.0f;
}
static FINLINE void
-map_release(struct map* map)
+map_release(struct aw_map* map)
{
ASSERT(map);
- str_release(&map->filename);
+ if(map->filename)
+ mem_free(map->filename);
}
static FINLINE void
-map_copy_pod__(struct map* dst, const struct map* src)
+map_copy_pod__(struct aw_map* dst, const struct aw_map* src)
{
ASSERT(dst && src);
- dst->mask_options = src->mask_options;
- dst->channel = src->channel;
- dst->texture_bias = src->texture_bias;
- dst->texture_scale = src->texture_scale;
- f3_set(dst->origin, src->origin);
- f3_set(dst->scale, src->scale);
- f3_set(dst->turbulence, src->turbulence);
+ dst->options_mask = src->options_mask;
+ dst->image_bias = src->image_bias;
+ dst->image_scale = src->image_scale;
+ f3_set(dst->texcoord_bias, src->texcoord_bias);
+ f3_set(dst->texcoord_scale, src->texcoord_scale);
+ f3_set(dst->texcoord_turbulence, src->texcoord_turbulence);
dst->resolution = src->resolution;
+ dst->scalar = src->scalar;
dst->bump_multiplier = src->bump_multiplier;
}
static FINLINE int
-map_copy(struct map* dst, const struct map* src)
+map_copy(struct aw_map* dst, const struct aw_map* src)
{
ASSERT(dst && src);
- map_copy_pod__(dst, src);
- return str_copy(&dst->filename, &src->filename);
-}
+ if(dst == src)
+ return 0;
-static FINLINE int
-map_copy_and_release(struct map* dst, struct map* src)
-{
- ASSERT(dst && src);
map_copy_pod__(dst, src);
- return str_copy_and_release(&dst->filename, &src->filename);
+ if(dst->filename)
+ mem_free(dst->filename);
+ if(src->filename) {
+ dst->filename = mem_alloc(strlen(src->filename)+1);
+ if(!dst->filename)
+ return -1;
+ strcpy(dst->filename, src->filename);
+ }
+ return 0;
}
/*******************************************************************************
- * Material helper data structure
+ * Material helper functions
******************************************************************************/
-struct material {
- struct str name;
- struct aw_color ambient;
- struct aw_color diffuse;
- struct aw_color specular;
- struct aw_color transmission;
- float specexp;
- float refraction_id;
- size_t illumination; /* Illumination model identifier */
- struct map ambient_map;
- struct map diffuse_map;
- struct map specular_map;
- struct map specexp_map;
- struct map bump_map;
-};
-
static FINLINE void
-material_init(struct mem_allocator* allocator, struct material* mtl)
+material_init(struct mem_allocator* allocator, struct aw_material* mtl)
{
ASSERT(mtl);
- str_init(allocator, &mtl->name);
+ memset(mtl, 0, sizeof(struct aw_material));
map_init(allocator, &mtl->ambient_map);
map_init(allocator, &mtl->diffuse_map);
map_init(allocator, &mtl->specular_map);
- map_init(allocator, &mtl->specexp_map);
+ map_init(allocator, &mtl->specular_exponent_map);
map_init(allocator, &mtl->bump_map);
}
static FINLINE void
-material_release(struct material* mtl)
+material_release(struct aw_material* mtl)
{
ASSERT(mtl);
- str_release(&mtl->name);
+ if(mtl->name)
+ mem_free(mtl->name);
map_release(&mtl->ambient_map);
map_release(&mtl->diffuse_map);
map_release(&mtl->specular_map);
- map_release(&mtl->specexp_map);
+ map_release(&mtl->specular_exponent_map);
map_release(&mtl->bump_map);
}
static FINLINE void
-material_copy_pod__(struct material* dst, const struct material* src)
+material_copy_pod__(struct aw_material* dst, const struct aw_material* src)
{
ASSERT(dst && src);
dst->ambient = src->ambient;
dst->diffuse = src->diffuse;
dst->specular = src->specular;
dst->transmission = src->transmission;
- dst->specexp = src->specexp;
- dst->refraction_id = src->refraction_id;
- dst->illumination = src->illumination;
+ dst->specular_exponent = src->specular_exponent;
+ dst->refraction_index = src->refraction_index;
+ dst->illumination_model = src->illumination_model;
}
static FINLINE int
-material_copy(struct material* dst, const struct material* src)
+material_copy(struct aw_material* dst, const struct aw_material* src)
{
+ if(dst == src)
+ return 0;
+ if(src->name) {
+ if(dst->name)
+ mem_free(dst->name);
+ dst->name = mem_alloc(strlen(src->name) + 1);
+ if(!dst->name)
+ return -1;
+ strcpy(dst->name, src->name);
+ }
+
material_copy_pod__(dst, src);
if(map_copy(&dst->ambient_map, &src->ambient_map))
return -1;
@@ -160,31 +140,11 @@ material_copy(struct material* dst, const struct material* src)
return -1;
if(map_copy(&dst->specular_map, &src->specular_map))
return -1;
- if(map_copy(&dst->specexp_map, &src->specexp_map))
+ if(map_copy(&dst->specular_exponent_map, &src->specular_exponent_map))
return -1;
if(map_copy(&dst->bump_map, &src->bump_map))
return -1;
- if(str_copy(&dst->name, &src->name))
- return -1;
-}
-static FINLINE int
-material_copy_and_release(struct material* dst, struct material* src)
-{
- ASSERT(dst && src);
- material_copy_pod__(dst, src);
- if(map_copy_and_release(&dst->ambient_map, &src->ambient_map))
- return -1;
- if(map_copy_and_release(&dst->diffuse_map, &src->diffuse_map))
- return -1;
- if(map_copy_and_release(&dst->specular_map, &src->specular_map))
- return -1;
- if(map_copy_and_release(&dst->specexp_map, &src->specexp_map))
- return -1;
- if(map_copy_and_release(&dst->bump_map, &src->bump_map))
- return -1;
- if(str_copy_and_release(&dst->name, &src->name))
- return -1;
return 0;
}
@@ -193,16 +153,15 @@ material_copy_and_release(struct material* dst, struct material* src)
******************************************************************************/
/* Generate the darray_mtl data structure */
#define DARRAY_NAME material
-#define DARRAY_DATA struct material
+#define DARRAY_DATA struct aw_material
#define DARRAY_FUNCTOR_INIT material_init
#define DARRAY_FUNCTOR_RELEASE material_release
#define DARRAY_FUNCTOR_COPY material_copy
-#define DARRAY_FUNCTOR_COPY_AND_RELEASE material_copy_and_release
#include <rsys/dynamic_array.h>
struct aw_mtl {
struct darray_material materials;
- struct material* newmtl; /* Pointer toward the current material */
+ struct aw_material* newmtl; /* Pointer toward the current material */
ref_T ref;
struct mem_allocator* allocator;
@@ -212,10 +171,43 @@ struct aw_mtl {
* Helper functions
******************************************************************************/
static enum aw_result
+parse_name(char** name, char* tk, char** tk_ctxt)
+{
+ struct str str;
+ enum aw_result res = AW_OK;
+ ASSERT(tk && tk_ctxt && name);
+
+ str_init(NULL, &str);
+ do {
+ if(str_len(&str) && str_append_char(&str, ' ')) {
+ res = AW_MEMORY_ERROR;
+ goto error;
+ }
+ if(str_append(&str, tk)) {
+ res = AW_MEMORY_ERROR;
+ goto error;
+ }
+ } while((tk = strtok_r(NULL, " \t", tk_ctxt)));
+
+ *name = mem_alloc(str_len(&str) + 1);
+ if(!*name) {
+ res = AW_MEMORY_ERROR;
+ goto error;
+ }
+ strcpy(*name, str_cget(&str));
+exit:
+ return res;
+error:
+ str_release(&str);
+ goto exit;
+}
+
+static enum aw_result
parse_newmtl(struct aw_mtl* mtl, char** word_tk)
{
char* word;
size_t nmtls;
+ enum aw_result res;
ASSERT(mtl && word_tk);
word = strtok_r(NULL, "\n", word_tk);
@@ -227,7 +219,8 @@ parse_newmtl(struct aw_mtl* mtl, char** word_tk)
return AW_MEMORY_ERROR;
mtl->newmtl = darray_material_data_get(&mtl->materials) + nmtls;
- if(str_set(&mtl->newmtl->name, word)) {
+ res = parse_name(&mtl->newmtl->name, word, word_tk);
+ if(res != AW_OK) {
darray_material_pop_back(&mtl->materials);
mtl->newmtl = NULL;
return AW_MEMORY_ERROR;
@@ -292,17 +285,17 @@ parse_size_t
static enum aw_result
parse_bool_option
- (int* mask_options,
- const enum map_flag option,
+ (int* options_mask,
+ const enum aw_map_flag option,
char** tk_ctxt)
{
char* word;
- ASSERT(mask_options && tk_ctxt);
+ ASSERT(options_mask && tk_ctxt);
word = strtok_r(NULL, " ", tk_ctxt);
if(!word)
return AW_BAD_ARGUMENT;
if(strcmp(word, "on") == 0) {
- *mask_options |= (int)option;
+ *options_mask |= (int)option;
} else if(strcmp(word, "off") != 0) {
return AW_BAD_ARGUMENT;
}
@@ -310,7 +303,7 @@ parse_bool_option
}
static FINLINE enum aw_result
-parse_imfchan_option(enum map_channel* channel, char** tk_ctxt)
+parse_imfchan_option(enum aw_map_channel* channel, char** tk_ctxt)
{
char* word;
ASSERT(channel && tk_ctxt);
@@ -318,17 +311,17 @@ parse_imfchan_option(enum map_channel* channel, char** tk_ctxt)
if(!word)
return AW_BAD_ARGUMENT;
if(!strcmp(word, "r")) {
- *channel = MAP_CHANNEL_RED;
+ *channel = AW_MAP_CHANNEL_RED;
} else if(!strcmp(word, "g")) {
- *channel = MAP_CHANNEL_GREEN;
+ *channel = AW_MAP_CHANNEL_GREEN;
} else if(!strcmp(word, "b")) {
- *channel = MAP_CHANNEL_BLUE;
+ *channel = AW_MAP_CHANNEL_BLUE;
} else if(!strcmp(word, "m")) {
- *channel = MAP_CHANNEL_MATTE;
+ *channel = AW_MAP_CHANNEL_MATTE;
} else if(!strcmp(word, "l")) {
- *channel = MAP_CHANNEL_LUMINANCE;
+ *channel = AW_MAP_CHANNEL_LUMINANCE;
} else if(!strcmp(word, "z")) {
- *channel = MAP_CHANNEL_DEPTH;
+ *channel = AW_MAP_CHANNEL_DEPTH;
} else {
return AW_BAD_ARGUMENT;
}
@@ -337,7 +330,7 @@ parse_imfchan_option(enum map_channel* channel, char** tk_ctxt)
static enum aw_result
parse_map
- (struct map* map,
+ (struct aw_map* map,
const enum map_type type,
char** tk_ctxt)
{
@@ -349,38 +342,40 @@ parse_map
enum aw_result res;
if(!strcmp(word, "-blendu")) {
- res = parse_bool_option(&map->mask_options, MAP_BLEND_U, tk_ctxt);
+ res = parse_bool_option(&map->options_mask, AW_MAP_BLEND_U, tk_ctxt);
} else if(!strcmp(word, "-blendv")) {
- res = parse_bool_option(&map->mask_options, MAP_BLEND_V, tk_ctxt);
+ res = parse_bool_option(&map->options_mask, AW_MAP_BLEND_V, tk_ctxt);
} else if(!strcmp(word, "-cc")) {
- res = parse_bool_option(&map->mask_options, MAP_COLOR_CORRECTION,tk_ctxt);
+ res = parse_bool_option(&map->options_mask, AW_MAP_COLOR_CORRECTION, tk_ctxt);
} else if(!strcmp(word, "-clamp")) {
- res = parse_bool_option(&map->mask_options, MAP_CLAMP, tk_ctxt);
+ res = parse_bool_option(&map->options_mask, AW_MAP_CLAMP, tk_ctxt);
} else if(!strcmp(word, "-imfchan") && (type & MAP_SCALAR)) {
- res = parse_imfchan_option(&map->channel, tk_ctxt);
+ res = parse_imfchan_option(&map->scalar, tk_ctxt);
} else if(!strcmp(word, "-mm")) { /* Image bias and scale */
res = parse_floatX
- (&map->texture_bias, 1, 1, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
+ (&map->image_bias, 1, 1, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
if(res == AW_OK) {
res = parse_floatX
- (&map->texture_scale, 1, 1, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
+ (&map->image_scale, 1, 1, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
}
} else if(!strcmp(word, "-o")) { /* Texcoord offset */
- res = parse_floatX(map->origin, 1, 3, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
+ res = parse_floatX
+ (map->texcoord_bias, 1, 3, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
} else if(!strcmp(word, "-s")) { /* Texcoord scale */
- res = parse_floatX(map->scale, 1, 3, -FLT_MAX, FLT_MAX, 1.f, tk_ctxt);
+ res = parse_floatX
+ (map->texcoord_scale, 1, 3, -FLT_MAX, FLT_MAX, 1.f, tk_ctxt);
} else if(!strcmp(word, "-t")) { /* Texcoord turbulence */
- res = parse_floatX(map->turbulence, 1, 3,-FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
+ res = parse_floatX
+ (map->texcoord_turbulence, 1, 3,-FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
} else if(!strcmp(word, "-texres")) { /* Texture resolution */
res = parse_size_t(&map->resolution, 1, SIZE_MAX, tk_ctxt);
} else if(!strcmp(word, "-bm") && (type == MAP_BUMP)) {/* Bump multiplier */
res = parse_floatX
(&map->bump_multiplier, 1, 1, -FLT_MAX, FLT_MAX, 0.f, tk_ctxt);
} else {
- do {
- if(str_append(&map->filename, word))
- return AW_MEMORY_ERROR;
- } while((word = strtok_r(NULL, " ", tk_ctxt)));
+ if(map->filename)
+ mem_free(map->filename);
+ res = parse_name(&map->filename, word, tk_ctxt);
}
if(res != AW_OK)
return res;
@@ -417,12 +412,12 @@ parse_mtl_file(struct aw_mtl* mtl, const char* path, char* content)
res = parse_color(&mtl->newmtl->transmission, &word_tk);
} else if(!strcmp(word, "Ns")) { /* Specular exponent */
res = parse_floatX
- (&mtl->newmtl->specexp, 1, 1, 0.f, FLT_MAX, 0.f, &word_tk);
+ (&mtl->newmtl->specular_exponent, 1, 1, 0.f, FLT_MAX, 0.f, &word_tk);
} else if(!strcmp(word, "Ni")) { /* Refraction index */
res = parse_floatX
- (&mtl->newmtl->refraction_id, 1, 1, 0.001f, 10.f, 0.001f, &word_tk);
+ (&mtl->newmtl->refraction_index, 1, 1, 0.001f, 10.f, 0.001f, &word_tk);
} else if(!strcmp(word, "illum")) { /* Illumination model */
- res = parse_size_t(&mtl->newmtl->illumination, 0, 10, &word_tk);
+ res = parse_size_t(&mtl->newmtl->illumination_model, 0, 10, &word_tk);
} else if(!strcmp(word, "map_Ka")) { /* Ambient texture */
res = parse_map(&mtl->newmtl->ambient_map, MAP_COMMON, &word_tk);
} else if(!strcmp(word, "map_Kd")) { /* Diffuse texture */
@@ -430,7 +425,7 @@ parse_mtl_file(struct aw_mtl* mtl, const char* path, char* content)
} else if(!strcmp(word, "map_Ks")) { /* Specular texture */
res = parse_map(&mtl->newmtl->specular_map, MAP_COMMON, &word_tk);
} else if(!strcmp(word, "map_Ns")) { /* Specular exponent texture */
- res = parse_map(&mtl->newmtl->specexp_map, MAP_SCALAR, &word_tk);
+ res = parse_map(&mtl->newmtl->specular_exponent_map, MAP_SCALAR, &word_tk);
} else if(!strcmp(word, "bump")) { /* Bump map */
res = parse_map(&mtl->newmtl->bump_map, MAP_BUMP, &word_tk);
} else {
@@ -570,19 +565,11 @@ enum aw_result
aw_mtl_material_get
(struct aw_mtl* mtl,
const size_t imaterial,
- struct aw_material* material)
+ const struct aw_material** material)
{
- const struct material* mtr;
if(!mtl || !material || imaterial>=darray_material_size_get(&mtl->materials))
return AW_BAD_ARGUMENT;
- mtr = darray_material_cdata_get(&mtl->materials) + imaterial;
- material->name = str_cget(&mtr->name);
- material->ambient = mtr->ambient;
- material->diffuse = mtr->diffuse;
- material->specular = mtr->specular;
- material->transmission = mtr->transmission;
- material->specular_exponent = mtr->specexp;
- material->refraction_index = mtr->refraction_id;
+ *material = darray_material_cdata_get(&mtl->materials) + imaterial;
return AW_OK;
}
diff --git a/src/test_aw_mtl.c b/src/test_aw_mtl.c
@@ -34,7 +34,7 @@ test_common(struct aw_mtl* mtl)
FILE* file;
size_t nmtls;
float tmp[3];
- struct aw_material mtr;
+ const struct aw_material* mtr;
NCHECK(mtl, NULL);
@@ -64,25 +64,69 @@ test_common(struct aw_mtl* mtl)
CHECK(aw_mtl_material_get(NULL, 0, &mtr), AW_BAD_ARGUMENT);
CHECK(aw_mtl_material_get(mtl, 0, &mtr), AW_OK);
- CHECK(strcmp(mtr.name, "my_mtl"), 0);
- CHECK(mtr.ambient.color_space, AW_COLOR_RGB);
+ CHECK(strcmp(mtr->name, "my_mtl"), 0);
+ CHECK(mtr->ambient.color_space, AW_COLOR_RGB);
f3(tmp, 0.0435f, 0.0436f, 0.0437f);
- CHECK(f3_eq(mtr.ambient.value, tmp), 1);
+ CHECK(f3_eq(mtr->ambient.value, tmp), 1);
- CHECK(mtr.diffuse.color_space, AW_COLOR_RGB);
+ CHECK(mtr->diffuse.color_space, AW_COLOR_RGB);
f3(tmp, 0.1086f, 0.1087f, 0.1088f);
- CHECK(f3_eq(mtr.diffuse.value, tmp), 1);
+ CHECK(f3_eq(mtr->diffuse.value, tmp), 1);
- CHECK(mtr.specular.color_space, AW_COLOR_RGB);
+ CHECK(mtr->specular.color_space, AW_COLOR_RGB);
f3_splat(tmp, 0.f);
- CHECK(f3_eq(mtr.specular.value, tmp), 1);
+ CHECK(f3_eq(mtr->specular.value, tmp), 1);
- CHECK(mtr.transmission.color_space, AW_COLOR_XYZ);
+ CHECK(mtr->transmission.color_space, AW_COLOR_XYZ);
f3(tmp, 0.987f, 0.988f, 0.989f);
- CHECK(f3_eq(mtr.transmission.value, tmp), 1);
-
- CHECK(mtr.specular_exponent, 10.f);
- CHECK(mtr.refraction_index, 1.19713f);
+ CHECK(f3_eq(mtr->transmission.value, tmp), 1);
+
+ CHECK(mtr->specular_exponent, 10.f);
+ CHECK(mtr->refraction_index, 1.19713f);
+ CHECK(mtr->illumination_model, 6);
+
+ CHECK(strcmp(mtr->ambient_map.filename, "chrome.mpc"), 0);
+ CHECK(mtr->ambient_map.options_mask, 0);
+ CHECK(mtr->ambient_map.image_bias, 0.f);
+ CHECK(mtr->ambient_map.image_scale, 1.f);
+ CHECK(f3_eq(mtr->ambient_map.texcoord_bias, f3_splat(tmp, 0.f)), 1);
+ CHECK(f3_eq(mtr->ambient_map.texcoord_scale, f3_splat(tmp, 1.f)), 1);
+ CHECK(f3_eq(mtr->ambient_map.texcoord_turbulence, f3_splat(tmp, 0.f)), 1);
+
+ CHECK(strcmp(mtr->diffuse_map.filename, "chrome.mpc"), 0);
+ CHECK(mtr->diffuse_map.options_mask, 0);
+ CHECK(mtr->diffuse_map.image_bias, 0.f);
+ CHECK(mtr->diffuse_map.image_scale, 1.f);
+ CHECK(f3_eq(mtr->diffuse_map.texcoord_bias, f3_splat(tmp, 0.f)), 1);
+ CHECK(f3_eq(mtr->diffuse_map.texcoord_scale, f3_splat(tmp, 1.f)), 1);
+ CHECK(f3_eq(mtr->diffuse_map.texcoord_turbulence, f3_splat(tmp, 0.f)), 1);
+
+ CHECK(strcmp(mtr->specular_map.filename, "chrome.mpc"), 0);
+ CHECK(mtr->specular_map.options_mask, 0);
+ CHECK(mtr->specular_map.image_bias, 0.f);
+ CHECK(mtr->specular_map.image_scale, 1.f);
+ CHECK(f3_eq(mtr->specular_map.texcoord_bias, f3_splat(tmp, 0.f)), 1);
+ CHECK(f3_eq(mtr->specular_map.texcoord_scale, f3_splat(tmp, 1.f)), 1);
+ CHECK(f3_eq(mtr->specular_map.texcoord_turbulence, f3_splat(tmp, 0.f)), 1);
+
+ CHECK(strcmp(mtr->specular_exponent_map.filename, "wisp.mps"), 0);
+ CHECK(mtr->specular_exponent_map.options_mask, 0);
+ CHECK(mtr->specular_exponent_map.image_bias, 0.f);
+ CHECK(mtr->specular_exponent_map.image_scale, 1.f);
+ CHECK(f3_eq(mtr->specular_exponent_map.texcoord_scale, f3_splat(tmp, 1.f)), 1);
+ CHECK(f3_eq(mtr->specular_exponent_map.texcoord_bias, f3_splat(tmp, 0.f)), 1);
+ CHECK(f3_eq(mtr->specular_exponent_map.texcoord_turbulence, tmp), 1);
+ CHECK(mtr->specular_exponent_map.scalar, AW_MAP_CHANNEL_LUMINANCE);
+
+ CHECK(strcmp(mtr->bump_map.filename, "sand.mpb"), 0);
+ CHECK(mtr->bump_map.options_mask, 0);
+ CHECK(mtr->bump_map.image_bias, 0.f);
+ CHECK(mtr->bump_map.image_scale, 1.f);
+ CHECK(f3_eq(mtr->bump_map.texcoord_scale, f3_splat(tmp, 1.f)), 1);
+ CHECK(f3_eq(mtr->bump_map.texcoord_bias, f3_splat(tmp, 0.f)), 1);
+ CHECK(f3_eq(mtr->bump_map.texcoord_turbulence, tmp), 1);
+ CHECK(mtr->bump_map.scalar, AW_MAP_CHANNEL_LUMINANCE);
+ CHECK(mtr->bump_map.bump_multiplier, 1.f);
}
int
