### Inno Setup Build Process

Source: https://github.com/tixl3d/tixl/blob/main/Installer/README.md

Steps to use Inno Setup to compile the installer script. This involves opening the 'installer.iss' file with the Inno Setup application and initiating the build process.

```Shell
# Download and install Inno Setup from jrsoftware.org
# Open Installer\installer.iss with Inno Setup
# Click the blue play button to start the build process
```

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

### Run install.bat for Dependencies

Source: https://github.com/tixl3d/tixl/wiki/help.Installation

Executes the install.bat script to resolve build dependencies and initialize default view layouts. This script is crucial after cloning the repository, especially if the solution was cleaned.

```batch
install.bat
```

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

### Tooll3 Project Build and Installer Setup

Source: https://github.com/tixl3d/tixl/blob/main/Installer/README.md

Instructions for setting up the Tooll3 project for building and preparing the installer environment. This includes cloning the repository, building the project in release mode, and downloading necessary dependencies like the .NET SDK and Visual C++ Redistributable.

```Bash
git clone git@github.com:tooll3/t3.git
cd t3
git checkout main
# Open in Rider or Visual Studio
# Ensure Release mode is selected
# Rebuild the solution
```

```Batch
REM Download .NET SDK
REM Download VC_redist.x64.exe
REM Place downloaded files in Installer\dependencies\downloads\
```

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

### TiXL Startup and Project Creation

Source: https://github.com/tixl3d/tixl/wiki/help.Introduction

Describes the initial steps to start TiXL, set up a user profile, and create a new project. It outlines the basic workflow for beginning a new creative coding session.

```APIDOC
TiXL Workflow:

1. Installation:
   - Download the latest version from GitHub releases.
   - Unzip the archive.
   - Run the executable (e.g., StartT3 on Windows).

2. Initial Setup:
   - Upon startup, TiXL prompts for a nickname to structure projects.
   - The 'home canvas' is created with comments and example operators.

3. Project Creation:
   - To start from scratch, use the menu: "Project" -> "New".
   - This generates a new, empty project canvas.
```

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

### Install and Build Tixl Project

Source: https://github.com/tixl3d/tixl/wiki/dev.VisualStudioCodeSetup

Commands to clone the Tixl3D repository, navigate to the install directory, run the installation script, and build the Player project using the .NET CLI.

```bash
cd Install
.\install.bat
cd ..
dotnet.exe build /p:Configuration=Release Player
```

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

### Installer Directory Structure

Source: https://github.com/tixl3d/tixl/blob/main/Installer/README.md

Illustrates the expected file and folder structure for the Tooll3 installer, showing the location of the built project output and the downloaded dependencies required by the Inno Setup script.

```Shell
Editor\bin\Release\net9.0-windows\

Installer\dependencies\downloads\dotnet-sdk-9.0.203-win-x64.exe
Installer\dependencies\downloads\VC_redist.x64.exe
```

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

### TiXL Live Patching Setup Steps

Source: https://github.com/tixl3d/tixl/wiki/help.LivePerformances

A step-by-step guide to setting up TiXL for live patching. This involves connecting hardware, configuring display settings, launching TiXL, creating or opening a project, enabling the second render window, adjusting output resolution, and pinning an operator to the output panel.

```text
1. Connect USB controllers.
2. Connect the second display.
3. Extend display (Windows-Key+P).
4. Set secondary display resolution to 1920x1080x60fps via Display Settings.
5. Start TiXL (Release mode recommended from IDE).
6. Open existing project or create a new one ('New → Empty Project').
7. Enable 'Window → 2nd Render Window'.
8. Adjust output resolution in the output panel toolbar to '1080p' (or desired resolution).
9. Switch to full-screen mode (View → Fullscreen).
10. Create an operator with a texture output (e.g., [RyojiPattern2]).
11. Pin the operator to the output panel (pin icon or 'P' key).
```

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

### TiXL Operator Examples and Descriptions

