material.c File Reference

#include "material.h"
#include "common/files.h"
#include "refresh/images.h"
#include "vk_util.h"
#include "shader/constants.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

Go to the source code of this file.

Classes
struct	CSV_values_s
struct	pbr_materials_table_s
struct	MaterialKind

Macros
#define	MAX_CSV_VALUES   32

Typedefs
typedef struct CSV_values_s	CSV_values_t
typedef struct pbr_materials_table_s	pbr_materials_table_t

Functions
static qerror_t	getStringValue (CSV_values_t const *csv, int index, char *dest)
static qerror_t	getFloatValue (CSV_values_t const *csv, int index, float *dest)
static qerror_t	getIntValue (CSV_values_t const *csv, int index, int *dest)
static qerror_t	getFlagValue (CSV_values_t const *csv, int index, uint32_t *flags, uint32_t mask)
static qerror_t	parse_CSV_line (char *linebuf, CSV_values_t *csv)
static size_t	truncateExtension (char const *src, char *dest)
const pbr_material_t *	MAT_GetPBRMaterialsTable ()
int	MAT_GetNumPBRMaterials ()
int	MAT_GetPBRMaterialIndex (pbr_material_t const *mat)
static void	MAT_Reset (pbr_material_t *mat, int mat_index)
static qerror_t	validateMaterialsTable (pbr_materials_table_t *table)
static uint32_t	getMaterialKind (char const *kindname)
static const char *	getMaterialKindName (uint32_t flag)
static qerror_t	writeMaterialsTable (char const *filename, pbr_materials_table_t const *table)
static qerror_t	parseMaterialsTable (char const *filename, pbr_materials_table_t *table)
qerror_t	MAT_InitializePBRmaterials ()
qerror_t	MAT_ReloadPBRMaterials ()
qerror_t	MAT_SavePBRMaterials ()
qerror_t	MAT_RegisterPBRMaterial (pbr_material_t *mat, image_t *image_diffuse, image_t *image_normals, image_t *image_emissive)
void	MAT_UpdateRegistration (pbr_material_t *mat)
qerror_t	MAT_ResetUnused ()
pbr_material_t *	MAT_GetPBRMaterial (int index)
pbr_material_t *	MAT_FindPBRMaterial (char const *name)
const pbr_material_t *	MAT_UpdatePBRMaterialSkin (image_t *image_diffuse)
void	MAT_PrintMaterialProperties (pbr_material_t const *mat)
qerror_t	MAT_SetPBRMaterialAttribute (pbr_material_t *mat, char const *token, char const *value)
uint32_t	MAT_SetKind (uint32_t material, uint32_t kind)
qboolean	MAT_IsKind (uint32_t material, uint32_t kind)

Variables
int	registration_sequence
static pbr_materials_table_t	pbr_materials_table = { .num_materials = 0, .num_custom_materials = 0, .alpha_sorted = qtrue }
static struct MaterialKind	materialKinds []
static int	nMaterialKinds = sizeof(materialKinds) / sizeof(struct MaterialKind)
static const char *	materials_filename = "materials.csv"

Macro Definition Documentation

MAX_CSV_VALUES

#define MAX_CSV_VALUES   32

Definition at line 36 of file material.c.

Typedef Documentation

CSV_values_t

typedef struct CSV_values_s CSV_values_t

pbr_materials_table_t

typedef struct pbr_materials_table_s pbr_materials_table_t

Function Documentation

getFlagValue()

static qerror_t getFlagValue ( CSV_values_t const *  csv, int  index, uint32_t *  flags, uint32_t  mask  )

static

Definition at line 67 of file material.c.

