https://www.linkedin.com/posts/narciscalin_this-2025-i-decided-to-start-learning-how-activity-7357485340300832768-1f3i

This 2025 I decided to start learning how to code, so I installed Visual Studio and I started looking into C++. After days of watching tutorials and guides about the basics of C++ and programming, I decided to make something physics-related. I started with a dot that fell to the ground and then I wanted to simulate gravitational attraction, so I made 2 circles attracting each other. I thought it was really cool to see something I made with code actually work, so I kept building on top of that small, basic program. And here we are after roughly 8 months of learning programming. This is Galaxy Engine, and it is a simulation software I have been making ever since I started my learning journey. It currently can simulate gravity, dark matter, galaxies, the Big Bang, temperature, fluid dynamics, breakable solids, planetary interactions, etc. The program can run many tens of thousands of particles in real time on the CPU thanks to the Barnes-Hut algorithm, mixed with Morton curves. It also includes its own PBR 2D path tracer with BVH optimizations. The path tracer can simulate a bunch of stuff like diffuse lighting, specular reflections, refraction, internal reflection, fresnel, emission, dispersion, roughness, IOR, nested IOR and more! I tried to make the path tracer closer to traditional 3D render engines like V-Ray. I honestly never imagined I would go this far with programming, and it has been an amazing learning experience so far. I think that mixing this knowledge with my 3D knowledge can unlock countless new possibilities. In case you are curious about Galaxy Engine, I made it completely free and Open-Source so that anyone can build and compile it locally! You can find the source code in GitHub

https://github.com/NarcisCalin/Galaxy-Engine

rgl.epfl.ch/publications/Zeltner2020Specular

import math,sys

def Exposure2Intensity(exposure): 
    exp = float(exposure)
    result = math.pow(2,exp)
    print(result)

Exposure2Intensity(0)

def Intensity2Exposure(intensity):
    inarg = float(intensity)
    
    if inarg == 0:
        print("Exposure of zero intensity is undefined.")
        return
    
    if inarg < 1e-323:
        inarg = max(inarg, 1e-323)
        print("Exposure of negative intensities is undefined. Clamping to a very small value instead (1e-323)")
    
    result = math.log(inarg, 2)
    print(result)

Intensity2Exposure(0.1)

Why Exposure?

Exposure is a stop value that multiplies the intensity by 2 to the power of the stop. Increasing exposure by 1 results in double the amount of light.

Artists think in “stops.” Doubling or halving brightness is easy math and common in grading and look-dev.
Exposure counts doublings in whole stops:

• +1 stop = ×2 brightness
• −1 stop = ×0.5 brightness

This gives perceptually even controls across both bright and dark values.

Why Intensity?

Intensity is linear.
It’s what render engines and compositors expect when:

• Summing values
• Averaging pixels
• Multiplying or filtering pixel data

Use intensity when you need the actual math on pixel/light data.

Formulas (from your Python)

• Intensity from exposure: intensity = 2**exposure
• Exposure from intensity: exposure = log₂(intensity)

Guardrails:

• Intensity must be > 0 to compute exposure.
• If intensity = 0 → exposure is undefined.
• Clamp tiny values (e.g. 1e−323) before using log₂.

Use Exposure (stops) when…

• You want artist-friendly sliders (−5…+5 stops)
• Adjusting look-dev or grading in even stops
• Matching plates with quick ±1 stop tweaks
• Tweening brightness changes smoothly across ranges

Use Intensity (linear) when…

• Storing raw pixel/light values
• Multiplying textures or lights by a gain
• Performing sums, averages, and filters
• Feeding values to render engines expecting linear data

Examples

• +2 stops → 2**2 = 4.0 (×4)
• +1 stop → 2**1 = 2.0 (×2)
• 0 stop → 2**0 = 1.0 (×1)
• −1 stop → 2**(−1) = 0.5 (×0.5)
• −2 stops → 2**(−2) = 0.25 (×0.25)
• Intensity 0.1 → exposure = log₂(0.1) ≈ −3.32

Rule of thumb

Think in stops (exposure) for controls and matching.
Compute in linear (intensity) for rendering and math.