Source: https://github.com/tixl3d/tixl/wiki/help.Introduction

Covers how to access and use example code snippets provided within operator descriptions in TiXL. This allows users to quickly learn and implement functionalities.

```APIDOC
Operator Examples:

- Accessing Examples:
  - Many operators include a short description and a small example.
  - These are typically found below the parameters in the Parameter Window.

- Using Examples:
  - Drag the example code directly onto the canvas.
  - This allows users to study the implementation and integrate it into their projects.
```

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

### Clone TiXL Repository (HTTPS)

Source: https://github.com/tixl3d/tixl/wiki/help.Installation

Clones the TiXL project repository from GitHub using HTTPS. This method is suitable for users who prefer not to use SSH or have not set up SSH keys.

```git
git clone git@github.com:tixl3d/tixl.git
```

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

### Install TiXL (Earlier Releases) with Bottles

Source: https://github.com/tixl3d/tixl/wiki/help.InstallLinux

Steps to install TiXL for earlier releases on Linux using Bottles. This involves setting up a Wine prefix, installing necessary Windows dependencies like .NET 6, downloading TiXL, placing it within the Wine prefix's file system, and running the startT3.exe executable.

```bash
# 1. Install Wine (e.g., using Bottles)
# Follow Flatpak setup if not preinstalled: https://www.flatpak.org/setup/

# 2. Start a Wine prefix in Bottles (e.g., 'Gaming' preset)
# This installs Windows 10, DXVK, VKD3D, DX9 DLLs, Microsoft Line Services, Arial, Times New Roman.

# 3. Install .NET Dependency
# Run 'dotnetcoredesktop6' from Dependencies list in Bottles or download SDK manually.
# Example command (conceptual, run within prefix context if possible):
# "/path/to/dotnet-sdk-6.0.403-win-x64.exe" /SILENT /VERYSILENT /SUPPRESSMSGBOXES

# 4. Download TiXL and extract into the Wine prefix
# Navigate to Bottles -> Prefix -> Browse Files (C Drive)
# Example: Save extracted tool3.8.1 directory in C:/users/Documents

# 5. Run startT3.exe with Bottles
# Select 'Run Executable...' and navigate to the startT3.exe file within the prefix.
# Path example: ~/.var/app/com.usebottles.bottles/data/bottles/bottles/<prefix_name>/drive_c/users/Documents/tool3.8.1/startT3.exe

# 5(a). Alternative: Run startT3.exe via Bottles file browser
# Open Bottles, select prefix, click 3 dots -> 'Browse Files', navigate to C Drive, find startT3.exe and double-click.
```

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

### Install TiXL v4.0 with Bottles

Source: https://github.com/tixl3d/tixl/wiki/help.InstallLinux

Instructions for installing TiXL version 4.0 on Linux using Bottles. This process includes setting up a Wine prefix, installing PowerShell Core, downloading the TiXL installer (.exe), placing it within the prefix, running the installer, and launching TiXL.

```bash
# 1. Install Bottles (Flatpak or distro package manager)

# 2. Start a new Wine prefix in Bottles ('Gaming' preset, e.g., soda-9.0-1 runner)

# 3. Install Dependencies in Bottles
# Go to Options > Dependencies and install 'powershell_core'

# 4. Download TiXL installer (.exe) from releases

# 5. Place installer in Wine prefix
# In Bottles, click 3 dots -> 'Browse Files...' (this is your prefix's C: drive).
# Example: Save installer in $WINE_PREFIX/drive_c/users/Public/Desktop/

# 6. Run TiXL installer via Bottles
# Click 'Run Executable...' and select the downloaded TiXL installer.
# This should also install the .NET 9 SDK.

# 7. Launch TiXL
# Allow automatic launch or run executable via Bottles.
# Default location: $WINE_PREFIX/drive_c/TiXL/

# 8. Add Desktop Entry
# Click 3 dots next to program entry -> 'Add Desktop Entry'.
```

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

