recursal/Fanatic-Fandom huggingface dataset:
Tutorial Blinking Stars

This tutorial will show you how to create a simple star particle effect based on one of the default particle systems to introduce you to the Particle Editor. Make sure you checked out the basic guides for the Editor and Scene Wallpaper as well.

## Create a New Particle Effect

   Click on *add* in the lower left to add a new particle effect.

   Select *Particle System* and choose the option *basic* on the right. Name the new effect *Stars* to find it more easily in case you will add multiple effects. Click *OK* to create the particle effect.

   With the new effect selected, click on *edit* on the right. This will open the Particle Editor.

## Modify the Effect

We will now modify the Particle Emitters, Particle Initializers and Particle Operators of this effect to make it look and behave the way we want. The goal is to cover the wallpaper with small blinking particles that resemble a starry sky.

    First, remove the existing Particle Emitter Sphere Random by clicking on the red *X* next to it. Then click the green *+* next to the emitter list and add a Particle Emitter Box Random instead. Being a box, it will cover the square wallpaper better.

    Select the box emitter and change its settings as follow:

* Rate: 40
* Distance max: 1000, 500, 0

This will make it spawn more particles and cover an area about the size of a 1080p wallpaper. The maximum distance from the center towards left and right is 1000 (so a combined area of 2000) and the maximum distance towards top and bottom is 500 (so combined 1000).

    Select Particle Initializer Lifetime Random and change:

* Min: 4
* Max: 8

This will make every particle appear for at least 4 seconds and max 8 seconds.

    Select Particle Initializer Size Random and change:

* Min: 5
* Max: 10

This will make the particles a lot smaller.

    To prevent the stars from moving, delete the Particle Initializer Velocity Random and Particle Operator Movement by clicking on the red *X* next to them.

    Select the existing Particle Operator Alpha Fade and change:

* Min: 0.1
* Max: 0.9

This means the particles will appear translucent over all. They will fade in for 10% of their lifetime and fade out from 10% of their lifetime.

    Finally, add a Particle Operator Oscillate Alpha by clicking on the green *+* next to the operators.

    By default, the oscillation is quite strong. Change the following to reduce it a bit:

* Frequency max: 3
* Scale min: 0.2

💡 **Pro tip:** You can also easily modify the color with the existing Particle Initializer Color Random

## Result

A subtle star shimmer that works well with any sky wallpaper.
Shader user variables

You can define uniforms that will show up in the editor as various controls like sliders, a color picker or a UV position picker. This also allows you to bind user properties or scripts to a variable and use that as an input to your shader.

Use the **Snippets --> Add Variable** menu and choose any of the variables to let the editor automatically insert the required code.

💡 **Pro tip:** Make sure all of your variables begin with the prefix **u\_**. This guarantees that no future update will break your shader! We might add global constants in the future and using u\_ as a prefix will ensure that there won't be any conflicts!

# Slider

```
uniform float u\_userNewSlider; // {"material":"My new slider","default":0,"range":[0,1]}

```

* **u\_userNewSlider**

This is the name of the variable. Make sure to rename it to anything that makes sense for you.

* **"material":"My new slider"**

You can enter the visible name for the variable here, this is what you will see in the editor.

* **"default":0**

This is the default value for the slider.

* **"range":[0,1]**

This is the minimum and maximum value of the slider.

# Color

```
uniform vec3 u\_userNewColor; // {"material":"My new color","type":"color","default":"1 1 1"}

```

* **u\_userNewColor**

This is the name of the variable. Make sure to rename it to anything that makes sense for you.

* **"material":"My new color"**

You can enter the visible name for the variable here, this is what you will see in the editor.

* **"default":"1 1 1"**

This is the default color, in this case it's white.

# UV Picker

```
uniform vec2 u\_userNewPosition; // {"material":"My new position","position":true,"default":"0.5 0.5"}

```

* **u\_userNewPosition**

This is the name of the variable. Make sure to rename it to anything that makes sense for you.

* **"material":"My new position"**

You can enter the visible name for the variable here, this is what you will see in the editor.

* **"default":"0.5 0.5"**

This is the default position, in this case it's right in the center.
Particle Operator Oscillate Size

Changes the size of a particle back and forth.

* **Frequency min** minimum possible frequency for a particle.
* **Frequency max** maximum possible frequency for a particle.
* **Scale min** minimum size multiplier.
* **Scale max** maximum size multiplier.
* **Phase min** minimum phase offset for each particle.
* **Phase max** maximum phase offset for each particle.

Operator Blending
SceneScript Class IInput

Global interface exposed via object **input** to access input related data.

# Properties

* **cursorWorldPosition**: Vec3

Position of the mouse cursor in the world/wallpaper. Only valid for 2D wallpapers right now.

* **cursorScreenPosition**: Vec2

Position of the mouse cursor relative to the top left corner of the wallpaper screen area.

* **cursorLeftDown**: Boolean

Whether the left mouse button is currently down.
SceneScript Class IConsole

Global interface exposed via object **console** to access the console log.

# Functions

* **log**(...): void

Converts all parameters to a string and concatenates them with a space, then prints them to the log as an info message.

* **error**(...): void

Converts all parameters to a string and concatenates them with a space, then prints them to the log as an error message.
SceneScript Class ITextureAnimation

