Interactive Shader Format (ISF)

https://docs.isf.video/
Admin
Interactive Shader Format (ISF) is a file format for describing GLSL shaders for real-time image...
Tokens:45,403
Snippets:138
Trust Score:6.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### For Loop Syntax and Example

Source: https://docs.isf.video/primer_chapter_4

Explains the structure of a 'for' loop in GLSL, which is typically counter-controlled, and provides an example of its basic usage.

```GLSL
	for (<counter variable>;<counter conditional>;<counter varying>)
	{
		//	code to be executed
	}

	float	val = 0.0;
	for (int i = 0;i < 4;i++)
	{
		val += 0.1;
	}
```

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

### ISF File Locations

Source: https://docs.isf.video/quickstart

Specifies the standard directories for installing ISF files on macOS and Windows to make them globally available to applications. Also mentions application-specific locations and online sharing platforms.

```APIDOC
MacOS:
  Global ISF files: /Library/Graphics/ISF or ~/Library/Graphics/ISF
  Application-specific ISFs: /Library/Application Support/app name or ~/Library/Application Support/app name

Windows:
  Global ISF files: /ProgramData/ISF (ideal), application-specific locations may vary.
```

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

### ISF Multi-Pass Rendering Example

Source: https://docs.isf.video/quickstart

Demonstrates multi-pass rendering in ISF, where the first pass renders to a smaller persistent buffer and the second pass scales it up. This allows for complex compositions by referencing previous render results.

```ISF
/*{
	"DESCRIPTION": "demonstrates the use of two-pass rendering- the first pass renders to a persistent buffer which is substantially smaller than the res of the image being drawn.  the second pass renders at the default requested size and scales up the image from the first pass",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		}
	],
	"PASSES": [
		{
			"TARGET":"bufferVariableNameA",
			"PERSISTENT": true,
			"WIDTH": "$WIDTH/16.0",
			"HEIGHT": "$HEIGHT/16.0"
		},
		{
		
		}
	]
	
}*/

void main()
{
	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
	if (PASSINDEX == 0) {
		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
	}
	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
	else if (PASSINDEX == 1) {
		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
	}
}
```

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

### ISF JSON Metadata Example

Source: https://docs.isf.video/primer_chapter_2

Demonstrates the JSON metadata structure required for an ISF composition, including descriptions, credits, version, categories, and input definitions.

```APIDOC
/*{
	"DESCRIPTION": "demonstrates the use of float-type inputs",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		},
		{
			"NAME": "level",
			"TYPE": "float",
			"DEFAULT": 0.5,
			"MIN": 0.0,
			"MAX": 1.0
		}
	]
}*/
```

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

### ISF Rendering in WebGL with Javascript

Source: https://docs.isf.video/primer_chapter_3

Describes the use of the interactive-shader-format-js project for loading and rendering ISF compositions within a WebGL pipeline. Provides a link to an example implementation on Glitch.com.

```javascript
The interactive-shader-format-js project includes code for loading and rendering ISF compositions as part of a WebGL pipeline.
An example implementation of using the javascript implementation of ISF can be found in the ISF Generator Example on Glitch.com.
```

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

### ISF Float Input Example

Source: https://docs.isf.video/quickstart

Demonstrates how to define a float uniform variable in ISF, which is typically rendered as a slider or knob in the host application. It includes attributes like NAME, TYPE, LABEL, MIN, MAX, and DEFAULT.

```GLSL
/*{
	"DESCRIPTION": "Demonstrates a float input",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL"
	],
	"INPUTS": [
		{
			"NAME": "level",
			"TYPE": "float",
			"LABEL": "Gray Level",
			"DEFAULT": 0.5,
			"MIN": 0.0,
			"MAX": 1.0
		}
	]
}*/

void main() {
	gl_FragColor = vec4(level,level,level,1.0);
}
```

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

### ISF Color Input Example