### Vertex and Pixel Shader Setup

Source: https://github.com/tixl3d/tixl/wiki/help.ShaderDevelopmentExample

Consolidated setup for vertex and pixel shaders, connecting necessary resources like shaders, constant buffers, SRVs, and samplers. This approach avoids redundant connections compared to separate stage operators.

```TixlNode
[SetupVertexAndPixelShaderStages] operator.

VertexShader: Resources\user\pixtur\research\1000Images\DrawPhotoMosaicBillboards.hlsl (EntryPoint: vsMain)
Constant Buffers:
- [FloatsToBuffer] for sprite 'Size' parameter.
- [TransformConstantBuffer] for transform matrices.
Shader Resource Views (SRVs):
- [GetBufferComponents] for point buffer SRV.
- [SrvFromTexture2D] for TextureArray and reference image SRVs.
Samplers:
- "ClampedSampler"
- "PointSampler" (for no blending between image indices)
```

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

### Checking Installed .NET SDK Versions

Source: https://github.com/tixl3d/tixl/wiki/dev.TixlVsTooll3

Shows how to list installed .NET SDK versions using the `dotnet --list-sdks` command. This is useful for diagnosing build issues related to SDK compatibility, especially when a specific version is required by the project.

```console
dotnet --list-sdks

5.0.302 [C:\Program Files\dotnet\sdk]
6.0.302 [C:\Program Files\dotnet\sdk]
6.0.401 [C:\Program Files\dotnet\sdk]
8.0.201 [C:\Program Files\dotnet\sdk]
8.0.300 [C:\Program Files\dotnet\sdk]
```

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

### Clone TiXL Repository (SSH)

Source: https://github.com/tixl3d/tixl/wiki/help.Installation

Clones the TiXL project repository from GitHub using SSH. This method is recommended for users with a GitHub account and SSH keys configured for secure access.

```git
git clone git@github.com:tixl3d/tixl.git
```

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

### TiXL Audio Reaction Setup

Source: https://github.com/tixl3d/tixl/wiki/help.LivePerformances

Steps to configure audio input settings for a project in TiXL, including selecting external audio devices and adjusting gain levels. It also outlines connecting the AudioReaction operator to other components like SampleGradient.

```APIDOC
Operator: AudioReaction
Description: Processes audio input for reactions and effects.
Usage:
1. Create an [AudioReaction] operator.
2. Connect its output to a [SampleGradient] operator.
3. Connect the color output of [SampleGradient] to a parameter of a visible operator.

Experiment with OutputMode (Pulse, Level, AccumulatedLevel) and inserting operators like [Damp] or [Multiply] for advanced control.

Related Operators:
- SampleGradient: Processes color data from audio input.
- Damp: Smooths out parameter changes.
- Multiply: Scales parameter values.
- MidiInput: Can control parameters like the strength of a Multiply operator.
- TriggerAnimation: Can be connected to the .WasHit output of AudioReaction.
```

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

### Time Operator Documentation

Source: https://github.com/tixl3d/tixl/wiki/dev.OperatorConventions

Documents the 'Time' operator, which returns the current time from the context, typically in bars. It details various time representations, parameter explanations, and usage tips for syncing animations and managing playback time.

```APIDOC
Time Operator:
  Description: Returns the current time from the "context". In most situations, this will be the playback time in bars (not seconds!) as a number. This could also be overridden by [SetCommandTime], [TimeClip], during beat tapping, or during rendering an image sequence. TiXL uses bars to represent time, allowing easy syncing of animations to varying soundtracks or BPM rates. At 120 Beats per Minute, 1 bar is equivalent to 2 seconds.
  Tips:
    - Add a [Modulo] or other math operators to repeat a time range.
    - Consider using [AnimValue] for other deterministic time values.
    - If you want to restart the timer during playback, try the [Modulo] operator.
    - Consider [RunTime] to get the time since application start.
  AKA: clock, seconds, bars

Parameters:
  Mode:
    Description: Selects the time representation used.
    Options:
      - LocalFxTimeInBars: Use context time in bars (not seconds!) with applied Idle Motion.
      - LocalTimeInBars: Use context time, without Idle Motion.
      - LocalTimeInSec: Use the current BPM to convert to seconds.
      - PlaybackTimeInBars: Ignore time overrides.
  SpeedFactor:
    Description: This parameter is equivalent to appending a [Multiply] operator. Note that animating this will probably result in very rapid changes. You might consider [Accumulator] to achieve smooth but non-deterministic changes in animation speed.
```

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

