Example #1
0
framebuffer = task.framebuffer((512, 512), '1f', samples=1)

vertex_size = 12
mesh = Obj.open('examples/monkey.obj').pack('vx vy vz')
vertex_count = len(mesh) // vertex_size

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };

        layout (location = 0) in vec3 in_vert;

        layout (location = 0) out float out_depth;

        void main() {
            vec4 vert = mvp * vec4(in_vert, 1.0);
            gl_Position = vert;
            out_depth = vert.z / vert.w;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (location = 0) in float in_depth;

        layout (location = 0) out float out_depth;
Example #2
0
framebuffer = task.framebuffer((512, 512))

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (location = 0) out vec4 out_color;

        vec2 positions[3] = vec2[](
            vec2(-0.5, -0.5),
            vec2(0.5, -0.5),
            vec2(0.0, 0.5)
        );

        vec4 colors[3] = vec4[](
            vec4(1.0, 0.0, 0.0, 1.0),
            vec4(0.0, 1.0, 0.0, 1.0),
            vec4(0.0, 0.0, 1.0, 1.0)
        );

        void main() {
            gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
            out_color = colors[gl_VertexIndex];
            gl_Position.y *= -1.0;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)
Example #3
0
vertex_data, index_data = pebble(10)
instance_data = fill(100)

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };

        layout (location = 0) in vec3 in_vert;
        layout (location = 1) in vec3 in_pos;
        layout (location = 2) in vec3 in_scale;

        layout (location = 0) out vec4 out_vert;
        layout (location = 1) out vec3 out_norm;

        void main() {
            out_vert = vec4(in_pos + in_vert * in_scale, 1.0);
            gl_Position = mvp * out_vert;
            out_norm = normalize(in_vert);
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (binding = 0) uniform Buffer {
Example #4
0
task = instance.task()

framebuffer = task.framebuffer((512, 512))

uniform_buffer = instance.buffer('uniform_buffer', 64)

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };

        layout (location = 0) in vec3 in_vert;
        layout (location = 1) in vec3 in_norm;

        layout (location = 0) out vec3 out_norm;

        void main() {
            gl_Position = mvp * vec4(in_vert, 1.0);
            out_norm = in_norm;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };
Example #5
0
task = instance.task()

image = instance.image((16, 16), layers=128)
image.write(data)

framebuffer = task.framebuffer((512, 512))

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (location = 0) in vec2 in_vert;
        layout (location = 1) in vec2 in_text;
        layout (location = 2) in float in_char;

        layout (location = 0) out vec3 out_text;

        void main() {
            gl_Position = vec4(in_vert, 0.0, 1.0);
            gl_Position.x += 0.1 * gl_InstanceIndex;
            out_text = vec3(in_text, in_char * 255.0);
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (binding = 0) uniform sampler2DArray Texture[];

        layout (location = 0) in vec3 in_text;
        layout (location = 0) out vec4 out_color;
Example #6
0
from glnext_compiler import glsl
from PIL import Image

instance = glnext.instance()
task = instance.task()

framebuffer = task.framebuffer((512, 512), compute=True)

compute = framebuffer.compute(
    compute_count=(512, 512),
    compute_shader=glsl('''
        #version 450
        #pragma shader_stage(compute)

        layout (binding = 0, rgba8) uniform image2D Result;

        void main() {
            vec2 pos = vec2(gl_GlobalInvocationID.xy) / 400.0f;
            vec3 color = vec3(sin(pos.x), sin(pos.y), cos(pos.x + pos.y));
            imageStore(Result, ivec2(gl_GlobalInvocationID.xy), vec4(color, 1.0));
        }
    '''),
    bindings=[
        {
            'binding': 0,
            'type': 'storage_image',
            'images': [{
                'image': framebuffer.output[0],
            }],
        },
    ],
)
Example #7
0
from glnext_compiler import glsl
from PIL import Image

instance = glnext.instance()
task = instance.task()

framebuffer = task.framebuffer((512, 512), '4p 4p', samples=4)

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        vec2 positions[3] = vec2[](
            vec2(-0.5, -0.5),
            vec2(0.5, -0.5),
            vec2(0.0, 0.5)
        );

        void main() {
            gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (location = 0) out vec4 out_color_1;
        layout (location = 1) out vec4 out_color_2;

        void main() {
            out_color_1 = vec4(0.8, 0.4, 0.1, 1.0);
Example #8
0
task = instance.task()

texture = Image.open('examples/rock.jpg').convert('RGBA')
image = instance.image(texture.size)
image.write(texture.tobytes())

framebuffer = task.framebuffer((512, 512))

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (location = 0) in vec2 in_vert;
        layout (location = 1) in vec2 in_text;

        layout (location = 0) out vec2 out_text;

        void main() {
            gl_Position = vec4(in_vert, 0.0, 1.0);
            out_text = in_text;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (binding = 0) uniform sampler2D Texture[];

        layout (location = 0) in vec2 in_text;
        layout (location = 0) out vec4 out_color;
Example #9
0
pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            vec2 scale;
        };

        layout (location = 0) out vec3 out_color;

        vec2 positions[3] = vec2[](
            vec2(-0.5, -0.5),
            vec2(0.5, -0.5),
            vec2(0.0, 0.5)
        );

        vec3 colors[3] = vec3[](
            vec3(1.0, 0.0, 0.0),
            vec3(0.0, 1.0, 0.0),
            vec3(0.0, 0.0, 1.0)
        );

        void main() {
            gl_Position = vec4(positions[gl_VertexIndex] * scale, 0.0, 1.0);
            out_color = colors[gl_VertexIndex];
        }
    '''),
    fragment_shader=glsl('''
        #version 450
Example #10
0
framebuffer = task.framebuffer((512, 512))

pipeline = framebuffer.render(
    mesh_shader=glsl('''
        #version 450
        #pragma shader_stage(mesh)
        #extension GL_NV_mesh_shader : require

        layout (local_size_x = 1) in;
        layout (max_vertices = 4, max_primitives = 2) out;
        layout (triangles) out;

        void main() {
            gl_MeshVerticesNV[0].gl_Position = vec4(-0.5, -0.5, 0.0, 1.0);
            gl_MeshVerticesNV[1].gl_Position = vec4(0.5, -0.5, 0.0, 1.0);
            gl_MeshVerticesNV[2].gl_Position = vec4(-0.5, 0.5, 0.0, 1.0);
            gl_MeshVerticesNV[3].gl_Position = vec4(0.5, 0.5, 0.0, 1.0);
            gl_PrimitiveIndicesNV[0] = 0;
            gl_PrimitiveIndicesNV[1] = 1;
            gl_PrimitiveIndicesNV[2] = 2;
            gl_PrimitiveIndicesNV[3] = 2;
            gl_PrimitiveIndicesNV[4] = 1;
            gl_PrimitiveIndicesNV[5] = 3;
            gl_PrimitiveCountNV += 2;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)
Example #11
0
task = instance.task()

framebuffer = task.framebuffer((1280, 720))

framebuffer.update(
    clear_values=glnext.pack([1.0, 1.0, 1.0, 1.0]),
)

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };

        layout (location = 0) in vec3 in_vert;

        void main() {
            gl_Position = mvp * vec4(in_vert, 1.0);
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (location = 0) out vec4 out_color;

        void main() {
            out_color = vec4(0.0, 0.0, 0.0, 1.0);
        }
Example #12
0
triangle_framebuffer = task.framebuffer((512, 512), mode='texture')

triangle_pipeline = triangle_framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (location = 0) out vec4 out_color;

        vec2 positions[3] = vec2[](
            vec2(-0.9, -0.9),
            vec2(0.9, -0.9),
            vec2(0.0, 0.9)
        );

        vec4 colors[3] = vec4[](
            vec4(1.0, 0.0, 0.0, 1.0),
            vec4(0.0, 1.0, 0.0, 1.0),
            vec4(0.0, 0.0, 1.0, 1.0)
        );

        void main() {
            gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
            out_color = colors[gl_VertexIndex];
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)
Example #13
0
shadow_fbo.update(
    clear_values=glnext.pack([1.0, 0.0, 0.0, 0.0]),
    clear_depth=1.0,
)

shadow_pipeline = shadow_fbo.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp_camera;
            mat4 mvp_light;
            vec3 camera;
            vec3 light;
        };

        layout (location = 0) in vec3 in_vert;
        layout (location = 0) out float out_depth;

        void main() {
            gl_Position = mvp_light * vec4(in_vert, 1.0);
            out_depth = gl_Position.z / gl_Position.w;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (location = 0) in float in_depth;
        layout (location = 0) out float out_depth;
Example #14
0
from glnext_compiler import glsl
from PIL import Image

instance = glnext.instance()
task = instance.task()

framebuffer = task.framebuffer((512, 512))

pipeline = framebuffer.render(
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (location = 0) in vec2 in_vert;
        layout (location = 1) in vec3 in_color;

        layout (location = 0) out vec3 out_color;

        void main() {
            gl_Position = vec4(in_vert, 0.0, 1.0);
            out_color = in_color;
        }
    '''),
    fragment_shader=glsl('''
        #version 450
        #pragma shader_stage(fragment)

        layout (location = 0) in vec3 in_color;
        layout (location = 0) out vec4 out_color;

        void main() {
            out_color = vec4(in_color, 1.0);
    vertex_shader=glsl('''
        #version 450
        #pragma shader_stage(vertex)

        layout (binding = 0) uniform Buffer {
            mat4 mvp;
        };

        layout (location = 0) in vec3 in_vert;
        layout (location = 1) in vec3 in_norm;

        layout (location = 2) in vec3 in_pos;
        layout (location = 3) in vec4 in_quat;
        layout (location = 4) in vec3 in_scale;

        layout (location = 0) out vec3 out_norm;

        vec3 qtransform(vec4 q, vec3 v) {
            return v + 2.0 * cross(cross(v, q.xyz) + q.w * v, q.xyz);
        }

        void main() {
            vec3 vert;
            if (gl_VertexIndex < 3516) {
                vert = in_vert * in_scale;
            } else if (gl_VertexIndex < 4284) {
                vert = in_vert * in_scale.y + vec3(0.0, 0.0, sign(in_vert.z) * (in_scale.x - in_scale.y / 2.0));
            } else {
                vert = in_vert * in_scale.y * 2.0 + vec3(normalize(in_vert.xy) * (in_scale.x - in_scale.y * 2.0), 0.0);
            }
            gl_Position = mvp * vec4(in_pos + qtransform(in_quat, vert), 1.0);
            out_norm = qtransform(in_quat, in_norm);
        }
    '''),