Security News
The Unpaid Backbone of Open Source: Solo Maintainers Face Increasing Security Demands
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
lygia, it's a granular and multi-language shader library designed for performance and flexibility
Tired of searching, porting and/or reimplementing the same functions over and over? LYGIA is a shader library of reusable functions that can be included easily into your projects. LYGIA is very granular and designed for reusability, performance, and flexibility. LYGIA can easily be added to any project or framework.
In your shader #include
the functions you need:
#ifdef GL_ES
precision mediump float;
#endif
uniform vec2 u_resolution;
uniform float u_time;
#include "lygia/space/ratio.glsl"
#include "lygia/math/decimate.glsl"
#include "lygia/draw/circle.glsl"
void main(void) {
vec3 color = vec3(0.0);
vec2 st = gl_FragCoord.xy/u_resolution.xy;
st = ratio(st, u_resolution);
color = vec3(st.x,st.y,abs(sin(u_time)));
color = decimate(color, 20.);
color += circle(st, .5, .1);
gl_FragColor = vec4(color, 1.0);
}
If you are working locally in an environment that can resolve #include
dependencies, just clone LYGIA into your project relative to the shader you are loading:
git clone https://github.com/patriciogonzalezvivo/lygia.git
or as a submodule:
git submodule add https://github.com/patriciogonzalezvivo/lygia.git
If you are working on a cloud platform you probably want to resolve the dependencies without needing to install anything. Just add a link to https://lygia.xyz/resolve.js
(JS) or https://lygia.xyz/resolve.esm.js
(ES6 module):
<!-- as a JavaScript source -->
<script src="https://lygia.xyz/resolve.js"></script>
<!-- Or as a ES6 module -->
<script type="module">
import resolveLygia from "https://lygia.xyz/resolve.esm.js"
</script>
To then resolve the dependencies by passing a string
or strings[]
to resolveLygia()
or resolveLygiaAsync()
:
// 1. FIRST
// Sync resolver, one include at a time
vertSource = resolveLygia(vertSource);
fragSource = resolveLygia(fragSource);
// OR.
// ASync resolver, all includes in parallel calls
vertSource = resolveLygiaAsync(vertSource);
fragSource = resolveLygiaAsync(fragSource);
// 2. SECOND
// Use the resolved source code
shdr = createShader(vertSource, fragSource);
Learn more about LYGIA and how to use it from these examples:
For more information, guidance, or feedback about using LYGIA, join #Lygia channel on shader.zone discord.
The functions are divided into different categories:
math/
: general math functions and constants: PI
, SqrtLength()
, etc.space/
: general spatial operations: scale()
, rotate()
, etc.color/
: general color operations: luma()
, saturation()
, blend modes, palettes, color space conversion, and tonemaps.animation/
: animation operations: easinggenerative/
: generative functions: random()
, noise()
, etc.sdf/
: signed distance field functions.draw/
: drawing functions like digits()
, stroke()
, fill
, etc/.sample/
: sample operationsfilter/
: typical filter operations: different kind of blurs, mean and median filters.distort/
: distort sampling operationssimulate/
: simulate sampling operationslighting/
: different lighting models and functions for foward/deferred/raymarching renderinggeometry/
: operation related to geometries: intersections and AABB accelerating structures.morphological/
: morphological filters: dilation, erosion, alpha and poisson fill.There are some functions whose behavior can be changed using the #defines
keyword before including it. For example, gaussian blurs are usually are done in two passes. By default, these are performed on their 1D version, but if you are interested in using a 2D kernel, all in the same pass, you will need to add the GAUSSIANBLUR_2D
keyword this way:
#define GAUSSIANBLUR_2D
#include "filter/gaussianBlur.glsl"
void main(void) {
...
vec2 pixel = 1./u_resolution;
color = gaussianBlur(u_tex0, uv, pixel, 9);
...
}
#include "path/to/file.*lsl"
which is defined by Khronos GLSL standard and requires a typical C-like pre-compiler MACRO which is easy to implement with just basic string operations to resolve dependencies.Here you can find some implementations on different languages:
C#:
. GLSLIncludes a small utility to add the include feature to glsl by z0rg.
C++:
. VERA's routines for resolving GLSL dependencies.
Python:
JavaScript:
. vanilla JS (online resolver) This small file brings resolveLygia()
which takes a string
or string[]
and parses it, solving all the #include
dependencies into a single string
you can load on your shaders.
. npm module (online resolver) by Eduardo Fossas; vite glsl plugin (local bundle) by Ustym Ukhman. Imports .glsl
local dependencies, or load inline shaders through vite.
. esbuild glsl plugin (local bundle) by Ricardo Matias. Imports local .glsl
dependencies through esbuild.
. webpack glsl plugin (local bundle) by Ryan Grieve that imports local .glsl
dependencies through webpack.
myFunc.glsl
contains myFunct()
. There are some files that just include a collection of files inside a folder with the same name. For example: color/blend.glsl
// which includes
color/blend/*.glsl
*.glsl
) and HLSL (*.hlsl
), but we are slowly extending to WGSL (*.wgsl
), CUDA (*.cuh
) and Metal (*.msl
). math/mirror.glsl
math/mirror.hlsl
math/mirror.wgsl
math/mirror.msl
math/mirror.cuh
#define
options
/*
original_author: <FULL NAME>
description: [DESCRIPTION + URL]
use: <vec2> myFunc(<vec2> st, <float> x [, <float> y])
options:
- MYFUNC_TYPE
- MYFUNC_SAMPLER_FNC()
*/
FNC_
is followed with the function name:
#ifndef FNC_MYFUNC
#define FNC_MYFUNC
float myFunc(float in) {
return in;
}
#endif
#defines
. Probably the most frequent use is templating the sampling function for reusability. The #define
options start with the name of the function, in this example MYFUNC_
. They are added as options:
in the header.
#ifndef MYFUNC_TYPE
#define MYFUNC_TYPE vec4
#endif
#ifndef MYFUNC_SAMPLER_FNC
#define MYFUNC_SAMPLER_FNC(TEX, UV) texture2D(TEX, UV)
#endif
#ifndef FNC_MYFUNC
#define FNC_MYFUNC
MYFUNC_TYPE myFunc(sampler2D tex, vec2 st) {
return MYFUNC_SAMPLER_FNC(tex, st);
}
#endif
sampler2D, mat4, mat3, mat2, vec4, vec3, vec2, float, ivec4, ivec3, ivec2, int, bool
/*
...
use: myFunc(<vec2> st, <vec2|float> x[, <float> y])
*/
#ifndef FNC_MYFUNC
#define FNC_MYFUNC
vec2 myFunc(vec2 st, vec2 x) {
return st * x;
}
vec2 myFunc(vec2 st, float x) {
return st * x;
}
vec2 myFunc(vec2 st, float x, float y) {
return st * vec2(x, y);
}
#endif
LYGIA has a long way to go. Your support will be appreciated and rewarded! All contributors are automatically added to the commercial license. This support can take multiple forms:
LYGIA is dual-licensed under the Prosperity License and the Patron License for sponsors and contributors.
Sponsors and contributors are automatically added to the Patron License and they can ignore any non-commercial rule of the Prosperity License software (please take a look at the exceptions).
It's also possible to get a permanent commercial license hooked to a single and specific version of LYGIA.
Exceptions:
color/mixBox.glsl
and color/mixBox.hlsl
are copyrighted by Secret Weapons with their own non-commercial license. These functions also require a LUT texture which is provided for research and evaluation purposes, if you wish to obtain it together with a commercial license, please contact them at mixbox@scrtwpns.com.Created and mantained by Patricio Gonzalez Vivo( Mastodon | Twitter | Instagram | GitHub ) and every direct or indirect contributors to the GitHub. This library has been built over years, and in many cases on top of the work of brilliant and generous people like: Inigo Quiles, Morgan McGuire, Alan Wolfe, Hugh Kennedy, Matt DesLauriers, and many others.
Sign up for the news letter below, join the LYGIA's channel on Discord or follow the Github repository
FAQs
lygia, it's a granular and multi-language shader library designed for performance and flexibility
The npm package lygia receives a total of 321 weekly downloads. As such, lygia popularity was classified as not popular.
We found that lygia demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
Security News
License exceptions modify the terms of open source licenses, impacting how software can be used, modified, and distributed. Developers should be aware of the legal implications of these exceptions.
Security News
A developer is accusing Tencent of violating the GPL by modifying a Python utility and changing its license to BSD, highlighting the importance of copyleft compliance.