🖌️ Organic Simulation Brushes

The Physics of Watercolor

🌊 Core Watercolor Engine

CLASS WatercolorBrush:
    // State variables
    waterLevel = 0.0        // 0 = dry, 1 = soaking wet
    pigmentDensity = 0.0    // Amount of pigment
    dryingRate = 0.0        // How fast water evaporates
    flowMap = []            // Simulates water flow on paper
    
    FUNCTION InitializeStroke(pressure, color):
        // Water amount based on pressure
        // Light touch = dry brush, heavy = wet
        waterLevel = 0.3 + (pressure * 0.7)
        
        // Extract pigment properties from color
        hsv = RGBtoHSV(color)
        pigmentDensity = hsv.s * hsv.v  // Saturated, dark = dense
        
        // Drying rate based on water amount
        dryingRate = 0.02 / waterLevel  // More water = slower drying
        
        // Initialize flow simulation
        flowMap = CreateFlowField(strokePath, waterLevel)
    END FUNCTION
    
    FUNCTION PlaceWatercolorStamp(position, pressure, velocity):
        // Step 1: Calculate wet/dry state
        currentWater = waterLevel * (1.0 - dryingRate * strokeAge)
        
        // Step 2: Determine diffusion radius
        IF currentWater > 0.7:
            // Wet-on-wet: extensive spreading
            diffusionRadius = baseSize * (1.0 + currentWater * 2.0)
            edgeSharpness = 0.1  // Very soft edges
        ELSE IF currentWater > 0.3:
            // Normal: moderate spreading
            diffusionRadius = baseSize * (1.0 + currentWater)
            edgeSharpness = 0.5
        ELSE:
            // Dry brush: minimal spreading
            diffusionRadius = baseSize * 0.8
            edgeSharpness = 0.9  // Sharp, textured edges
        END IF
        
        // Step 3: Apply diffusion
        FOR EACH pixel IN diffusionRadius:
            distance = Distance(pixel, position)
            
            // Gaussian-like diffusion, but asymmetric
            diffusion = exp(-distance / diffusionRadius)
            
            // Flow influence (water runs downhill)
            flowVector = SampleFlowMap(pixel)
            diffusion *= (1.0 + dot(flowVector, gradient) * 0.3)
            
            // Apply color with transparency
            opacity = pigmentDensity * diffusion * pressure
            BlendPixel(pixel, color, opacity, "watercolor")
        END FOR
        
        // Step 4: Edge accumulation (pigment pushed to edges)
        edgePixels = GetPixelsAtDistance(position, diffusionRadius * 0.9)
        FOR EACH pixel IN edgePixels:
            // Darken edges - characteristic watercolor behavior
            currentColor = GetPixel(pixel)
            darkenedColor = currentColor * 0.85
            BlendPixel(pixel, darkenedColor, 0.3, "multiply")
        END FOR
        
        // Step 5: Granulation (if using granulating pigment)
        IF pigmentDensity > 0.7 AND currentWater < 0.5:
            ApplyGranulation(position, diffusionRadius)
        END IF
        
        // Step 6: Backrun effect (random blooms)
        IF currentWater > 0.8 AND Random() < 0.1:
            CreateBackrun(position, diffusionRadius)
        END IF
        
        // Update stroke age for next stamp
        strokeAge += deltaTime
    END FUNCTION
    
    FUNCTION ApplyGranulation(center, radius):
        // Pigment settles in paper texture valleys
        paperTexture = GetPaperTexture(center, radius)
        
        FOR EACH pixel IN radius:
            textureDepth = paperTexture.GetDepth(pixel)
            
            // Deeper valleys get more pigment
            IF textureDepth > 0.6:
                granuleChance = (textureDepth - 0.6) * 2.5
                
                IF Random() < granuleChance:
                    // Place pigment granule
                    granuleSize = 1 + Random() * 2
                    granuleOpacity = 0.2 + Random() * 0.3
                    
                    DrawGranule(pixel, granuleSize, color, granuleOpacity)
                END IF
            END IF
        END FOR
    END FUNCTION
    
    FUNCTION CreateBackrun(center, radius):
        // Simulate water pushing pigment outward
        backrunPoints = RandomInt(8, 16)
        
        FOR i FROM 0 TO backrunPoints:
            angle = (i / backrunPoints) * TWO_PI + Random() * 0.5
            distance = radius * (0.7 + Random() * 0.3)
            
            backrunCenter = center + PolarToCartesian(distance, angle)
            backrunRadius = radius * (0.2 + Random() * 0.15)
            
            // Create dark ring (pigment pushed by water)
            FOR EACH pixel IN GetRingPixels(backrunCenter, backrunRadius):
                // Darken in ring pattern
                currentColor = GetPixel(pixel)
                darkenedColor = currentColor * 0.7
                BlendPixel(pixel, darkenedColor, 0.4, "multiply")
            END FOR
            
            // Lighten center (where water pushed from)
            FOR EACH pixel IN GetCirclePixels(backrunCenter, backrunRadius * 0.5):
                currentColor = GetPixel(pixel)
                lightenedColor = Lerp(currentColor, paperColor, 0.3)
                BlendPixel(pixel, lightenedColor, 0.5, "normal")
            END FOR
        END FOR
    END FUNCTION
    
    FUNCTION CreateFlowField(strokePath, waterAmount):
        // Simulate how water would flow on tilted paper
        // Uses simplified fluid dynamics
        
        flowField = InitializeGrid(canvasSize)
        
        // Gravity direction (paper tilt)
        gravity = Vector2D(0, 1)  // Downward by default
        
        FOR EACH point IN strokePath:
            // Water creates flow vectors
            influence = waterAmount * 0.5
            
            FOR EACH nearbyPixel IN GetRadius(point, 50):
                distance = Distance(nearbyPixel, point)
                strength = 1.0 - (distance / 50.0)
                
                // Combine gravity and local flow
                localFlow = gravity * 0.3 + RandomVector() * 0.1
                flowField[nearbyPixel] += localFlow * strength * influence
            END FOR
        END FOR
        
        // Normalize flow field
        flowField.Normalize()
        
        RETURN flowField
    END FUNCTION
