sculpto
Classes | Functions
scl::assets_manager Namespace Reference

Classes

class  mesh_loader_phong
 
class  shader_preprocessor
 

Functions

std::string LoadFile (const std::filesystem::path &FilePath)
 
void SaveFile (const std::string &Data, const std::filesystem::path &FilePath)
 
shared< mesh > LoadMeshes (const std::filesystem::path &ModelFilePath)
 
shared< shader_program > LoadShader (const std::filesystem::path &ShaderProgamFilePath)
 
shared< shader_program > LoadShader (const std::filesystem::path &VertexShaderFilePath, const std::filesystem::path &PixelShaderFilePath)
 
shared< shader_program > LoadShader (const std::filesystem::path &VertexShaderFilePath, const std::filesystem::path &GeomShaderFilePath, const std::filesystem::path &PixelShaderFilePath)
 
void UpdateShader (shared< shader_program > ShaderProgram)
 
shared< texture_2d > LoadTexture (const std::filesystem::path &TextureImageFilePath)
 

Function Documentation

◆ LoadFile()

std::string scl::assets_manager::LoadFile ( const std::filesystem::path &  FilePath)
  • File text load function.
Parameters
FilePath- file to path to load.
Returns
file text string.

Definition at line 12 of file files_load.cpp.

13{
14 std::stringstream file_buffer;
15 std::ifstream file(FilePath);
16 SCL_CORE_ASSERT(file.is_open(), "File \"{}\" not found.", FilePath.string());
17
18 file_buffer << file.rdbuf();
19 return file_buffer.str();
20}
SCL_CORE_ASSERT
#define SCL_CORE_ASSERT(expr,...)
Definition: assert.h:69

◆ LoadMeshes()

scl::shared< scl::mesh > scl::assets_manager::LoadMeshes ( const std::filesystem::path &  ModelFilePath)
  • Load model (all meshes with materials) from file function.
Parameters
ModelFilePath- model file path.
Returns
loaded mesh pointer.

Definition at line 99 of file meshes_load.cpp.

100{
101 SCL_CORE_INFO("Mesh creation from file \"{}\" started (this may take time).", ModelFilePath.string());
102
103 u32 flags = aiProcess_Triangulate
104 | aiProcess_OptimizeMeshes
105 | aiProcess_GenNormals
106 | aiProcess_CalcTangentSpace;
107 Assimp::Importer importer {};
108 const aiScene *scene = importer.ReadFile(ModelFilePath.string(), flags);
109 SCL_CORE_ASSERT(scene && (!scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) && scene->mRootNode,
110 "Error while loading model: {}", importer.GetErrorString());
111
112 std::vector<submesh_props<vertex>> out_submeshes;
113 mesh_loader_phong mesh_loader(scene, ModelFilePath.parent_path().string(), out_submeshes);
114 mesh_loader.ProcessNode(scene->mRootNode);
115
116 auto loaded_mesh = mesh::Create(out_submeshes);
117 loaded_mesh->FileName = ModelFilePath.string();
118 return loaded_mesh;
119}
SCL_CORE_INFO
#define SCL_CORE_INFO(...)
Definition: log.h:41
scl::u32
uint32_t u32
Definition: math_common.h:21

◆ LoadShader() [1/3]

scl::shared< scl::shader_program > scl::assets_manager::LoadShader ( const std::filesystem::path &  ShaderProgamFilePath)
  • Load shader from file function.
Parameters
ShaderProgamFilePath- file containing all shaders to compile in program.
Returns
pointer to shader, loaded from file.

Definition at line 15 of file shaders_load.cpp.

16{
17 SCL_CORE_INFO("Shader creation from file \"{}\" started.", ShaderProgamFilePath.string());
18
19 std::string shader_text = LoadFile(ShaderProgamFilePath);
20 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgamFilePath.string(), ShaderProgamFilePath.parent_path().string(), shader_text);
21
22 std::vector<shader_props> Out;
23 assets_manager::shader_preprocessor::SeparateShaders(ShaderProgamFilePath.string(), shader_text, Out);
24
25 auto shader = shader_program::Create(Out, ShaderProgamFilePath.string());
26 shader->SingleSourceFileName = ShaderProgamFilePath.string();
27 return shader;
28}
scl::assets_manager::LoadFile
std::string LoadFile(const std::filesystem::path &FilePath)
Definition: files_load.cpp:12

◆ LoadShader() [2/3]

