ObjReader / orbtool — New GLB Import Feature

I am pleased to introduce a new capability recently added to orbtool:

Direct .GLB → .ORB conversion

This allows modern asset pipelines (Blender, Maya, etc.) to feed ObjReader without relying on the legacy OBJ stage.

------------------------------------------------------------

Why GLB?

GLB is the binary form of glTF and provides several practical advantages:

• compact binary structure 
• faster parsing 
• embedded geometry, materials, and textures 
• fewer ambiguities than text-based formats 

That said, GLB is NOT intended to become a runtime format inside ObjReader.

ORB remains the native, optimized container designed for fast loading and deterministic behavior.

The workflow is intentionally simple:

DCC Tool → GLB → orbtool → ORB → ObjReader

GLB acts as an asset source, while ORB stays the final runtime format.

------------------------------------------------------------

Architecture Notes

• GLB parsing is strictly isolated inside orbtool 
• No glTF code is introduced into the runtime engine 
• ORDLL remains lightweight and rendering-focused 
• CRT-free discipline is preserved 

This separation ensures the viewer stays fast and avoids dependency creep.

------------------------------------------------------------

Early Results

Initial integration shows:

• controlled binary growth 
• stable conversion 
• preserved materials 
• clean mesh extraction 

Further optimizations will follow as the pipeline matures.

------------------------------------------------------------

What This Means

This addition quietly moves ObjReader toward a more modern asset workflow while keeping the engine philosophy intact:

✔ preprocess offline 
✔ load fast 
✔ render immediately 

Exactly what a runtime should do.

------------------------------------------------------------

The latest orbtool version is attached to this post, with its full VS2022 C/C++ source code.
The release folder is provided with a ferrari.glb 3D model for test purpose.

Syntax to convert a .glb into a .orb
orbtool -c ferrari.glb -o ferrari.orb

BBP_Glow

Converted from https://www.shadertoy.com/view/W3tSR4
Original created by Xor on 2025-08-23
Audio + color LUT + BBP_plugin integration by Patrice Terrier



Paste this in the BBProc section    case BBP_CREATE:
        // Host asks: "who are you and what do you render to?"
        strcpy(BBP.title,"Volumetric Glow");
        strcpy(BBP.author, "Xor (Shadertoy)");
        BBP.version  = MAKEWORD(1,0);

        // Critical: This plugin renders using OpenGL into the host-provided GL context.
        BBP.renderto = BBP_OPENGL;

        // Default background ARGB used by host (informational/fallback).
        BBP.backargb = bbpARGB(255,0,0,0);
        break;
