Immutable texture storage does not mean that the texture’s ‘gpu-array‘ data is immutable. It means that the underlying format of the texture data cannot be changed. It is rare that you would want mutable storage and when you do, it is very hard to not create ’incomplete-textures’. https://www.opengl.org/wiki/Immutable_Storage_Texture#Texture_completeness

CEPL tries to make only complete textures so this is not a concern. If you do need this level of control, please raise a github issue as I would love to understand your usecase.

Package: cepl.textures.
Source: core/textures/textures.lisp.

Special Variable: *red/green-compressed-formats* ¶

A list of all of OpenGL’s red/green compressed formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *regular-color-formats* ¶

A list of all of OpenGL’s regular color formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *s3tc/dxt-compessed-formats* ¶

A list of all of OpenGL’s s3tc/dxt compessed formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *signed-integral-formats* ¶

A list of all of OpenGL’s signed integral formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *signed-normalized-integer-formats* ¶

A list of all of OpenGL’s signed normalized integer formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *special-color-formats* ¶

A list of all of OpenGL’s special color formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *srgb-color-formats* ¶

A list of all of OpenGL’s srgb color formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *stencil-formats* ¶

A list of all of OpenGL’s stencil formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *unsigned-integral-formats* ¶

A list of all of OpenGL’s unsigned integral formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *unsigned-normalized-integer-formats* ¶

A list of all of OpenGL’s unsigned normalized integer formats

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: *valid-image-formats-for-buffer-backed-texture* ¶

A list of all of OpenGL’s valid image formats for buffer backed texture

Package: cepl.image-formats.
Source: core/types/image-format.lisp.

Special Variable: +null-buffer-backed-gpu-array+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Special Variable: +null-fbo+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Special Variable: +null-gpu-buffer+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Special Variable: +null-texture+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Special Variable: +null-texture-backed-gpu-array+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Special Variable: +null-vao+ ¶

Package: %cepl.types.
Source: core/types/nulls-and-uninitialized.lisp.

Next: Compiler macros, Previous: Special variables, Up: Public Interface [Contents][Index]

5.1.3 Macros

Macro: assert-lambda-list (lambda-list expression datum &rest arguments) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: assoc-bind (lambda-list alist &body body) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: case= (form &body cases) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: dbind (lambda-list expressions &body body) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: def-glsl-stage (name args body-form outputs) ¶

def-glsl-stage is useful when you wish to define a CEPL pipeline stage in glsl rather than lisp. This is especially useful if you want to use some pre-exisiting glsl without rewriting it to lisp.

It is used like this:

(def-glsl-stage frag-glsl (("color_in" :vec4) &context :330 :fragment) "void main() {
color_out = color_in;
}"
(("color_out" :vec4)))

It differs from a regular ‘defun-g‘ definition in a few ways.

- argument names are specified using strings.

- &context is mandatory. You must specify what shader stage this can be used for and also what version/s this stage requires

- You are defining the entire stage, not just a function body. This means you can define local shader functions etc

- You have to specify the outputs in lisp as well as the inputs. This allows CEPL to compose this stage in pipelines with regular CEPL gpu functions.

CEPL will write all the in, out and uniform definitions for your shader so do not specify those yourself.

This stage fully supports livecoding, so feel free to change and recomplile the text in the stage at runtime.

Package: cepl.pipelines.
Source: core/pipelines/glsl-stages.lisp.

Macro: defcondition (name (&key condition-type prefix print-circle print-escape print-length print-level print-lines print-right-margin) (&rest args) error-string &body body) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: deferror (name (&key error-type prefix print-circle print-escape print-length print-level print-lines print-right-margin) (&rest args) error-string &body body) ¶

Package: cepl-utils.
Source: core/utils.lisp.

Macro: define-compiler-macro-g (name lambda-list &body body) ¶

This lets you define a compiler-macro that only works with gpu-functions.

