Raytracer/MaterialManager.cpp at main · AnanasikDev/Raytracer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
// This is a personal academic project. Dear PVS-Studio, please check it.

// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: https://pvs-studio.com

#include "template.h"
#include "MaterialManager.h"
#include "ogt_vox.h"
#include "Noise.h"

Material& MaterialManager::GetMaterialRW(size_t id)
{
    return m_materials[id];
}

const Material& MaterialManager::GetMaterialR(size_t id) const
{
    return m_materials[id];
}

const Material& MaterialManager::GetMaterialR(std::string name, size_t variant) const
{
    if (!m_dict.contains(name))
    {
        assert(false);
        printf("GetMaterialR failed: m_dict doesn't contain material with name: %s\n", name.c_str());
        return m_materials[0];
    }

    const std::vector<size_t>& variants = m_dict.at(name);
    if (variants.size() == 0)
    {
        assert(false);
        printf("GetMaterialR failed: no variants of material with name: %s\n", name.c_str());
        return m_materials[0];
    }
    if (variants.size() <= variant)
    {
        assert(false);
        printf("GetMaterialR failed: variant number %d of material of name: %s doesn't exist (there are only %d variants of that material)\n", (int)variant, name.c_str(), (int)variants.size());
        variant = std::clamp(variant, 0ull, variants.size() - 1);
    }
    return GetMaterialR(variants[variant]);
}

const Material& MaterialManager::GetRandomMaterialVariantR(std::string name) const
{
    if (!m_dict.contains(name))
    {
        assert(false);
        printf("GetMaterialR failed: m_dict doesn't contain material with name: %s\n", name.c_str());
        return m_materials[0];
    }

    const std::vector<size_t>& variants = m_dict.at(name);
    const size_t size = variants.size();
    if (size == 0)
    {
        assert(false);
        printf("GetMaterialR failed: no variants of material with name: %s\n", name.c_str());
        return m_materials[0];
    }
    size_t variant = Noise::SimpleWhite::GetNext<size_t>(Noise::Config().MinMax(0.f, static_cast<float>(size) - 0.1f));
    if (variant >= size)
    {
        assert(false);
        printf("GetMaterialR failed: material with name: %s has only %d variants (%d requested)\n", name.c_str(), static_cast<int>(size), static_cast<int>(variant));
        variant = size - 1;
    }
    return GetMaterialR(variants[variant]);
}

Material& MaterialManager::New()
{
    return New("Unnamed");
}

Material& MaterialManager::New(std::string name)
{
    m_materials.emplace_back();
    const size_t index = GetCount() - 1ull;
    Material& result = m_materials[index];
    result.m_identifier.m_name = name;
    std::vector<size_t>& variants = m_dict[name];
    const size_t variant = variants.size();
    result.m_identifier.m_variantID = static_cast<unsigned char>(variant);
    result.m_index = static_cast<Material::ID_T>(index);
    variants.push_back(index);
    return result;
}

Material& MaterialManager::Import(const ogt_vox_matl& data, float4 color)
{
    Material& m = New();
    m.Color(color);
    switch (data.type)
    {
    case ogt_matl_type_diffuse:
    {
    } break;
    case ogt_matl_type_metal:
    {
        if (data.content_flags & k_ogt_vox_matl_have_metal) m.Reflectivity(data.metal);
        if (data.content_flags & k_ogt_vox_matl_have_rough) m.Roughness(data.rough);
    } break;
    case ogt_matl_type_glass:
    {
        if (data.content_flags & k_ogt_vox_matl_have_metal) m.Reflectivity(data.metal);
        if (data.content_flags & k_ogt_vox_matl_have_rough) m.Roughness(data.rough);
        if (data.content_flags & k_ogt_vox_matl_have_ior) m.IOR(1.f + data.ior);
        if (data.content_flags & k_ogt_vox_matl_have_trans) m.Transparency(data.trans);
        if (data.content_flags & k_ogt_vox_matl_have_d) m.Density(data.d * 10);
    } break;
    case ogt_matl_type_blend:
    {
        if (data.content_flags & k_ogt_vox_matl_have_metal) m.Reflectivity(data.metal);
        if (data.content_flags & k_ogt_vox_matl_have_rough) m.Roughness(data.rough);
        if (data.content_flags & k_ogt_vox_matl_have_ior) m.IOR(1.f + data.ior);
        if (data.content_flags & k_ogt_vox_matl_have_trans) m.Transparency(data.trans);
        if (data.content_flags & k_ogt_vox_matl_have_d) m.Density(data.d * 10);
    } break;
    }
    return m;
}

size_t MaterialManager::GetCount() const
{
    return m_materials.size();
}

std::vector<Material>& MaterialManager::GetAllRW()
{
    return m_materials;
}