SoftGLRender

Softglrender

Tiny C ++ Renderer / Rasterizer qui implémente les étapes principales du pipeline de rendu GPU, y compris la rasterisation point, la ligne et les polygones, la cartographie de la texture, les tests de profondeur, le mélange de couleurs, etc., et émule les shaders vertex et les shaders de fragments en utilisant C ++, les modèles 3D (GLTF) sont chargés par Animp, et l'utilisation de GLM comme bibliothèque mathématique. Le projet ajoute également une implémentation OpenGL et Vulkan Renderers, vous pouvez basculer entre eux (logiciel / opengl / vulkan) en temps réel pendant l'exécution.

Le but de ce projet est de fournir un point de départ aux développeurs qui souhaitent en savoir plus sur la programmation graphique moderne.

Exemples

Caractéristiques

Rendu logiciel

Pipeline

• Ombrage du sommet
• Afficher l'abattage de Frustum (ligne et triangle)
• Perspective Interpolation correcte
• Amélioration du visage à l'arrière
• Point / ligne / triangle rasterisation
• Ombrage des fragments
• DÉRIVATION DE SHADER dFdx dFdy
• Test de profondeur et mélange alpha
• Test de z précoce et Z inversé Z
• MSAA 4X

Cartographie de texture

• Génération et échantillonnage de MIPMAP
• Exemples de paramètres: Lod , Bias , Offset
• Toutes sortes de mode de filtrage et d'enveloppement de texture
• Carrelage de stockage d'images et swizzling
  • Linéaire: les valeurs de pixels sont stockées ligne par ligne, couramment utilisées comme tampon RGBA d'image
  • Carrelé: stockage à base de blocs, à l'intérieur des pixels de blocs, sont stockés comme Linear
  • Morton: stockage de base de blocs, à l'intérieur des pixels de blocs, sont stockés sous forme de motif Morton (similaire à Zigzag)

Optimisation

• Multi-threading: Rasterization est basé sur un bloc avec un support multi-threading
• SIMD: calcul des coordonnées barycentriques, interpolation variable du shader, etc.

Téléspectateur

• Panneau de configuration basé sur imgui
• Contrôleur de caméra en orbite
• Ombrage de blinn-phong
• PBR & IBL OBDING
• Skybox Cumbemap & Equirectangular
• Cartographie de l'ombre
• FXAA Anti-aliasing
• Capture du cadre de l'application de rendudoc

Abstraction de rendu

Tous les rendus (logiciel / OpenGL / Vulkan) sont mis en œuvre en fonction de cette classe de rendu abstraite:

 class Renderer {
 public:
  // framebuffer
  std::shared_ptr<FrameBuffer> createFrameBuffer ( bool offscreen);

  // texture
  std::shared_ptr<Texture> createTexture ( const TextureDesc &desc);

  // vertex
  std::shared_ptr<VertexArrayObject> createVertexArrayObject ( const VertexArray &vertexArray);

  // shader program
  std::shared_ptr<ShaderProgram> createShaderProgram ();

  // pipeline states
  std::shared_ptr<PipelineStates> createPipelineStates ( const RenderStates &renderStates);

  // uniform
  std::shared_ptr<UniformBlock> createUniformBlock ( const std::string &name, int size);
  std::shared_ptr<UniformSampler> createUniformSampler ( const std::string &name, const TextureDesc &desc);

  // pipeline
  void beginRenderPass (std::shared_ptr<FrameBuffer> &frameBuffer, const ClearStates &states);
  void setViewPort ( int x, int y, int width, int height);
  void setVertexArrayObject (std::shared_ptr<VertexArrayObject> &vao);
  void setShaderProgram (std::shared_ptr<ShaderProgram> &program);
  void setShaderResources (std::shared_ptr<ShaderResources> &uniforms);
  void setPipelineStates (std::shared_ptr<PipelineStates> &states);
  void draw ();
  void endRenderPass ();
};

Commencer

Condition préalable

Pour construire le projet, vous devez d'abord installer les outils suivants:

• Cmake 3.10 ou plus
• Environnement du compilateur avec le support C ++ 11

Si vous souhaitez exécuter le Vulkan Renderer, vous devez installer la bibliothèque Vulkan comme suit:

1. Téléchargez le SDK Vulkan sur le site officiel: https://vulkan.lunarg.com/sdk/home
2. Installez le SDK sur votre système. Le processus d'installation peut varier en fonction de votre système d'exploitation.
3. Définissez la variable d'environnement vulkan_sdk / vk_icd_filenames / vk_layer_path sur le chemin où vous avez installé le SDK.

Obtenir le code

Pour obtenir le code de cette bibliothèque, vous pouvez cloner le référentiel GitHub en utilisant la commande suivante:

git clone https://github.com/keith2018/SoftGLRender.git

Alternativement, vous pouvez télécharger le code source en tant que fichier zip à partir du référentiel GitHub.

Construire le projet

Pour construire le projet, accédez au répertoire racine du référentiel et exécutez les commandes suivantes:

mkdir build
cmake -B ./build -DCMAKE_BUILD_TYPE=Release
cmake --build ./build --config Release

Cela générera le fichier exécutable et la copie des actifs vers Directory bin , que vous pouvez exécuter en exécutant la commande suivante:

 cd bin/Release
./SoftGLRender

Structure de répertoire

• assets : Modèles GLTF et Textures Skybox, assets.json est l'index de tous les matériaux du modèle et Skybox
• src : répertoire de code source principal
  • Base : classes utilitaires de base comme le fichier, le hachage, la minuterie, etc.
  • Render : abstraction de rendu, inclure le sommet, la texture, l'uniforme, le framebuffer, etc.
    • Software : implémentation de rendu logiciel
    • OpenGL : mise en œuvre d'OpenGl Renderer
    • Vulkan : Mise en œuvre de Vulkan Renderer
  • Viewer : Chargement GLTF (basé sur Asimp), appareil photo et contrôleur, panneau de configuration et gestion des passes
    • Shader/GLSL : Code de shader GLSL, pour OpenGl & Vulkan Renderer
    • Shader/Software : simulation C ++ des shaders vertex et des shaders de fragments
• third_party : bibliothèques et actifs externes

Bibliothèques tierces

• assimp https://github.com/assimp/assimp
• glfw https://github.com/glfw/glfw
• glm https://github.com/g-truc/glm
• glslang https://github.com/khronosgroup/glslang
• imgui https://github.com/ocornut/imgui
• json11 https://github.com/dropbox/json11
• stb_image https://github.com/nothings/stb
• vma https://github.com/gpuopen-braresandsdks/vulkanmemoryallocator

Contributif

Si vous souhaitez contribuer au projet, vous êtes invités à soumettre des demandes de traction avec des corrections de bogues, de nouvelles fonctionnalités ou d'autres améliorations. Veuillez vous assurer que votre code est bien documenté et adhère aux normes de codage du projet.

Licence

Ce code est concédé sous licence MIT (voir licence).