Bram Stout

@stoutnl.bsky.social

60 Followers 306 Following

Working on animations (including Minecraft animations) for over 10 years. Doing things like story writing, CG cinematography, CG pipeline development, rigging, and consulting. Creator of MiEx, a Minecraft world exporter. https://bramstout.nl

A CG render of a devastated village in the "devastated lands" region from the video game Hytale

Screenshot from Blender showcasing texture overlays, part of Connected Textures, that were exported out using MiEx with UltimaCraft as the resource pack

Screenshot of the build script run by the custom build system.

Code shown:
import build.build as build

build.Package(
name="...",
version="0.1.0",
dependencies=[
build.Dependency(
packageName="..."
)
]
)

build.addFolder("...")

if __name__ == "__main__":
build.buildAllPackages()

A screenshot of Blender with a Minecraft world exported from MiEx that shows off the ambient occlusion calculated by MiEx, exported out as a vertex color set, and applied to the diffuse color in the material

Raw assembled pizza on a pizza peel, ready to he put into the oven.

Home-made pizza dough, using a preferment and sourdough-powder. Slow-fermented. Topped with crushed tomatoes, basil, olive oil, parmigiano reggiano, mozzarella, ham, and bacon

Photograph of Loch Doon in Scotland

Video showing the new Element Animation Maya launcher, including custom splash screen and an audio file, randomly selected from a group of audio files, saying "Element Maya" in Element Animation's Villager voice

Photograph of a cat scratching himself

Screenshot of some custom Autodesk Maya shelves that are part of the Element Animation pipeline

Thumbnail of the YouTube video "Minecraft LIVE – March 2025: A Wandering Trader Springs to Life!"

Screenshot from the animation, showing two llamas next to a wandering trader lying on the ground. A tear is falling down from one of the llama's face

A CG Minecraft render of a lava pool in a cave, with a shaft of light beaming down onto the lava and items scattered around

A collection of images comparing the colour renderings from different colour management workflows (Khronos PBR Neutral, Agx, and ACES) with the colour renderings from LOOCS.

High quality version of the image available at: https://bramstout.nl/content/LOOCS_Comparison_1.jpg

Code segment combining all of the different operations together:
res = loocs.gamut.convertToGamut(RGB, loocs.gamut.GAMUT_LOOCSG1, loocs.gamut.GAMUT_LOOCSG2)
res = satClip(res)

res = satVib(res, 1.37, 1.41)

res = satContrast(res, 4.0, 0.9, 4.0)

res = resat(res, 500.0, 1.932, 0.816)

res = desat(res, 500.0, 2.0)

res.r = tonemap(res.r)
res.g = tonemap(res.g)
res.b = tonemap(res.b)

res = satVib(res, 0.971, 0.58)

res = res.clamp(0.0, maxLuminance)

g2Res = Color(res.r, res.g, res.b)
res = loocs.gamut.convertToGamut(res, loocs.gamut.GAMUT_LOOCSG2, loocs.gamut.GAMUT_LOOCSG1)

res = g2SatCurve(res, g2Res)

return res

Code segment of the saturation remapping code:
def maxSat(RGB : Color):
# Calculate the RGB colour with saturation set to 100%.
Cmax = RGB.maxComponent()
Cmin = RGB.minComponent()
sat = 0.0
if Cmax > 0.00001:
sat = min(max(1.0 - (Cmin / Cmax), 0.0), 1.0)

if sat < 0.99999:
RGB2 = (RGB - Cmin) / (1.0 - sat)
return RGB2
return Color(RGB.r, RGB.g, RGB.b)

def remapSat(sat, maxSat):
# Remap the saturation so that maxSat maps to an output value of 1.0.
scale = 1.0 - maxSat
m = -20.0
mexp = math.exp(m)

f = (math.exp((sat / maxSat) * -m + m) - mexp) / (1.0 - mexp)

return min(max(sat + f * scale, 0.0), 1.0)

def g2SatCurve(RGB : Color, RGB_G2 : Color) -> Color:
# Calculate the maximum saturation in the G2 gamut.
maxSatRGB = maxSat(RGB_G2)

maxSatRGB = loocs.gamut.convertToGamut(maxSatRGB, loocs.gamut.GAMUT_LOOCSG2, loocs.gamut.GAMUT_LOOCSG1)
# Calculate what the maximum saturation achievable by Filmic Classic is in the G1 gamut.
g2Cmax = maxSatRGB.maxComponent()
g2Cmin = maxSatRGB.minComponent()
g2MaxSat = 1.0
if g2Cmax > 0.00001:
g2MaxSat = min(max(1.0 - (g2Cmin / g2Cmax), 0.0), 1.0)

