material.h File Reference

#include "shared/shared.h"
#include "refresh/refresh.h"

Go to the source code of this file.

Classes
struct	pbr_material_s

Macros
#define	MAX_PBR_MATERIALS   4096

Typedefs
typedef struct image_s	image_t
typedef struct pbr_material_s	pbr_material_t

Functions
int	MAT_GetPBRMaterialIndex (pbr_material_t const *mat)
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)
const pbr_material_t *	MAT_UpdatePBRMaterialSkin (image_t *image_diffuse)
qerror_t	MAT_SetPBRMaterialAttribute (pbr_material_t *mat, char const *token, char const *value)
qerror_t	MAT_InitializePBRmaterials ()
qerror_t	MAT_ResetUnused ()
const pbr_material_t *	MAT_GetPBRMaterialsTable ()
int	MAT_GetNumPBRMaterials ()
pbr_material_t *	MAT_GetPBRMaterial (int index)
pbr_material_t *	MAT_FindPBRMaterial (char const *name)
qerror_t	MAT_ReloadPBRMaterials ()
qerror_t	MAT_SavePBRMaterials ()
void	MAT_PrintMaterialProperties (pbr_material_t const *mat)
uint32_t	MAT_SetKind (uint32_t material, uint32_t kind)
qboolean	MAT_IsKind (uint32_t material, uint32_t kind)

Macro Definition Documentation

MAX_PBR_MATERIALS

#define MAX_PBR_MATERIALS   4096

Definition at line 25 of file material.h.

Typedef Documentation

image_t

typedef struct image_s image_t

Definition at line 27 of file material.h.

pbr_material_t

typedef struct pbr_material_s pbr_material_t

Function Documentation

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_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().