Source: https://docs.isf.video/quickstart

Shows how to define a color uniform variable (vec4) in ISF, which is usually represented by a color picker interface. It specifies the NAME, TYPE, and a DEFAULT color value.

```GLSL
/*{
	"DESCRIPTION": "Demonstrates a color input",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL"
	],
	"INPUTS": [
		{
		  "NAME" : "colorValue",
		  "TYPE" : "color",
		  "DEFAULT" : [
			1.0,
			0.5,
			0.25,
			1.0
		  ]
		}
	]
}*/

void main() {
	gl_FragColor = colorValue;
}
```

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

### GLSL do-while Loop Example

Source: https://docs.isf.video/primer_chapter_4

Provides an example of a 'do-while' loop in GLSL. This loop increments a float variable and continues as long as the variable is less than a specified value, ensuring the increment happens at least once.

```GLSL
float	val = 0.0;
do
{
	val += 0.1;
}
while (val < 1.0);
```

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

### ISF Persistent Buffer Example (Motion Blur)

Source: https://docs.isf.video/ref_multipass

Demonstrates using a persistent buffer in ISF to create a motion blur effect. It utilizes a one-step rendering pass and shows how to define persistent buffers with floating-point precision.

```GLSL
/*{
	"DESCRIPTION": "demonstrates the use of a persistent buffer to create a motion-blur type effect. also demonstrates the simplest use of steps: a one-step rendering pass",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		},
		{
			"NAME": "blurAmount",
			"TYPE": "float"
		}
	],
	"PASSES": [
		{
			"TARGET": "bufferVariableNameA",
			"PERSISTENT": true,
			"FLOAT": true
		}
	]
	
}*/

void main()
{
	vec4		freshPixel = IMG_THIS_PIXEL(inputImage);
	vec4		stalePixel = IMG_THIS_PIXEL(bufferVariableNameA);
	gl_FragColor = mix(freshPixel,stalePixel,blurAmount);
}
```

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

### ISF Multi-Pass Shader Example

Source: https://docs.isf.video/primer_chapter_7

Demonstrates a two-pass rendering process in ISF. The first pass renders to a persistent, downscaled buffer, and the second pass upscales this buffer. It utilizes the PASSES array for defining render targets and dimensions, and PASSINDEX to control logic per pass.

```JSON
{
	"DESCRIPTION": "demonstrates the use of two-pass rendering- the first pass renders to a persistent buffer which is substantially smaller than the res of the image being drawn.  the second pass renders at the default requested size and scales up the image from the first pass",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		}
	],
	"PASSES": [
		{
			"TARGET":"bufferVariableNameA",
			"PERSISTENT": true,
			"WIDTH": "$WIDTH/16.0",
			"HEIGHT": "$HEIGHT/16.0"
		},
		{
		
		}
	]
	
}
```

```GLSL
void main()
{
	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
	if (PASSINDEX == 0) {
		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
	}
	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
	else if (PASSINDEX == 1) {
		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
	}
}
```

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

### ISF Multi-Pass Shader Example (Scaled Rendering)

Source: https://docs.isf.video/ref_multipass

Illustrates a two-pass ISF shader where the first pass renders to a smaller persistent buffer, and the second pass scales up this buffer. This showcases multi-pass rendering and dynamic buffer sizing.

```GLSL
/*{
	"DESCRIPTION": "demonstrates the use of two-pass rendering- the first pass renders to a persistent buffer which is substantially smaller than the res of the image being drawn.  the second pass renders at the default requested size and scales up the image from the first pass",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		}
	],
	"PASSES": [
		{
			"TARGET":"bufferVariableNameA",
			"PERSISTENT": true,
			"WIDTH": "$WIDTH/16.0",
			"HEIGHT": "$HEIGHT/16.0"
		},
		{
		
		}
	]
	
}*/

void main()
{
	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
	if (PASSINDEX == 0)	{
		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
	}
	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
	else if (PASSINDEX == 1)	{
		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
	}
}
```

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