The &context lambda list keyword allows you to restrict this macro to only be valid in gpu functions with compatible contexts.

&whole and &environment are not supported.

Package: cepl.pipelines.
Source: core/pipelines/gpu-macros.lisp.

Macro: define-const (name val &key type) ¶

Differs from alexandrias define-context in that it wont eval the val form at all if the var is already bound. This was we are always eq.

Package: cepl-utils.
Source: core/utils.lisp.

Macro: define-defn-declaration (name args &body body) ¶

Package: cepl.defn.
Source: defn/defn.lisp.

Macro: defmacro-g (name lambda-list &body body) ¶

This lets you a define a macro that only works in gpu code.

The &context lambda list keyword allows you to restrict this macro to only be valid in gpu functions with compatible contexts.

&whole and &environment are not supported.

Package: cepl.pipelines.
Source: core/pipelines/gpu-macros.lisp.

Macro: defmethod+ (name &rest args) ¶

Package: cepl.defn.
Source: defn/defn.lisp.

Macro: defn (name typed-args result-types &body body) ¶

Define a typed function

Package: cepl.defn.
Source: defn/defn.lisp.

Macro: defn-inline (name typed-args result-types &body body) ¶

Define a typed function and request that it be inlined

Package: cepl.defn.
Source: defn/defn.lisp.

Macro: defpipeline-g (name context &body gpipe-args) ¶

‘defpipeline-g‘ is how we define named rendering pipelines in CEPL.

Rendering pipelines are constructed by composing gpu-functions.

Rendering in OpenGL is descibed as a pipeline where a ‘buffer-stream‘ of data usually describing geometry) is mapped over whilst a number of uniforms are available as input and the outputs are written into an ‘FBO‘.

There are many stages to the pipeline and a full explanation of the GPU pipeline is beyond the scope of this docstring. However it surfices to say that only
5 stages are fully programmable (and a few more customizable).

defpipeline-g lets you specify the code (shaders) to run the programmable
parts (stages) of the pipeline.

The available stages kinds are:

- :vertex
- :tessellation-control
- :tessellation-evaluation
- :geometry
- :fragment
- :compute

To define code that runs on the gpu in CEPL we use gpu functions (gfuncs). Which are defined with ‘defun-g‘.

Here is an example pipeline:

(defun-g vert ((position :vec4) &uniform (i :float))
(values position (sin i) (cos i)))

(defun-g frag ((s :float) (c :float))
(v! s c 0.4 1.0))

(defpipeline-g prog-1 ()
(vert :vec4)
(frag :float :float))

Here we define a pipeline #’prog-1 which uses the gfunc vert as its vertex shader and used the gfunc frag as the fragment shader.

It is also possible to specify the name of the stages

(defpipeline-g prog-1 ()
:vertex (vert :vec4)
:fragment (frag :float :float))

But this is not neccesary unless you need to distinguish between tessellation
or geometry stages.

**– Compile Context –**

The second argument to defpipeline-g is the a list of additional information that is confusingly called the ’pipeline’s compile-context’.

Valid things that can be in this list are:

*A primitive type:*

This specifies what primitives can be passed into this pipeline.
By default all pipelines expect triangles. When you map a buffer-stream over a pipeline the primitive kind of the stream must match the pipeline.

The valid values are:

:dynamic
:points
:lines :line-loop :line-strip
:lines-adjacency :line-strip-adjacency
:triangles :triangle-fan :triangle-strip
:triangles-adjacency :triangle-strip-adjacency
(:patch <patch-size>)

:dynamic is special, it means that the pipeline will take the primitive kind from the buffer-stream being mapped over. This won’t work for with pipelines with geometry or tessellation stages, but it otherwise quite useful.

*A version restriction:*

This tells CEPL to compile the stage for a specific
version of GLSL. You usually do not want to use this as CEPL will compile for the version the user is using.

The value can be one of:

:140 :150 :330 :400 :410 :420 :430 :440 :450 :460