This class represents a texture animation. By default, all instances of an animated texture share an animation state. Calling any function here that changes the animation will disconnect it from the shared state. You can revert this and use the shared animation state again by calling *join*.

# Properties

* **frameCount**: Number (readonly)

The number of frames of this animation.

* **duration**: Number (readonly)

The duration in seconds of this animation.

* **rate**: Number

Speed factor of the animation, default is 1.

# Functions

* **play**()

Continues or starts playing the animation if it was paused or stopped.

* **stop**()

Stops the animation and reverts to the beginning.

* **pause**()

Pauses the animation at the current position.

* **isPlaying**(): Boolean

Returns whether the animation is currently playing or if it's paused/stopped.

* **getFrame**(): Number

Get the current frame of the animation.

* **setFrame**(frame: Number)

Set the animation to the specified frame.

* **join**()

Return to the global, shared animation between all objects.
Texture

A texture is an image ready to be accessed by your graphics card and displayed on your screen. Textures are used everywhere, for image layers and 3D models alike. You can adjust texture options when importing new textures or by clicking on the gear icon of a texture property. They are usually assigned within a Material that defines how the texture is drawn to the screen.

## Compile Options

* **Format** RGBA8888 is an uncompressed texture with 4 channels. The VRAM occupied equals *width \* height \* 4* bytes. The compiled texture is saved with LZ4 compression and a bit smaller on disk. DXT5 is a compressed format using *width \* height* bytes of VRAM. Both have *N* versions for normal maps, these swizzle the G and A channels which allows more precision when using it along with DXT5.
* **Point filter** disables bilinear texture filtering. Use it for pixel art.
* **No mip maps** disables mip mapping [1] for this texture. Less VRAM and disk space will be occupied, but the texture will flicker when it occupies less screen space than its resolution has. Recommended to be disabled for large background images, but don't disable it on 3D models.
* **Clamp UVs** disables texture repetition when textures are sampled outside of normalized (0 - 1) coordinates and will instead return the color of the nearest pixel still on the actual texture.
Shader Casting

Since shaders are translated into HLSL, it is recommended to use the following casting macros for construction and casting. For example, when you want to cast a 4x4 matrix into 3x3 or when you want to create a vec3 from a single float.

* **CAST2()**

This will call vec2(x) in GLSL and do (float2)x in HLSL.

* **CAST3()**

This will call vec3(x) in GLSL and do (float3)x in HLSL.

* **CAST4()**

This will call vec4(x) in GLSL and do (float4)x in HLSL.

* **CAST3X3()**

This will call mat3(x) in GLSL and do (float3x3)x in HLSL.
Ghul

Ghule to nieumarłe istoty powstające zazwyczaj ze zwłok dotkniętych celową lub przypadkową klątwą. Niektórzy spekulują też, że ten, kto za życia żywił się ludzkim mięsem po śmierci zmieni się w ghula, ale ta teoria nie została nigdy potwierdzona.

Taki stwór błąka się po świecie szukając zwłok do pożarcia. Ghule są bardziej aktywne nocą, ale jeśli poczują w pobliżu smakowity kąsek, potrafią też przetrwać w świetle dnia.

Najłatwiejszym sposobem na zabicie ghula jest ogień. Jego ciało jest suche jak popiół, często też odziane w stare szmaty, i błyskawicznie staje w płomieniach. Bez ognia ghula zabić trudno, ponieważ potrafi on przetrwać rany, które natychmiast powaliłyby zwykłego człowieka.
Particle Operator Turbulence

Applies a 3D simplex noise to the velocity of each particle to simulate a natural looking motion.

* **Timescale** how fast the noise field changes shape.
* **Mask** limits the axes that the noise is applied to.
* **Scale** the detail level of the noise field.
* **Speed min** the minimum velocity applied to particles.
* **Speed max** the maximum velocity applied to particles.
* **Phase min** the minimum time offset of the noise field for a particle.
* **Phase max** the maximum time offset of the noise field for a particle.

### Audio Response Options

Use these options to scale the particle property based on the amplitude of a frequency range. If the amplitude of the selected range is below the *lower bound*, the particle property will become disabled, while reaching the *upper bound* means, that the property will be in full effect. Everything in between will scale accordingly.

* **Mode** Choose which channel to listen to. Center will use the average output of the left and right channel.
* **Exponent** Exponential scale between the lower and upper bound of the effect. 1 means no scaling, 2 means scaling towards the lower bound - 0.5 towards the upper.
* **Bounds** The lower and upper bound of the audio to listen to.
* **Frequency start** The start of frequencies to check.
* **Frequency end** The end of frequencies to check.

The frequency range is already combined into fewer bins, i.e. you can use 0 - 2 to detect bass and 13 - 15 for high tones. If you want to fully turn the effect on and off quickly according to the sound, using a high lower and upper bound is helpful to detect kicks and beats (for example 0.9 - 1.0).
Particle Emitter Box Random

Spawns particles within a sphere.

* **Offset** the center of the emitter from the position of the particle system in XYZ.
* **Directions** offset the particles along these axes.
* **Rate** how fast particles spawn.
* **Duration** how long this emitter spawns particles. 0 for indefinite duration.
* **Distance min** minimum distance from the center.
* **Distance max** maximum distance from the center.
* **Speed min** how much minimum velocity particles receive, the velocity points away from the center.
* **Speed max** how much maximum velocity particles receive, the velocity points away from the center.
* **Instantaneous** how many particles are immediately spawned when the particle system starts.
* **Control point** which control point to emit from.