Paste this in the GLSL.h sectionstatic GLuint CompileShaderFromString() {
    const char* CharBuffer =
    "#version 330 core\n"
    "\n"
    "uniform vec3  iResolution;\n"
    "uniform float iTime;\n"
    "uniform float iAudio;\n" // smoothed audio level (0..~1)
    "\n"
    "out vec4 FragColor;\n"
    "\n"
    "#define STEPS 50.0\n"
    "#define FOV   1.0\n"
    "#define BASE_DENSITY 1.5\n"
    "\n"
    "float Audio01() {\n"
    "    float a = max(iAudio, 0.0);\n"
    "    a = 1.0 - exp(-1.8 * a);\n"
    "    return clamp(a, 0.0, 1.0);\n"
    "}\n"
    "\n"
    "float volumeField(vec3 p, float density, float wfreq) {\n"
    "    float l = length(p);\n"
    "    vec3 v = cos(abs(p) * wfreq / max(4.0, l) + iTime);\n"
    "    return length(vec4(max(v, v.yzx) - 0.9, l - 4.0)) / density;\n"
    "}\n"
    "\n"
    "vec3 rotate90(vec3 p, vec3 a) {\n"
    "    return a * dot(p, a) + cross(p, a);\n"
    "}\n"
    "\n"
    "// MOIRE FIX: tiny stable per-pixel hash (no noise texture needed)\n"
    "float hash12(vec2 p) {\n"
    "    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n"
    "    p3 += dot(p3, p3.yzx + 33.33);\n"
    "    return fract((p3.x + p3.y) * p3.z);\n"
    "}\n"
    "\n"
    "void main() {\n"
    "    vec2 fragCoord = gl_FragCoord.xy;\n"
    "    vec2 center = 2.0 * fragCoord - iResolution.xy;\n"
    "\n"
    "    float a = Audio01();\n"
    "\n"
    "    float breathe = 1.0 - 0.08 * a;\n"
    "\n"
    "    float density = BASE_DENSITY * (1.0 + 1.2 * a);\n"
    "    float wfreq   = 8.0 * mix(1.0, 0.65, a);\n"
    "    float brightness = 0.002 * (1.0 + 0.6 * a);\n"
    "\n"
    "    vec3 axis = normalize(cos(vec3(0.5 * iTime) + vec3(0.0, 2.0, 4.0)));\n"
    "\n"
    "    vec3 dir = rotate90(normalize(vec3(center, FOV * iResolution.y)), axis);\n"
    "\n"
    "    float camZ = -8.0 * mix(1.0, 0.92, a);\n"
    "    vec3 cam = rotate90(vec3(0.0, 0.0, camZ), axis);\n"
    "\n"
    "    // Start point\n"
    "    vec3 pos = cam;\n"
    "\n"
    "    // MOIRE FIX: jitter the start along the ray by a tiny amount (breaks band alignment)\n"
    "    float j = hash12(floor(fragCoord));\n"
    "    pos += dir * (j - 0.5) * 0.10;\n"
    "\n"
    "    vec3 col = vec3(0.0);\n"
    "\n"
    "    for (float i = 0.0; i < STEPS; i += 1.0) {\n"
    "        float vol = volumeField(pos * breathe, density, wfreq);\n"
    "        pos += dir * vol;\n"
    "        float inv = 1.0 / max(vol, 0.02);\n"
    "        col += (cos(pos.z / (1.0 + vol) + iTime + vec3(6.0, 1.0, 2.0)) + 1.2) * inv;\n"
    "    }\n"
    "\n"
    "    col = tanh(brightness * col);\n"
    "    FragColor = vec4(col, 1.0);\n"
    "}\n";

    GLuint fs = CompileShader(GL_FRAGMENT_SHADER, CharBuffer);
    return fs;
}

BassBox GLSL Plugin – Minimal Tutorial (Template Walkthrough)

This post explains how to use the provided bbp_GLSL.cpp + GLSL.h template
to build a simple GLSL-based visual plugin for BassBox64 / MBox64.

The goal is not to introduce “modern OpenGL”, but to show how a GLSL fragment shader
is integrated cleanly into the existing BassBox OpenGL pipeline.

The template uses:
- a legacy full-screen quad (glBegin / glVertex)
- a minimal passthrough vertex shader
- a fragment shader driven by audio and time
- a 32-color LUT system shared between CPU and GPU


----------------------------------------------------------------
1) Plugin lifecycle (BBProc)
----------------------------------------------------------------

The host communicates with the plugin through the exported function:

    ExportC long BBProc(BBPLUGIN &BBP);

The most important messages are:

BBP_CREATE 
Called once to declare plugin identity and rendering mode.
Here you set:
- title
- author
- version
- BBP_OPENGL (mandatory for GLSL plugins)

BBP_INIT 
Called once when the plugin is initialized.
This is where you:
- bind the host OpenGL context (wglMakeCurrent)
- reset OpenGL state
- initialize time and audio variables
- create textures (including the LUT)
- compile and link GLSL shaders
- cache uniform and sampler locations

BBP_RENDER 
Called every frame.
This is where you:
- update time and audio values
- send uniforms to the shader
- bind textures
- draw a full-screen quad

BBP_SIZE 
Called when the plugin window is resized.
You must update glViewport and internal width/height.

BBP_DESTROY 
Called when the plugin is unloaded.
You must delete:
- GLSL program
- textures
- any allocated resources


----------------------------------------------------------------
2) Rendering model
----------------------------------------------------------------

This template uses a very simple and reliable rendering model:

- A full-screen quad is drawn in clip space (-1 .. +1)
- The vertex shader simply forwards gl_Vertex to gl_Position
- The fragment shader runs once per pixel

No VBO, no VAO, no FBO, no multipass.
This keeps the focus on the shader logic itself.


----------------------------------------------------------------
3) Core uniforms provided to the shader
----------------------------------------------------------------

The following uniforms are automatically filled by the plugin:

uniform vec3 iResolution; 
- x = viewport width in pixels 
- y = viewport height in pixels 
- z = 1.0 (convention)

uniform float iTime; 
- Accumulated animation time
- Already modulated by audio on the CPU side
- Suitable for driving motion directly