*The recompilation restriction*:

By adding the symbol ‘:static‘ to the list you tell CEPL that this pipeline
will not be recompiled again this session. This means CEPL will not automatically recompile it if one of the gpu-functions that make up it’s stages are recompiled.

It also allows CEPL to perform optimizations on the generated code that it couldnt usually due to expecting signature/type changes.

For a dryer version of the above please see the documentation for ‘compile-context‘.

**– Stage Names –**

Notice that we have to specify the typed signature of the stage. This is because CEPL allows you to ’overload’ gpu functions. The signature for the a gpu-function is a list which starts with the function name and whose other elements are the types of the non-uniforms arguments. As an example we can see above that the signature for vert is (vert :vec4), not (vert :vec4 :float).

**– Passing values from Stage to Stage –**

The return values of the gpu functions that are used as stages are passed as the input arguments of the next. The exception to this rule is that the first return value from the vertex stage is taken and used by GL, so only the subsequent values are passed along.

We can see this in the example above: #’vert returns 3 values but #’frag only receives 2.

The values from the fragment stage are writen into the current FBO. This may be the default FBO, in which case you will likely see the result on the screen, or it may be a FBO of your own.

By default GL only writed the fragment return value to the FBO. For handling multiple return values please see the docstring for ‘with-fbo-bound‘.

**– Using our pipelines –**

To call a pipeline we use the ‘map-g‘ macro (or one of its siblings ‘map-g-into‘/‘map-g-into*‘). The doc-strings for those macros go into more details but the basics are that map-g maps a buffer-stream over our pipeline and the results of the pipeline are fed into the ’current’ fbo.

We pass our stream to map-g as the first argument after the pipeline, we then pass the uniforms in the same style as keyword arguments. For example let’s see our prog-1 pipeline again:

(defun-g vert ((position :vec4) &uniform (i :float))
(values position (sin i) (cos i)))

(defun-g frag ((s :float) (c :float))
(v! s c 0.4 1.0))

(defpipeline-g prog-1 ()
(vert :vec4)
(frag :float :float))

We can call this as follows:

(map-g #’prog-1 v4-stream :i game-time)

Package: cepl.pipelines.
Source: core/pipelines/defpipeline.lisp.

Macro: defstruct-g (name-and-options &body slot-descriptions) ¶

‘defstruct-g‘ defines a struct that can be used both gpu-side (in gpu functions, ‘gpu-array‘s, ‘ubos‘, etc) and also cpu-side (in ‘c-array‘s, other gstructs, etc)

You create these using defstruct-g so lets look at an example right now:

(defstruct-g our-data
(position :vec3)
(val :int :accessor val))

This should seem familiar if you have used common lisp’s structs.

You provide a name (with options if you need them) and the definitions for the slots. The format for a slot is:

(slot-name slot-type)

-or-

(slot-name slot-type :accessor accessor-name)

– make-* –

Once defined you would create the above struct as follows:

(defvar x (make-our-data :position (v! 1 2 3) :val 5))

This will return a fully populated struct in foreign memory. if values are not provided then the slots will be left uninitialized and the contents of the slot are unknown (and likely unsafe)
It is rather rare to make a one-off struct like this as it is much more common to use the type in a data-structure like a c-arrays or gpu-array.

– Accessors –

In the ’our-data’ example above, the slot named ’position’ doesnt have an accesor but the ’val’ slot does.

Both slots will get a lisp-struct-style accessor functions however because of the :accessor in val’s slot definition a generic function named by the symbol after :accessor will also be created.

For the example this means the functions #’our-data-position, #’our-data-val and the generic function #’val are available.

Whilst :accessor results in a generic function on the cpu side (with the associated overheads) on the gpu side the function to be used is resolved statically and so there is not performance cost.

– Options –

With the exception of :constructor the options for defstruct-g are rarely used but are documented here for the sake of completeness.

:constructor
Setting this to nil means that you will get *no* make- function
Setting this to any other symbol will name the constructor using that symbol The default will is that the constructor will be called make-<struct-name>

:readers
Setting this to nil means that you will get *no* functions to get the slots’ data

:writers
Setting this to nil means that you will get *no* setf functions to set the slots’ data

:accessors
Setting this to nil means that you will get *neither* of the above.

:pull-push
Setting this to nil means that you will get *no* ‘push-g‘ or ‘pull-g‘ methods defined for your type

:attribs
Setting this to nil means that defstruct-g will not be able to make buffer-streams from arrays of this type.

:populate
Setting this to nil means that you will not get a internal populate function for this type. <DEPRECATED>

Some of the above options are redundent in combination with others.
For example the ‘push-g‘ method uses #’populate behind the scenes so with populate disabled you can have ‘push-g‘ for this type.

CEPL currently does a poor job at communicating these conflicts to the user.

Package: cepl.types.
Source: core/types/structs.lisp.

Macro: defun+ (name args &body body) ¶

Package: cepl.defn.
Source: defn/defn.lisp.

Macro: defun-g (name args &body body) ¶

‘defun-g‘ let’s you define a function which will be run on the gpu.
Commonly refered to in CEPL as a ’gpu function’ or ’gfunc’

Gpu functions try to feel similar to regular CL functions however naturally
there are some differences.

The first and most obvious one is that gpu function should only be called
from other gpu functions and/or composed into a pipeline using ‘defpipeline-g‘.

Whilst it is actually possible to call on from a lisp function this is provided solely for making interactive development and debugging easier. Please see the ‘EXPERIMENTAL‘ section below for more info

When a gfunc is composed into a pipeline then that function takes on the role
of one of the ’shader stages’ of the pipeline. For a proper breakdown of pipelines see the docstring for defpipeline-g.

Let’s see a simple example of a gpu function we can then break down

;; {0} {3} {1} {2}
(defun-g example ((vert my-struct) &uniform (loop :float))
(values (v! (+ (my-struct-pos vert) ;; {4}
(v! (sin loop) (cos loop) 0))
1.0)
(my-struct-col vert)))

{0} So like the normal defun we specify a name first, and the arguments as a
list straight afterwards

{1} The &uniform lambda keyword says that arguments following it are ’uniform arguments’. A uniform is an argument which has the same value for the entire stage.
&optional and &key are not supported

{2} Here is our definition for the uniform value. If used in a pipeline as a vertex shader #’example will be called once for every value in the ‘buffer-stream‘ given. That means the ’vert’ argument will have a different value for each of the potentially millions of invocations in that ONE pipeline call, however ’loop’ will have the same value for the entire pipeline call.

{2 & 3} All arguments must have their types declared

{4} Here we see we are using CL’s values special form. CEPL fully supports multiple value return in your shaders. If our function #’example was called from another gpu-function then you can use multiple-value-bind to bind the returned values. If however our example function were used as a stage in a pipeline then the multiple returned values will be mapped to the multiple arguments of the next stage in the pipeline.

That’s the basics of gpu-functions. For more details on how they can be used
in pipelines please see the documentation for defpipeline-g.

*More Argument Kinds*

Along with ‘&uniform‘ there are also ‘&shared‘ & ‘&context‘.

‘&context‘ specifies restrictions on how & where the gpu-function can be used. You can specify what versions of GLSL this function is valid for, what primtive kind it operates on, what pipeline stage it can be used for, and how CEPL compiles the cpu side representation.

For more info please see the documentation on ‘compile-context‘

‘&shared‘ is only valid for gpu-functions which will be used as compute stages
It lets you specify variables whos data will be shared within the ’local group’ You can use any non opaque type for the shared variable.

*EXPRERIMENTAL*

CEPL has a highly experimental feature to allow you to call gpu-functions directly What it aims to allow you to do is to generate and run a pipeline which runs your function once with the given arguments on the GPU.

By doing this it gives you a way to try out your gpu-functions from the REPL without having to make a pipeline map-g over it whilst use ssbos or transform-feedback to capture the result.

Currently this only works with functions that would work within a vertex
shader (so things like gl-frag-pos will not work) however we want to expand on this in the future.

This is not intended to be used *anywhere* where performance matters, it was
made solely as a debugging/development aid. Every time it is run it must:

- generate a pipeline
- compile it
- map-g over it
- marshal the results back to lisp
- free the pipeline

This is *extremly* expensive, however as long as it takes less that 20ms or so
it is fast enough for use from the repl.

Package: cepl.pipelines.
Source: core/pipelines/gpu-functions.lisp.

Macro: defun-g-equiv (name args &body body) ¶

Defun-g-equiv let’s you define a function which will be run on the gpu.
Commonly refered to in CEPL as a ’gpu function’ or ’gfunc’

The difference between defun-g-equiv & ‘defun-g‘ is that defun-g will create
a ’dummy’ lisp function so that ’jump to definition’ and signature hits work
in your editor, defun-g-equiv does not do this.

The advantage of defun-g-equiv is that you are then free define a lisp
equivalent of your gpu-function. This means you can use the same functions in
cpu or gpu code, which is very compelling.

*- the rest of the doc-string is the same as for defun-g -*

Gpu functions try to feel similar to regular CL functions however naturally
there are some differences.

The first and most obvious one is that whilst gpu function can be called
from other gpu functions, they cannot be called from lisp functions directly. They first must be composed into a pipeline using ‘defpipeline-g‘.

When a gfunc is composed into a pipeline then that function takes on the role of one of the ’shader stages’ of the pipeline. For a proper breakdown of pipelines see the docstring for defpipeline-g.

Let’s see a simple example of a gpu function we can then break down

;; {0} {3} {1} {2}
(defun-g-equiv example ((vert my-struct) &uniform (loop :float))
(values (v! (+ (my-struct-pos vert) ;; {4}
(v! (sin loop) (cos loop) 0))
1.0)
(my-struct-col vert)))

The cepl Reference Manual

Table of Contents

1 Introduction

2 Systems

2.1 cepl

2.2 cepl.build

3 Files

3.1 Lisp

3.1.1 cepl/cepl.asd

3.1.2 cepl.build/cepl.build.asd

3.1.3 cepl/package.lisp

3.1.4 cepl/host/api-api.lisp

3.1.5 cepl/host/api-generics.lisp

3.1.6 cepl/host/api-0.lisp

3.1.7 cepl/host/api-1.lisp

3.1.8 cepl/host/api-2.lisp

3.1.9 cepl/host/api-common.lisp

3.1.10 cepl/core/ffi.lisp

3.1.11 cepl/core/early.lisp

3.1.12 cepl/core/utils.lisp

3.1.13 cepl/project.lisp

3.1.14 cepl/core/context/documentation-functions.lisp

3.1.15 cepl/core/lifecycle.lisp

3.1.16 cepl/core/measurements/measurements.lisp

3.1.17 cepl/core/memory/memory.lisp

3.1.18 cepl/core/types/math.lisp

3.1.19 cepl/core/types/cepl-types.lisp

3.1.20 cepl/core/types/checks.lisp

3.1.21 cepl/core/types/nulls-and-uninitialized.lisp

3.1.22 cepl/core/context/gl-context.lisp

3.1.23 cepl/core/context/types.lisp

3.1.24 cepl/core/context/cepl-context.lisp

3.1.25 cepl/core/context/surface.lisp

3.1.26 cepl/core/context/delayed-resource-init.lisp

3.1.27 cepl/core/context/version.lisp

3.1.28 cepl/core/blending/blending.lisp

3.1.29 cepl/core/stencil/stencil.lisp

3.1.30 cepl/core/stencil/mask.lisp

3.1.31 cepl/core/scissor/scissor.lisp

3.1.32 cepl/core/color/color.lisp

3.1.33 cepl/core/pixel-store/pixel-store.lisp

3.1.34 cepl/core/depth/depth.lisp

3.1.35 cepl/core/face/face.lisp

3.1.36 cepl/core/types/initalized-p.lisp

3.1.37 cepl/core/internals.lisp

3.1.38 cepl/core/types/types.lisp

3.1.39 cepl/core/errors.lisp

3.1.40 cepl/core/viewports/viewport.lisp

3.1.41 cepl/core/types/image-format.lisp

3.1.42 cepl/core/types/pixel-format.lisp

3.1.43 cepl/core/types/cffi-extra-primitive-types.lisp

3.1.44 cepl/core/types/cffi-helpers.lisp

3.1.45 cepl/core/c-arrays/def.lisp

3.1.46 cepl/core/c-arrays/aref-c.lisp

3.1.47 cepl/core/c-arrays/populate.lisp

3.1.48 cepl/core/c-arrays/make.lisp

3.1.49 cepl/core/c-arrays/map.lisp

3.1.50 cepl/core/c-arrays/rest.lisp

3.1.51 cepl/core/types/layout.lisp

3.1.52 cepl/core/types/structs.lisp

3.1.53 cepl/core/gpu-buffers/gpu-buffers.lisp

3.1.54 cepl/core/gpu-arrays/buffer-backed.lisp

3.1.55 cepl/core/vaos/vaos.lisp

3.1.56 cepl/core/streams/buffer-streams.lisp

3.1.57 cepl/core/transform-feedback/transform-feedback.lisp

3.1.58 cepl/core/pipelines/compile-context.lisp

3.1.59 cepl/core/pipelines/generics.lisp

3.1.60 cepl/core/pipelines/uniforms.lisp

3.1.61 cepl/core/pipelines/gpu-macros.lisp

3.1.62 cepl/core/pipelines/gpu-pipeline-base.lisp

3.1.63 cepl/core/pipelines/pipeline-validation.lisp

3.1.64 cepl/core/pipelines/funcall-g.lisp

3.1.65 cepl/core/pipelines/gpu-functions.lisp

3.1.66 cepl/core/pipelines/glsl-stages.lisp

3.1.67 cepl/core/pipelines/mapg-context.lisp

3.1.68 cepl/core/pipelines/uniform-assigners-generation.lisp

3.1.69 cepl/core/pipelines/programs.lisp

3.1.70 cepl/core/pipelines/multi-draw.lisp

3.1.71 cepl/core/pipelines/defpipeline.lisp

3.1.72 cepl/core/pipelines/gpu-lambda.lisp

2.1 `cepl`

2.2 `cepl.build`

3.1.1 `cepl/cepl.asd`

3.1.2 `cepl.build/cepl.build.asd`

3.1.3 `cepl/package.lisp`

3.1.4 `cepl/host/api-api.lisp`

3.1.5 `cepl/host/api-generics.lisp`

3.1.6 `cepl/host/api-0.lisp`

3.1.7 `cepl/host/api-1.lisp`

3.1.8 `cepl/host/api-2.lisp`

3.1.9 `cepl/host/api-common.lisp`

3.1.10 `cepl/core/ffi.lisp`

3.1.11 `cepl/core/early.lisp`

3.1.12 `cepl/core/utils.lisp`

3.1.13 `cepl/project.lisp`

3.1.14 `cepl/core/context/documentation-functions.lisp`

3.1.15 `cepl/core/lifecycle.lisp`

3.1.16 `cepl/core/measurements/measurements.lisp`

3.1.17 `cepl/core/memory/memory.lisp`

3.1.18 `cepl/core/types/math.lisp`

3.1.19 `cepl/core/types/cepl-types.lisp`

3.1.20 `cepl/core/types/checks.lisp`

3.1.21 `cepl/core/types/nulls-and-uninitialized.lisp`

3.1.22 `cepl/core/context/gl-context.lisp`

3.1.23 `cepl/core/context/types.lisp`

3.1.24 `cepl/core/context/cepl-context.lisp`

3.1.25 `cepl/core/context/surface.lisp`

3.1.26 `cepl/core/context/delayed-resource-init.lisp`

3.1.27 `cepl/core/context/version.lisp`

3.1.28 `cepl/core/blending/blending.lisp`

3.1.29 `cepl/core/stencil/stencil.lisp`

3.1.30 `cepl/core/stencil/mask.lisp`

3.1.31 `cepl/core/scissor/scissor.lisp`

3.1.32 `cepl/core/color/color.lisp`

3.1.33 `cepl/core/pixel-store/pixel-store.lisp`

3.1.34 `cepl/core/depth/depth.lisp`

3.1.35 `cepl/core/face/face.lisp`

3.1.36 `cepl/core/types/initalized-p.lisp`

3.1.37 `cepl/core/internals.lisp`

3.1.38 `cepl/core/types/types.lisp`

3.1.39 `cepl/core/errors.lisp`

3.1.40 `cepl/core/viewports/viewport.lisp`

3.1.41 `cepl/core/types/image-format.lisp`

3.1.42 `cepl/core/types/pixel-format.lisp`

3.1.43 `cepl/core/types/cffi-extra-primitive-types.lisp`

3.1.44 `cepl/core/types/cffi-helpers.lisp`

3.1.45 `cepl/core/c-arrays/def.lisp`

3.1.46 `cepl/core/c-arrays/aref-c.lisp`

3.1.47 `cepl/core/c-arrays/populate.lisp`

3.1.48 `cepl/core/c-arrays/make.lisp`

3.1.49 `cepl/core/c-arrays/map.lisp`

3.1.50 `cepl/core/c-arrays/rest.lisp`

3.1.51 `cepl/core/types/layout.lisp`

3.1.52 `cepl/core/types/structs.lisp`

3.1.53 `cepl/core/gpu-buffers/gpu-buffers.lisp`

3.1.54 `cepl/core/gpu-arrays/buffer-backed.lisp`

3.1.55 `cepl/core/vaos/vaos.lisp`

3.1.56 `cepl/core/streams/buffer-streams.lisp`

3.1.57 `cepl/core/transform-feedback/transform-feedback.lisp`

3.1.58 `cepl/core/pipelines/compile-context.lisp`

3.1.59 `cepl/core/pipelines/generics.lisp`

3.1.60 `cepl/core/pipelines/uniforms.lisp`

3.1.61 `cepl/core/pipelines/gpu-macros.lisp`

3.1.62 `cepl/core/pipelines/gpu-pipeline-base.lisp`

3.1.63 `cepl/core/pipelines/pipeline-validation.lisp`

3.1.64 `cepl/core/pipelines/funcall-g.lisp`

3.1.65 `cepl/core/pipelines/gpu-functions.lisp`

3.1.66 `cepl/core/pipelines/glsl-stages.lisp`

3.1.67 `cepl/core/pipelines/mapg-context.lisp`

3.1.68 `cepl/core/pipelines/uniform-assigners-generation.lisp`

3.1.69 `cepl/core/pipelines/programs.lisp`

3.1.70 `cepl/core/pipelines/multi-draw.lisp`

3.1.71 `cepl/core/pipelines/defpipeline.lisp`

3.1.72 `cepl/core/pipelines/gpu-lambda.lisp`

3.1.73 `cepl/core/pipelines/bake.lisp`

3.1.74 `cepl/core/textures/def.lisp`

3.1.75 `cepl/core/samplers/samplers.lisp`

3.1.76 `cepl/core/textures/textures.lisp`

3.1.77 `cepl/core/textures/texture-samplers.lisp`

3.1.78 `cepl/core/render-buffers/render-buffer.lisp`