You need a movement operator for the speed parameters to have any effect.

### Audio Response Options

Use these options to scale the particle property based on the amplitude of a frequency range. If the amplitude of the selected range is below the *lower bound*, the particle property will become disabled, while reaching the *upper bound* means, that the property will be in full effect. Everything in between will scale accordingly.

* **Mode** Choose which channel to listen to. Center will use the average output of the left and right channel.
* **Exponent** Exponential scale between the lower and upper bound of the effect. 1 means no scaling, 2 means scaling towards the lower bound - 0.5 towards the upper.
* **Bounds** The lower and upper bound of the audio to listen to.
* **Frequency start** The start of frequencies to check.
* **Frequency end** The end of frequencies to check.

The frequency range is already combined into fewer bins, i.e. you can use 0 - 2 to detect bass and 13 - 15 for high tones. If you want to fully turn the effect on and off quickly according to the sound, using a high lower and upper bound is helpful to detect kicks and beats (for example 0.9 - 1.0).
Image Effect Blend

Blends images and image layers together. A simple tool useful to build complex layered animations. In the example on the right, a scrolling beam has been *multiplied* via blend with a filtered version of the source image. The result of that has been blended with *linear dodge* to achieve a gleam effect.

## Combos

* **Blend mode**: How the blend texture is blended with the background image.

## Textures

* **Blend texture**: A source image or another image layer to be blended.
* **Opacity mask**: Controls where the blend on the image happens.

## Parameters

* **Multiply**: A multiplicator for the amount of blending.
Particle Operator Control Point Force

Applies velocity to particles to steer them towards a specific control point.

* **Offset** positional offset in XYZ coordinates from the control point.
* **Scale** how strongly the control point attracts or repels.
* **Threshold** the maximum distance between particle and control point where the force takes effect.
* **Control point** index of the control point to use.
Tutorial Car

This tutorial will show you how to animate a car by spinning its wheels. Make sure you checked out the basic guides for the Editor and Scene Wallpaper!

## Preparation

* Open the Editor.
* Get an image you want to animate, for example this:

## Import the Image

   Drag and drop the image into the editor.

   The project name and scheme color will be automatically set, you can change them if you like. Press *OK* to import the image and create the wallpaper.

    A new wallpaper will be created and the image should become visible.

## Animate Wheels

    Select the image on the left and then click *Add* in the effects menu to add a new effect.

    Choose the Image Effect Spin and click *OK*.

    First, change the speed to 0 on the right, this will make it easier to edit everything else.

    Click on the crosshair icon near *center* and then click in the exact center of the right wheel. This will make the spin effect center on the wheel later.

    Start painting a mask for the spin effect by clicking on *paint* near the opacity mask option.

    First, click on *Show mask* to make the mask visible. Now change the value to 0 and click *clear*, this will turn the mask black.

    Change the value to 255 and paint the rim of the wheel white like shown here, this is the part that should spin later.

💡 **Pro tip:** You can make the spin more realistic by turning the inner part slightly black again, this will avoid rotating the break unit. You can also make the border a bit more smooth for a nicer result:

**Click OK in the paint options to save your changes now.**

    Change the *speed* to -5. The wheel will now start rotating, but the perspective is still wrong.

    To correct the perspective, enable the *elliptical* option. You will now see two new controls, ratio and angle. You can use these to correct the aspect ratio of the ellipsis and the angle it should face. For the right wheel here, use *angle*: 0.15 and *ratio*: 1.42. You can use the arrow keys to adjust the value with more precision than the slider until you find the correct ones.

    The right wheel should now be rolling, repeat the same for the left, start by adding another Image Effect Spin.

## Animate Subtle Car Motion

    We also want to make the car shake down and up a little to make it look more lively. Add an Image Effect Shake to the image. Adjust the *strength* to 0.05 and the *speed* to 3. Then click on *paint* for the flow map as shown on the image.

    Increase the size of the paint brush and make sure the options are set to the ones shown here.

    Now paint the shake movement of the car in one or two strokes with the large paint brush. You can overlap the background for now.

    Reduce the size of the paint brush and set *value* to 0.

    Paint around the car with these settings to remove the shake effect from the surroundings again.

## Result

The final result of the animation. Additionally, we've added Image Effect Water Ripple to animate the water, Image Effect Clouds for the sky and Image Effect Water Flow for the road in this example.
Shader Preprocessor

Wallpaper Engine uses a custom preprocessor[1] to cull unused code and introspect a shader before compilation. The preprocessor is not a fullfledged C preprocessor and is lacking, for example, string conversion and concatenation. Conditionals should however work with boolean and logic operators, except for #elif, which isn't supported.

## The following define directives are applied based on context:

* **GLSL**

Shader is being compiled as GLSL.

* **HLSL**

Shader is being compiled as HLSL.

* **HLSL\_SM40**

Shader is being compiled for shader model 4.

* **HLSL\_GS40**

Current renderer supports shader model 4 geometry shaders.

## The following directives make it easier to write a shader that supports GLSL and HLSL:

* **texSample2D** (sampler, vec2 uvs) -> vec4

Sample a simple 2D texture. First parameter is a sampler constant and the second parameter a vec2 texture coordinate.