uniform float iAudio; 
- Smoothed audio level
- Typically in the range 0.0 .. 1.0 (may slightly exceed)
- Stable enough for visual modulation

uniform vec3 iLutColor; 
- One color selected from the 32-color LUT
- Chosen on the CPU side according to audio peaks
- Already normalized (0..1)

uniform vec3 iMouse; 
- Present for compatibility
- Currently set to (0,0,0) in the template
- Can be wired later via BBP_MOUSE

uniform vec4 iDate; 
- Only iDate.w is used in the template
- Contains raw system time in seconds
- Useful if you need a non-audio-modulated time source


----------------------------------------------------------------
4) LUT system (CPU + GPU)
----------------------------------------------------------------

The template defines a 32-color palette:

- On the CPU:
  - gP.color[32]  : packed ARGB
  - gP.fR/G/B[32]: normalized float values

- On the GPU:
  - a 32x1 RGB texture bound to iChannel1

You can:
- use iLutColor for a single selected color
- sample iChannel1 in the shader for custom palette logic

The LUT texture uses:
- GL_NEAREST filtering
- GL_CLAMP_TO_EDGE wrapping


----------------------------------------------------------------
5) Demo fragment shader (what it shows)
----------------------------------------------------------------

The provided demo shader demonstrates:

- coordinate normalization using iResolution
- time-based animation using iTime
- audio-driven modulation using iAudio
- color tinting using iLutColor
- a simple ring/pulse effect
- a subtle vignette

It does NOT require:
- any texture input
- any mouse interaction
- any advanced OpenGL features

Alpha output is set to 1.0, producing an opaque image.


----------------------------------------------------------------
6) Where to modify things
----------------------------------------------------------------

To change the visual effect: 
Edit the quoted GLSL string inside:

    static GLuint CompileShaderFromString()

To add textures: 
Populate gP.mt[] in BBP_INIT and sample them as iChannel0..3.

To enable transparency: 
- Output alpha < 1.0 in gl_FragColor
- Enable blending in BBP_INIT or BBP_RENDER
- Ensure the host compositing mode supports it

To react more strongly to audio: 
- Adjust the scaling of audioNow
- Modify smoothing factor
- Use iAudio directly in the shader


----------------------------------------------------------------
7) Why this template matters
----------------------------------------------------------------

This template is intentionally:

- minimal
- stable
- legacy-compatible
- host-friendly

It avoids:
- undefined OpenGL state
- hidden multipass logic
- fragile modern-only constructs

Once this base works reliably, more complex shaders and techniques
can be layered on top with confidence.


----------------------------------------------------------------
End of tutorial
----------------------------------------------------------------

The VS 2022 bbp_GLSL.zip is attached to this post

BassBox64 3.00 – New Version Highlights

• Full VS2022 C/C++ source code project
• Advanced Desktop Window Manager (DWM) integration
• New skin theme based on DWM blur glass
• Plugin-level blur mode with adjustable blur strength
• Fully DPI-aware rendering (high-DPI and mixed-DPI setups)
• Correct alpha composition and stable transparency
• Native Windows 10 / 11 composited window support
• Remanent histogram processing for persistent audio visuals
• Smoother audio-to-visual response and temporal coherence
• One-pass GLSL support from version 1.20 up to 3.30
• Unified legacy / modern GLSL pipeline (no multipass overhead)
• Enhanced texture support (formats, precision, alpha handling)
• Improved OpenGL performance and rendering stability
• Better multi-monitor and high refresh-rate handling
• Tiny standalone executable built with TCLib
• No Microsoft CRT dependency (reduced size and overhead)

Note: This version use exclusively 64-bit plugins, with brand new GLSL support (converted from Shadertoy).

Strongest Points of the New BassBox64 Version

Full Visual Studio 2022 Source Code Provided
The complete, build-ready VS2022 project is included, offering full transparency, long-term maintainability, and the ability to study, modify, or extend every subsystem of BassBox64.

Deep DWM Integration with Blur Glass UI
Native use of Windows DWM composition enables true blur-glass visuals, seamless desktop blending, and a modern, premium look that plugins can fully exploit.

Plugin-Level Blur with Fine Control
Blur is no longer a static UI effect: each plugin can control blur intensity dynamically, allowing glass, crystal, or frosted effects that enhance depth without hiding audio-reactive elements.