END CLASS

Simulating Different Pigment Types

Not all watercolor pigments behave the same! Here's how to simulate different types:

🎨 Practical Implementation Tips

Tip 1: Layer Your Simulation

// Don't try to simulate everything at once!
// Use multiple render passes:

Pass 1: Base diffusion (fast, simple)
Pass 2: Edge accumulation (targeted)
Pass 3: Granulation (if needed)
Pass 4: Special effects (backruns, blooms)

// Each pass is cheaper than one complex pass

Tip 2: Use Time-Based Drying

// Track how long since stroke started
strokeAge = CurrentTime() - strokeStartTime

// Adjust behavior based on age
IF strokeAge < 0.5 seconds:
    // Very wet - maximum bleeding
    wetness = 1.0
ELSE IF strokeAge < 2.0 seconds:
    // Drying - reduced bleeding
    wetness = 1.0 - ((strokeAge - 0.5) / 1.5)
ELSE:
    // Fully dry - no more changes
    wetness = 0.0
    FinalizeStroke()  // Convert to permanent pixels
END IF

Tip 3: Optimize with Texture Stamps

// Pre-render common effects as textures
// Instead of calculating granulation per pixel:

// Pre-generated:
granulationTexture = LoadTexture("granulation_pattern.png")

// Runtime (much faster):
FOR EACH stamp:
    BlendTexture(position, granulationTexture, opacity)
END FOR

Oil Paint Characteristics

🎨 Advanced Oil Paint Engine

CLASS OilPaintBrush:
    // Paint state
    paintThickness = 0.0      // How much paint loaded on brush
    wetness = 1.0             // How wet the paint is (1.0 = fresh)
    mixingEnabled = true       // Whether to pick up canvas colors
    brushPressure = 0.0       // Current pressure
    heightMap = []            // Tracks 3D paint thickness
    
    FUNCTION InitializeOilStroke(pressure, color, thickness):
        paintThickness = thickness * pressure
        wetness = 1.0
        currentColor = color
        
        // More pressure = more paint deposited
        depositAmount = paintThickness * pressure
    END FUNCTION
    
    FUNCTION PlaceOilStamp(position, pressure, velocity, direction):
        // Step 1: Sample existing canvas color for mixing
        IF mixingEnabled AND paintThickness < 0.5:
            // Thin paint picks up underlayer
            canvasColor = SampleCanvas(position)
            mixRatio = (1.0 - paintThickness) * 0.3  // Subtle mixing
            currentColor = MixColors(currentColor, canvasColor, mixRatio)
        END IF
        
        // Step 2: Calculate paint deposition
        depositThickness = paintThickness * pressure
        opacity = min(1.0, 0.5 + depositThickness)
        
        // Step 3: Apply brush texture
        brushTexture = GetBrushTexture(direction)
        
        FOR EACH pixel IN brushRadius:
            // Sample brush texture for this pixel
            textureValue = SampleTexture(brushTexture, pixel)
            
            // Modulate opacity by texture
            pixelOpacity = opacity * textureValue
            
            // Apply color
            BlendPixel(pixel, currentColor, pixelOpacity, "normal")
            
            // Update height map (for impasto effect)
            heightMap[pixel] += depositThickness * textureValue
        END FOR
        
        // Step 4: Add impasto lighting
        IF depositThickness > 0.3:
            ApplyImpastoLighting(position, depositThickness, direction)
        END IF
        
        // Step 5: Reduce paint on brush
        paintThickness *= 0.98  // Gradual depletion
        
        // Step 6: Apply directional marks
        ApplyBrushMarks(position, direction, pressure)
    END FUNCTION
    
    FUNCTION MixColors(color1, color2, mixRatio):
        // Real paint color mixing (subtractive)
        // Convert to RYB color space for realistic mixing
        
        ryb1 = RGBtoRYB(color1)
        ryb2 = RGBtoRYB(color2)
        
        // Mix in RYB space
        mixedRYB = Lerp(ryb1, ryb2, mixRatio)
        
        // Convert back to RGB
        mixedRGB = RYBtoRGB(mixedRYB)
        
        RETURN mixedRGB
    END FUNCTION
    
    FUNCTION ApplyImpastoLighting(center, thickness, lightDirection):
        // Simulate light hitting raised paint
        
        // Light source (typically from upper left)
        lightVector = Normalize(Vector2D(-1, -1))
        
        FOR EACH pixel IN GetRadius(center, brushSize):
            // Calculate surface normal from height map
            heightHere = heightMap[pixel]
            heightRight = heightMap[pixel + Vector2D(1, 0)]
            heightDown = heightMap[pixel + Vector2D(0, 1)]
            
            // Approximate normal vector
            normalX = heightHere - heightRight
            normalY = heightHere - heightDown
            normal = Normalize(Vector3D(normalX, normalY, 1.0))
            
            // Calculate lighting
            lightIntensity = max(0, Dot(normal, lightVector))
            
            // Apply highlight
            IF lightIntensity > 0.7:
                currentColor = GetPixel(pixel)
                highlightColor = Lerp(currentColor, WHITE, 0.3 * thickness)
                BlendPixel(pixel, highlightColor, 0.5, "screen")
            END IF
            
            // Apply shadow
            IF lightIntensity < 0.3:
                currentColor = GetPixel(pixel)
                shadowColor = currentColor * 0.8
                BlendPixel(pixel, shadowColor, 0.3, "multiply")
            END IF
        END FOR
    END FUNCTION
    
    FUNCTION ApplyBrushMarks(position, direction, pressure):
        // Simulate individual bristle marks
        
        bristleCount = 10 + pressure * 20  // More pressure = more bristles visible
        bristleSpread = brushSize * 0.8
        
        FOR i FROM 0 TO bristleCount:
            // Calculate bristle position
            offset = (i / bristleCount - 0.5) * bristleSpread
            
            // Perpendicular to stroke direction
            perpendicular = Vector2D(-direction.y, direction.x)
            bristlePos = position + perpendicular * offset
            
            // Each bristle creates a thin mark
            markLength = 5 + pressure * 10
            markWidth = 1 + pressure
            
            // Draw bristle mark
            FOR t FROM 0 TO markLength STEP 0.5:
                markPixel = bristlePos + direction * t
                
                // Add slight waviness
                wave = sin(t * 0.5) * 0.5
                markPixel += perpendicular * wave
                
                // Deposit paint
                alpha = (1.0 - t / markLength) * 0.2  // Fade along length
                BlendPixel(markPixel, currentColor, alpha, "normal")
            END FOR
        END FOR
    END FUNCTION
    
    FUNCTION GetBrushTexture(direction):
        // Load or generate brush texture aligned to stroke direction
        
        baseTexture = LoadTexture("oil_brush_base.png")
        
        // Rotate texture to match stroke direction
        angle = atan2(direction.y, direction.x)
        rotatedTexture = RotateTexture(baseTexture, angle)
        
        RETURN rotatedTexture
    END FUNCTION
    
    // Color space conversions for realistic mixing
    FUNCTION RGBtoRYB(rgb):
        // Simplified RGB to RYB conversion
        // Red Yellow Blue - artist's color wheel
        
        r = rgb.r / 255.0
        g = rgb.g / 255.0
        b = rgb.b / 255.0
        
        // Remove white
        w = min(r, g, b)
        r -= w
        g -= w
        b -= w
        
        mg = max(r, g, b)
        
        // Convert to RYB
        ry = r - min(r, g)
        yy = (g + min(r, g)) / 2.0
        by = (b + g - min(r, g)) / 2.0
        
        // Normalize
        IF mg > 0:
            n = max(ry, yy, by) / mg
            ry /= n
            yy /= n
            by /= n
        END IF
        
        // Add back white
        ry += w
        yy += w
        by += w
        
        RETURN {r: ry, y: yy, b: by}
    END FUNCTION
    
    FUNCTION RYBtoRGB(ryb):
        // Simplified RYB to RGB conversion
        // Inverse of above
        
        ry = ryb.r
        yy = ryb.y
        by = ryb.b
        
        // Remove white
        w = min(ry, yy, by)
        ry -= w
        yy -= w
        by -= w
        
        my = max(ry, yy, by)
        
        // Convert to RGB
        r = ry + yy - min(yy, by)
        g = yy + min(yy, by)
        b = 2.0 * (by - min(yy, by))
        
        // Normalize
        IF my > 0:
            n = max(r, g, b) / my
            r /= n
            g /= n
            b /= n
        END IF
        
        // Add back white
        r += w
        g += w
        b += w
        
        // Convert back to 0-255
        RETURN {
            r: r * 255,
            g: g * 255,
            b: b * 255
        }
    END FUNCTION