### Art-Net to DMX Script Example

Source: https://github.com/tixl3d/tixl/wiki/help.ArtnetAndDMX

References a Python script for converting Art-Net to DMX, useful for testing with FTDI converters or when TiXL doesn't directly support USB DMX output.

```Python
# Example usage of an Art-Net to DMX script
# This script is not provided directly, but referenced for functionality.
# See: https://github.com/nt2ds/ArtNetDMX

# import artnet_dmx_script

# # Assuming the script is imported or run separately
# # Connect to a DMX converter and send Art-Net data
# artnet_dmx_script.send_dmx_data(universe, dmx_channels)
```

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

### TiXL Custom Operator C# Code

Source: https://github.com/tixl3d/tixl/wiki/(wip)-Your-first-C

Example C# code for a TiXL operator that processes an input string, replacing occurrences of 'TiXL' with 'Tooolll'. It defines an output slot and implements the update logic.

```csharp
        [Output(Guid = "42aab94d-c2d4-4334-8312-8bd74d83f5df")]
        public readonly Slot<string> overdone = new Slot<string>();

        public new_operator()
        {
            overdone.UpdateAction = Update;
        }

        private void Update(EvaluationContext context)
        {
            var inString = InputText.GetValue(context);
            overdone.Value = inString.Replace("TiXL", "Tooolll");
        }
```

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

### Art-Net Local Testing and Configuration

Source: https://github.com/tixl3d/tixl/wiki/help.ArtnetAndDMX

Provides guidance on testing Art-Net output locally and configuring network settings for Art-Net communication. It highlights potential issues with localhost and suggests tools for monitoring.

```APIDOC
ArtNetOutput:
  Local IP Address: string
    Set to your actual local IP address (e.g., 192.168.X.X) when running Art-Net locally.
    Avoid using 127.0.0.1 (localhost) as Art-Net does not play nicely with it.

Light Configuration:
  DMX Mode: string
    Lights may need to be configured into 'DMX mode' to function correctly.
  Channel Size: integer
    Ensure an appropriate channel size is set for the lights.
    Improperly configured channel sizes can lead to unexpected behavior.

Monitoring Tools:
  QLC+:
    Can be used to accept TiXL Art-Net output and pipe it to different devices.
    Also capable of monitoring Art-Net traffic.
  The ArtNetominator:
    A dedicated tool for monitoring Art-Net traffic.
```

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

### PlayVideoClip Command Documentation

Source: https://github.com/tixl3d/tixl/wiki/operators/Lib.io.video.PlayVideoClip

Details the __PlayVideoClip__ command for loading and playing video files. It specifies input parameters like file path, volume, and resync threshold, and outlines the output types: a Texture2D and a Command TimeSlot.

```APIDOC
__PlayVideoClip__

Implementation to load and play Videofiles with similar options like a [TimeClip].
Also see [PlayVideo] and [PlayVideoExample] for an operator with more options.

Input Parameters:
  Command (Command): -
  Path (String): Path to the videofile
  Volume (Single): Defines the volume of the sound output
  ResyncThreshold (Single): Threshold for timing resyncing

Outputs:
  Texture (T3.Core.DataTypes.Texture2D): -
  TimeSlot (T3.Core.DataTypes.Command): -
```

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

### Install MSDF BMFont Converter