### ISF JSON Structure and GLSL Example

Source: https://docs.isf.video/ref_json

Demonstrates the required JSON structure within a comment block at the beginning of an ISF file, followed by GLSL code. The JSON defines shader metadata and inputs, while the GLSL code processes an input image based on a level parameter.

```JSON
{
	"DESCRIPTION": "demonstrates the use of float-type inputs",
	"CREDIT": "by zoidberg",
	"ISFVSN": "2.0",
	"VSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		},
		{
			"NAME": "level",
			"TYPE": "float",
			"DEFAULT": 0.5,
			"MIN": 0.0,
			"MAX": 1.0
		}
	]
}
```

```GLSL
void main()
{
	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
	float		luma = (srcPixel.r+srcPixel.g+srcPixel.b)/3.0;
	vec4		dstPixel = (luma>level) ? srcPixel : vec4(0,0,0,1);
	gl_FragColor = dstPixel;
}
```

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

### ISF Sample Files and Repositories

Source: https://docs.isf.video/using_isf

Provides access to sample ISF files for testing basic features and a GitHub repository with over a hundred ISF files, including images and filters, which are part of the standard set published by VIDVOX.

```Documentation
Sample Files:
- Simple test ISF files demonstrating basic features.
- ISF Files repository on GitHub: Includes over a hundred ISF files (images and filters).
- Standard set published by VIDVOX, included with VDMX.
- Recommended placement: /Library/Graphics/ISF
```

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

### ISF GLSL Conversion Tips

Source: https://docs.isf.video/quickstart

Guidance for converting GLSL shaders to ISF, including variable name changes, texture access, uniform handling, and coordinate systems.

```ISF
// Variable Time: Change 'u_time' or 'iTime' to 'TIME'
// Texture Access: Replace texture2D() with IMG_NORM_PIXEL() for normalized coordinates
//               Replace texture2DRect() with IMG_PIXEL() for non-normalized coordinates

// Uniforms: Replace custom uniform declarations with entries in the INPUTS section of the JSON blob.

// Built-in Uniforms:
// RENDERSIZE: vec2, dimensions of the rendered image.
// TIME: float, duration (in seconds) the shader has been running.

// Coordinates:
// gl_FragCoord.xy: Fragment coordinates.
// isf_FragNormCoord.xy: Normalized fragment coordinates.

// Vertex Shaders:
// If using a custom vertex shader, name it with a .vs extension and call 'isf_vertShaderInit();' in main().

// Importing Images:
// Use the 'imported' key in the JSON dict to import image files.
// Access imported images via IMG_PIXEL() or IMG_NORM_PIXEL().

// Texture Clamping:
// Ensure texture coordinates are properly ranged to avoid visual artifacts.
```

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

### GLSL while Loop Example

Source: https://docs.isf.video/primer_chapter_4

An example of a 'while' loop in GLSL that increments a float variable until it reaches a certain threshold. This illustrates how loop conditions can be modified within the loop body.

```GLSL
float	val = 0.0;
while (val < 1.0)
{
	val += 0.1;
}
```

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

### GLSL Simple If Statement Example

Source: https://docs.isf.video/primer_chapter_4

A basic example of an if statement in GLSL, checking if a distance variable is less than a radius. If the condition is true, the code within the curly braces is executed.

```GLSL
if (dist < radius_sized) 	{
		//	do some stuff
	}
```

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

### Introduction to ISF and GLSL

Source: https://docs.isf.video/primer_chapter_1

Explains ISF as a file format built on GLSL for creating video generators and FX plugins. Highlights ISF's cross-platform compatibility and ease of use for those familiar with GLSL.