END CLASS

Implementing Classic Oil Painting Techniques

1. Scumbling (Dry Brush)

FUNCTION Scumble(position, color, pressure):
    // Very low paint load, high texture visibility
    paintAmount = 0.2 * pressure
    opacity = 0.3 + pressure * 0.3
    
    // High texture sampling
    FOR EACH pixel IN brushRadius:
        // Only paint where texture is high
        textureHeight = GetPaperTexture(pixel)
        
        IF textureHeight > 0.6:  // Only peaks
            pixelOpacity = opacity * (textureHeight - 0.6) * 2.5
            BlendPixel(pixel, color, pixelOpacity, "normal")
        END IF
    END FOR
END FUNCTION

2. Glazing (Transparent Layers)

FUNCTION Glaze(position, color, pressure):
    // Very thin, transparent paint
    opacity = 0.1 + pressure * 0.15
    
    // No mixing with underlayer
    mixingEnabled = false
    
    // Smooth application
    FOR EACH pixel IN brushRadius:
        distance = Distance(pixel, position)
        falloff = 1.0 - (distance / brushRadius)
        
        pixelOpacity = opacity * falloff
        BlendPixel(pixel, color, pixelOpacity, "multiply")
    END FOR
END FUNCTION

3. Palette Knife (Angular Marks)

FUNCTION PaletteKnife(position, direction, color, pressure):
    // Thick, angular application
    thickness = 0.8 + pressure * 0.2
    
    // Create rectangular mark
    width = brushSize * 0.3
    length = brushSize * 1.5
    
    // Calculate corners
    perpendicular = RotateVector(direction, 90)
    
    corner1 = position - perpendicular * width/2
    corner2 = position + perpendicular * width/2
    corner3 = corner2 + direction * length
    corner4 = corner1 + direction * length
    
    // Fill quadrilateral with paint
    FillQuad(corner1, corner2, corner3, corner4, color, thickness)
    
    // Add sharp highlights on edge
    edgeLine = [corner2, corner3]
    DrawLine(edgeLine, LightenColor(color, 0.4), 2)
END FUNCTION

Dry Media Characteristics

✏️ Advanced Pencil/Charcoal Engine