scl::shared< scl::shader_program > scl::assets_manager::LoadShader ( const std::filesystem::path &  VertexShaderFilePath,
const std::filesystem::path &  GeomShaderFilePath,
const std::filesystem::path &  PixelShaderFilePath 
)
  • Load shader from file function.
Parameters
VertexShaderFilePath- file containing vertex shader.
GeomShaderFilePath- file containing pixel(fragment) shader.
PixelShaderFilePath- file containing pixel(fragment) shader.
Returns
pointer to shader, loaded from files.

Definition at line 55 of file shaders_load.cpp.

58{
59 std::stringstream file_buffer;
60 std::string shader_text;
61 std::vector<shader_props> shaders;
62
63 SCL_CORE_INFO("Shader creation from files \"{}\", \"{}\", \"{}\" started.", VertexShaderFilePath.string(), GeomShaderFilePath.string(), PixelShaderFilePath.string());
64
65 // Vertex shader
66 shader_text = LoadFile(VertexShaderFilePath);
67 assets_manager::shader_preprocessor::ProcessIncludes(VertexShaderFilePath.string(), VertexShaderFilePath.parent_path().string(), shader_text);
68 shaders.push_back({ shader_type::VERTEX, shader_text });
69
70 // Geometry shader
71 shader_text = LoadFile(GeomShaderFilePath);
72 assets_manager::shader_preprocessor::ProcessIncludes(GeomShaderFilePath.string(), GeomShaderFilePath.parent_path().string(), shader_text);
73 shaders.push_back({ shader_type::GEOMETRY, shader_text });
74
75 // Fragment shader
76 shader_text = LoadFile(PixelShaderFilePath);
77 assets_manager::shader_preprocessor::ProcessIncludes(PixelShaderFilePath.string(), PixelShaderFilePath.parent_path().string(), shader_text);
78 shaders.push_back({ shader_type::PIXEL, shader_text });
79
80 auto shader = shader_program::Create(shaders, VertexShaderFilePath.string());
81 shader->VertexShadersourceFileName = VertexShaderFilePath.string();
82 shader->GeometryShadersourceFileName = GeomShaderFilePath.string();
83 shader->PixelShadersourceFileName = PixelShaderFilePath.string();
84 return shader;
85}

◆ LoadShader() [3/3]

scl::shared< scl::shader_program > scl::assets_manager::LoadShader ( const std::filesystem::path &  VertexShaderFilePath,
const std::filesystem::path &  PixelShaderFilePath 
)
  • Load shader from file function.
Parameters
VertexShaderFilePath- file containing vertex shader.
PixelShaderFilePath- file containing pixel(fragment) shader.
Returns
pointer to shader, loaded from files.

Definition at line 30 of file shaders_load.cpp.

32{
33 std::stringstream file_buffer;
34 std::string shader_text;
35 std::vector<shader_props> shaders;
36
37 SCL_CORE_INFO("Shader creation from files \"{}\", \"{}\" started.", VertexShaderFilePath.string(), PixelShaderFilePath.string());
38
39 // Vertex shader
40 shader_text = LoadFile(VertexShaderFilePath);
41 assets_manager::shader_preprocessor::ProcessIncludes(VertexShaderFilePath.string(), VertexShaderFilePath.parent_path().string(), shader_text);
42 shaders.push_back({ shader_type::VERTEX, shader_text });
43
44 // Fragment shader
45 shader_text = LoadFile(PixelShaderFilePath);
46 assets_manager::shader_preprocessor::ProcessIncludes(PixelShaderFilePath.string(), PixelShaderFilePath.parent_path().string(), shader_text);
47 shaders.push_back({ shader_type::PIXEL, shader_text });
48
49 auto shader = shader_program::Create(shaders, VertexShaderFilePath.string());
50 shader->VertexShadersourceFileName = VertexShaderFilePath.string();
51 shader->PixelShadersourceFileName = PixelShaderFilePath.string();
52 return shader;
53}

◆ LoadTexture()

scl::shared< scl::texture_2d > scl::assets_manager::LoadTexture ( const std::filesystem::path &  TextureImageFilePath)
  • Texture load from file function.
Parameters
TextureImageFilePath- texture image file path.
Returns
loaded texture pointer.

Definition at line 14 of file textures_load.cpp.

