claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clang format

Browse source
This commit is contained in:
Sascha Willems 2020-06-06 11:05:56 +02:00
parent a1afaf3de5
commit 9e96aeaa5f
2 changed files with 521 additions and 421 deletions
Download patch file Download diff file Expand all files Collapse all files

753
examples/gltfskinning/gltfskinning.cpp
View file

File diff suppressed because it is too large Load diff

189
examples/gltfskinning/gltfskinning.h
View file

@ -15,10 +15,10 @@
* If you are looking for a complete glTF implementation, check out https://github.com/SaschaWillems/Vulkan-glTF-PBR/
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <vector>
#define GLM_FORCE_RADIANS
@ -31,89 +31,93 @@
#define STB_IMAGE_IMPLEMENTATION
#define TINYGLTF_NO_STB_IMAGE_WRITE
#ifdef VK_USE_PLATFORM_ANDROID_KHR
#define TINYGLTF_ANDROID_LOAD_FROM_ASSETS
# define TINYGLTF_ANDROID_LOAD_FROM_ASSETS
#endif
#include "tiny_gltf.h"
#include <vulkan/vulkan.h>
#include "vulkanexamplebase.h"
#include "VulkanTexture.hpp"
#include "vulkanexamplebase.h"
#include <vulkan/vulkan.h>
#define ENABLE_VALIDATION false
// Contains everything required to render a glTF model in Vulkan
// This class is heavily simplified (compared to glTF's feature set) but retains the basic glTF structure
class VulkanglTFModel
class VulkanglTFModel
{
public:
vks::VulkanDevice* vulkanDevice;
VkQueue copyQueue;
public:
vks::VulkanDevice *vulkanDevice;
VkQueue copyQueue;
/*
Base glTF structures, see gltfscene sample for details
*/
struct Vertices {
VkBuffer buffer;
struct Vertices
{
VkBuffer buffer;
VkDeviceMemory memory;
} vertices;
struct Indices {
int count;
VkBuffer buffer;
struct Indices
{
int count;
VkBuffer buffer;
VkDeviceMemory memory;
} indices;
struct Node;
struct Material {
struct Material
{
glm::vec4 baseColorFactor = glm::vec4(1.0f);
uint32_t baseColorTextureIndex;
uint32_t baseColorTextureIndex;
};
struct Image {
vks::Texture2D texture;
struct Image
{
vks::Texture2D texture;
VkDescriptorSet descriptorSet;
};
struct Texture {
struct Texture
{
int32_t imageIndex;
};
struct Primitive {
struct Primitive
{
uint32_t firstIndex;
uint32_t indexCount;
int32_t materialIndex;
int32_t materialIndex;
};
struct Mesh {
struct Mesh
{
std::vector<Primitive> primitives;
};
struct Node {
Node* parent;
uint32_t index;
std::vector<Node*> children;
Mesh mesh;
// Matrix components are stored separately as they are affected by animations
glm::vec3 translation{};
glm::vec3 scale{ 1.0f };
glm::quat rotation{};
// Index of the skin for this node
int32_t skin = -1;
glm::mat4 matrix;
// Gets the current local matrix based on translation, rotation and scale, which can all be affected by animations
glm::mat4 getLocalMatrix();
struct Node
{
Node * parent;
uint32_t index;
std::vector<Node *> children;
Mesh mesh;
glm::vec3 translation{};
glm::vec3 scale{1.0f};
glm::quat rotation{};
int32_t skin = -1;
glm::mat4 matrix;
glm::mat4 getLocalMatrix();
};
struct Vertex {
struct Vertex
{
glm::vec3 pos;
glm::vec3 normal;
glm::vec2 uv;
glm::vec3 color;
// Contains indices of the joints that effect this vertex
glm::vec4 jointIndices;
// Contains the weights that define how strongly this vertex is affected by above joints
glm::vec4 jointWeights;
};
@ -121,74 +125,79 @@ public:
Skin structure
*/
struct Skin {
std::string name;
Node* skeletonRoot = nullptr;
struct Skin
{
std::string name;
Node * skeletonRoot = nullptr;
std::vector<glm::mat4> inverseBindMatrices;
std::vector<Node*> joints;
// The joint matrices for this skin are stored in an shader storage buffer
vks::Buffer ssbo;
VkDescriptorSet descriptorSet;
std::vector<Node *> joints;
vks::Buffer ssbo;
VkDescriptorSet descriptorSet;
};
/*
Animation related structures
*/
struct AnimationSampler {
std::string interpolation;
std::vector<float> inputs;
struct AnimationSampler
{
std::string interpolation;
std::vector<float> inputs;
std::vector<glm::vec4> outputsVec4;
};
struct AnimationChannel {
struct AnimationChannel
{
std::string path;
Node* node;
uint32_t samplerIndex;
Node * node;
uint32_t samplerIndex;
};
struct Animation {
std::string name;
struct Animation
{
std::string name;
std::vector<AnimationSampler> samplers;
std::vector<AnimationChannel> channels;
float start = std::numeric_limits<float>::max();
float end = std::numeric_limits<float>::min();
float currentTime = 0.0f;
float start = std::numeric_limits<float>::max();
float end = std::numeric_limits<float>::min();
float currentTime = 0.0f;
};
std::vector<Image> images;
std::vector<Texture> textures;
std::vector<Material> materials;
std::vector<Node*> nodes;
std::vector<Skin> skins;
std::vector<Image> images;
std::vector<Texture> textures;
std::vector<Material> materials;
std::vector<Node *> nodes;
std::vector<Skin> skins;
std::vector<Animation> animations;
uint32_t activeAnimation = 0;
~VulkanglTFModel();
void loadImages(tinygltf::Model& input);
void loadTextures(tinygltf::Model& input);
void loadMaterials(tinygltf::Model& input);
Node* findNode(Node* parent, uint32_t index);
Node* nodeFromIndex(uint32_t index);
void loadSkins(tinygltf::Model& input);
void loadAnimations(tinygltf::Model& input);
void loadNode(const tinygltf::Node& inputNode, const tinygltf::Model& input, VulkanglTFModel::Node* parent, uint32_t nodeIndex, std::vector<uint32_t>& indexBuffer, std::vector<VulkanglTFModel::Vertex>& vertexBuffer);
glm::mat4 getNodeMatrix(VulkanglTFModel::Node* node);
void updateJoints(VulkanglTFModel::Node* node);
void updateAnimation(float deltaTime);
void drawNode(VkCommandBuffer commandBuffer, VkPipelineLayout pipelineLayout, VulkanglTFModel::Node node);
void draw(VkCommandBuffer commandBuffer, VkPipelineLayout pipelineLayout);
void loadImages(tinygltf::Model &input);
void loadTextures(tinygltf::Model &input);
void loadMaterials(tinygltf::Model &input);
Node * findNode(Node *parent, uint32_t index);
Node * nodeFromIndex(uint32_t index);
void loadSkins(tinygltf::Model &input);
void loadAnimations(tinygltf::Model &input);
void loadNode(const tinygltf::Node &inputNode, const tinygltf::Model &input, VulkanglTFModel::Node *parent, uint32_t nodeIndex, std::vector<uint32_t> &indexBuffer, std::vector<VulkanglTFModel::Vertex> &vertexBuffer);
glm::mat4 getNodeMatrix(VulkanglTFModel::Node *node);
void updateJoints(VulkanglTFModel::Node *node);
void updateAnimation(float deltaTime);
void drawNode(VkCommandBuffer commandBuffer, VkPipelineLayout pipelineLayout, VulkanglTFModel::Node node);
void draw(VkCommandBuffer commandBuffer, VkPipelineLayout pipelineLayout);
};
class VulkanExample : public VulkanExampleBase
{
public:
public:
bool wireframe = false;
struct ShaderData {
struct ShaderData
{
vks::Buffer buffer;
struct Values {
struct Values
{
glm::mat4 projection;
glm::mat4 model;
glm::vec4 lightPos = glm::vec4(5.0f, 5.0f, 5.0f, 1.0f);
@ -196,12 +205,14 @@ public:
} shaderData;
VkPipelineLayout pipelineLayout;
struct Pipelines {
struct Pipelines
{
VkPipeline solid;
VkPipeline wireframe = VK_NULL_HANDLE;
} pipelines;
struct DescriptorSetLayouts {
struct DescriptorSetLayouts
{
VkDescriptorSetLayout matrices;
VkDescriptorSetLayout textures;
VkDescriptorSetLayout jointMatrices;
@ -212,15 +223,15 @@ public:
VulkanExample();
~VulkanExample();
void loadglTFFile(std::string filename);
void loadglTFFile(std::string filename);
virtual void getEnabledFeatures();
void buildCommandBuffers();
void loadAssets();
void setupDescriptors();
void preparePipelines();
void prepareUniformBuffers();
void updateUniformBuffers();
void prepare();
void buildCommandBuffers();
void loadAssets();
void setupDescriptors();
void preparePipelines();
void prepareUniformBuffers();
void updateUniformBuffers();
void prepare();
virtual void render();
virtual void OnUpdateUIOverlay(vks::UIOverlay* overlay);
virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay);
};