```English
ISF, aka Interactive Shader Format, is a file format for creating video generators and FX plugins that can run on desktop, mobile and WebGL. ISF is built on top of GLSL, a powerful cross-platform language that runs on the GPU. By writing shaders that meet the ISF specification you can easily re-use your creations across different software applications without having to make environment specific modifications.
If you already know some GLSL, learning how to take advantage of ISF will be very easy as it is merely a set of simple conventions to follow. Having already encountered some of the limitations of the language on its own will hopefully make you appreciate some of the ideas introduced by ISF.
If you don't already know any GLSL, get excited, because this is some crazy powerful stuff that you are about to add to your visual toolkit. There is a rich community of developers who are sharing their experience online for you to learn from and the underlying concepts are widely applicable to a wide variety of platforms.
```

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

### ISF Image Filter Example (Invert Colors)

Source: https://docs.isf.video/quickstart

An example of an ISF image filter that inverts the colors of an input image. It requires an 'inputImage' of type 'image' and uses the IMG_NORM_PIXEL function to access pixel data.

```GLSL
/*{
	"DESCRIPTION": "demonstrates an invert image filter",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		}
	]
}*/

vec3 invertColor (vec3 c)
{
	return 1.0 - c;
}

void main()
{
	vec4		srcPixel = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
	srcPixel.rgb = invertColor(srcPixel.rgb);
	gl_FragColor = srcPixel;
}
```

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

### ISF Color Invert Shader

Source: https://docs.isf.video/primer_chapter_2

Inverts the RGB channels of an input image while preserving the alpha channel. This is an example of an image processing FX shader.

```ISF
/*{
	"DESCRIPTION": "Inverts each pixel",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2",
	"CATEGORIES": [
		"Color Effect"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		}
	]
}*/

void main() {
	vec4	srcPixel = IMG_THIS_PIXEL(inputImage);
	gl_FragColor = vec4(1.0-srcPixel.r, 1.0-srcPixel.g, 1.0-srcPixel.b, srcPixel.a);
}
```

```ISF
gl_FragColor = vec4(1.0-srcPixel.rgb,srcPixel.a);
```

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

### Adding ISF Support to 3rd Party Software

Source: https://docs.isf.video/using_isf

Information for developers on integrating ISF support, including links to source code repositories and resources. Details open-source codebases in Objective-C, C++, and Javascript for parsing and rendering ISF files.

```Objective-C
VVOpenSource repository:
- Contains original ISF Editor and VVISFKit framework codebases.
- Written in Objective-C for Mac.
```

```C++
VVISF-GL repository:
- Crossplatform libraries (Mac and Windows) for parsing and rendering ISF files in OpenGL.
- Includes Mac and Windows versions of the ISF Editor written in Qt.
```

```Javascript
ISF-JS-Renderer:
- Parses and renders ISF files through Javascript.
```

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

### Other Open Source Projects Using ISF

Source: https://docs.isf.video/using_isf

A list of additional open-source projects that utilize ISF, including libraries for parsing, editors, and integrations with platforms like TouchDesigner, OpenFrameworks, and HeavyM.

```Documentation
Other Projects:
- libisf: Library for parsing ISF files with an example Qt editor.
- ISF TouchDesigner: Partial support for ISF files in TouchDesigner.
- ofxISF: Partial support for ISF files in OpenFrameworks.
- ISFHeavyM and ISFgif: Create ISF shared libraries with GIF preview for HeavyM.
```

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

### ISF Editor Features (Mac/Windows)

Source: https://docs.isf.video/primer_chapter_3

Highlights the key features of the ISF Editor application for Mac and Windows, including rendering, video input support, Syphon/Spout output, debugging tools, and conversion from Shadertoy/GLSL Sandbox.

```text
Features:
- Browses, renders, and displays ISF files.
- Supports webcam, Syphon/Spout, and AVCapture video inputs.
- Publishes output as Syphon/Spout source.
- Automatic UI generation for inputs.
- Built-in shader editor with syntax coloring and error display.
- Output window for debugging render passes.
- 'Import from Shadertoy/GLSL Sandbox' feature.
```

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