* **texSample2DLod** (sampler, vec2 uvs, float lod) -> vec4

Sample a simple 2D texture. First parameter is a sampler constant, the second parameter a vec2 texture coordinate and the third parameter a float to designate which mip maps get sampled.

* **mix**

Mix is the GLSL name for lerp in HLSL and accepted for both in Wallpaper Engine. So you should use **mix** to make the shader fully compatible.

* **frac**

frac is the HLSL name for fract in GLSL. So you should use **frac** to make the shader fully compatible.

* **saturate**

saturate is the HLSL name for clamp(x, 0, 1) in GLSL.

* **atan2**

atan2 is the HLSL name for atan in GLSL. So you should use **atan2**  to make the shader fully compatible.

* **ddx**

ddx is the HLSL name for dFdx in GLSL. So you should use **ddx** to make the shader fully compatible.

* **ddy**

ddy is the HLSL name for dFdy in GLSL. So you should use **ddy** to make the shader fully compatible.
Image Effect Color Key

Turns the image translucent where it has a specific color. That is how green screens work in a nutshell and this effect is a very simple implementation of that.

## Combos

* **Flatten**: Will additionally remove the color from translucent areas.
* **Invert**: Inverts which parts of the image are translucent and which aren't.

## Parameters

* **Color**: The color to be turned translucent.
* **Fuzziness**: Makes the transition between opaque and translucent more smooth.
* **Tolerance**: The tolerance in detecting the color key.
* **Write alpha**: What alpha value should be written in the detected places, 0 turns it completely translucent.
Image Effect Water Waves

Applies an abstract water wave to the image. Can be used for cloth or hair animations as well.

## Textures

* **Opacity mask**: Controls which area of the image becomes distorted.

## Parameters

* **Direction**: The direction of the waves.
* **Perspective**: Scales the waves towards the center of the image to simulate a perspective distortion.
* **Scale**: Sets the frequency of the waves.
* **Speed**: Defines how fast the waves animate.
* **Strength**: Control how much the image is distorted by the wave.

## Examples

      The effect can also be used to animate hair or clothes waving in the wind.
SceneScript Class IImageLayer

Class that provides access to functions specific to image layers.

# Properties

* **size**: Vec2

Resolution of the base image.

* **perspective**: Boolean

Controls the perspective rendering option.

* **solid**: Boolean

Controls whether the layer is solid to click events.

# Functions

* **getEffect**(name: String|Number): IEffect

Retrieves an effect by index or custom name, if set.

* **getEffectCount**(): Number

Total number of effects used by this image layer.

* **getTextureAnimation**(): ITextureAnimation

Gets the texture animation if the albedo texture of this image layer is a sprite sheet/GIF.

* **getAnimationLayerCount**(): Number

Get the number of animation layers currently used on this layer.

* **getAnimationLayer**(name: String|Number): IAnimationLayer

Get an existing animation layer object by name or index.

* **createAnimationLayer**(animation: String|Object): IAnimationLayer

Create a new animation layer by animation name or JSON config.

* **destroyAnimationLayer**(animationLayer: String|Object|IAnimationLayer): Boolean

Remove an existing animation layer by name, index or IAnimationLayer object reference.

* **getBoneCount**(): Number

Get the number of skeletal bones.

* **getBoneTransform**(bone: String|Number): Mat4

Get world bone transform by name or index.

* **setBoneTransform**(bone: String|Number, transform: Mat4): void

Set world bone transform by name or index.

* **getBoneIndex**(name: String): Number

Get the index of a bone by name.

* **getBoneParentIndex**(child: Number|String): Number

Get the index of a bone by name.

* **applyBonePhysicsImpulse**(bone?: String|Number, directionalImpulse: Vec3, angularImpulse: Vec3): void

Apply directional or angular impulse to a physics bone.

* **resetBonePhysicsSimulation**(bone?: String|Number): void

Resets physics forces and position.
SceneScript Class IScene

Global interface exposed via object **thisScene** to access the currently loaded scene.

# Properties

* **bloom**: Boolean

Turns the bloom effect on and off.

* **bloomstrength**: Number

Strength of the bloom effect.

* **bloomthreshold**: Number

Minimum brightness required to make bloom show up.

* **clearenabled**: Boolean

Whether the backbuffer will be cleared at the beginning of a frame.

* **clearcolor**: Vec3

The color to clear the backbuffer with.

* **ambientcolor**: Vec3

The ambient color in 3D.

* **skylightcolor**: Vec3

The lower ambient color in 3D.

* **fov**: Number

Field of view in 3D.

* **nearz**: Number

Near Z plane distance for 3D.

* **farz**: Number

Far Z plane distance for 3D.

* **camerafade**: Boolean

Whether the camera will show the fade effect when changing paths.

* **camerashake**: Boolean

Turns camera shake on or off.

* **camerashakespeed**: Number

Sets the base speed for the camera shake.

* **camerashakeamplitude**: Number

Sets the magnitude of the camera shake.

* **camerashakeroughness**: Number

Sets how rough the camera will shake.

* **cameraparallax**: Boolean

Turns the camera parallax effect on or off.

* **cameraparallaxamount**: Number

How strong the parallax will scale.

* **cameraparallaxdelay**: Number

How quickly or slowly the parallax effect will transition.

* **cameraparallaxmouseinfluence**: Number

How much the parallax effect is affected by the cursor position.

