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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
#include <string.h>
#include <daw/types.h>
#include <daw/daw.h>
#include <daw/logging.h>
#include <daw/resources.h>
#include <daw/rendering.h>
extern Instance* GLOBAL_PLATFORM;
extern const char* ShaderType_str[];
void* get_asset(Resources* r, u32 idx) {
switch (r->assets[idx].type) {
case Asset_shader:
// The shaders used to compile shader programs are not preserved.
WARN("We don't store pure shaders");
break;
case Asset_shaderprog:
LOG("Idx: r->get[%d] = %d", idx, r->get[idx]);
//LOG("Ptr: &r->shader[r->get[idx]] = %z", &r->shader[r->get[idx]]);
return &r->shader[r->get[idx]];
case Asset_texture:
return &r->texture[r->get[idx]];
case Asset_error:
case Asset_audio:
case Asset_font:
default:
ERROR("Asset type Not implemented");
break;
}
return NULL;
}
i32 resources_load(Resources *resources) {
resources->get = calloc(resources->assets_len, sizeof(usize));
usize audio_len = 0;
usize font_len = 0;
usize shader_len = 0;
usize shaderprog_len = 0;
usize texture_len = 0;
usize i = 0;
// Count each type of resource so we can allocate appropriate sizes.
for (i = 0; i < resources->assets_len; i++) {
usize idx = 0;
switch (resources->assets[i].type) {
case Asset_audio: idx = audio_len++; WARN("Audio resource type not implemented!"); break;
case Asset_font: idx = font_len++; WARN("Font resource type not implemented!"); break;
case Asset_shader: idx = shader_len++; break;
case Asset_shaderprog: idx = shaderprog_len++; break;
case Asset_texture: idx = texture_len++; break;
case Asset_error: break;
default:
ERROR("Unknown resource type!");
exit(EXIT_FAILURE);
break;
}
// Update index translation table.
resources->get[i] = idx;
}
//resources->audio = calloc(audio_len, sizeof());
//resources->font = calloc(font_len, sizeof());
resources->shader = calloc(shaderprog_len, sizeof(Shader));
resources->texture = calloc(texture_len, sizeof(Texture));
Shader* imm_shader = calloc(shader_len, sizeof(Shader));
audio_len = 0;
font_len = 0;
shader_len = 0;
shaderprog_len = 0;
texture_len = 0;
for (i = 0; i < resources->assets_len; i++) {
switch (resources->assets[i].type) {
case Asset_audio:
//resources->audio_len++;
WARN("Audio resource type not implemented!");
break;
case Asset_font:
//resources->font_len++;
WARN("Font resource type not implemented!");
break;
case Asset_shader: {
ShaderType t =
guess_shadertype_from_filename(resources->assets[i].shader.path);
const Shader s = compile_shader(resources->assets[i].shader.path, t);
LOG("Compiled %s! (%s)", resources->assets[i].shader.path, ShaderType_str[t]);
imm_shader[shader_len] = s;
shader_len++;
} break;
case Asset_shaderprog: {
const usize sz = resources->assets[i].shaderprog.shader_len;
const u32* shader_ids = resources->assets[i].shaderprog.shader;
Shader* shaders = calloc(sz, sizeof(Shader));
for (usize j = 0; j < sz; j++) {
//DEBUG("shader[%d] = %d\n", j, imm_shader[resources->assets[i].shaderprog.shader[j]].program);
//shaders[j] = imm_shader[resources->assets[i].shaderprog.shader[j]];
u32 shader_idx = shader_ids[j];
//DEBUG("Idx: get[%d] = %d\n", shader_idx, imm_shader[resources->get[shader_idx]].program);
shaders[j] = imm_shader[resources->get[shader_idx]];
}
const Shader s = compose_shader(shaders, sz);
resources->shader[resources->shader_len] = s;
resources->shader_len++;
} break;
case Asset_texture:
resources->texture[resources->texture_len] = load_texture(&resources->assets[i].texture);
resources->texture_len++;
LOG("Loaded texture \"%s\"!", resources->assets[i].texture.path);
break;
case Asset_error:
break;
default:
ERROR("Unknown resource type!");
exit(EXIT_FAILURE);
break;
}
//resources->get[i] = idx;
}
LOG("Total assets: %lu", resources->assets_len);
LOG(" Shaders: %lu", resources->shader_len);
LOG(" Textures: %lu", resources->texture_len);
// Delete the immediate shaders
for (i = 0; i < shader_len; i++) {
// glDeleteShader()
}
shaders_delete(imm_shader, shader_len);
free(imm_shader);
return 0;
}
isize resource_make_global(isize resource_id) {
ERROR("`resource_make_global` Not implemented");
return -1;
}
|
