[docs] Various docs fixes

Author: jeremyfa

runtime/src/ceramic/Lazy.hx

@@ -2,50 +2,45 @@ package ceramic;
 
 /**
  * Interface for implementing lazy initialization of properties in Ceramic classes.
- * 
+ *
  * When a class implements the Lazy interface, properties marked with `@lazy` metadata
  * will be initialized only when first accessed, not when the object is created.
  * This can improve performance by deferring expensive computations or object allocations
  * until they are actually needed.
- * 
+ *
  * The lazy initialization is implemented through compile-time code generation using
  * the LazyMacro build macro, which transforms lazy properties into getter methods
  * with initialization logic.
- * 
+ *
  * Example usage:
  * ```haxe
  * class MyClass implements Lazy {
- *     
+ *
  *     // This heavy texture atlas will only be loaded when first accessed
  *     @lazy public var atlas:TextureAtlas = TextureAtlas.fromTexture(heavyTexture);
- *     
+ *
  *     // Expensive computation deferred until needed
  *     @lazy public var complexData:Array<Float> = computeExpensiveData();
- *     
- *     // Can also use lazy initialization with function syntax
- *     @lazy function expensiveObject():ExpensiveObject {
- *         trace("Creating expensive object...");
- *         return new ExpensiveObject();
- *     }
  * }
- * 
+ *
  * // Usage:
  * var obj = new MyClass(); // No lazy properties initialized yet
  * var atlas = obj.atlas;   // Now the atlas is loaded
  * var data = obj.complexData; // Now the data is computed
  * ```
- * 
+ *
  * Benefits:
  * - Faster object creation when not all properties are immediately needed
  * - Reduced memory usage when some properties may never be accessed
- * - Automatic thread-safe initialization (single initialization guaranteed)
+ * - Automatic initialization (single initialization guaranteed)
  * - Clean syntax without manual lazy initialization boilerplate
- * 
+ *
  * Limitations:
  * - Only works with instance properties, not static properties
  * - The initialization expression is evaluated in the context of first access
  * - Cannot be used with properties that have custom getters/setters
- * 
+ * - Not thread safe: should be used on objects that are tied to a single thread
+ *
  * @see ceramic.macros.LazyMacro The macro that implements lazy initialization
  */
 #if (!macro && !completion && !display)

runtime/src/ceramic/Visual.hx

@@ -1221,6 +1221,7 @@ class Visual extends #if ceramic_visual_base VisualBase #else Entity #end #if pl
         }
         return clipDirty;
     }