CLASS PencilBrush:
                    // Medium properties
    hardness = 0.5           // 0 = 6B (soft), 1 = 9H (hard)
    particleSize = 0.0       // Size of graphite particles
    depositRate = 0.0        // How much material deposits
    smudgeFactor = 0.0       // How easily it smudges
    
    FUNCTION InitializePencil(grade):
        // Grade: "9H" to "9B" or "charcoal"
        
        IF grade == "charcoal":
            hardness = 0.1
            particleSize = 2.5
            depositRate = 0.8
            smudgeFactor = 0.9
        ELSE:
            // Parse grade (e.g., "2B", "HB", "3H")
            value = ParsePencilGrade(grade)
            
            // Map to properties
            hardness = MapRange(value, -9, 9, 0.1, 0.9)
            particleSize = MapRange(value, -9, 9, 2.0, 0.3)
            depositRate = MapRange(value, -9, 9, 0.7, 0.2)
            smudgeFactor = MapRange(value, -9, 9, 0.8, 0.2)
        END IF
    END FUNCTION
    
    FUNCTION PlacePencilStroke(position, pressure, velocity):
        // Step 1: Get paper texture at position
        paperTexture = GetPaperTexture(position, brushSize)
        
        // Step 2: Calculate particle deposit amount
        // Light pressure deposits less
        depositAmount = depositRate * pressure
        
        // Fast strokes deposit less (pencil skips over surface)
        speedFactor = 1.0 - min(velocity * 0.5, 0.5)
        depositAmount *= speedFactor
        
        // Step 3: Distribute particles based on texture
        particleDensity = CalculateParticleDensity(depositAmount, particleSize)
        
        FOR i FROM 0 TO particleDensity:
            // Random position within brush radius
            offset = RandomInCircle(brushSize)
            particlePos = position + offset
            
            // Sample paper texture at this position
            textureDepth = paperTexture.SampleDepth(particlePos)
            
            // Particles lodge in valleys (high depth)
            // Pressure affects how deep into texture we reach
            minDepth = 0.3 + pressure * 0.4
            
            IF textureDepth >= minDepth:
                // Calculate particle darkness
                // Deeper valleys get darker deposits
                darkness = (textureDepth - minDepth) / (1.0 - minDepth)
                darkness *= (1.0 - hardness)  // Softer pencils darker
                
                // Place particle
                particleAlpha = 0.1 + darkness * 0.6
                particleRadius = particleSize * (0.5 + Random() * 0.5)
                
                DrawParticle(particlePos, particleRadius, 
                            graphiteColor, particleAlpha)
            END IF
        END FOR
        
        // Step 4: Add subtle blending between strokes
        IF smudgeFactor > 0.3:
            ApplySubtleSmudge(position, smudgeFactor * 0.3)
        END IF
    END FUNCTION
    
    FUNCTION CalculateParticleDensity(depositAmount, size):
        // More deposit = more particles
        // Larger particles = fewer needed for same coverage
        
        baseDensity = 100  // Particles per unit area
        sizeFactor = 1.0 / (size * size)
        
        density = baseDensity * depositAmount * sizeFactor
        
        RETURN floor(density)
    END FUNCTION
    
    FUNCTION ApplySubtleSmudge(position, amount):
        // Simulate slight smudging/blending of graphite
        
        FOR EACH pixel IN GetRadius(position, brushSize):
            // Sample surrounding pixels
            neighborColors = SampleNeighborhood(pixel, 2)
            
            // Average with slight bias to darker values
            // (graphite smudges darker)
            avgColor = WeightedAverage(neighborColors, "darker")
            
            // Blend very subtly
            currentColor = GetPixel(pixel)
            newColor = Lerp(currentColor, avgColor, amount * 0.2)
            
            SetPixel(pixel, newColor)
        END FOR
    END FUNCTION
END CLASS

Implementing Specialized Pencil Techniques

1. Cross-Hatching Simulation

FUNCTION CrossHatch(position, direction, density, pressure):
    // Two sets of parallel lines at angles
    
    angle1 = direction
    angle2 = direction + 60  // 60-degree cross
    
    lineCount = 5 + density * 15
    lineSpacing = brushSize / lineCount
    
    FOR angle IN [angle1, angle2]:
        perpendicular = RotateVector(direction, 90)
        
        FOR i FROM -lineCount/2 TO lineCount/2:
            // Calculate line position
            startPos = position + perpendicular * i * lineSpacing
            endPos = startPos + direction * brushSize
            
            // Draw line with pencil texture
            DrawPencilLine(startPos, endPos, pressure * 0.7)
        END FOR
    END FOR
END FUNCTION

2. Stippling (Dotwork)

FUNCTION Stipple(position, density, pressure):
    // Create tone through dots
    
    dotCount = density * 100
    dotSize = particleSize * (0.5 + pressure * 0.5)
    
    FOR i FROM 0 TO dotCount:
        // Random position in brush area
        offset = RandomInCircle(brushSize)
        dotPos = position + offset
        
        // Check paper texture
        textureDepth = GetPaperTexture(dotPos).depth
        
        IF textureDepth > 0.4:
            // Place dot
            darkness = 0.3 + pressure * 0.5
            DrawDot(dotPos, dotSize, graphiteColor, darkness)
        END IF
    END FOR
END FUNCTION

3. Blending/Smudging Tool

FUNCTION Smudge(position, direction, pressure):
    // Simulate finger or blending stump
    
    smudgeRadius = brushSize
    smudgeStrength = pressure * smudgeFactor
    
    // Sample the area to be smudged
    sourceColor = SampleArea(position, smudgeRadius)
    
    // Push color in direction of stroke
    pushDistance = smudgeRadius * pressure
    targetPos = position + direction * pushDistance
    
    // Create gradient from source to target
    FOR t FROM 0 TO 1 STEP 0.1:
        currentPos = Lerp(position, targetPos, t)
        falloff = 1.0 - t
        
        // Blend with surrounding area
        FOR EACH pixel IN GetRadius(currentPos, smudgeRadius * (1 - t * 0.5)):
            currentColor = GetPixel(pixel)
            blendedColor = Lerp(currentColor, sourceColor, 
                               smudgeStrength * falloff * 0.3)
            SetPixel(pixel, blendedColor)
        END FOR
    END FOR
END FUNCTION

🎯 The Paper Texture Trinity

Every paper texture has three key properties that affect how media behaves:

• Tooth (Roughness): The physical texture - peaks and valleys
• Absorbency: How readily it accepts wet media
• Weight: Thickness affects buckling, texture retention

Paper Types and Their Properties

📄 Procedural Paper Texture Generator