# Functions

* **getLayer**(name: String|Number): ILayer

Get a layer by index or custom name.

* **getLayerCount**(): Number

Get the total layer count.

* **enumerateLayers**(): ILayer[]

Get all layers in an array.

* **destroyLayer**(name: String|Number|ILayer): Boolean

Remove a layer by index, name or reference. The layer will actually be removed in a deferred manner so consider this when expecting scripts to stop or destroy on that layer.

* **createLayer**(configuration: String|Object|IAssetHandle): ILayer

Creates a new layer and returns a reference to it. The configuration can simply be a path to the asset relative to the project, a custom object just like in the scene.json file itself with any overrides you want or an IAssetHandle returned by engine.registerAsset().

* **sortLayer**(layer: String|Number|ILayer, index: Number): Boolean

Changes the display order of a layer.

* **getLayerIndex**(layer: String|ILayer): Number

Returns the current index of a layer in the scene graph.

* **getInitialLayerConfig**(layer: String|Number|ILayer): Object;

Get the initial configuration of an existing layer.

* **getCameraTransforms**(): CameraTransforms

Returns the current, static camera transforms. Do not use this while using a camera path!

* **setCameraTransforms**(cameraTransforms: CameraTransforms): void

Changes the current, static camera transforms. Do not use this while using a camera path!
Particle Initializer Color Random

Sets a random color for each particle between two color options. You can add multiple color random initializers to provide more variety (colors are multiplied).

* **Min** the first color to blend between.
* **Max** the second color to blend between.
* **Exponent** biases towards the first or second color.
Tutorial Scripting Color Shift Snippet

This tutorial will show you to use a script snippet to continuously shift a color input of any effect like the tint effect. Make sure you checked out the basic guides for the Editor and Scene Wallpaper!

## Preparation

* Open the Editor.
* Get an image you want to animate, for example this:

## Import the Image

   Drag and drop the image into the editor.

   The project name and scheme color will be automatically set, you can change them if you like. Press *OK* to import the image and create the wallpaper.

    A new wallpaper will be created and the image should become visible.

## Add Tint Effect

    Select the image on the left and then click *Add* in the effects menu to add a new effect.

    Add the *tint* effect from the menu.

    Bind a new script to the *color* property.

    Replace the script contents with the *Rainbow Color* snippet from the menu.

    Adjust the script variables to your liking. You can control how quickly the color will be shifted with *rainbowSpeed* while you can change the saturation and brightness with the other two variables respectively.

This snippet uses the update event and the color module to animate the hue component of the property every frame.

    Finally, click the *Run script* button to check the result.
Tutorial Shimmer

This tutorial will show you how to create an masked shimmer effect by combining multiple images and image effects. Make sure you checked out the basic guides for the Editor and Scene Wallpaper beforehand. It is recommended that you are already familiar with creating simpler effects before trying this one.

## Preparation

* Create a new 2D scene wallpaper in the editor.
* You will need three images for this effect. A background image like this one , a shimmer mask with a lower resolution like this  and finally some kind of beam that will be scrolling over the mask like .
* You can create the mask image in Wallpaper Engine, but keep in mind that everything in Wallpaper Engine is computed in real time and therefore more costly to display. A simple way of getting a mask is using this method [1] in GIMP.

## Create Scrolling Beam

    Drag and drop the beam  into the editor.

    Disable the *adjust wallpaper size and center* option, because this image will not be used as the background picture that the wallpaper will evolve around.

    Add a new image effect and choose Image Effect Scroll.

    Change *speed y* to 0 and *speed x* to -0.7.

    Add another effect and choose Image Effect Transform. Set *angle* to 0.33 and *scale* 0.5, 1.

    You should now have a scrolling, slanted beam.

## Add Shimmer Mask

    Import the shimmer mask with these options. Move it out of the way, somewhere next to the beam, using the Gizmos.

    Add Image Effect Blend to the mask. Now drag and drop the *beam* image layer onto the *blend texture* option. The mask will now animate based on the movement of the beam.

    Add Image Effect Blur to the shimmer mask layer, right after the blend we added before. Change kernel size to 7x7.

    You should now have a smoothly animated shimmer mask.

## Combine Shimmer with Background

    Import the main image with these settings. Make sure to tick *adjust wallpaper size and center* this time.

    Add a new Image Effect Blend to this image and drag and drop the mask image layer onto the blend texture here.

    Change the *blend mode* to *linear dodge* and adjust the *multiply* option to your liking, it controls the strength of the effect now.

💡 **Pro tip:** Hide the beam and shimmer mask layers by unchecking *visible*, this will save a little performance!
SceneScript Class IEngine

Global interface exposed via object **engine** to access general features of the application.

# Properties

* **screenResolution**: Vec2

The size of the screen the wallpaper is displayed on.

* **canvasSize**: Vec2

The size of the wallpaper project defined in the editor. Only for 2D.

* **userProperties**: Object

Access to the user properties currently selected by the user. Color properties are converted to Vec3 automatically.

* **timeOfDay**: Number

The time of day in the range [0, 1] representing the 24h clock.

* **frametime**: Number

Time it took to update the last frame.

* **runtime**: Number

Total time in seconds that the wallpaper has been running.

⚠️ **Warning:** The runtime has a rollover to retain floating point precision. That means you should not use this value to set up a timer or event for the future, instead you should for example use **frametime** to decrease your time value until it hits 0.

