Pixel Composer

https://docs.pixel-composer.com
Admin
Pixel Composer is a visual node-based software for creating pixel art, animations, 3D scenes, and...
Tokens:26,004
Snippets:584
Trust Score:5.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### PCX Basic Syntax and Variable Examples

Source: https://docs.pixel-composer.com/scriptings/pcx

Demonstrates basic PCX syntax for variable assignment, arithmetic operations, and accessing global variables and constants. It showcases how local variables are defined and used, and how to reference read-only global variables and mathematical constants like pi.

```PCX
a = 5
a * 2 // Returns 10

// Global variables and constants are read-only
// For example, accessing project frame:
Project.frame

// Mathematical constants:
pi
```

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

### PCX Conditional Statements

Source: https://docs.pixel-composer.com/scriptings/pcx

Provides an example of conditional logic in PCX using 'if', 'elseif', and 'else' statements. This allows for dynamic control flow based on specified conditions.

```PCX
if(value > 10) {
  1
} elseif(value < 0) {
  -1
} else {
  0
}
```

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

### HLSL Default Fragment Code Example

Source: https://docs.pixel-composer.com/scriptings/hlsl

This HLSL code snippet demonstrates the basic functionality of the HLSL node in Pixel Composer. It samples a texture at the current pixel's UV coordinates and outputs the sampled color. This is a fundamental example for understanding pixel processing in HLSL.

```hlsl
float4 surfaceColor = gm_BaseTextureObject.Sample(gm_BaseTexture, input.uv);
output.color = surfaceColor;
```

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

### Lua Basic Syntax: For Loop

Source: https://docs.pixel-composer.com/scriptings/lua

Illustrates the 'for' loop in Lua, used for iterating a specific number of times. It requires defining a start value, an end value, and an optional step, with the loop block enclosed by 'do' and 'end'.

```lua
for i = 1, 10, 1 do
print(i)
end
```

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

### Input/Output Functions

Source: https://docs.pixel-composer.com/scriptings/lua

Documentation for functions related to input and output operations.

```APIDOC
## Input/Output Functions

### print(string)

Prints a string to the console or output.
```

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

### Pixel Composer Lua: Drawing Functions

Source: https://docs.pixel-composer.com/scriptings/lua

Provides examples of drawing primitives and image manipulation within Pixel Composer's Lua Surface node. These functions allow for rendering shapes and modifying surface content.

```lua
draw(surface, x, y)
drawBlend(surface, x, y, color = white, alpha = 1)
drawTransform(surface, x, y, xs = 1, ys = 1, rot = 0)
drawGeneral(surface, x, y, xs = 1, ys = 1, rot = 0, color = white, alpha = 1)
drawRect(x0, y0, x1, y1)
drawRectOutline(x0, y0, x1, y1, thick = 1)
drawCircle(x, y, radius)
drawCircleOutline(x, y, radius, thick = 1)
drawEllipse(x0, y0, x1, y1)
drawEllipseOutline(x0, y0, x1, y1, thick = 1)
drawLine(x0, y0, x1, y1, thick = 1)
drawLineRound(x0, y0, x1, y1, thick = 1)
drawPixel(x, y)
```

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

### PCX Value Variable and Global Structs

Source: https://docs.pixel-composer.com/scriptings/pcx

Illustrates the usage of the 'value' variable to retrieve the current property's value, and demonstrates accessing global structs like 'Project' and 'Device' for animation and real-time information.

```PCX
// Accessing the current property value
value

// Accessing project information
Project.frame
Project.progress
Project.frameTotal
Project.fps
Project.time
Project.name

// Accessing real-time device information
Device.timeSecond
Device.timeMinute
Device.timeHour
Device.timeDay
Device.timeDayInWee
Device.timeMonth
Device.timeYear
```

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

### PCX Array Creation and Access

Source: https://docs.pixel-composer.com/scriptings/pcx

Demonstrates the creation of arrays using square brackets and accessing elements by their zero-based index. This is fundamental for handling collections of data within PCX scripts.