CLASS PaperTextureGenerator:
    
    FUNCTION GeneratePaperTexture(width, height, paperType):
        // Create height map representing paper surface
        heightMap = CreateGrid(width, height)
        
        SWITCH paperType:
            CASE "smooth":
                RETURN GenerateSmoothTexture(heightMap)
            CASE "cold_press":
                RETURN GenerateColdPressTexture(heightMap)
            CASE "rough":
                RETURN GenerateRoughTexture(heightMap)
            CASE "canvas":
                RETURN GenerateCanvasTexture(heightMap)
            CASE "newsprint":
                RETURN GenerateNewsprintTexture(heightMap)
        END SWITCH
    END FUNCTION
    
    FUNCTION GenerateSmoothTexture(heightMap):
        // Minimal texture - very fine grain
        
        FOR EACH pixel IN heightMap:
            // Very subtle high-frequency noise
            noise = PerlinNoise(pixel.x * 0.5, pixel.y * 0.5)
            
            // Extremely low amplitude
            height = 0.5 + noise * 0.02
            
            heightMap[pixel] = height
        END FOR
        
        // Slight blur for smoothness
        heightMap = GaussianBlur(heightMap, radius: 0.5)
        
        RETURN heightMap
    END FUNCTION
    
    FUNCTION GenerateColdPressTexture(heightMap):
        // Moderate texture - medium grain
        
        FOR EACH pixel IN heightMap:
            // Multi-octave noise for natural texture
            noise = 0
            amplitude = 1.0
            frequency = 0.05
            
            FOR octave FROM 0 TO 3:
                noise += PerlinNoise(
                    pixel.x * frequency,
                    pixel.y * frequency
                ) * amplitude
                
                amplitude *= 0.5
                frequency *= 2.0
            END FOR
            
            // Normalize
            noise = (noise + 1.0) / 2.0
            
            // Moderate amplitude
            height = 0.5 + (noise - 0.5) * 0.2
            
            heightMap[pixel] = height
        END FOR
        
        RETURN heightMap
    END FUNCTION
    
    FUNCTION GenerateRoughTexture(heightMap):
        // Heavy texture - large grain
        
        FOR EACH pixel IN heightMap:
            // Low frequency, high amplitude noise
            baseNoise = PerlinNoise(
                pixel.x * 0.02,
                pixel.y * 0.02
            )
            
            // Add smaller detail
            detailNoise = PerlinNoise(
                pixel.x * 0.1,
                pixel.y * 0.1
            ) * 0.3
            
            combinedNoise = baseNoise + detailNoise
            
            // High amplitude for pronounced texture
            height = 0.5 + combinedNoise * 0.35
            
            // Add some randomness for organic feel
            height += Random(-0.05, 0.05)
            
            heightMap[pixel] = Clamp(height, 0, 1)
        END FOR
        
        RETURN heightMap
    END FUNCTION
    
    FUNCTION GenerateCanvasTexture(heightMap):
        // Regular weave pattern
        
        weaveSize = 4  // Pixels per thread
        
        FOR EACH pixel IN heightMap:
            // Determine position in weave pattern
            xPattern = floor(pixel.x / weaveSize) % 2
            yPattern = floor(pixel.y / weaveSize) % 2
            
            // Over/under weave
            IF xPattern == yPattern:
                height = 0.6  // Thread over
            ELSE:
                height = 0.4  // Thread under
            END IF
            
            // Add subtle variation
            variation = PerlinNoise(
                pixel.x * 0.1,
                pixel.y * 0.1
            ) * 0.1
            
            height += variation
            
            heightMap[pixel] = height
        END FOR
        
        // Slight blur to soften weave
        heightMap = GaussianBlur(heightMap, radius: 0.8)
        
        RETURN heightMap
    END FUNCTION
    
    FUNCTION GenerateNewsprintTexture(heightMap):
        // Rough, fibrous texture
        
        FOR EACH pixel IN heightMap:
            // Multiple scales of noise
            largeScale = PerlinNoise(
                pixel.x * 0.01,
                pixel.y * 0.01
            ) * 0.4
            
            mediumScale = PerlinNoise(
                pixel.x * 0.05,
                pixel.y * 0.05
            ) * 0.25
            
            smallScale = PerlinNoise(
                pixel.x * 0.2,
                pixel.y * 0.2
            ) * 0.15
            
            // Add fiber-like patterns
            fiberAngle = Random(0, TWO_PI)
            fiberNoise = abs(sin(
                pixel.x * cos(fiberAngle) * 0.1 +
                pixel.y * sin(fiberAngle) * 0.1
            )) * 0.2
            
            height = 0.5 + largeScale + mediumScale + 
                     smallScale + fiberNoise
            
            heightMap[pixel] = Clamp(height, 0, 1)
        END FOR
        
        RETURN heightMap
    END FUNCTION
    
    FUNCTION ApplyMediaToTexture(heightMap, mediaType, amount, position):
        // How different media interact with texture
        
        SWITCH mediaType:
            CASE "pencil":
                // Deposits in valleys
                threshold = 0.3 + amount * 0.4
                FOR EACH pixel IN GetRadius(position, brushSize):
                    IF heightMap[pixel] >= threshold:
                        DepositParticle(pixel, amount)
                    END IF
                END FOR
            
            CASE "watercolor":
                // Settles in valleys, pools
                FOR EACH pixel IN GetRadius(position, brushSize):
                    depth = 1.0 - heightMap[pixel]  // Invert for valleys
                    settleFactor = pow(depth, 2)  // Prefer deep valleys
                    DepositPigment(pixel, amount * settleFactor)
                END FOR
            
            CASE "oil":
                // Covers peaks and valleys more evenly
                FOR EACH pixel IN GetRadius(position, brushSize):
                    // Slight preference for valleys but covers well
                    coverageFactor = 0.7 + (1.0 - heightMap[pixel]) * 0.3
                    DepositPaint(pixel, amount * coverageFactor)
                END FOR
            
            CASE "dry_brush":
                // Only catches on peaks
                threshold = 0.6 - amount * 0.3
                FOR EACH pixel IN GetRadius(position, brushSize):
                    IF heightMap[pixel] < threshold:  // Peaks
                        DepositPaint(pixel, amount * 0.5)
                    END IF
                END FOR
        END SWITCH
    END FUNCTION
