[#79] Asset-Loader refactoring mostly done

Signed-off-by: Tobias Frisch <tfrisch@uni-koblenz.de>

modules/asset_loader/include/vkcv/asset/asset_loader.hpp

@@ -49,14 +49,24 @@ namespace vkcv::asset {
  * (TRIANGLES) if no mode is given in the file.
  */
 enum class PrimitiveMode : uint8_t {
-	POINTS=0, LINES, LINELOOP, LINESTRIP, TRIANGLES, TRIANGLESTRIP,
-	TRIANGLEFAN
+	POINTS = 0,
+	LINES = 1,
+	LINELOOP = 2,
+	LINESTRIP = 3,
+	TRIANGLES = 4,
+	TRIANGLESTRIP = 5,
+	TRIANGLEFAN = 6
 };
 
 /**
  * The indices in the index buffer can be of different bit width.
  */
-enum class IndexType : uint8_t { UNDEFINED=0, UINT8=1, UINT16=2, UINT32=3 };
+enum class IndexType : uint8_t {
+	UNDEFINED=0,
+	UINT8=1,
+	UINT16=2,
+	UINT32=3
+};
 
 /**
  * This struct defines a sampler for a texture object. All values here can
@@ -67,25 +77,29 @@ enum class IndexType : uint8_t { UNDEFINED=0, UINT8=1, UINT16=2, UINT32=3 };
  * Since glTF does not specify border sampling for more than two dimensions,
  * the addressModeW is hardcoded to a default: VK_SAMPLER_ADDRESS_MODE_REPEAT.
  */
-typedef struct {
+struct Sampler {
 	int minFilter, magFilter;
 	int mipmapMode;
 	float minLOD, maxLOD;
 	int addressModeU, addressModeV, addressModeW;
-} Sampler;
+};
 
 /**
  * This struct describes a loaded texture.
  * Note that textures are currently always loaded with 4 channels as RGBA, even
  * if the image has just RGB or is grayscale.
  */
-typedef struct {
-	int uri;		// index into the URIs array of the Scene
-	int sampler;		// index into the sampler array of the Scene
-	uint8_t channels;	// number of channels
-	uint16_t w, h;		// width and height of the texture
-	std::vector<uint8_t> data;	// binary data of the decoded texture
-} Texture;
+struct Texture {
+	std::filesystem::path path; // file path of the encoded texture data
+	int sampler;				// index into the sampler array of the Scene
+	
+	union { int width; int w; };
+	union { int height; int h; };
+	int channels;
+	
+	// binary data of the decoded texture
+	std::vector<char*> data;
+};
 
 /**
  * Flags for the bit-mask in the Material struct. To check if a material has a
@@ -93,7 +107,11 @@ typedef struct {
  * the material struct and the enum.
  */
 enum class PBRTextureTarget {
-	baseColor=1, metalRough=2, normal=4, occlusion=8, emissive=16
+	baseColor=1,
+	metalRough=2,
+	normal=4,
+	occlusion=8,
+	emissive=16
 };
 
 /**
@@ -112,10 +130,12 @@ enum class PBRTextureTarget {
  * The asset loader module only supports the PBR-MetallicRoughness model for
  * materials.
  */
-typedef struct {
+struct Material {
 	uint16_t textureMask;	// bit mask with active texture targets
+	
 	// Indices into the Scene.textures vector
 	int baseColor, metalRough, normal, occlusion, emissive;
+	
 	// Scaling factors for each texture target
 	struct { float r, g, b, a; } baseColorFactor;
 	float metallicFactor, roughnessFactor;
@@ -128,12 +148,13 @@ typedef struct {
 	 * struct, its bit is set in the textureMask. You can use this function
 	 * to check that:
 	 * if (myMaterial.hasTexture(baseColor)) {...}
+	 *
 	 * @param t The target to query for
 	 * @return Boolean to signal whether the texture target is active in
 	 * the material.
 	 */
-	bool hasTexture(const PBRTextureTarget t) const;
-} Material;
+	bool hasTexture(PBRTextureTarget target) const;
+};
 
 /* With these enums, 0 is reserved to signal uninitialized or invalid data. */
 enum class PrimitiveType : uint32_t {
@@ -157,21 +178,28 @@ enum class PrimitiveType : uint32_t {
  * avoid exposing that dependency, thus it is re-defined here.
  */
 enum class ComponentType : uint16_t {
-    NONE = 0, INT8 = 5120, UINT8 = 5121, INT16 = 5122, UINT16 = 5123,
-    UINT32 = 5125, FLOAT32 = 5126
+    NONE = 0,
+    INT8 = 5120,
+    UINT8 = 5121,
+    INT16 = 5122,
+    UINT16 = 5123,
+    UINT32 = 5125,
+    FLOAT32 = 5126
 };
 
 /**
  * This struct describes one vertex attribute of a vertex buffer.
  */
-typedef struct {
+struct VertexAttribute {
     PrimitiveType type;			// POSITION, NORMAL, ...
+    
     uint32_t offset;			// offset in bytes
     uint32_t length;			// length of ... in bytes
     uint32_t stride;			// stride in bytes
+    
     ComponentType componentType;	// eg. 5126 for float
     uint8_t  componentCount;		// eg. 3 for vec3
-} VertexAttribute;
+};
 
 /**
  * This struct represents one (possibly the only) part of a mesh. There is
@@ -180,100 +208,96 @@ typedef struct {
  * by indexBuffer.data being empty. Each vertex buffer can have one or more
  * vertex attributes.
  */
-typedef struct {
+struct VertexGroup {
 	enum PrimitiveMode mode;	// draw as points, lines or triangle?
-	size_t numIndices, numVertices;
+	size_t numIndices;
+	size_t numVertices;
+	
 	struct {
-		int uri;		// index into the URIs array of Scene
 		enum IndexType type;	// data type of the indices
 		std::vector<uint8_t> data; // binary data of the index buffer
 	} indexBuffer;
+	
 	struct {
-		int uri;		// index into the URIs array of Scene
 		std::vector<uint8_t> data; // binary data of the vertex buffer
 		std::vector<VertexAttribute> attributes; // description of one
 	} vertexBuffer;
+	
 	struct { float x, y, z; } min;	// bounding box lower left
 	struct { float x, y, z; } max;	// bounding box upper right
+	
 	int materialIndex;		// index to one of the materials
-} VertexGroup;
+};
 
 /**
  * This struct represents a single mesh as it was loaded from a glTF file. It
  * consists of at least one VertexGroup, which then references other resources
  * such as Materials.
  */
-typedef struct {
+struct Mesh {
 	std::string name;
 	std::array<float, 16> modelMatrix;
 	std::vector<int> vertexGroups;
-} Mesh;
-
-/**
- * The scene struct is simply a collection of objects in the scene as well as
- * the resources used by those objects.
- * Note that parent-child relations are not yet possible.
- */
-typedef struct {
-	std::vector<Mesh> meshes;
-	std::vector<VertexGroup> vertexGroups;
-	std::vector<Material> materials;
-	std::vector<Texture> textures;
-	std::vector<Sampler> samplers;
-	std::vector<std::string> uris;
-} Scene;
-
-/**
- * Load every mesh from the glTF file, as well as materials, textures and other
- * associated objects.
- *
- * @param path	must be the path to a glTF- or glb-file.
- * @param scene is a reference to a Scene struct that will be filled with the
- * 	content of the glTF file being loaded.
- */
-int loadScene(const std::filesystem::path &path, Scene &scene);
+};
 
-/**
- * Parse the given glTF file and create a shallow description of the content.
- * Only the meta-data of the objects in the scene is loaded, not the binary
- * content. The rationale is to provide a means of probing the content of a
- * glTF file without the costly process of loading and decoding large amounts
- * of data. The returned Scene struct can be used to search for specific meshes
- * in the scene, that can then be loaded on their own using the loadMesh()
- * function. Note that the Scene struct received as output argument will be
- * overwritten by this function.
- * After this function completes, the returned Scene struct is completely
- * initialized and all information is final, except for the missing binary
- * data. This means that indices to vectors will remain valid even when the
- * shallow scene struct is filled with data by loadMesh().
- *
- * @param path	must be the path to a glTF- or glb-file.
- * @param scene	is a reference to a Scene struct that will be filled with the
- * 	meta-data of all objects described in the glTF file.
- */
-int probeScene(const std::filesystem::path &path, Scene &scene);
+	/**
+	 * The scene struct is simply a collection of objects in the scene as well as
+	 * the resources used by those objects.
+	 * Note that parent-child relations are not yet possible.
+	 */
+	struct Scene {
+		std::vector<Mesh> meshes;
+		std::vector<VertexGroup> vertexGroups;
+		std::vector<Material> materials;
+		std::vector<Texture> textures;
+		std::vector<Sampler> samplers;
+		std::vector<std::string> uris;
+	};
 
-/**
- * This function loads a single mesh from the given file and adds it to the
- * given scene. The scene must already be initialized (via probeScene()).
- * The mesh_index refers to the Scenes meshes array and identifies the mesh to
- * load. To find the mesh you want, iterate over the probed scene and check the
- * meshes details (eg. name).
- * Besides the mesh, this function will also add any associated data to the
- * Scene struct such as Materials and Textures required by the Mesh.
- *
- * @param path	must be the path to a glTF- or glb-file.
- * @param scene	is the scene struct to which the results will be written.
- */
-int loadMesh(Scene &scene, int mesh_index);
+	/**
+	 * Parse the given glTF file and create a shallow description of the content.
+	 * Only the meta-data of the objects in the scene is loaded, not the binary
+	 * content. The rationale is to provide a means of probing the content of a
+	 * glTF file without the costly process of loading and decoding large amounts
+	 * of data. The returned Scene struct can be used to search for specific meshes
+	 * in the scene, that can then be loaded on their own using the loadMesh()
+	 * function. Note that the Scene struct received as output argument will be
+	 * overwritten by this function.
+	 * After this function completes, the returned Scene struct is completely
+	 * initialized and all information is final, except for the missing binary
+	 * data. This means that indices to vectors will remain valid even when the
+	 * shallow scene struct is filled with data by loadMesh().
+	 *
+	 * @param path	must be the path to a glTF- or glb-file.
+	 * @param scene	is a reference to a Scene struct that will be filled with the
+	 * 	meta-data of all objects described in the glTF file.
+	 */
+	int probeScene(const std::filesystem::path &path, Scene &scene);
 
-struct TextureData {
-    int width;
-    int height;
-    int componentCount;
-    std::vector<char*> data;
-};
+	/**
+	 * This function loads a single mesh from the given file and adds it to the
+	 * given scene. The scene must already be initialized (via probeScene()).
+	 * The mesh_index refers to the Scenes meshes array and identifies the mesh to
+	 * load. To find the mesh you want, iterate over the probed scene and check the
+	 * meshes details (eg. name).
+	 * Besides the mesh, this function will also add any associated data to the
+	 * Scene struct such as Materials and Textures required by the Mesh.
+	 *
+	 * @param path	must be the path to a glTF- or glb-file.
+	 * @param scene	is the scene struct to which the results will be written.
+	 */
+	int loadMesh(Scene &scene, int mesh_index);
+	
+	/**
+	 * Load every mesh from the glTF file, as well as materials, textures and other
+	 * associated objects.
+	 *
+	 * @param path	must be the path to a glTF- or glb-file.
+	 * @param scene is a reference to a Scene struct that will be filled with the
+	 * 	content of the glTF file being loaded.
+	 */
+	int loadScene(const std::filesystem::path &path, Scene &scene);
 
-TextureData loadTexture(const std::filesystem::path& path);
+	Texture loadTexture(const std::filesystem::path& path);
 
 }