One-Pass GLSL Pipeline (1.20 → 3.30)
A unified single-pass GLSL architecture supports both legacy and modern shaders without multipass overhead, keeping performance high and code paths clean.

Remanent Histogram Audio Processing
Visualizations retain audio energy over time, producing smoother, more musical, and more expressive visuals than classic peak-based FFT displays.

True DPI Awareness and Modern Display Handling
Correct scaling and alignment across high-DPI, mixed-DPI, multi-monitor, and high-refresh-rate setups—no blurry scaling, no clipped viewports.

Enhanced Texture and Alpha Handling
Improved texture precision, format support, and alpha correctness ensure stable transparency and consistent visuals in both OpenGL and composited modes.

Tiny Standalone Executable (No CRT)
Built with TCLib and no Microsoft CRT dependency, the executable remains extremely small, fast to load, and free from runtime bloat.

Tight Audio-to-Visual Synchronization
Refined timing and smoothing logic deliver visuals that feel directly connected to the music, not just reactive but musically coherent.

Native 64-bit, Low-Latency Architecture
Pure C/C++ design focused on performance, predictability, and long-term maintainability—no frameworks, no unnecessary layers.

Context-sensitive blur control
when “Plugin fully visible” is disabled, the blur level can be adjusted interactively using the mouse wheel.

Bonjour Monsieur Lauzon

J'ai installé VS 2026 community, je n'ai pas trouvé de différence fondamentale pour ce qui concerne C++.

Il y a 2–3 points “pièges” avec GLUT sous Visual Studio 2022/2026, surtout en x64. Le plus important est de choisir une implémentation compatible (FreeGLUT recommandé) et de bien aligner architecture (x86/x64), lib et DLL.

1) Recommandation : utiliser FreeGLUT (plutôt que l’ancien “GLUT”)
Le GLUT historique (Mark Kilgard) est ancien et on trouve souvent des binaires incomplets ou seulement x86. FreeGLUT est l’alternative maintenue et plus simple à intégrer.

2) Le point critique : x64 vs x86

Si le projet est en x64, il faut freeglut.lib + freeglut.dll en x64.

En Win32, il faut les versions x86.
Ne mélangez jamais : une lib x86 avec un EXE x64 (erreur de link assurée).

3) Où mettre les fichiers
Typiquement :

Headers : GL\freeglut.h (et parfois GL\glut.h selon le package)

Lib : freeglut.lib (et éventuellement freeglut_static.lib si tu veux statique)

DLL : freeglut.dll (si lien dynamique)


Organisation conseillée (simple et propre) :

D:\Dev\libs\freeglut\include\GL\...
D:\Dev\libs\freeglut\lib\x64\freeglut.lib
D:\Dev\libs\freeglut\bin\x64\freeglut.dll


4) Réglages VS2022 (par projet)
Dans Project Properties (Configuration = Debug/Release, Platform = x64/Win32) :
C/C++ → General → Additional Include Directories

Ajouter :
D:\Dev\libs\freeglut\include

Linker → General → Additional Library Directories
Ajouter :
D:\Dev\libs\freeglut\lib\x64 (ou ...\lib\x86)


Linker → Input → Additional Dependencies
Ajouter au minimum :
freeglut.lib
opengl32.lib
glu32.lib (si vous utilisez GLU)
gdi32.lib (souvent nécessaire avec GLUT/FreeGLUT)
winmm.lib (parfois requis par FreeGLUT selon build)


5) DLL : où la mettre pour que ça lance
Si liés avec freeglut.lib (dynamique), il faut freeglut.dll :
soit dans le même dossier que l'.exe (le plus simple),
soit dans un dossier du PATH.


Piège classique : ça compile/link, puis au lancement Windows dit qu’il manque la DLL.
6) Un mini test de compilation
Inclure :
#include <windows.h>
#include <GL/freeglut.h>

Puis un main/WinMain simple qui fait glutInit, glutCreateWindow, glutMainLoop.
7) Cas particulier : conflit avec le pipeline OpenGL/Win32 existant

GLUT crée sa propre fenêtre et gère sa loop (glutMainLoop), ce qui peut être incompatible avec une architecture OpenGL standard.


En ce qui me concerne je n'utilise jamais GLUT, je préfère attaquer OpenGL directement, ainsi que les extensions WGL.

Le plus simple, est de partir d'un projet existant avec une boucle de message et une procédure de traitement standard, avec ou sans GDImage.