{
    if (index >= csv->num_values || csv->values[index][0] == '\0')
        return Q_ERR_FAILURE;
    if (atoi(csv->values[index]))
        *flags = *flags | mask;
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

getFloatValue()

static qerror_t getFloatValue ( CSV_values_t const *  csv, int  index, float *  dest  )

static

Definition at line 50 of file material.c.

{
    dest[0] = '\0';
    if (index >= csv->num_values || csv->values[index][0] == '\0')
        return Q_ERR_FAILURE;
    *dest = atof(csv->values[index]);
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

getIntValue()

static qerror_t getIntValue ( CSV_values_t const *  csv, int  index, int *  dest  )

static

Definition at line 59 of file material.c.

{
    if (index >= csv->num_values || csv->values[index][0] == '\0')
        return Q_ERR_FAILURE;
    *dest = atoi(csv->values[index]);
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

getMaterialKind()

static uint32_t getMaterialKind ( char const *  kindname )

static

Definition at line 209 of file material.c.

{
    for (int i = 0; i < nMaterialKinds; ++i)
        if (Q_stricmp(kindname, materialKinds[i].name) == 0)
            return materialKinds[i].flag;
    return MATERIAL_KIND_REGULAR;
}

Referenced by MAT_SetPBRMaterialAttribute(), and parseMaterialsTable().

getMaterialKindName()

static const char* getMaterialKindName ( uint32_t  flag )

static

Definition at line 217 of file material.c.

{
    for (int i = 0; i < nMaterialKinds; ++i)
        if ((flag & MATERIAL_KIND_MASK) == materialKinds[i].flag)
            return materialKinds[i].name;
    return NULL;
}

Referenced by MAT_PrintMaterialProperties(), and writeMaterialsTable().

getStringValue()

static qerror_t getStringValue ( CSV_values_t const *  csv, int  index, char *  dest  )

static

Definition at line 42 of file material.c.

{
    if (index >= csv->num_values)
        return Q_ERR_FAILURE;
    strncpy(dest, csv->values[index], MAX_QPATH);
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

MAT_FindPBRMaterial()

pbr_material_t* MAT_FindPBRMaterial

(

char const *

name

)

Definition at line 465 of file material.c.

{
    char name_copy[MAX_QPATH];
    int len = truncateExtension(name, name_copy);
    assert(len>0);
 
    pbr_materials_table_t * table = &pbr_materials_table;
 
    // note : key comparison must be case insensitive
 
    int search_start = 0;
 
    if (table->alpha_sorted)
    {
        // binary search if names are sorted in alpha order
        int left = 0, right = table->num_materials - 1;
 
        while (left <= right)
        {
            int middle = floor((left + right) / 2);
            pbr_material_t * mat = &table->materials[middle];
            int cmp = Q_strcasecmp(name_copy, mat->name);
            if (cmp < 0)
                right = middle - 1;
            else if (cmp > 0)
                left = middle + 1;
            else
                return mat;
        }
 
        search_start = pbr_materials_table.num_materials;
    }
    
    // brute-force search if the table is not sorted or if the material is not found in the main table
    for (int i = search_start; i < table->num_materials + table->num_custom_materials; ++i)
    {
        pbr_material_t * mat = &table->materials[i];
        if (Q_strcasecmp(mat->name, name_copy) == 0)
            return mat;
    }
 
    // not found - create a material entry
    int index = table->num_materials + table->num_custom_materials;
    table->num_custom_materials++;
    pbr_material_t * mat = &table->materials[index];
    MAT_Reset(mat, index);
    strcpy(mat->name, name_copy);
    Com_Printf("Created a material entry %d for unknown material %s\n", index, name_copy);
 
    return mat;
}

Referenced by bsp_mesh_register_textures(), MAT_UpdatePBRMaterialSkin(), MOD_LoadMD2_RTX(), vkpt_print_material(), and vkpt_set_material().

MAT_GetNumPBRMaterials()

int MAT_GetNumPBRMaterials

(

)

Definition at line 144 of file material.c.

{
    return pbr_materials_table.num_materials + pbr_materials_table.num_custom_materials;
}

Referenced by vkpt_light_buffer_upload_to_staging().

MAT_GetPBRMaterial()

pbr_material_t* MAT_GetPBRMaterial

(

int

index

)

Definition at line 457 of file material.c.

{
    if (index < pbr_materials_table.num_materials + pbr_materials_table.num_custom_materials)
        return &pbr_materials_table.materials[index];
    return NULL;
}

Referenced by compute_world_tangents(), and process_render_feedback().

MAT_GetPBRMaterialIndex()

int MAT_GetPBRMaterialIndex

(

pbr_material_t const *

mat

)

Definition at line 149 of file material.c.

{
    return mat->flags & MATERIAL_INDEX_MASK;
}

MAT_GetPBRMaterialsTable()

const pbr_material_t* MAT_GetPBRMaterialsTable

(

)

Definition at line 139 of file material.c.

{
    return &pbr_materials_table.materials[0];
}

Referenced by vkpt_light_buffer_upload_to_staging().

MAT_InitializePBRmaterials()

qerror_t MAT_InitializePBRmaterials

(

)

Definition at line 341 of file material.c.

{   
    return parseMaterialsTable(materials_filename, &pbr_materials_table);
}

Referenced by R_Init_RTX().

MAT_IsKind()

qboolean MAT_IsKind	(	uint32_t	material,
		uint32_t	kind
	)

Definition at line 665 of file material.c.

{
    return (material & MATERIAL_KIND_MASK) == kind;
}

Referenced by bsp_mesh_register_textures(), collect_sky_and_lava_ligth_polys(), collect_surfaces(), create_poly(), fill_model_instance(), filter_all(), filter_static_sky(), is_model_transparent(), is_sky_or_lava_cluster(), and is_transparent_material().

MAT_PrintMaterialProperties()

void MAT_PrintMaterialProperties

(

pbr_material_t const *

mat

)

Definition at line 549 of file material.c.

{
    Com_Printf("{ %s\n", mat->name);
    Com_Printf("    image_diffuse = '%s'\n", mat->image_diffuse ? mat->image_diffuse->name : "");
    Com_Printf("    image_normals = '%s'\n", mat->image_normals ? mat->image_normals->name : "");
    Com_Printf("    image_emissive = '%s'\n", mat->image_emissive ? mat->image_emissive->name : "");
    Com_Printf("    bump_scale = %f,\n", mat->bump_scale);
    Com_Printf("    rough_override = %f,\n", mat->rough_override);
    Com_Printf("    specular_scale = %f,\n", mat->specular_scale);
    Com_Printf("    emissive_scale = %f,\n", mat->emissive_scale);
    char const * kind = getMaterialKindName(mat->flags);
    Com_Printf("    kind = '%s',\n", kind ? kind : "");
    Com_Printf("    light = %d,\n", (mat->flags & MATERIAL_FLAG_LIGHT) ? (mat->enable_light_styles ? 1 : 2) : 0);
    Com_Printf("    correct_albedo = %d\n", (mat->flags & MATERIAL_FLAG_CORRECT_ALBEDO) != 0);
    Com_Printf("}\n");
}

Referenced by vkpt_print_material().

MAT_RegisterPBRMaterial()

qerror_t MAT_RegisterPBRMaterial	(	pbr_material_t *	mat,
		image_t *	image_diffuse,
		image_t *	image_normals,
		image_t *	image_emissive
	)

Definition at line 397 of file material.c.

{
    if (!mat)
    {
        //Com_Error(ERR_FATAL, "%s: bad pbr material", __func__);
        return Q_ERR_FAILURE;
    }
 
    // already registered ?
    if (mat->registration_sequence == registration_sequence)
        return Q_ERR_SUCCESS;
 
    mat->registration_sequence = registration_sequence;
 
    mat->image_diffuse = image_diffuse;
    mat->image_normals = image_normals;
    mat->image_emissive = image_emissive;
 
    //if (mat->image_diffuse == R_NOTEXTURE)
    //    mat->flags &= ~(MATERIAL_FLAG_VALID);
 
    return Q_ERR_SUCCESS;
}

Referenced by bsp_mesh_register_textures(), and MOD_LoadMD2_RTX().

MAT_ReloadPBRMaterials()

qerror_t MAT_ReloadPBRMaterials

(

)

Definition at line 347 of file material.c.

{
    pbr_materials_table_t newtable;
 
    pbr_materials_table_t * old_table = &pbr_materials_table,
                          * new_table = &newtable;
 
    if (parseMaterialsTable(materials_filename, new_table) == Q_ERR_SUCCESS)
    {
        if (new_table->num_materials != old_table->num_materials)
        {
            Com_EPrintf("Cannot reload materials table : table has different material count, please restart the game\n");
            return Q_ERR_FAILURE;
        }
 
        if (new_table->alpha_sorted != old_table->alpha_sorted)
        {
            Com_EPrintf("Cannot reload materials table : table has different material keys, please check your edits\n");
            return Q_ERR_FAILURE;
        }
 
        for (int i = 0; i < old_table->num_materials; ++i)
        {       
            pbr_material_t * old_mat = &old_table->materials[i],
                           * new_mat = &new_table->materials[i];
 
            if (strncmp(old_mat->name, new_mat->name, MAX_QPATH) != 0)
            {
                Com_EPrintf("Cannot update material '%s' : incorrect name, please check your edits\n", new_mat->name);
                continue;
            }
 
            // update CSV values
            old_mat->bump_scale = new_mat->bump_scale;
            old_mat->rough_override = new_mat->rough_override;
            old_mat->specular_scale = new_mat->specular_scale;
            old_mat->emissive_scale = new_mat->emissive_scale;
            old_mat->flags = new_mat->flags;
        }
        Com_Printf("Reloaded '%s' : %d materials updated\n", materials_filename, old_table->num_materials);
    }
    return Q_ERR_FAILURE;
}

Referenced by vkpt_reload_materials().

MAT_Reset()

static void MAT_Reset ( pbr_material_t *  mat, int  mat_index  )

static

Definition at line 154 of file material.c.

{
    mat->image_diffuse = mat->image_normals = mat->image_emissive = R_NOTEXTURE;
    mat->bump_scale = mat->specular_scale = mat->emissive_scale = 1.0f;
    mat->rough_override = -1.0f;
    mat->flags = mat_index;
    assert((mat->flags & ~MATERIAL_INDEX_MASK) == 0);
    mat->registration_sequence = 0;
    mat->num_frames = 1;
    mat->next_frame = mat_index;
}

Referenced by MAT_FindPBRMaterial(), and parseMaterialsTable().

MAT_ResetUnused()

qerror_t MAT_ResetUnused

(

)

Definition at line 433 of file material.c.

{
    pbr_materials_table_t * table = &pbr_materials_table;
 
    for (int i = 0; i < table->num_materials + table->num_custom_materials; ++i)
    {
        pbr_material_t * mat = table->materials;
 
        if (mat->registration_sequence == registration_sequence)
            continue;
 
        if (!mat->registration_sequence)
            continue;
 
        mat->image_diffuse = R_NOTEXTURE;
        mat->image_normals = R_NOTEXTURE;
        mat->image_emissive = R_NOTEXTURE;
 
        mat->registration_sequence = 0;
    }
    return Q_ERR_SUCCESS;
}

Referenced by R_EndRegistration_RTX().

MAT_SavePBRMaterials()

qerror_t MAT_SavePBRMaterials

(

)

Definition at line 391 of file material.c.

{
    return writeMaterialsTable(materials_filename, &pbr_materials_table);
}

Referenced by vkpt_save_materials().

MAT_SetKind()

uint32_t MAT_SetKind	(	uint32_t	material,
		uint32_t	kind
	)

Definition at line 660 of file material.c.

{
    return (material & ~MATERIAL_KIND_MASK) | kind;
}

Referenced by collect_surfaces(), fill_model_instance(), MAT_SetPBRMaterialAttribute(), and parseMaterialsTable().

MAT_SetPBRMaterialAttribute()

qerror_t MAT_SetPBRMaterialAttribute	(	pbr_material_t *	mat,
		char const *	token,
		char const *	value
	)

Definition at line 570 of file material.c.

{
    assert(mat);
 
    // valid token-value pairs
 
    enum TokenType { TOKEN_BOOL, TOKEN_FLOAT, TOKEN_STRING };
 
    static struct Token {
        int index;
        char const * name;
        enum TokenType type;
    } tokens[] = {
        {0, "bump_scale", TOKEN_FLOAT},
        {1, "roughness_override", TOKEN_FLOAT},
        {2, "specular_scale", TOKEN_FLOAT},
        {3, "emissive_scale", TOKEN_FLOAT},
        {4, "kind", TOKEN_STRING},
        {5, "light_flag", TOKEN_BOOL},
        {6, "correct_albedo_flag", TOKEN_BOOL} };
 
    static int ntokens = sizeof(tokens) / sizeof(struct Token);
 
    if (token == NULL || value == NULL)
        goto usage;
 
    struct Token const * t = NULL;
    for (int i = 0; i < ntokens; ++i)
    {
        if (strcmp(token, tokens[i].name) == 0)
            t = &tokens[i];
    }
    if (!t)
    {
        Com_EPrintf("Unknown material token '%s'\n", Cmd_Argv(1));
        goto usage;
    }
 
    float fvalue = 0.f; qboolean bvalue = qfalse; char const * svalue = NULL;
    switch (t->type)
    {
        case TOKEN_BOOL:   bvalue = atoi(value) == 0 ? qfalse : qtrue; break;
        case TOKEN_FLOAT:  fvalue = (float)atof(value); break;
        case TOKEN_STRING: svalue = value; break;
        default:
            assert("unknown PBR MAT attribute token type");
    }
 
    // set material
 
    switch (t->index)
    {
        case 0: mat->bump_scale = fvalue; break;
        case 1: mat->rough_override = fvalue; break;
        case 2: mat->specular_scale = fvalue; break;
        case 3: mat->emissive_scale = fvalue; break;
        case 4: {
            uint32_t kind = getMaterialKind(svalue);
            if (kind != 0)
                mat->flags = MAT_SetKind(mat->flags, kind);
            else 
            {
                Com_EPrintf("Unknown material kind '%s'\n", svalue);
                return Q_ERR_FAILURE;
            }
        } break;
        case 5: mat->flags = bvalue == qtrue ? mat->flags | MATERIAL_FLAG_LIGHT : mat->flags & ~(MATERIAL_FLAG_LIGHT); break;
        case 6: mat->flags = bvalue == qtrue ? mat->flags | MATERIAL_FLAG_CORRECT_ALBEDO : mat->flags & ~(MATERIAL_FLAG_CORRECT_ALBEDO); break;
    }
 
    return Q_ERR_SUCCESS;
 
usage:
    Com_Printf("Usage : set_material <token> <value>\n");
    for (int i = 0; i < ntokens; ++i)
    {
        struct Token const * t = &tokens[i];
 
        char const * typename = "(undefined)";
        switch (t->type)
        {
        case TOKEN_BOOL: typename = "bool [0,1]"; break;
        case TOKEN_FLOAT: typename = "float"; break;
        case TOKEN_STRING: typename = "string"; break;
        }
        Com_Printf("  %s (%s)\n", t->name, typename);
    }
    return Q_ERR_FAILURE;
}

Referenced by vkpt_set_material().

MAT_UpdatePBRMaterialSkin()

const pbr_material_t* MAT_UpdatePBRMaterialSkin

(

image_t *

image_diffuse

)

Definition at line 517 of file material.c.

{
    pbr_material_t const * material = MAT_FindPBRMaterial(image_diffuse->name);
    assert(material);
 
    if (material->image_diffuse == image_diffuse)
        return material;
 
    {
        pbr_material_t * mat = (pbr_material_t *)material;
        //MAT_Reset(mat, MAT_GetPBRMaterialIndex(mat));
 
        mat->image_diffuse = image_diffuse;
 
        // update registration sequence of material and its textures
        int registration_sequence = image_diffuse->registration_sequence;
 
        if (mat->image_normals)
            mat->image_normals->registration_sequence = registration_sequence;
 
        if (mat->image_emissive)
            mat->image_emissive->registration_sequence = registration_sequence;
 
        mat->registration_sequence = registration_sequence;
    }
    return material;
}

Referenced by get_mesh_material().

MAT_UpdateRegistration()

void MAT_UpdateRegistration

(

pbr_material_t *

mat

)

Definition at line 421 of file material.c.

{
    if (!mat)
        return;
 
    mat->registration_sequence = registration_sequence;
    if (mat->image_diffuse) mat->image_diffuse->registration_sequence = registration_sequence;
    if (mat->image_normals) mat->image_normals->registration_sequence = registration_sequence;
    if (mat->image_emissive) mat->image_emissive->registration_sequence = registration_sequence;
}

Referenced by MOD_Reference_RTX().

parse_CSV_line()

static qerror_t parse_CSV_line ( char *  linebuf, CSV_values_t *  csv  )

static

Definition at line 76 of file material.c.

{
    static char delim = ',';
 
    char * cptr = linebuf, c;
    int inquote = 0;
 
    int index = 0;
    csv->values[index] = cptr;
    
    while ((c = *cptr) != '\0' && index < MAX_CSV_VALUES)
    {
        if (c == '"')
        {
            if (!inquote)
                csv->values[index] = cptr + 1;
            else
                *cptr = '\0';
            inquote = !inquote;
        }
        else if (c == delim && !inquote)
        {
            *cptr = '\0';
            csv->values[++index] = cptr + 1;
        }
        cptr++;
    }
    csv->num_values = index + 1;
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

parseMaterialsTable()

static qerror_t parseMaterialsTable ( char const *  filename, pbr_materials_table_t *  table  )

static

Definition at line 261 of file material.c.

{
    assert(table);
 
    table->num_materials = 0;
 
    byte * buffer = NULL; ssize_t buffer_size = 0;
    buffer_size = FS_LoadFile(filename, (void**)&buffer);
    if (buffer == NULL)
    {
        Com_EPrintf("cannot load materials table '%s'\n", filename);
        return Q_ERR_FAILURE;
    }
 
    Q_concat(table->filename, sizeof(table->filename), filename, NULL);
 
    int currentLine = 0;
    char const * ptr = (char const *)buffer;
    char linebuf[MAX_QPATH * 3];
    while (sgets(linebuf, sizeof(linebuf), &ptr))
    {
        // skip first line because it contains the column names
        if (currentLine == 0 && strncmp(linebuf, "Material", 8) == 0)
            continue;
 
        pbr_material_t * mat = &table->materials[table->num_materials];
 
        MAT_Reset(mat, table->num_materials);
 
        qerror_t status = Q_ERR_SUCCESS;
        CSV_values_t csv = { 0 };
 
        if (parse_CSV_line(linebuf, &csv)==Q_ERR_SUCCESS)
        {
            if (getStringValue(&csv, 0, mat->name) == Q_ERR_SUCCESS && mat->name[0] != '\0')
            {
                status |= getFloatValue(&csv, 1, &mat->bump_scale);
                status |= getFloatValue(&csv, 2, &mat->rough_override);
                status |= getFloatValue(&csv, 3, &mat->specular_scale);
                status |= getFloatValue(&csv, 4, &mat->emissive_scale);
 
                char kindname[MAX_QPATH];
                getStringValue(&csv, 5, kindname);
                mat->flags |= getMaterialKind(kindname);
                
                int light_flag = 0;
                status |= getIntValue(&csv, 6, &light_flag);
                if (light_flag != 0) mat->flags |= MATERIAL_FLAG_LIGHT;
                mat->enable_light_styles = (light_flag <= 1);
 
                status |= getFlagValue(&csv, 7, &mat->flags, MATERIAL_FLAG_CORRECT_ALBEDO);
            }
            else
                status = Q_ERR_FAILURE;
        }
        if (status == Q_ERR_SUCCESS)
        {
            ++table->num_materials;
        }
        else
        {
            mat->flags = MAT_SetKind(mat->flags, MATERIAL_KIND_INVALID);
            Com_EPrintf("CSV error in materials table : '%s':%d", table->filename, currentLine);
        }
        ++currentLine;
    }
 
    qerror_t status = validateMaterialsTable(table);
 
    Com_Printf("Loaded '%s' (fast search = %s)\n", filename, table->alpha_sorted == qtrue ? "true" : "false");
 
    FS_FreeFile(buffer);
 
    return status;
}

Referenced by MAT_InitializePBRmaterials(), and MAT_ReloadPBRMaterials().

truncateExtension()

static size_t truncateExtension ( char const *  src, char *  dest  )

static

Definition at line 111 of file material.c.

{
    // remove extension if any
    size_t len = strlen(src);
    assert(len < MAX_QPATH);
 
    if (len > 4 && src[len - 4] == '.')
        len -= 4;
 
    // make a copy of the name without the extension: we need to compare full names, and "skin_rgh" == "skin" is unacceptable
    memcpy(dest, src, len);
    dest[len] = 0;
    return len;
}

Referenced by MAT_FindPBRMaterial().

validateMaterialsTable()

static qerror_t validateMaterialsTable ( pbr_materials_table_t *  table )

static

Definition at line 166 of file material.c.

{   
    table->alpha_sorted = qtrue;
    for (int i = 1; i < table->num_materials; ++i)
    {
        pbr_material_t const * a = &table->materials[i - 1];
        pbr_material_t const * b = &table->materials[i];
        int cmp = Q_strcasecmp(a->name, b->name);
        if (cmp == 0)
        {
            Com_EPrintf("duplicate material names in materials table '%s'\n", table->filename);
            return Q_ERR_FAILURE;
        }
        else if (cmp > 0)
        {
            Com_WPrintf("materials table '%s' is not sorted - fast search disabled\n", table->filename);
            table->alpha_sorted = qfalse;
        }
    }
    return Q_ERR_SUCCESS;
}

Referenced by parseMaterialsTable().

writeMaterialsTable()

static qerror_t writeMaterialsTable ( char const *  filename, pbr_materials_table_t const *  table  )

static

Definition at line 229 of file material.c.

{
    char path[MAX_OSPATH];
    qhandle_t f = FS_EasyOpenFile(path, sizeof(path), FS_MODE_WRITE | FS_FLAG_TEXT, "", filename, "");
    if (!f) {
        Com_EPrintf("Error opening '%s'\n", path);
        return Q_ERR_FAILURE;
    }
 
    FS_FPrintf(f, "Material,Bump Scale,Roughness Override,Specular Scale,Emissive Scale,Kind,Invisible Flag,Light Flag,Correct Albedo Flag\n");
 
    for (int i = 0; i < table->num_materials; ++i)
    {
        pbr_material_t const * mat = &table->materials[i];
 
        FS_FPrintf(f, "%s,",  mat->name);
 
        FS_FPrintf(f, "%g,%g,%g,%g,", mat->bump_scale, mat->rough_override, mat->specular_scale, mat->emissive_scale);
 
        char const * kind = getMaterialKindName(mat->flags);
        FS_FPrintf(f, "%s,", kind ? kind : "");
 
        FS_FPrintf(f, "%d,", mat->flags & MATERIAL_FLAG_LIGHT ? (mat->enable_light_styles ? 1 : 2) : 0);
        FS_FPrintf(f, "%d\n", mat->flags & MATERIAL_FLAG_CORRECT_ALBEDO ? 1 : 0);
    }
    
    FS_FCloseFile(f);
 
    Com_Printf("Saved '%s'\n", path);
    return Q_ERR_SUCCESS;
}

Referenced by MAT_SavePBRMaterials().

Variable Documentation

materialKinds

struct MaterialKind materialKinds[]

static

Initial value:

= {
    {"CHROME", MATERIAL_KIND_CHROME},
    {"GLASS", MATERIAL_KIND_GLASS},
    {"WATER", MATERIAL_KIND_WATER},
    {"LAVA", MATERIAL_KIND_LAVA},
    {"SKY", MATERIAL_KIND_SKY},
    {"SLIME", MATERIAL_KIND_SLIME},
    {"INVISIBLE", MATERIAL_KIND_INVISIBLE},
    {"SCREEN", MATERIAL_KIND_SCREEN},
    {"CAMERA", MATERIAL_KIND_CAMERA},
}

Referenced by getMaterialKind(), and getMaterialKindName().

materials_filename

const char* materials_filename = "materials.csv"

static

Definition at line 338 of file material.c.

Referenced by MAT_InitializePBRmaterials(), MAT_ReloadPBRMaterials(), and MAT_SavePBRMaterials().

nMaterialKinds

int nMaterialKinds = sizeof(materialKinds) / sizeof(struct MaterialKind)

static

Definition at line 207 of file material.c.

Referenced by getMaterialKind(), and getMaterialKindName().

pbr_materials_table

pbr_materials_table_t pbr_materials_table = { .num_materials = 0, .num_custom_materials = 0, .alpha_sorted = qtrue }

static

Definition at line 137 of file material.c.

Referenced by MAT_FindPBRMaterial(), MAT_GetNumPBRMaterials(), MAT_GetPBRMaterial(), MAT_GetPBRMaterialsTable(), MAT_InitializePBRmaterials(), MAT_ReloadPBRMaterials(), MAT_ResetUnused(), and MAT_SavePBRMaterials().

registration_sequence

int registration_sequence

Definition at line 34 of file main.c.

Referenced by enqueue_stretch_pic(), find_or_load_image(), GL_LoadWorld(), GL_PostInit(), IMG_FreeUnused(), MAT_RegisterPBRMaterial(), MAT_ResetUnused(), MAT_UpdatePBRMaterialSkin(), MAT_UpdateRegistration(), MOD_FreeUnused(), MOD_Reference(), MOD_Reference_GL(), MOD_Reference_RTX(), R_BeginRegistration(), R_BeginRegistration_GL(), R_BeginRegistration_RTX(), R_Init_RTX(), R_InitImages(), R_RegisterModel(), and R_RegisterRawImage().