END CLASS

Combining Multiple Texture Layers

// Professional approach: Layer multiple textures
FUNCTION CreateRealisticPaperTexture(width, height):
    // Layer 1: Base paper fiber structure
    baseTexture = GenerateFiberTexture(width, height, 
                                       fiberLength: 20,
                                       fiberDensity: 0.3)
    
    // Layer 2: Manufacturing marks (subtle)
    manufacturingMarks = GenerateDirectionalNoise(
        width, height,
        direction: "horizontal",
        strength: 0.05
    )
    
    // Layer 3: Surface variation
    surfaceVariation = GeneratePerlinNoise(
        width, height,
        frequency: 0.02,
        amplitude: 0.1
    )
    
    // Layer 4: Micro-texture
    microTexture = GenerateHighFrequencyNoise(
        width, height,
        frequency: 0.5,
        amplitude: 0.03
    )
    
    // Combine layers
    finalTexture = baseTexture * 0.5 +
                   manufacturingMarks * 0.1 +
                   surfaceVariation * 0.3 +
                   microTexture * 0.1
    
    // Normalize to 0-1 range
    finalTexture = Normalize(finalTexture)
    
    RETURN finalTexture
END FUNCTION

🚀 State-of-the-Art Techniques

1. Real-Time Fluid Simulation (Watercolor)

// Simplified Navier-Stokes for real-time watercolor
CLASS FluidSimulator:
    velocityField = []    // Water movement
    pigmentField = []     // Pigment concentration
    
    FUNCTION Update(deltaTime):
        // Step 1: Advection (move pigment with water)
        AdvectPigment(velocityField, pigmentField, deltaTime)
        
        // Step 2: Diffusion (pigment spreads)
        DiffusePigment(pigmentField, diffusionRate, deltaTime)
        
        // Step 3: Apply external forces (gravity, paper tilt)
        ApplyForces(velocityField, deltaTime)
        
        // Step 4: Project (make velocity field divergence-free)
        ProjectVelocity(velocityField)
        
        // Step 5: Evaporation (reduce water over time)
        EvaporateWater(velocityField, evaporationRate, deltaTime)
    END FUNCTION
END CLASS

2. Height Map Lighting (Oil Paint)

// Normal mapping from height for realistic lighting
FUNCTION ApplyImpastoLighting(heightMap, lightDirection):
    FOR EACH pixel IN heightMap:
        // Calculate surface normal from height
        dhdx = heightMap[pixel + (1, 0)] - heightMap[pixel]
        dhdy = heightMap[pixel + (0, 1)] - heightMap[pixel]
        
        normal = Normalize(Vector3(-dhdx, -dhdy, 1.0))
        
        // Lambertian lighting
        light = max(0, Dot(normal, lightDirection))
        
        // Add specular highlight for wet paint
        viewDir = Vector3(0, 0, 1)  // Looking straight at canvas
        halfVector = Normalize(lightDirection + viewDir)
        specular = pow(max(0, Dot(normal, halfVector)), 32)
        
        // Apply lighting
        baseColor = GetPixelColor(pixel)
        litColor = baseColor * (0.4 + light * 0.6) + specular * 0.3
        
        SetPixelColor(pixel, litColor)
    END FOR
END FUNCTION

3. Adaptive Detail Level

// LOD for simulation based on zoom
FUNCTION GetSimulationQuality(zoomLevel):
    IF zoomLevel > 200%:
        // Zoomed in - maximum detail
        RETURN {
            particleDensity: 1.0,
            textureResolution: "high",
            simulationSteps: 10
        }
    ELSE IF zoomLevel > 100%:
        // Normal view - balanced
        RETURN {
            particleDensity: 0.7,
            textureResolution: "medium",
            simulationSteps: 5
        }
    ELSE:
        // Zoomed out - optimize
        RETURN {
            particleDensity: 0.4,
            textureResolution: "low",
            simulationSteps: 2
        }
    END IF
END FUNCTION

Combining Pre-computation with Real-time

Professional approach: Pre-compute expensive parts, simulate simple parts in real-time

// Example: Watercolor system
CLASS HybridWatercolorSimulator:
    
    // Pre-computed data (loaded once)
    paperTextureMap = null
    flowPotentialField = null
    granulationPattern = null
    
    // Real-time state
    wetMap = []
    pigmentMap = []
    
    FUNCTION Initialize():
        // OFFLINE: Generate once, save to disk
        paperTextureMap = GeneratePaperTexture()
        flowPotentialField = CalculateFlowField(paperTilt)
        granulationPattern = GenerateGranulationTexture()
        
        // These never change during painting!
    END FUNCTION
    
    FUNCTION PaintStroke(position, color, pressure):
        // REAL-TIME: Fast, simple operations
        
        // 1. Sample pre-computed flow
        flowDirection = SampleFlowField(position)
        
        // 2. Add water and pigment
        wetMap[position] += pressure * 0.5
        pigmentMap[position] = BlendColor(
            pigmentMap[position],
            color,
            pressure
        )
        
        // 3. Simple diffusion (few iterations)
        FOR i FROM 0 TO 3:  // Only 3 steps!
            SimpleDiffusion(pigmentMap, wetMap, flowDirection)
        END FOR
        
        // 4. Sample pre-computed granulation
        IF IsGranulatingPigment(color):
            granulation = SampleGranulation(position, pressure)
            ApplyGranulation(position, granulation)
        END IF
        
        // Total: ~5ms per stamp (plenty fast enough!)
    END FUNCTION
END CLASS