+
     /**
      * If set, the visual will be rendered into this target RenderTexture instance
      * instead of being drawn onto screen directly.
@@ -1234,6 +1235,9 @@ class Visual extends #if ceramic_visual_base VisualBase #else Entity #end #if pl
         return renderTarget;
     }
 
+    /**
+     * The blending to use for this visual.
+     */
     public var blending(default,set):Blending = Blending.AUTO;
     function set_blending(blending:Blending):Blending {
         return this.blending = blending;

runtime/src/ceramic/scriptable/ScriptableAlphaColor.hx

@@ -3,31 +3,31 @@ package ceramic.scriptable;
 
 /**
  * Scriptable wrapper for AlphaColor to expose RGBA color functionality to scripts.
- * 
+ *
  * This class serves as a placeholder that gets mapped to the actual AlphaColor
  * implementation when used in scripts. It represents RGBA colors stored as a
  * single integer value, where the alpha channel is combined with RGB values.
- * 
+ *
  * In scripts, this type is exposed as `AlphaColor` (without the Scriptable prefix)
  * and provides the same functionality as ceramic.AlphaColor, including:
  * - Creating colors from RGB values and alpha
  * - Extracting RGB and alpha components
  * - Color manipulation and conversion
- * 
+ *
  * ## Usage in Scripts
- * 
- * ```hscript
+ *
+ * ```haxe
  * // Create an opaque red color
  * var red = AlphaColor.fromColor(Color.RED);
- * 
+ *
  * // Create a semi-transparent blue
  * var transBlue = AlphaColor.fromColorAndAlpha(Color.BLUE, 0.5);
- * 
+ *
  * // Extract components
  * var rgb = transBlue.color;     // Get RGB as Color
  * var alpha = transBlue.alpha;   // Get alpha value
  * ```
- * 
+ *
  * @see ceramic.AlphaColor The actual implementation
  * @see ceramic.scriptable.ScriptableColor For RGB colors without alpha
  */

runtime/src/ceramic/scriptable/ScriptableBlending.hx

@@ -2,50 +2,50 @@ package ceramic.scriptable;
 
 /**
  * Scriptable wrapper for Blending enum to expose blending modes to scripts.
- * 
+ *
  * This class provides constants representing different pixel blending modes
  * that can be used when rendering visuals. In scripts, this type is exposed
  * as `Blending` (without the Scriptable prefix).
- * 
+ *
  * Blending modes control how pixels from a source (the visual being drawn)
  * are combined with pixels from the destination (what's already on screen).
- * 
+ *
  * ## Usage in Scripts
- * 
- * ```hscript
+ *
+ * ```haxe
  * // Set a visual to use additive blending
  * myVisual.blending = Blending.ADD;
- * 
+ *
  * // Reset to default blending
  * myVisual.blending = Blending.AUTO;
  * ```
- * 
+ *
  * ## Available Modes
- * 
+ *
  * - **AUTO**: Default blending, automatically chosen by Ceramic
  * - **PREMULTIPLIED_ALPHA**: Standard premultiplied alpha blending
  * - **ADD**: Additive blending (brightens the destination)
  * - **ALPHA**: Traditional alpha blending (rarely needed)
  * - **SET**: Replace destination pixels without blending
  * - **RENDER_TO_TEXTURE**: Special mode for render textures
- * 
+ *
  * @see ceramic.Blending The actual implementation
  * @see ceramic.Visual For setting blending on visuals
  */
 class ScriptableBlending {
-    
+
     /**
      * Automatic/default blending in ceramic. Internally, this translates to premultiplied alpha blending as textures
      * are already transformed for this blending at asset copy phase, except in some situations (render to texture) where
      * ceramic may use some more specific blendings as needed.
      */
     public static var AUTO:Int = 0;
-    
+
     /**
      * Explicit premultiplied alpha blending
      */
     public static var PREMULTIPLIED_ALPHA:Int = 1;
-    
+
     /**
      * Additive blending
      */
@@ -60,7 +60,7 @@ class ScriptableBlending {
      * Blending used by ceramic when rendering to texture.
      */
     public static var RENDER_TO_TEXTURE:Int = 5;
-    
+
     /**
      * Traditional alpha blending. This should only be used on very specific cases. Used instead of `NORMAL` blending
      * when the visual is drawing a RenderTexture.

runtime/src/ceramic/scriptable/ScriptableColor.hx

@@ -2,54 +2,54 @@ package ceramic.scriptable;
 
 /**
  * Scriptable wrapper for Color to expose RGB color functionality to scripts.
- * 
+ *
  * This class provides comprehensive color manipulation features for scripts.
  * In scripts, this type is exposed as `Color` (without the Scriptable prefix)
  * and provides the same functionality as ceramic.Color.
- * 
+ *
  * Colors are represented as integers in RGB format (0xRRGGBB). You can use
  * hex values directly or create colors using various color space methods.
- * 
+ *
  * ## Usage in Scripts
- * 
- * ```hscript
+ *
+ * ```haxe
  * // Use predefined colors
  * var red = Color.RED;
  * var blue = Color.BLUE;
- * 
+ *
  * // Create from hex value
  * var purple = 0x9400D3;
- * 
+ *
  * // Create from RGB values
  * var orange = Color.fromRGB(255, 165, 0);
- * 
+ *
  * // Create from HSB (hue, saturation, brightness)
  * var cyan = Color.fromHSB(180, 1.0, 1.0);
- * 
+ *
  * // Interpolate between colors
  * var blend = Color.interpolate(red, blue, 0.5);
- * 
+ *
  * // Modify colors
  * var darkRed = Color.getDarkened(red, 0.3);
  * var lightBlue = Color.getLightened(blue, 0.3);
  * ```
- * 
+ *
  * ## Color Spaces
- * 
+ *
  * - **RGB**: Red, Green, Blue (0-255 per channel)
  * - **HSB/HSV**: Hue (0-360°), Saturation (0-1), Brightness/Value (0-1)
  * - **HSL**: Hue (0-360°), Saturation (0-1), Lightness (0-1)
  * - **CMYK**: Cyan, Magenta, Yellow, Key/Black (0-1 per channel)
  * - **HSLuv**: Perceptually uniform color space (if enabled)
- * 
+ *
  * Note that colors are stored internally as RGB, so repeated conversions
  * between color spaces may result in precision loss.
- * 
+ *
  * @see ceramic.Color The actual implementation
  * @see ceramic.scriptable.ScriptableAlphaColor For colors with alpha channel
  */
 class ScriptableColor {
-    
+
     public static final NONE:Color =        -1;
 
     public static final WHITE:Color =       0xFFFFFF;

runtime/src/ceramic/scriptable/ScriptableFlags.hx

@@ -2,56 +2,56 @@ package ceramic.scriptable;
 
 /**
  * Scriptable wrapper for Flags to expose bit flag operations to scripts.
- * 
+ *
  * This class provides utility methods for working with bit flags, which are
  * commonly used to store multiple boolean values in a single integer.
  * In scripts, this type is exposed as `Flags` (without the Scriptable prefix).
- * 
+ *
  * Bit flags allow efficient storage of up to 32 boolean values in a single
  * integer, where each bit position represents a different flag.
- * 
+ *
  * ## Usage in Scripts
- * 
- * ```hscript
+ *
+ * ```haxe
  * // Define flag positions as constants
  * var FLAG_ACTIVE = 0;      // Bit 0
  * var FLAG_VISIBLE = 1;     // Bit 1
  * var FLAG_ENABLED = 2;     // Bit 2
- * 
+ *
  * // Start with no flags set
  * var flags = 0;
- * 
+ *
  * // Set the ACTIVE flag to true
  * flags = Flags.setBoolAndGetFlags(flags, FLAG_ACTIVE, true);
- * 
+ *
  * // Set multiple flags
  * flags = Flags.setBoolAndGetFlags(flags, FLAG_VISIBLE, true);
  * flags = Flags.setBoolAndGetFlags(flags, FLAG_ENABLED, false);
- * 
+ *
  * // Check if a flag is set
  * if (Flags.getBool(flags, FLAG_ACTIVE)) {
  *     trace("Object is active");
  * }
- * 
+ *
  * // Toggle a flag
  * var isVisible = Flags.getBool(flags, FLAG_VISIBLE);
  * flags = Flags.setBoolAndGetFlags(flags, FLAG_VISIBLE, !isVisible);
  * ```
- * 
+ *
  * ## Bit Positions
- * 
+ *
  * - Bit 0: Rightmost bit, value 1
  * - Bit 1: Second bit, value 2
  * - Bit 2: Third bit, value 4
  * - And so on up to bit 31
- * 
+ *
  * @see ceramic.Flags The actual implementation
  */
 class ScriptableFlags {
 
     /**
      * Check if a specific bit flag is set.
-     * 
+     *
      * @param flags The integer containing the bit flags
      * @param bit The bit position to check (0-31)
      * @return True if the bit is set (1), false if not set (0)
@@ -65,10 +65,10 @@ class ScriptableFlags {
 
     /**
      * Set or clear a specific bit flag and return the updated flags value.
-     * 
+     *
      * This method does not modify the input flags parameter, but returns
      * a new integer with the specified bit updated.
-     * 
+     *
      * @param flags The integer containing the bit flags
      * @param bit The bit position to modify (0-31)
      * @param bool True to set the bit (1), false to clear it (0)