# Functions

* **isRunningInEditor**(): Boolean

You can use this to check whether the script is currently running inside the editor or not.

* **isPortrait**(): Boolean

Returns true if the display of the wallpaper uses a portrait resolution.

* **isLandscape**(): Boolean

Returns true if the display of the wallpaper uses a landscape resolution.

* **registerAudioBuffers**(resolution: Number): IAudioBuffers

Call this from the global scope of a script to register your script with the audio responsive system in Wallpaper Engine and get access to the audio spectrum. The *resolution* is the number of samples per buffer. It must be 16, 32 or 64.

* **registerAsset**(file: String): IAssetHandle

Use this to mark an asset as being used by your wallpaper even when it's currently not used on any layer. This is important for releasing a wallpaper to the Workshop, only used or marked assets will be included in the scene archive that is generated.

* **setTimeout**(callback: Function, delay?: Number): Function

Starts a timeout callback in milliseconds. Returns a new callback that can be used to stop the timeout prematurely.

* **setInterval**(callback: Function, delay?: Number): Function

Starts a repeating interval callback in milliseconds. Returns a new callback that can be used to stop the interval.

* **isDekstopDevice**(): Boolean
* **isMobileDevice**(): Boolean
* **isWallpaper**(): Boolean
* **isScreensaver**(): Boolean
Image Effects

Similar to Photoshop filters, image effects will modify your image and animate it. They are all rendered in real-time and some of them should be used sparingly. You can use them on image layers, fullscreen layers and composition layers, stack multiple effects and even link layers through effects to blend them together.

## Adding/Editing an Image Effect

   To add one, select the layer you want to add it to and click on *Add* on the right. You can modify it later by double clicking it or clicking on *Edit*. Use drag and drop to change their rendering order in the list. All available effects can be found here: Image Effects

   The effect can be removed by clicking on the red *X*.
SceneScript Class ICursorEvent

Provides information about the cursor position during cursor change events like cursorEnter.

⚠️ **Warning:** This class is only well implemented for 2D wallpapers right now and the z position of both coordinates is not used.

# Properties

* **worldPosition**: Vec3

Hit position in absolute world coordinates.

* **localPosition**: Vec3

Hit position relative to the object, i.e. for image layers x will be in the range of [0, thisLayer.size.x] and y in the range of [0, thisLayer.size.y].
Image Effect Clouds

Adds a layer of clouds on top of the image.

## Combos

* **Blend mode**: How the clouds are blended with the background image.
* **Perspective**: Enables perspective distortion.
* **Shading**: Adds light and dark areas to the clouds as if they were lit by a light.
* **Write alpha**: Makes the image only opaque where there are clouds.

## Textures

* **Albedo**: The source texture used to generate the clouds, should be a noise image.
* **Opacity mask**: Controls in which parts of the image clouds will appear.

💡 **Pro tip:** Instead of just painting a simple mask, drag and drop a cloud image here to make the effect look more realistic, like this one:

## Parameters

* **Alpha**: How opaque the clouds are.
* **Color end**: The color used at the cloud borders.
* **Color start**: The color used in the cloud center.
* **Feather**: How smooth the clouds transition.
* **Perspective warp (Perspective only)**: Distorts the image on each border. The order of borders is: Top, Left, Bottom, Right.
* **Scale**: The size of the cloud textures. They control the scale along the X and Y axis for both noise samples respectively.
* **Shading amount (Shading only)**: How much the shading is visible.
* **Shading direction (Shading only)**: From which direction the shading is applied.
* **Speed**: How fast the clouds move. The 4 values represent the horizontal and vertical movement for each respective layer.
* **Threshold**: Controls the density of the clouds.

## Examples

Perspective and shaded clouds that become smaller the farther they are away.
Renderable

These are objects in your scene wallpaper that can be drawn to the screen. They have different types and offer different properties and features.

## Types

1. Image Layer
2. Particle System
3. Model
4. Fullscreen Layer
5. Composition Layer

## Common Properties

These properties can be found for various types of renderables:

1. **Visible** controls whether a renderable is drawn to the screen. Useful to prerender 2D renderables offscreen and use them as inputs to other renderables.
2. **Name** defines a name to identify the renderable more easily in the scene graph.
3. **Origin** is the position in XYZ coordinates.
4. **Angles** describes the rotation in degrees and euler angles.
5. **Scale** is the size along the XYZ axis.
6. **Blend mode** works like photoshop blend modes for 2D renderables.
7. **Parallax depth** for 2D renderables if the camera has parallax enabled in the scene options. This controls how much a renderable is affected by the effect, making it possible to create an illusion of depth.
8. **Materials** a list of materials that are used by the renderable.
Tutorial Scene Optimization

The performance of scene wallpapers highly depends on the images and effects used. The resolution and number of images, the number and type of effects or even certain settings that are part of an effect. You can follow these optional guides to further optimize the performance of your wallpapers for low to mid range computers.

## Particles (TBD)

* Optimize particle simulation performance
* Optimize particle memory
Tutorial Scripting Mario Jump

💡 **Pro tip:** This tutorial is extremely advanced and you will need some programming knowledge to understand the script. You can Google JavaScript tutorials to learn JavaScript, then learn about everything that is part of Wallpaper Engine's scripting here on this wiki.