```PCX
a = [ 0, 1, 2, 3, 4, 5 ]
a[2] // Returns 2
```

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

### String Functions

Source: https://docs.pixel-composer.com/scriptings/lua

Provides documentation for string manipulation functions including length, search, substring extraction, case conversion, replacement, and splitting.

```APIDOC
## String Functions

### stringLength(string)

Returns the length of a string.

### stringSearch(string, searchString)

Returns the starting index of the first occurrence of `searchString` within `string`, or -1 if not found.

### stringCopy(string, start, length)

Extracts a substring from `string` starting at `start` index for a given `length`.

### stringUpper(string)

Converts a string to uppercase.

### stringLower(string)

Converts a string to lowercase.

### stringReplace(string, replaceFrom, replaceTo)

Replaces the first occurrence of `replaceFrom` with `replaceTo` in `string`.

### stringReplaceAll(string, replaceFrom, replaceTo)

Replaces all occurrences of `replaceFrom` with `replaceTo` in `string`.

### stringSplit(string, delimiter)

Splits a string into an array of substrings based on a `delimiter`.
```

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

### PCX Drawing and Surface Functions

Source: https://docs.pixel-composer.com/scriptings/pcx

Details functions for drawing on surfaces and querying surface dimensions. This includes the 'draw' function for rendering and 'surface_get_*' functions for obtaining surface properties.

```PCX
// Drawing function
draw(surface, x = 0, y = 0, xs = 1, ys = 1, rot = 0, color = white, alpha = 1)

// Surface information functions
surface_get_dimension(surface)
surface_get_width(surface)
surface_get_height(surface)
```

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

### PCX Utility and Noise Functions

Source: https://docs.pixel-composer.com/scriptings/pcx

Highlights utility functions for generating procedural noise (wiggle, random), creating ranges, determining data length, and type conversions (string, number, character code).

```PCX
// Noise functions
wiggle(time, frequency, octave = 1, seed = 0)
random(min = 0, max = 1)
irandom(min = 0, max = 1)

// Utility functions
range(length, start = 0, step = 1)
length(value)
string(value)
number(value)
chr(x)
ord(char)
```

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

### Wavelet Noise Node

Source: https://docs.pixel-composer.com/nodes/generate/wavelet_noise

Documentation for the Wavelet Noise node, used for generating procedural wavelet noise textures with various input controls.

```APIDOC
## Wavelet Noise Node

### Description
Generates procedural wavelet noise. This node allows for detailed control over noise generation through various parameters and input maps.

### Method
N/A (This describes a node within a system, not a direct HTTP API endpoint)

### Endpoint
N/A

### Parameters
#### Inputs
- **dimension** (Dimension) - Input for defining the dimensionality of the noise generation.
- **Position** (vec2) - Controls the position offset for the noise generation.
- **Scale** (vec2) - Sets the scaling factor for the noise pattern.
- **seed** (float) - A float value used to seed the random number generator for the noise.
- **Progress** (float) - Controls the progression or evolution of the noise pattern over time or a sequence.
- **Detail** (float) - Adjusts the level of detail or complexity in the generated noise.
- **Scale Map** (map) - A texture map that influences the scale of the noise.
- **Progress Map** (map) - A texture map that influences the progress of the noise.
- **Detail Map** (map) - A texture map that influences the detail level of the noise.
- **Rotation** (Rotation) - Controls the rotation of the noise pattern.
- **Mask** (surface) - A mask to define areas where the noise should be applied.

#### Outputs
- **Surface Out** (Surface) - The generated noise texture as a surface output.
```

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

### Lua Basic Syntax: While Loop

Source: https://docs.pixel-composer.com/scriptings/lua

Shows the 'while' loop structure in Lua, which repeatedly executes a block of code as long as a given condition remains true. The loop block is defined between 'do' and 'end'.

```lua
while(value < 10) do
value += 1
end
```
Tokens:
Raw