Source: https://github.com/tixl3d/tixl/wiki/help.AddingFonts

Installs the `msdf-bmfont-xml` command-line tool globally using npm. This tool is essential for generating MSDF font atlases from TrueType fonts.

```bash
npm install msdf-bmfont-xml -g
```

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

### Chunk Instancing Example Output

Source: https://github.com/tixl3d/tixl/wiki/operators/Lib.point.draw.ChunkInstancingExample

This section describes the output of the ChunkInstancingExample. It specifies that the primary output is an update command of type T3.Core.DataTypes.Command, which is used to prepare draw mesh chunks at points.

```APIDOC
ChunkInstancingExample:
  Description: Prepare draw mesh chunks at points.
  Outputs:
    __Update__: T3.Core.DataTypes.Command
```

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

### TiXL Operators for Live Performance

Source: https://github.com/tixl3d/tixl/wiki/help.Introduction

Documentation for key TiXL operators used in live performance scenarios. This includes controlling animation playback, syncing, and reacting to external inputs like audio and MIDI.

```APIDOC
Operator: AudioReaction
  Description: Processes audio input to generate animation signals.
  Features:
    - Input: Audio device selection.
    - Sync Mode: Supports 'tapping' for manual beat synchronization.
    - Controls:
      - Ctrl+Drag: Adjust detection range and threshold.
    - Outputs:
      - Detected signals for animation.
      - "Was Hit" output for event triggering.
    - Options: Extensive settings for signal output and processing.

Operator: TriggerAnim
  Description: Triggers animations based on input signals, often used in conjunction with other operators like AudioReaction.
  Usage:
    - Can be fed signals from AudioReaction's "Was Hit" output.
    - Can be combined with noise generators for effects like camera shake.

Parameter Control via MIDI:
  Description: Allows controlling animation parameters using MIDI controllers.
  Steps:
    1. Click on the parameter input.
    2. Select '[MIDI Input]' from the context menu.
  Behavior:
    - Automatically picks the first active MIDI controller.
    - Offers options for smoothing, output range, and other settings.

Syncing and Time:
  Description: TiXL's time is based on the BPM rate, allowing AnimValues to sync to tracks.
  Features:
    - Sync Mode: Can be set to 'tapping'.
    - Timeline Sync: Tap beats with a sync button.
    - Measure Sync: Resync the start of a measure via right-click.
    - Refinement: Adjust syncing and rate by resyncing measures later.

Focus Mode:
  Description: Switches to a UI-less view for direct parameter interaction.
  Activation:
    - Press F12.
  Features:
    - Displays parameters directly at the selected operator.
    - Provides access to presets and documentation.
    - Play icon renders output to the background.

2nd Render View:
  Description: Enables outputting the final image to a second display.
  Activation:
    - Enable the "2nd render view" option (requires a second display attached).
```

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

### Batch File for Windowed Mode

Source: https://github.com/tixl3d/tixl/wiki/help.ExportExecutables

An example batch file demonstrating how to launch `Player.exe` with specific command-line arguments for windowed mode and resolution.

```batch
Player.exe --width 1280 --height 720 --windowed true
```

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

### Update Installer Version in ISS File

Source: https://github.com/tixl3d/tixl/wiki/dev.TixlVsTooll3

Updates the MyAppVersion and MyAppName defines in the Installer.iss script to reflect the new release version. This ensures the installer correctly identifies and packages the new build.

```c
#define MyAppVersion "4.0.2.1"
#define MyAppName "TiXL-v4.0.2.1"

```

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

### Troubleshooting TiXL Shader Compilation Issues

Source: https://github.com/tixl3d/tixl/wiki/help.InstallLinux

Guidance for resolving TiXL crashes or shader compilation failures when selecting a shader operator. The solution involves installing a specific DLL dependency within the Wine environment.

```bash
# If TiXL launches but crashes or fails to compile shaders:
# Install d3dcompiler_46.dll from the Dependencies list in Bottles.
```