🌟 The Hybrid Philosophy

Why choose? Use traditional media for what it does best (happy accidents, natural texture, tactile experience) and digital for its strengths (undo, layers, iteration speed). The combination is more powerful than either alone!

Workflow 1: Traditional Sketch → Digital Painting

Steps:
1. Pencil sketch on paper (fast, intuitive)
2. Scan at high resolution (600+ DPI)
3. Clean up and enhance in digital
4. Paint over using simulated media
5. Preserve sketch texture underneath

Advantages:
✓ Natural, expressive sketching
✓ Digital flexibility for painting
✓ Best of both worlds

Workflow 2: Digital Underpaint → Traditional Finish

Steps:
1. Block in composition digitally (fast iteration)
2. Establish values and colors digitally
3. Print on watercolor paper (giclee)
4. Paint over with real watercolor
5. Rescan for final digital adjustments

Advantages:
✓ Fast digital planning
✓ Real watercolor texture
✓ Authentic traditional feel

Workflow 3: Traditional Texture Library

Steps:
1. Create real media swatches:
   - Watercolor washes
   - Pencil textures
   - Oil paint marks
2. Scan at high resolution
3. Extract as brush textures
4. Use in digital brushes

Advantages:
✓ Authentic texture
✓ Reusable assets
✓ Consistent quality

Creating Custom Brushes from Traditional Media

// Process real media samples into brushes
FUNCTION CreateBrushFromScan(scanPath):
    // 1. Load scanned image
    image = LoadImage(scanPath)
    
    // 2. Convert to grayscale
    grayImage = ConvertToGrayscale(image)
    
    // 3. Adjust levels for clean extraction
    grayImage = AdjustLevels(grayImage,
                            blackPoint: 30,
                            whitePoint: 225)
    
    // 4. Extract alpha channel
    alphaChannel = ExtractAlpha(grayImage)
    
    // 5. Create brush tip
    brushTip = CreateBrushTip(alphaChannel,
                              size: 512)
    
    // 6. Analyze for dynamics
    properties = AnalyzeBrushProperties(brushTip)
    // Properties: grain size, directional bias, density
    
    // 7. Configure brush based on analysis
    brush = CreateBrush(
        tip: brushTip,
        spacing: properties.optimalSpacing,
        scatter: properties.naturalScatter,
        texture: properties.grainPattern
    )
    
    RETURN brush
END FUNCTION

What to Submit

1. Final Artworks (6-8 pieces)

• High-resolution exports (300 DPI minimum)
• Both full resolution and web-optimized versions
• Properly titled and dated

2. Process Documentation

For Each Artwork:
├── Progress shots (3-5 stages)
├── Brush settings screenshots
├── Layer breakdown (if applicable)
├── Time-lapse video (optional but recommended)
└── Notes on challenges and solutions

3. Technical Breakdown Document

Document Structure (per artwork):

ARTWORK TITLE
└── Medium & Approach
    ├── Traditional medium simulated
    ├── Custom brushes used (list with descriptions)
    ├── Paper texture choice and why
    └── Overall strategy
    
└── Technical Details
    ├── Brush algorithms implemented
    ├── Special techniques used
    ├── Performance considerations
    └── Problems solved
    
└── Artistic Choices
    ├── Why this subject for this medium
    ├── Color palette decisions
    ├── Composition notes
    └── Reference images (if used)
    
└── Authenticity Analysis
    ├── Traditional behaviors replicated
    ├── Digital advantages utilized
    ├── Hybrid aspects (if any)
    └── How convincing is the simulation?

4. Custom Brush Pack

• All custom brushes created for this project
• Organized by medium
• Named consistently
• Include usage notes

5. Reflection Essay (1000-1500 words)

• What you learned about each medium
• Challenges in simulating traditional media
• Insights gained about digital vs traditional
• Future directions for your work
• How this project developed your skills

📅 Recommended 6-Week Schedule

Week 1: Setup & Research
├── Study traditional media (online resources, books)
├── Gather reference images
├── Test brush creation for each medium
├── Create paper texture library
└── Plan each piece (sketches, concepts)

Week 2: Watercolor & Oil Studies
├── Complete watercolor piece (2-3 days)
├── Complete oil paint piece (3-4 days)
├── Document process thoroughly
└── Begin technical writeups

Week 3: Pencil & Charcoal Studies
├── Complete pencil/graphite piece (2-3 days)
├── Complete charcoal piece (2-3 days)
├── Refine brush settings based on results
└── Continue documentation

Week 4: Choice Studies
├── Complete first choice medium (2-3 days)
├── Complete second choice medium (2-3 days)
├── Review all work so far
└── Make adjustments as needed

Week 5: Hybrid Study & Refinement
├── Complete hybrid piece (3-4 days)
├── Final refinements to all pieces
├── Ensure consistency across series
└── Complete all progress documentation

Week 6: Documentation & Presentation
├── Finalize technical breakdowns
├── Write reflection essay
├── Organize brush pack
├── Create presentation materials
└── Final review and submission prep

💡 Pro Tips for Success

Before You Start:

• 🎨 Study the real thing: Watch videos of artists using traditional media. Notice the accidents, happy mistakes, and natural behaviors
• 📚 Build a reference library: Collect images of real traditional media artwork. What makes them look authentic?
• 🖌️ Test extensively: Create test swatches with each brush before starting finished work
• 📝 Document everything: Take screenshots at every stage. Future you will thank you!

During Creation:

• ⏱️ Don't rush: Traditional media has a natural pace. Slow down and let the simulation breathe
• 🎯 Embrace imperfection: Traditional media isn't perfect. A too-clean result screams "digital!"
• 🔄 Iterate on brushes: Adjust your brushes as you paint. They'll improve with use
• 💾 Save versions: Keep major stages saved separately. You might want to backtrack
• 👀 Zoom out often: Judge your work at actual size, not zoomed in

For Authenticity:

• ✨ Add happy accidents: Real media has unexpected bleeds, drips, smudges. Add them intentionally!
• 🎨 Respect the medium: Each traditional medium has limitations. Honor them in your simulation
• 📄 Show the paper: Let paper texture be visible. Covering every pixel makes it look digital
• 🖼️ Consider the edges: Real artwork on paper has organic edges. Don't make everything perfectly rectangular
• ⏳ Simulate drying time: Work in stages like you would with real media. Don't do everything at once

⚠️ Common Pitfalls to Avoid

• ❌ Too clean: Digital-perfect results don't look traditional
• ❌ Wrong paper choice: Watercolor on smooth paper, pencil on canvas - respect media-paper pairings
• ❌ Over-blending: Especially in watercolor - leave some hard edges!
• ❌ Ignoring texture: Paper texture should be visible and interactive
• ❌ Perfect symmetry: Traditional media is organic and asymmetric
• ❌ Digital shortcuts visible: Perfect circles, ruler-straight lines, obvious gradients
• ❌ Inconsistent lighting: Impasto should show dimensional lighting
• ❌ Wrong color mixing: Use RYB for traditional media, not RGB!

🎯 Mastery Achievements Unlocked!

Congratulations on completing this deep dive into organic simulation! You've gained expertise that few digital artists possess:

• ✅ Watercolor physics and fluid dynamics
• ✅ Oil paint mixing and impasto simulation
• ✅ Pencil and charcoal particle systems
• ✅ Paper texture generation and interaction
• ✅ Real-time simulation techniques
• ✅ Multi-layer rendering systems
• ✅ RYB color space for authentic mixing
• ✅ Height map lighting for 3D paint
• ✅ Hybrid digital-traditional workflows
• ✅ Advanced texture integration
• ✅ Performance-optimized simulation
• ✅ Professional media replication

🎨 The Philosophy of Simulation

"Perfect simulation isn't about copying appearance - it's about understanding and recreating behavior. When you understand why watercolor bleeds, why oil paint layers, and why pencil catches on texture, you can create something that feels authentic at a fundamental level."

Core Principles to Remember:

1. Physics drives appearance: Understand the physical/chemical processes, simulate the results
2. Imperfection is authentic: Real media has randomness, accidents, and organic variation
3. Texture is functional: Paper texture isn't decoration - it governs how media deposits
4. Layering matters: Traditional media is built up in layers. Simulate the process, not just the result
5. Respect limitations: Each medium has constraints. Working within them creates authenticity
6. Optimize intelligently: Pre-compute expensive parts, simulate simple parts in real-time
7. Hybrid is powerful: Combine digital and traditional for best results

📚 Essential Reading

Traditional Media Technique:

• "Watercolor Painting: A Comprehensive Approach" by Edgar Whitney
• "Oil Painting Techniques and Materials" by Harold Speed
• "The Natural Way to Draw" by Kimon Nicolaïdes
• "Keys to Drawing" by Bert Dodson
• "Color and Light" by James Gurney (color mixing theory)

Simulation & Technical:

• "Real-Time Fluid Dynamics for Games" by Jos Stam
• "Simulating Decorative Mosaics" by Alejo Hausner (texture algorithms)
• "Painterly Rendering for Animation" - various SIGGRAPH papers
• "Fluid Simulation for Computer Graphics" by Robert Bridson
• "Digital Painting Techniques" vol. 1-8 by 3DTotal

Academic Papers (Free Online):

• "Computer-Generated Watercolor" - Cassidy Curtis et al.
• "Real-Time Watercolor Painting on Virtual Canvas" - Lei & Chang
• "Simulating Charcoal and Pastel" - Takagi et al.
• "Oil Paint Simulation" - Baxter et al.

🔗 Online Resources

Video Learning:

• Ctrl+Paint - Digital painting fundamentals (free)
• New Masters Academy - Traditional media techniques
• Proko - Figure drawing and traditional skills
• YouTube: Search for traditional medium demonstrations

Technical Communities:

• Polycount - Technical art forums
• CGSociety - Digital art community
• ConceptArt.org - Focused on digital painting
• Reddit: r/DigitalPainting, r/learnart

Tools for Experimentation:

• Processing/p5.js - Algorithm prototyping
• Shadertoy - Visual effect testing
• Krita - Open source with advanced brush engine
• Rebelle - Specialized realistic media simulation software

🚀 Continue Your Journey

Immediate Next Steps:

1. Complete the traditional media study series project
2. Build a personal library of traditional texture samples
3. Create brush packs for each medium
4. Study masterworks in traditional media (what makes them work?)
5. Experiment with hybrid workflows in your own projects

Advanced Challenges:

• Implement real-time fluid simulation for watercolor
• Create a full impasto lighting system
• Build a procedural paper texture generator
• Develop a color mixing system using real pigment models
• Create brushes that respond to canvas tilt (using device sensors)
• Implement dry-time simulation (paint behavior changes over time)

Next Lesson Preview:

In Lesson 1.3: Procedural Art Systems, we'll explore generative and rule-based painting systems. Learn to create brushes that paint complex subjects automatically, pattern-based workflows, and fractal/noise-driven art generation!

🎓 From Simulation to Innovation

You've learned to recreate centuries of traditional media digitally. But here's the exciting part: you're not limited to simulation! Now that you understand these systems deeply, you can invent new media that could never exist physically. Watercolor that flows upward. Oil paint that changes color over time. Pencil that responds to music. The principles you've learned are the foundation for creative innovation.

Traditional media taught us what's possible with atoms and molecules. Digital simulation teaches us what's possible with algorithms and imagination. The future of art is in your hands - create something that has never existed before!

🌟 Share Your Traditional Media Studies!

When you complete your series, share it with the community! Tag your work with #DigitalTraditionalMedia and #OrganicSimulation to connect with other artists pushing the boundaries of authentic simulation.

Challenge: Can you fool traditional artists into thinking your work is traditional? That's the ultimate test!