# Calculate the saturation of the current colour in the G1 gamut.
Cmax = RGB.maxComponent()
Cmin = RGB.minComponent()
sat = 0.0
if Cmax > 0.00001:
sat = min(max(1.0 - (Cmin / Cmax), 0.0), 1.0)

# Remap the saturation.
newSat = remapSat(sat, g2MaxSat)

# Apply the new saturation.
if Cmax > 0.0000001:
RGB /= Cmax

Cmin = RGB.minComponent()
RGB -= Cmin
if Cmin < 0.99999:
RGB /= 1.0 - Cmin

RGB *= newSat
RGB += 1.0 - newSat

RGB *= Cmax

return RGB

Comparison image with and without saturation remapping

Code segment for the saturation driven contrast code:
def satContrast(RGB : Color, gamma, contrast, contrastPivot) -> Color:
Cmax = RGB.maxComponent()
Cmin = RGB.minComponent()
# Calculate the saturation.
sat = 0.0
if Cmax > 0.00001:
sat = min(max(1.0 - (Cmin / Cmax), 0.0), 1.0)

# Calculate by how much to reduce the contrast.
contrastStrength = 1.0 - pow(1.0 - sat, 1.0 / gamma)

contrastStrength *= min(max(Cmax / 0.01, 0.0), 1.0)

contrast2 = contrast * contrastStrength + (1.0 - contrastStrength)

# Apply the contrast. The typical contrast formula found online,
# is a pivoted scale, which comes from photographic film and therefore
# is to be applied in logarithmic space. Often the formula is copied
# without this considuration and thus applied to linear or gamma images
# producing incorrect results. This is the same formula but then converted
# to operate in linear space. This linear version of the contrast operator
# has one benifit over the log version, it's able to keep 0.0 at 0.0.
CmaxNew = pow(Cmax / contrastPivot, contrast2) * contrastPivot

# The contrast is applied on the maximum value of the colour rather than
# each individual channel, so as to not affect saturation or hue.
if Cmax > 0.000001:
RGB *= CmaxNew / Cmax

return RGB

Comparison image with and without saturation-based contrast

Code segment for the saturation operations. It is applied before and after the tone-mapping with different values.
def satVib(RGB : Color, sat, vib) -> Color:
Cmax = RGB.maxComponent()

if Cmax > 0.0000001:
# Apply normalised gamma as a saturation operation.
RGB /= Cmax

RGB.r = pow(RGB.r, vib)
RGB.g = pow(RGB.g, vib)
RGB.b = pow(RGB.b, vib)

RGB *= Cmax

Cmax = RGB.maxComponent()

if Cmax > 0.0000001:
# Apply the typical saturation operation.
# But rather than calculating the new saturation
# by multiplying by some factor, which can cause
# saturation to go above 100%, the new saturation
# is calculated by remapping it using a pow operation.
RGB /= Cmax
Cmin = RGB.minComponent()

RGB -= Cmin
if Cmin < 0.99999:
RGB /= 1.0 - Cmin

oldSat = 1.0 - Cmin
newSat = 1.0 - pow(1.0 - oldSat, sat)

RGB *= newSat
RGB += 1.0 - newSat

RGB *= Cmax

return RGB

Comparison image with and without pre/post saturation

Code segment for the increase in saturation code:
def resat(RGB : Color, desatMaxValue, resatGamma, resatStrength) -> Color:
# Values copied from the desaturation code.
noDesatAt = math.log10(0.01)
fullDesatAt = math.log10(desatMaxValue)

Cmax = RGB.maxComponent()

if Cmax > 0.0000001:
lCmax = math.log10(Cmax)

# Calculate how much to saturate by based on the maximum value
# in a logarithmic space.
factor = min(max((lCmax - noDesatAt) / (fullDesatAt - noDesatAt), 0.0), 1.0)
factor = math.pow(factor, resatGamma)

factor *= resatStrength

# Apply a normalised gamma operation to saturate the colour.
RGB /= Cmax

RGB.r = pow(RGB.r, 1.0 + factor)
RGB.g = pow(RGB.g, 1.0 + factor)
RGB.b = pow(RGB.b, 1.0 + factor)

RGB *= Cmax

return RGB

Comparison image with and without resaturation

Code segment of the desaturation:
def desat(RGB : Color, desatMaxValue, desatGamma) -> Color:
# The value that the tone-mapper maps to 1.0
tonemapClip = 32.8761
noDesatAt = math.log10(0.01)
# The Cmax value where it should produce pure white.
fullDesatAt = math.log10(desatMaxValue)
# The amount to desaturate a 100% saturated colour to
# produce pure white once run through the tone-mapper.
desatAmount = tonemapClip / max(desatMaxValue, tonemapClip)