### Open Source Libraries for ISF Development

Source: https://docs.isf.video/primer_chapter_3

Lists open-source projects and libraries that facilitate working with ISF files at a code level. Includes a C++ library for cross-platform rendering, a Javascript renderer for web browsers, and legacy Objective-C codebases.

```C++
The VVISF-GL repository contains a crossplatform C++ library for loading and rendering ISF shaders.
```

```javascript
The ISF-JS-Renderer can be used to parse and render ISF files through javascript in a web browser.
```

```Objective-C
Legacy objective-c ISF Editor and VVISFKit framework codebases for Mac and iOS can be found in the VVOpenSource repository.
```

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

### GLSL Function with Void Return Type

Source: https://docs.isf.video/primer_chapter_4

An example of a GLSL function that does not return a value (uses the 'void' return type). This function modifies a passed-in parameter by flipping its x and y values.

```GLSL
//	flip the x and y values
void flipValues(vec2 point)
{
	vec2	tmp = point;
	point.x = tmp.y;
	point.y = tmp.x;
}
```

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

### ISF Web Editor Features

Source: https://docs.isf.video/using_isf

The ISF Web Editor allows online creation, viewing, and sharing of ISF files. It provides features for browsing community shaders, using various media sources, and automatically generating UI elements for shader inputs.

```APIDOC
ISF Web Editor Features:
  - Online creation, preview, and sharing of ISF files.
  - Community shader browsing and downloading.
  - Input sources: webcam, static images, uploaded GIFs.
  - Automatic UI generation for shader inputs for user interaction.
```

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

### GLSL If/Else with Compound Condition

Source: https://docs.isf.video/primer_chapter_4

An example demonstrating an if/else statement in GLSL that uses multiple comparison operators combined with the OR logical operator (||). This checks if a pixel coordinate is outside normalized bounds.

```GLSL
if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
		gl_FragColor = vec4(0.0);
	}
	else	{
		gl_FragColor = color;
	}
```

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

### GLSL Commenting Syntaxes

Source: https://docs.isf.video/primer_chapter_2

