Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/gnd/glslr

Ultra-lightweight GLSL livecoding framework.
https://github.com/gnd/glslr

glsl glsl-livecoding-framework glsl-shaders linux macosx shader

Last synced: 24 days ago
JSON representation

Ultra-lightweight GLSL livecoding framework.

Awesome Lists containing this project

README 

        
# glslr



![Ultra-lightweight GLSL interpreter](glslr.png)



## Features

- Ultra-lightweight GLSL livecoding framework for Linux and Mac OS X.

- Enables quick fragment shader development in your favorite editor.

- Changes in the fragment shader are compiled in realtime.

- Uniform variables can be filled with data received from a socket.

- Enables GLSL code-reuse across projects with support of #include.

- Has experimental Video4Linux support.

- Has support for livestreaming from a Sony AS30 ActionCam.

- Can save frames to .jpg or .tga.



## Installation:



On Ubuntu:

```

apt-get install git libgles2-mesa-dev libglfw3-dev libcurl4-openssl-dev libjpeg8-dev

git clone https://github.com/gnd/glslr

cd glslr

make

sudo make install

```

On Mac OSX:

```

(get CodeX, homebrew)

brew install glfw3 glew libjpeg

git clone https://github.com/gnd/glslr

cd glslr 

make

sudo make install

```

Please note that you can edit the src/makefile to enable/disable v4l2 support, simply by changing VIDEO=yes or VIDEO=no before compilation. V4l2 support is disabled when compiing on Mac OSX.



## Usage:



This will read the fragment shader from shaders/tunnel.glsl and render it in a 800x600 window on the primary monitor. Any changes you make to the file while **glslr** is running, will be automatically recompiled and sent to the GPU on save:

```

glslr shaders/tunnel.glsl

```



This will read the fragment shader from shaders/template.glsl and render it into a 1024x768 window on the primary monitor:

```

glslr --primary-res 1024x768 shaders/template.glsl

```



This will read the fragment shader and render it fullscreen on the secondary monitor (if any):

```

glslr --secondary-fs shaders/glass_sphere.glsl

```



For other options see bellow:

```

usage: glslr [options]  [layer1.glsl] [layer2.glsl] ...

options:

  window properties:

    --primary-fs                            create a fullscreen window on primary monitor

    --primary-res [WidthxHeight]            create a width x height window on primary monitor (default: 800x600)

    --secondary-fs                          create a fullscreen window on secondary monitor

    --secondary-res [WidthxHeight]          create a width x height window on secondary monitor

  offscreen format:

    --RGB888

    --RGBA8888 (default)

    --RGB565

    --RGBA4444

  interpolation mode:

    --nearestneighbor (default)

    --bilinear

  wrap mode:

    --wrap-clamp_to_edge

    --wrap-repeat (default)

    --wrap-mirror_repeat

  backbuffer:

    --backbuffer                            enable backbuffer (default:OFF)

  network:

    --net                                   enable network (default:OFF)

    --tcp                                   enable TCP (default:UDP)

    --port [port]                           listen on port (default:6666)

    --params [n]                            number of net input params (default:0)

  sony:

     --sony                                 enable Sony ActionCAM AS30 support

  video:

    --vdev [device number]                  v4l2 device number (default: 0 eg. /dev/video0)

  saving:

    --save-tga                              use TGA format instead of the default JPEG

    --save-dir [dir]                        directory where to save frames

    --save-file [filename]                  filename to save frames in the form: name_%0nd

                                            %0nd stands for number of digits, eg. my_%06d

                                            will be saved as my_000001.jpg, my_000002.jpg, etc.. (or .tga)

```

## Usage with network:

```

glslr --net --port [port] --params N example.glsl

```



The parameters must be sent via UDP to the [port] in the form: *"param0 param1 param2 ... paramN;"*.  

A reference is to use PureData's object [netsend]. Currently only integer and float variables are supported.



**glslr** makes the received data available in the shader as uniform float. The data can be accessed if you declare pamaters like this in the shader:

```

uniform float m0;

..

uniform float mN;

```

You can use the parameters to carry input from a MIDI controller, sound-analysis or anything you like. The maximum count of parameters is 99 for now.



## Usage with video:



**glslr** makes it possible to use experimental live video input from a V4L device. Currently only YUV422 devices are supported. The image is raw YUV422 - conversion into RGBA is up to you in the shader.

```

glslr --vdev [video device number] example.glsl

```

Provide the video device number to be able to use it in the shader. Default is 0 which expands to /dev/video0.  

Eg. if you want to use /dev/video1 do:



```

glslr --vdev 1 shaders/test_video.glsl

````

In the shader you can access the video data by using uniform sampler2D variable called video. To start camera press 'v'.

```

#version 130



out vec4 PixelColor;

uniform vec2 resolution;

uniform sampler2D video;



// press 'v' to start video



void main(void) {

	vec2 p = vec2( gl_FragCoord.x / resolution.x, 1.0 - gl_FragCoord.y / resolution.y);

	PixelColor = texture(video, p);

}

```



## Using Sony ActionCam input:



**glslr** makes it possible to use live video input from a Sony AS30 ActionCam. 

```

glslr --sony shaders/test_sony.glsl

```



In the shader you can access the video data by using uniform sampler2D variable called sony:

```

#version 130



out vec4 PixelColor;

uniform vec2 resolution;

uniform sampler2D sony;



void main(void) {

	vec2 p = vec2( gl_FragCoord.x / resolution.x, 1.0 - gl_FragCoord.y / resolution.y);

	PixelColor = texture(sony, p);

}

```



## Using include:



**glslr** provides support to include GLSL files from within the shader. Lines containing the string //#include file will be replaced with the contents of the file:



function.glsl:

```

color = vec3(1.,0.,0.);

```



project.glsl:

```

void main(void) {

	vec3 color = vec3(0.,1.,0.);



	//#include function.glsl  

    // ^^^ this line will be replaced with contents of the function.glsl file



	gl_FragColor = vec4(color, 1.0);

}

```

## 



**glslr** is a fork of pijockey-sound (https://github.com/gnd/pijockey-sound), a GLSL livecoding framework for RaspberryPi, an extension of the original sourcecode of **PiJockey by sharrow**.  

**glslr** was ported to x86, using GLFW. The Video4Linux capability was scrambled from **glutcam** by George Koharchik.  

**glslr** is being occasionally developed (when preparing for a new performance) by gnd ♥ gnd.sk.