This example wallpaper shows how you can make Mario walk towards your cursor, jump when clicking on him and collect coins that spawn in the air.

The source wallpaper files are here: https://gofile.io/?c=c1p71y copy them into the **myprojects** directory (*C:\Program Files (x86)\Steam\steamapps\common\wallpaper\_engine\projects\myprojects*) to open the project.

## Result

You can see the wallpaper in action here: https://streamable.com/saz7a

## Construction

* The background layer covers the entire wallpaper and uses the scroll image effect to scroll to the left.
* The second background layer contains the blocks. It has a script attached to its origin that moves it to the left and resets it to the right side when it goes outside of the wallpaper.
* The third background layer is the small patch of grass at the bottom, it scrolls to the left with the scroll image effect.
* The layer *mario\_walk\_1* contains the walk animation that consists of two PNG frames. This layer also contains all of the code.
* The layer *mario\_jump* contains the single jump sprite, it will start as invisible.
* The jump sound effect layer is set to playback mode single and start silent.
* The coin sound effect layer is set to playback mode single and start silent.

## Main Script

This script is attached to the layer *mario\_walk\_1* and contains the bulk of the logic. It uses the following events: init, update and cursorDown.

Make sure to read the comments in the script to see what each part of the code is about. You will need to understand some linear algebra, the Vec3 class is important to move and position every object through the script.

* init will locate the jump sprite layer to turn it visible/invisible later and also makes it invisible for the beginning.
* update will spawn new coins occasionally, move all coins to the left and destroy coins either when Mario touches them or they go out of bounds. It also moves Mario up and down (jumping, gravity) and to the left and right towards your cursor.
* cursorDown will initiate a jump by turning the walk sprite invisible and the jump sprite visible while also setting the vertical velocity up.
SceneScript Class IAnimation

This class represents a timeline property animation.

# Properties

* **fps**: Number (readonly)

The speed of the animation.

* **frameCount**: Number (readonly)

The number of frames of this animation.

* **duration**: Number (readonly)

The duration in seconds of this animation.

* **name**: String (readonly)

The custom name of this animation.

* **rate**: Number

Speed factor of the animation.

# Functions

* **play**()

Continues or starts playing the animation if it was paused or stopped.

* **stop**()

Stops the animation and reverts to the beginning.

* **pause**()

Pauses the animation at the current position.

* **isPlaying**(): Boolean

Returns whether the animation is currently playing or if it's paused/stopped.

* **getFrame**(): Number

Get the current frame of the animation.

* **setFrame**(frame: Number)

Set the animation to the specified frame.
Image Effect Local Contrast

Enhances the contrast of the image.

This effect is expensive. Consider limiting the effect to optimize the wallpaper.

It is further recommended to only use it inside Wallpaper Engine if you make it dynamic and animated so that applying it to the raw image beforehand is not possible.

## Combos

* **Kernel size**: Controls quality and size of enhancement detection.
* **Greyscale**: Whether the contrast is enhanced only based on luminosity or color.

## Textures

* **Opacity mask**: Limit the effect to parts of the image.

## Parameters

* **Scale**: Controls the size of the contrast filter.
* **Strength**: How much of the effect is applied.
Particle Control Points

They define a position inside the particle system that can be used in operators or emitters.

* **Offset** a static offset relative to the position of the particle system.
* **Lock to pointer** this control point will follow the mouse cursor.
* **Worldspace** the control point will always be at the same position in the world, independent from the position of the particle system.
Image Effect Water Flow

Simulates a continuous flow on the image in-place. The section that this effect is applied to will be repeated on a small scale.

## Textures

* **Flow map**: Determines which places the effect will be applied to and in which direction.
* **Flow phase**: Offsets the point in time that the loop of the effect occurs, to make the transition more natural.

## Parameters

* **Phase scale**: The detail scale of the phase texture.
* **Speed**: The speed of the flow animation.
* **Strength**: The maximum distance that the effect will cover.
Tutorial Clothes

This tutorial will show you how to make clothes sway in the wind in a wallpaper. Make sure you checked out the basic guides for the Editor and Scene Wallpaper!

## Preparation

* Open the Editor.
* Get an image you want to animate, for example this:

## Import the Image

   Drag and drop the image into the editor.

   The project name and scheme color will be automatically set, you can change them if you like. Press *OK* to import the image and create the wallpaper.

    A new wallpaper will be created and the image should become visible.

## Animate the Clothes

    Select the image and click *add* in the effects menu on the right.

    Select the Image Effect Water Waves and click *OK*.

    The effect is now applied to the entire image. Click on *Paint* next to the opacity mask to start selecting the area around the dress only.

    It is easier to clear the entire mask first. Change the *value* to 0 and then click *clear*.

    Change the *value* back to 255 and start painting on the clothes you want to animate. Use a low *opacity* to slowly increase the strength of the animation.

    In this example, we want the clothes to only animate very diligently at the top and more strongly at the bottom, this can be achieved by painting less at the top and using a lower *value* or *opacity* while working there. You can use the *show mask* button to verify where you have painted already.

**Click OK when you're done to save the mask.**

    To make the effect believable, we want to reduce the frequency and amplitude of the waves. Change the settings on the right like this to make the animation look more like clothes.

* Direction: 5.4
* Scale: 53
* Speed: 2.6
* Strength 0.05

## Result