Cmax = RGB.maxComponent()

if Cmax > 0.0000001:
lCmax = math.log10(Cmax)

# Calculate how much to desaturate by based on the maximum value
# in a logarithmic space.
factor = min(max((lCmax - noDesatAt) / (fullDesatAt - noDesatAt), 0.0), 1.0)
factor = math.pow(factor, desatGamma)

factor *= desatAmount

# Desaturate the colour.
RGB *= 1.0 - factor
RGB += Cmax * factor

return RGB

Comparison image with and without desaturation

Code segment of tone-mapping:
def tonemapLinear(x : float, slope : float, px : float, py : float) -> float:
return slope * (x - px) + py

def sigmoid(x : float, gamma : float) -> float:
"""
A sigmoid curve that as an additional gamma parameter which changes how
quickly it goes to the extremities without changing the slope at (0, 0).
Only the positive side of the sigmoid is usable.
"""
return 1.0 - math.pow(1.0 - (2.0 / (1.0 + math.exp(-2.0 * x / gamma)) - 1.0), gamma)

def tonemapHighlight(x : float, slope : float, scale : float, gamma : float, px : float, py : float) -> float:
return sigmoid((x - px) * slope / scale, gamma) * scale + py

def tonemapShadow(x : float, slope : float, scale : float, gamma : float, px : float, py : float) -> float:
return -sigmoid((-x + px) * slope / scale, gamma) * scale + py

def tonemap(x : float) -> float:
x = max(x, 0.0000001)
x = math.log10(x)

maxLuminanceLog : float = math.log10(maxLuminance)
slope : float = 1.6
middleGrayX : float = math.log10(0.18)
middleGrayY : float = -0.95
highlightX : float = -0.735 + (maxLuminanceLog / slope)
highlightY : float = tonemapLinear(highlightX, slope, middleGrayX, middleGrayY)
shadowX : float = -1.073
shadowY : float = tonemapLinear(shadowX, slope, middleGrayX, middleGrayY)

if x > highlightX:
x = tonemapHighlight(x, slope, 0.94, 10.0, highlightX, highlightY)
elif x > shadowX:
x = tonemapLinear(x, slope, middleGrayX, middleGrayY)
else:
x = tonemapShadow(x, slope, 1.05, 1.0, shadowX, shadowY)

# clamp to the range that we accept.
x = min(max(x, -2.5), maxLuminanceLog)

x = math.pow(10.0, x)

Dmin : float = math.pow(10.0, -2.5)
x -= Dmin
x /= maxLuminance - Dmin
x *= maxLuminance
return x

A diagram of the tone-curve used in LOOCS Filmic Classic.

Comparison image with and without tone-mapping

Code segment of the saturation clipping:
def satClip(RGB : Color) -> Color:
origLuminance = loocs.color.luminanceG0(RGB, loocs.gamut.GAMUT_LOOCSG2)

# Clamp the saturation to 100% max.
Cmin = min(RGB.minComponent(), 0.0)
Cmax = RGB.maxComponent()
RGB -= Cmin
Cmax2 = RGB.maxComponent()
if Cmax2 > 0.0000001:
RGB *= Cmax / Cmax2

newLuminance = loocs.color.luminanceG0(RGB, loocs.gamut.GAMUT_LOOCSG2)

# Correct for luminance change to preserve the luminance.
if newLuminance > 0.00000001:
RGB *= origLuminance / newLuminance

return RGB

Diagram of the LOOCS G0, G1, G2, and sRGB gamuts.

G0 is used for archival and sharing of footage. It's meant to be able to store any colour from any camera without loss of data.

G1 is the main working gamut. Providing a wide gamut that can represent most colours captured by cinema cameras.

G2 is the second working gamut intended for CG rendering and other cases where you don't want any colours that could be outside of the visible spectrum

Comparion image between two colour rendering found in LOOCS, LOOCS Neutral and LOOCS Filmic Classic

Picture of my cat, Loetje, who is really sweet and definitely did not trust my new camera

A screen recording of Blackmagic Design Fusion Studio showing off a custom Fuse node that spawns random points on 3D geometry. The random points a stuck to the geometry as the camera moves around and new points smoothly spawn in or are removed to keep a constant density in screen-space.

A mock-up of a node graph that combines vertical flow for geometry data and horizontal flow for non-geometry data

Bifrost graph: Root of the graph. Takes in a mesh from Maya, applies the compound on it and outputs it back to Maya. The compound has a feedback loop, so it gets the previous frame's result back.

A collection of images comparing the colour renderings from different colour management workflows (Khronos PBR Neutral, Agx, and ACES) with the colour renderings from LOOCS