Demonstrates the use of single-line (//) and multi-line (/* */) comments in GLSL shaders. Comments are ignored by the compiler and are useful for explaining code.

```GLSL
void main() {
	//	this is a code comment
	
	/*
		everything between these markers is another code comment
	*/
	
	gl_FragColor = IMG_NORM_PIXEL(inputImage,vec2(mod(isf_FragNormCoord.x+TIME,1.0),isf_FragNormCoord.y));
}
```

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

### GLSL Scalar Data Types Example

Source: https://docs.isf.video/primer_chapter_4

Demonstrates the usage of GLSL scalar data types: int, float, and bool. It shows how to declare variables of these types and use them in a simple shader logic, including a for loop.

```GLSL
void main() {
	int	myInt = 3;
	float	myFloat = 0.1;
	bool	myBool = true;
	float	alpha = 0.0;
	if (myBool == true) {
		int i;
		for (i = 0;i < myInt;++i) {
			alpha += myFloat;
		}
	}
	gl_FragColor = vec4(1.0,0.5,0.0,alpha);
}
```

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

### ISF Shader Parameter Interface

Source: https://docs.isf.video/primer_chapter_1

ISF shaders describe their adjustable parameters to host applications using a commented-out JSON blob above the GLSL source code. This allows for standardized metadata and easier integration.

```APIDOC
ISF Shader Metadata:
  Format: Commented-out JSON blob above GLSL source code.
  Purpose: Describes shader parameters, uniforms, and other metadata to host applications.
  Example Structure:
    /*
    {
      "name": "My Shader",
      "description": "A sample ISF shader.",
      "author": "Example User",
      "categories": ["Generators", "Effects"],
      "inputDimensions": [
        {"name": "inputImage", "type": "texture"}
      ],
      "params": [
        {
          "name": "color",
          "type": "color",
          "label": "Tint Color",
          "default": [1.0, 1.0, 1.0, 1.0]
        },
        {
          "name": "intensity",
          "type": "float",
          "label": "Effect Intensity",
          "default": 0.5,
          "min": 0.0,
          "max": 1.0
        }
      ]
    }
    */
```

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

### ISF vs. GLSL

Source: https://docs.isf.video/primer_chapter_1

Clarifies that ISF is a specification built upon GLSL, allowing developers to leverage existing GLSL resources and adapt projects to the ISF standard.

```English
As mentioned, ISF is a specification built on top of an existing popular language known as GLSL. This means that you can take advantage of other resources for learning how to write GLSL shaders and in many cases adapt other GLSL projects to meet the ISF specification.
```

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

### GLSL Vector Data Types Example

Source: https://docs.isf.video/primer_chapter_4

Illustrates the use of GLSL vector data types (vec2, vec3, vec4) for representing coordinates and colors. It shows how to create vectors, access their components, and perform operations on them.

```GLSL
void main() {
	float	myX = 0.25;
	float	myY = 0.5;
	vec2	myPoint = vec2(myX, myY);
	myPoint += 0.1;
myX = myPoint.x;
myY = myPoint.y;
	vec3	myColor = vec3(myX,myY,0.5);
	gl_FragColor = vec4(myColor,1.0);
}
```

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

### ISF Directory Locations (macOS)

Source: https://docs.isf.video/primer_chapter_3

Details the standard directory locations on macOS where ISF compositions are stored and automatically accessed by supporting host applications.

```text
/Library/Graphics/ISF/
~/Library/Graphics/ISF/
```

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

### ISF Persistent Buffer for Inverting Feedback

Source: https://docs.isf.video/primer_chapter_7

An example of an ISF shader that creates an inverting feedback effect using a persistent buffer. It inverts the RGB values of the previous frame's output before blending it with the current input.

```ISF
/*{
	"DESCRIPTION": "creates a simple inverting feedback effect",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2.0",
	"CATEGORIES": [
		"TEST-GLSL FX"
	],
	"INPUTS": [
		{
			"NAME": "inputImage",
			"TYPE": "image"
		},
		{
			"NAME": "blurAmount",
			"TYPE": "float"
		}
	],
	"PASSES": [
		{
			"TARGET": "bufferVariableNameA",
			"PERSISTENT": true,
			"FLOAT": true
		}
	]
	
}*/

void main()
{
	vec4		freshPixel = IMG_THIS_PIXEL(inputImage);
	vec4		stalePixel = IMG_THIS_PIXEL(bufferVariableNameA);
	stalePixel.rgb = 1.0 - stalePixel.rgb;
	gl_FragColor = mix(freshPixel,stalePixel,blurAmount);
}
```

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

### ISF Editor for Mac Features

Source: https://docs.isf.video/using_isf

The ISF Editor for Mac allows browsing, rendering, and displaying ISF files. It supports various video inputs, publishes output via Syphon, automatically creates UI for inputs, and includes a shader editor with syntax highlighting and error display.

```Documentation
Features:
- Browses, renders, and displays ISF files.
- Supports built-in video source, QC comps, movie files, image files, Syphon video servers, or AVCapture-compatible video inputs.
- Publishes rendered output as a Syphon source.
- Automatically creates UI items for inputs.
- Built-in shader editor with syntax coloring and error display.
- Output window can be paused and used to view individual render pass outputs.
- 'Import from Shadertoy/GLSL Sandbox' feature for automatic conversion.
```

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

### ISF Coordinate Normalization Refactoring

Source: https://docs.isf.video/primer_chapter_9

This example demonstrates a refactoring of GLSL code within an ISF shader. It shows how to replace a manual calculation of normalized fragment coordinates with a built-in ISF variable for simplicity and potential performance improvement.

```GLSL
vec2 st = gl_FragCoord.xy/RENDERSIZE.xy;


```

```GLSL
vec2 st = isf_FragNormCoord;
```

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

### ISF File Extensions

Source: https://docs.isf.video/primer_chapter_3

Specifies the file extensions used for ISF compositions. Fragment shaders use '.fs', and vertex shaders use '.vs'. This is important for saving and organizing ISF files correctly.

```text
Fragment shaders: .fs
Vertex shaders: .vs
```

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

### About ISF Compositions

Source: https://docs.isf.video/primer_chapter_1

Describes ISF compositions as small, self-contained files for visual effects that can be run independently or combined. Emphasizes real-time rendering accelerated by the GPU.

```English
The core concept of writing generators and FX in ISF is that each idea is designed to be a small self contained file that can be run on its own or combined with other ISF compositions within a variety of different host environments. Artists and new developers can focus on creating specific visual effects without having to write an entire application around them. By writing shaders against the ISF standard, the same rendering code can often be re-used on desktop, mobile and web platforms. In most cases ISF compositions are designed to be run in real-time, accelerated by the computer graphics card.
```

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

### GLSL Grayscale Conversion Function

Source: https://docs.isf.video/primer_chapter_4

An example of a GLSL function that calculates the grayscale value of a pixel by averaging its RGB channels. It takes a vec4 color as input and returns a float representing the grayscale amount, ignoring the alpha channel.

```GLSL
//	determines the grayscale value for the pixel by averaging the RGB channels
float grayscaleAmount(vec4 color)
{
	//	ignores alpha
	return (color.r + color.g + color.b) / 3.0;
}
```

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

### Manual GLSL to ISF Conversion Tips

Source: https://docs.isf.video/primer_chapter_9

Manually convert GLSL shaders to ISF by adjusting function and variable names, such as changing `u_time` to `TIME`. This is useful for code examples from sources like Shader Toy or The Book of Shaders, or when automatic conversion is insufficient.

```GLSL
// Example: Changing time variable
// Original (e.g., ShaderToy):
// uniform float u_time;

// ISF:
// const float TIME = _time; // ISF provides TIME automatically
```

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

### ISF Audio Data Representation

Source: https://docs.isf.video/primer_chapter_8

Explains the conventions for packing audio data into images for ISF shaders. This includes image dimensions, pixel mapping, and color channel usage.

```APIDOC
Audio Data Conventions in ISF:
- Image Width: Number of audio samples.
- Image Height: Number of audio channels.
- Pixel (x=0): First audio sample.
- Pixel (y=0): First audio channel.
- RGB Channels: Grayscale amplitude value (0.0 to 1.0, centered at 0.5).
- Data Precision: Preferably 32-bit floating point.
```

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

### Pass Thru Vertex Shader (GLSL)

Source: https://docs.isf.video/quickstart

A basic vertex shader for ISF that initializes the shader and passes normalized coordinates to the fragment shader.

```GLSL
//	passthru.vs
//	put your code in the main() {} function

varying vec2 translated_coord;

void main()
{
	//	make sure to call this in your custom ISF shaders to perform initial setup!
	isf_vertShaderInit();
	translated_coord = isf_FragNormCoord;
}

```

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

### ISF Audio FFT Input Declaration

Source: https://docs.isf.video/primer_chapter_8

Demonstrates the JSON structure for declaring an 'audioFFT' input in ISF. It specifies the input name, type, and optional parameters like MAX for controlling the number of samples.

```APIDOC
{
	"DESCRIPTION": "Visualizes an FFT analysis image with custom set colors for frequency domain",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2",
	"CATEGORIES": [
		"Generator"
	],
	"INPUTS": [
		{
			"NAME": "fftImage",
			"TYPE": "audioFFT"
		},
		{
			"NAME": "strokeSize",
			"TYPE": "float",
			"MIN": 0.0,
			"MAX": 0.25,
			"DEFAULT": 0.01
		},
		{
			"NAME": "gain",
			"TYPE": "float",
			"MIN": 1.0,
			"MAX": 5.0,
			"DEFAULT": 1.0
		},
		{
			"NAME": "minRange",
			"TYPE": "float",
			"MIN": 0.0,
			"MAX": 1.0,
			"DEFAULT": 0.0
		},
		{
			"NAME": "maxRange",
			"TYPE": "float",
			"MIN": 0.0,
			"MAX": 1.0,
			"DEFAULT": 0.9
		},
		{
			"NAME": "topColor",
			"TYPE": "color",
			"DEFAULT": [
				0.0,
				0.0,
				0.0,
				0.0
			]
		},
		{
			"NAME": "bottomColor",
			"TYPE": "color",
			"DEFAULT": [
				0.0,
				0.5,
				0.9,
				1.0
			]
		},
		{
			"NAME": "strokeColor",
			"TYPE": "color",
			"DEFAULT": [
				0.25,
				0.25,
				0.25,
				1.0
			]
		}
	]
}
```

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

### ISF for Motion Graphics and Video Editing

Source: https://docs.isf.video/primer_chapter_3

Highlights the use of ISF shaders for non-realtime applications like motion graphics and video editing, enabling the rendering of complex shaders at high resolutions and frame rates. Mentions an add-on for Motion and FCP X that includes standard ISF assets and custom creations.

```ISF
One of the interesting ways to take advantage of using GLSL shaders is for non-realtime use when creating motion graphics and editing video. This can be especially useful for rendering out complex shaders at high resolutions and frame rates.
The ISF for Motion and FCP X add-on includes the standard set of ISF 200+ generators, filters, and transitions and the ability to use your own creations.
```

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

### Declare Audio Input in ISF

Source: https://docs.isf.video/primer_chapter_8

Demonstrates how to declare an audio input within the ISF JSON structure. This allows host applications to pass audio waveform data to shaders.

```APIDOC
{
  "INPUTS": {
    "audio": {
      "TYPE": "audio",
      "NAME": "audio_waveform",
      "MAX": 1024, 
      "LABEL": "Audio Waveform"
    }
  }
}
```

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

### GLSL Fragment Shader Basics

Source: https://docs.isf.video/primer_chapter_1

GLSL fragment shaders run on the GPU and describe algorithms executed for each pixel. They are fundamental for generating or processing pixel information in real-time graphics.

```GLSL
#version 300 es

precision mediump float;

// Input from vertex shader (normalized coordinates)
in vec2 v_texCoord;

// Output color for the fragment
out vec4 fragColor;

void main() {
    // Example: Create a gradient based on texture coordinates
    float gradient = v_texCoord.x;
    fragColor = vec4(gradient, v_texCoord.y, 0.5, 1.0);
}
```

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

### ISF Multi-Pass and Persistent Buffers

Source: https://docs.isf.video/primer_chapter_1

ISF supports multi-pass rendering chains within a single file and allows for the creation of persistent buffers to store data between render passes, enabling more complex shader algorithms.

```APIDOC
ISF Multi-Pass Rendering:
  Concept: Allows chaining multiple GLSL shaders (passes) within a single ISF file.
  Mechanism: Typically involves defining multiple shader stages or using specific conventions to pass output from one pass as input to the next.
  Persistent Buffers:
    Purpose: Store data (e.g., textures, intermediate results) across different render passes.
    Usage: Enables feedback loops and complex state management within a single ISF file.
  Example (Conceptual):
    // Pass 1: Generate a texture
    // ... GLSL code for Pass 1 ...
    // Output to a buffer named 'bufferA'

    // Pass 2: Use 'bufferA' as input
    // ... GLSL code for Pass 2, sampling 'bufferA' ...
    // Output to final render target
```
Tokens:
Raw