15{
16 SCL_CORE_INFO("Texture creation from file \"{}\" started.", TextureImageFilePath.string());
17
18 image texture_image(TextureImageFilePath.string());
19 if (texture_image.IsEmpty())
20 {
21 SCL_CORE_ERROR("Texture \"{}\" not found!", TextureImageFilePath.string());
22 return nullptr;
23 }
24
25 if (render_context::GetApi() == render_context_api::OpenGL)
26 texture_image.FlipHorizontaly();
27
28 return texture_2d::Create(texture_image, texture_type::COLOR);
29}
SCL_CORE_ERROR
#define SCL_CORE_ERROR(...)
Definition: log.h:44

◆ SaveFile()

void scl::assets_manager::SaveFile ( const std::string &  Data,
const std::filesystem::path &  FilePath 
)
  • File text save function.
Parameters
Data- file text buffer.
FilePath- outpus file path.
Returns
file text string.

Definition at line 12 of file files_save.cpp.

13{
14 std::ofstream file(FilePath);
15 SCL_CORE_ASSERT(file.is_open(), "Error during opening/creating file \"{}\".", FilePath.string());
16
17 file << Data;
18}

◆ UpdateShader()

void scl::assets_manager::UpdateShader ( shared< shader_program >  ShaderProgram)
  • Update existing shader program function.
Parameters
ShaderProgram- shader program to update.
Returns
None.

Definition at line 87 of file shaders_load.cpp.

88{
89 std::stringstream file_buffer;
90 std::string shader_text;
91 std::vector<shader_props> shaders;
92
93 if (ShaderProgram->SingleSourceFileName != "") {
94 SCL_CORE_INFO("Shader updation from file \"{}\" started.", ShaderProgram->SingleSourceFileName);
95 shader_text = LoadFile(ShaderProgram->SingleSourceFileName);
96 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->SingleSourceFileName,
97 std::filesystem::path(ShaderProgram->SingleSourceFileName).parent_path().string(),
98 shader_text);
99
100 assets_manager::shader_preprocessor::SeparateShaders(ShaderProgram->SingleSourceFileName, shader_text, shaders);
101 ShaderProgram->Update(shaders);
102 } else if (ShaderProgram->VertexShadersourceFileName != "" && ShaderProgram->PixelShadersourceFileName != "" &&
103 ShaderProgram->GeometryShadersourceFileName == "") {
104 SCL_CORE_INFO("Shader updation from files \"{}\", \"{}\" started.", ShaderProgram->VertexShadersourceFileName, ShaderProgram->PixelShadersourceFileName);
105
106 // Vertex shader
107 shader_text = LoadFile(ShaderProgram->VertexShadersourceFileName);
108 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->VertexShadersourceFileName,
109 std::filesystem::path(ShaderProgram->VertexShadersourceFileName).parent_path().string(),
110 shader_text);
111 shaders.push_back({ shader_type::VERTEX, shader_text });
112
113 // Fragment shader
114 shader_text = LoadFile(ShaderProgram->PixelShadersourceFileName);
115 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->PixelShadersourceFileName,
116 std::filesystem::path(ShaderProgram->PixelShadersourceFileName).parent_path().string(),
117 shader_text);
118 shaders.push_back({ shader_type::PIXEL, shader_text });
119
120 ShaderProgram->Update(shaders);
121 } else {
122 SCL_CORE_INFO("Shader creation from files \"{}\", \"{}\", \"{}\" started.", ShaderProgram->VertexShadersourceFileName, ShaderProgram->GeometryShadersourceFileName, ShaderProgram->PixelShadersourceFileName);
123
124 // Vertex shader
125 shader_text = LoadFile(ShaderProgram->VertexShadersourceFileName);
126 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->VertexShadersourceFileName,
127 std::filesystem::path(ShaderProgram->VertexShadersourceFileName).parent_path().string(),
128 shader_text);
129 shaders.push_back({ shader_type::VERTEX, shader_text });
130
131 // Geometry shader
132 shader_text = LoadFile(ShaderProgram->GeometryShadersourceFileName);
133 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->GeometryShadersourceFileName,
134 std::filesystem::path(ShaderProgram->GeometryShadersourceFileName).parent_path().string(),
135 shader_text);
136 shaders.push_back({ shader_type::GEOMETRY, shader_text });
137
138 // Fragment shader
139 shader_text = LoadFile(ShaderProgram->PixelShadersourceFileName);
140 assets_manager::shader_preprocessor::ProcessIncludes(ShaderProgram->PixelShadersourceFileName,
141 std::filesystem::path(ShaderProgram->PixelShadersourceFileName).parent_path().string(),
142 shader_text);
143 shaders.push_back({ shader_type::PIXEL, shader_text });
144
145 ShaderProgram->Update(shaders);
146 }
147}
Generated by doxygen 1.9.4