From c0ea1fde8f20fdd9c82d74de23c9b2a4a9fc6831 Mon Sep 17 00:00:00 2001
From: GigaSoft <137882010+Turbo1337GS@users.noreply.github.com>
Date: Sat, 9 Dec 2023 23:29:36 +0100
Subject: [PATCH] Created I will show you how to display SVG icons in ImGui
 with glfw and OpenGL3. (markdown)

---
 ...G-icons-in-ImGui-with-glfw-and-OpenGL3..md | 124 ++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 I-will-show-you-how-to-display-SVG-icons-in-ImGui-with-glfw-and-OpenGL3..md

diff --git a/I-will-show-you-how-to-display-SVG-icons-in-ImGui-with-glfw-and-OpenGL3..md b/I-will-show-you-how-to-display-SVG-icons-in-ImGui-with-glfw-and-OpenGL3..md
new file mode 100644
index 0000000..9ad6b27
--- /dev/null
+++ b/I-will-show-you-how-to-display-SVG-icons-in-ImGui-with-glfw-and-OpenGL3..md
@@ -0,0 +1,124 @@
+```cpp
+// Define the implementation for NanoSVG
+#define NANOSVG_IMPLEMENTATION
+#include "nanosvg.h"
+// Define the implementation for the NanoSVG rasterizer
+#define NANOSVGRAST_IMPLEMENTATION
+#include "nanosvgrast.h"
+#include <iostream>
+#include <GL/gl.h>
+#include "imgui.h"
+
+/**
+ * Helper function to render SVG image to a pixel buffer.
+ * @param image Pointer to the NSVGimage object.
+ * @param w Reference to an integer to store the width of the image.
+ * @param h Reference to an integer to store the height of the image.
+ * @return Pointer to the pixel buffer containing the rendered image.
+ */
+unsigned char* RenderSVGToBuffer(NSVGimage* image, int& w, int& h) {
+    // Set the image dimensions
+    w = (int)image->width;
+    h = (int)image->height;
+
+    // Allocate buffer for image data in RGBA format (4 bytes per pixel)
+    unsigned char* buffer = new unsigned char[w * h * 4];
+    NSVGrasterizer* rast = nsvgCreateRasterizer();
+    if (rast == nullptr) {
+        std::cerr << "Failed to create rasterizer." << std::endl;
+        delete[] buffer;
+        return nullptr;
+    }
+
+    // Rasterize the SVG image into the pixel buffer
+    nsvgRasterize(rast, image, 0, 0, 1, buffer, w, h, w * 4);
+    nsvgDeleteRasterizer(rast);
+    return buffer;
+}
+
+/**
+ * Function to load and display an SVG image.
+ * @param filePathSvg The file path of the SVG image.
+ */
+void LoadAndDisplaySVG(const char* filePathSvg) {
+    // Parse the SVG image from a file
+    NSVGimage* image = nsvgParseFromFile(filePathSvg, "px", 96.0f);
+    if (image == nullptr) {
+        std::cerr << "SVG file not found: " << filePathSvg << std::endl;
+        return;
+    }
+
+    int w, h;
+    // Render the SVG image to a buffer
+    unsigned char* buffer = RenderSVGToBuffer(image, w, h);
+    if (buffer == nullptr) {
+        nsvgDelete(image);
+        return;
+    }
+
+    // Create an OpenGL texture from the buffer
+    GLuint textureID;
+    glGenTextures(1, &textureID);
+    glBindTexture(GL_TEXTURE_2D, textureID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
+
+    // Display the texture using ImGui
+    ImGui::Image((void*)(intptr_t)textureID, ImVec2((float)w, (float)h));
+
+    // Clean up
+    delete[] buffer;
+    nsvgDelete(image);
+}
+
+int main() {
+    // Example usage
+    // LoadAndDisplaySVG("path_to_svg_file.svg");
+
+    return 0;
+}
+```
+
+Rendering and Displaying SVG Images in ImGui using NanoSVG
+Overview
+This repository presents a comprehensive solution for rendering Scalable Vector Graphics (SVG) in ImGui, leveraging the capabilities of NanoSVG and NanoSVGRast. This approach enables users to easily load, render, and display SVG images within the ImGui framework, enriching the graphical user interface with scalable and visually appealing graphics.
+
+Features
+SVG Rendering: Utilizes NanoSVG for parsing and loading SVG files.
+Pixel Buffer Conversion: Converts rendered SVG images into RGBA pixel buffers.
+ImGui Integration: Seamlessly displays rendered SVG images in ImGui interfaces.
+OpenGL Texture Mapping: Converts pixel buffers into OpenGL textures for efficient rendering.
+How it Works
+The code consists of two primary functions:
+
+RenderSVGToBuffer(NSVGimage* image, int& w, int& h): This function takes an NSVGimage object (loaded SVG file) and renders it into a pixel buffer in RGBA format. It returns a pointer to the buffer and updates the width (w) and height (h) variables with the image dimensions.
+LoadAndDisplaySVG(const char* filePathSvg): This function handles the complete process from loading an SVG file, rendering it to a pixel buffer, creating an OpenGL texture, and finally displaying it in ImGui.
+Usage
+To use this code in your project:
+
+Ensure you have NanoSVG, NanoSVGRast, ImGui, and OpenGL set up in your project.
+Add the provided functions to your codebase.
+Call LoadAndDisplaySVG("path_to_your_svg_file.svg") to load and display an SVG image in your ImGui interface.
+Example
+Here's a simple usage example to demonstrate how to integrate this functionality into your ImGui project.
+
+
+
+```cpp
+// Example main function
+int main() {
+    // Initialize ImGui, OpenGL, and other necessary setups
+
+    // Load and display an SVG image
+    LoadAndDisplaySVG("path_to_your_svg_file.svg");
+
+    // Render ImGui frame and handle the rest of your application logic
+
+    return 0;
+}
+
+```
+Contributions and Feedback
+Contributions to enhance this implementation are welcome! If you have suggestions, improvements, or encounter any issues, please feel free to open an issue or submit a pull request.
+