The strength and speed have been increased a little here to make it more obvious for the GIF.
Image Effect Pulse

Adds a color pulse to the image. Can be used to animate flickering or pulsating lights.

## Combos

* **Blend mode**: How the pulse color is blended with the background image.
* **Pulse alpha**: Make the pulse animation affect the opacity of the image.
* **Pulse color**: Make the pulse animation affect the color of the image.

## Textures

* **Noise**: Texture used for the noise effect, by default this is not used.
* **Opacity mask**: A paintable mask to determine which area of the image is affected. By default the entire image will pulse.

## Parameters

* **Noise amount**: How much you want the animation to flicker.
* **Noise speed**: How fast it should flicker.
* **Power**: Exponent for the pulse animation.
* **Pulse amount**: A multiplier for the pulse output value.
* **Pulse bounds**: This maps how much time the pulse is *bright* and *dark*. For example, set to *0.8, 1* for a short pulse.
* **Pulse phase**: The time offset of this effect.
* **Pulse speed**: The speed of the pulse animation.
* **Tint high**: Color applied to the *bright* state of the pulse.
* **Tint low**: Color applied to the *dark* state of the pulse.

## Examples

   Short, strong pulses created by setting the *pulse bounds* to *0.8, 1* and the *pulse amount* to *2*.
Don Galbani

## Przynależność

Rodzina Galbani

Don Galbani to głowa rodziny Galbani - najbardziej wpływowej rodziny kupieckiej w Zadrożdżewie. Historia rodu Galbani sięga czasów założenia Drożdżewa, ale jego wpływy z czasem zmalały do tego stopnia, że w 1320 roku rodzina została zmuszona do sprzedania swojej drożdżewskiej rezydencji i przeprowadzki do jednej ze swoich pomniejszych posiadłości w Zadrożdżewie.

Kiedy podczas wojny w roku 1327 Drożdżewo zostało wyrżnięte i spalone, rodzina Galbani nagle stała się drugą najbardziej wpływową rodziną w regionie, tuż za rodziną Agrigento. Choć okoliczności były tragiczne, wydarzenia te rozbudziły ambicję Dona Galbani, który postanowił odbudować dawną chwałę rodu.

Między rodami Galbani i Agrigento nawiązała się ostra rywalizacja, choć nie doszło nigdy do rozlewu krwi. Najpoważniejszy incydent polegał na zbeszczeszczeniu mauzoleum Galbanich przez agentów Dona Agrigento. Przeklęta runa narysowana na jednym z sarkofagów sprawiła, że jeden z przodków Dona Galbani powstał jako ghul. Sprawę tę rozwiązął Team Mariuszek zabijając potwora i niszcząc sarkofag.

W 1337 roku, z pomocą golema Unglormatora Galbani wygnał z Zadrożdżewa rodzinę Agrigento i spełnił swoje marzenie. Wynagrodził golema wielką buławą swojego przodka, ponieważ nie musiał już spoglądać w przeszłość. Ród Galbani odzyskał należną mu pozycję.
Material

Defines which shader and textures are combined to draw something to the screen. It also exposes various shader properties that can be adjusted.

* **Blending** controls low level graphics blending. Translucent will blend using the alpha channel, additive will *add* the color on top of the existing background. I.e. use additive to make things glow.
* **Depth write** enables writing to the depth buffer. Use it for opaque models but not images or translucent objects.
* **Depth test** disable this if you want to draw *behind* objects.
* **Culling** defines which side of a model is visible or if both should be rendered. For foliage, set it to no cull.

## Combos

These are special switches that control various shader features.

## Textures

The actual images that are rendered are referred to as textures. Multiple textures can be used to accomplish effects specific to different shaders. Click on *Browse* to choose a texture that already exists somewhere in the project or import/export a texture. Click on the gear icon to change its settings.

## Shader

You can find shader properties here that are exposed by the shader used in the material.
Image Layer

These renderables display custom images on your 2D scene wallpaper. They can have Image Effects applied to them and you can use them as input textures into image effects used on other renderables.

## Supported Formats

PNG, TGA, JPEG, GIF, BMP, ICO, DDS are supported. For translucent layers TGA is recommended. Using the TGA format, you are able to directly edit the alpha channel in your image editor of choice and avoid seams around the translucent borders of your image.

## Adding an Image Layer

   Drag and drop an image file into the editor. Alternative you can click on Edit -> Import Image or Add -> Image Layer.

   A new dialog will open that allows you to configure the Texture Options (1.) for the import and a checkbox that will resize the wallpaper to match your image and center it (2.). Usually you want this checkbox to be enabled for your background image only, which you should import first.

After clicking *OK* the image will be copied into your project and compiled into a texture. It will be added as a new layer and asset automatically.
Zjarani Trubadurzy

## Przynależność

Zjarani Trubadurzy

Zjarani Trubadurzy byli wędrownymi grajkami, poetami oraz bajarzami podróżującymi po całej Normmiki oraz Soraski. Wsławili się baśnią z tęczowej polany napisaną w 1336 roku. Zrezygnowali ze swoich imion ponieważ woleli być określani jednakowo przez wszystkich. Przynależało do nich czterech przyjaciół oraz ich wierny, jedyny w swoim rodzaju dżdżownikot ceniący ich obecność, a nie bogato zdobione domy. Trubadurzy szukali weny podczas palenia ogromnej ilości bagiennego ziela.