varjo

Varjo Reference Documentation

This is the documentation for the public api of Varjo. For the reference documentation for Vari (the language Varjo compiles to GLSL) please see here

WARNING: Much of this API still has unneccesarily inconsistant or misleading naming and is very subject to change.

Copyright

Package Index

• VARJO.API

  • *DEFAULT-VERSION*

    special

    *default-version* is a variable that holds the version of GLSL that will be used for a compile task if a version is not specified in the context

  • *STAGE-NAMES*

    special

    *stage-names* is a variable that holds the list of keyword stage names that Varjo recognises

  • *STAGE-TYPE-NAMES*

    special

    *stage-type-names* is a variable that holds a list of type-names that map to the stages named in *stage-names*

  • *SUPPORTED-VERSIONS*

    special

    *supported-versions* is a variable that holds the list of GLSL version Varjo ostensibly supports.

    Note: That 'ostensibly' is there as I'm very sure that the lower levels of GLSL varjo is currently doing a very poor job. If you have the time please file issues that you find at https://github.com/cbaggers/varjo/issues

  • COMPILED-COMPUTE-STAGE

    class

    compiled-compute-stage is a type which is used to respresent the compiled equivalent of compute-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-FRAGMENT-STAGE

    class

    compiled-fragment-stage is a type which is used to respresent the compiled equivalent of fragment-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-GEOMETRY-STAGE

    class

    compiled-geometry-stage is a type which is used to respresent the compiled equivalent of geometry-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-STAGE

    class

    compiled-stage is a type which is used to respresent the compiled equivalent of. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-TESSELLATION-CONTROL-STAGE

    class

    compiled-tessellation-control-stage is a type which is used to respresent the compiled equivalent of tessellation-control-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-TESSELLATION-EVALUATION-STAGE

    class

    compiled-tessellation-evaluation-stage is a type which is used to respresent the compiled equivalent of tessellation-evaluation-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPILED-VERTEX-STAGE

    class

    compiled-vertex-stage is a type which is used to respresent the compiled equivalent of vertex-stage. Along with the data stored for stage you can also query:

    • The compiled glsl-code using the glsl-code function
    • The output-variables usings the output-variables function
    • The uniforms implicitly adding during compilation by calling the implicit-uniforms function
    • The primitive output from the stage by calling the primitive-out function
    • The external-functions used from this stage by calling the external-functions function

  • COMPUTE-STAGE

    class

    compute-stage is the class that represents a uncompiled compute stage

    compiled-compute-stage inherits from this class

  • DYNAMIC

    class

    dynamic is the class that represents the simarlaly named GL primitive.

  • FEEDBACK-QUALIFIER

    class

    feedback-qualifier is the class that holds data specified in a transform- feedback qualifier.

  • FRAGMENT-STAGE

    class

    fragment-stage is the class that represents a uncompiled fragment stage.

    compiled-fragment-stage inherits from this class

  • GEOMETRY-STAGE

    class

    geometry-stage is the class that represents a uncompiled geometry stage.

    compiled-geometry-stage inherits from this class

  • IMPLICIT-UNIFORM-VARIABLE

    class

    implicit-uniform-variable is a class which holds data about the uniforms that added implicitly (whether by globally scoped variable capture or by use of add-lisp-form-as-uniform)

    You can call the following functions on it to retrieve the data:

    • name
    • v-type-of
    • glsl-name

  • INPUT-VARIABLE

    class

    input-variable is a class which holds data about the input parameters to the stage

    You can call the following functions on it to retrieve the data:

    • name
    • v-type-of
    • glsl-name

  • LINE-LOOP

    class

    line-loop is the class that represents the simarlaly named GL primitive.

  • LINE-STRIP

    class

    line-strip is the class that represents the simarlaly named GL primitive.

  • LINE-STRIP-ADJACENCY

    class

    line-strip-adjacency is the class that represents the simarlaly named GL primitive.

  • LINES

    class

    lines is the class that represents the simarlaly named GL primitive.

  • LINES-ADJACENCY

    class

    lines-adjacency is the class that represents the similarly named GL primitive.

  • PATCHES

    class

    patches is the class that represents the similarly named GL primitive.

  • POINTS

    class

    points is the class that represents the similarly named GL primitive.

  • QUADS

    class

    quads is the class that represents the similarly named GL primitive.

  • QUALIFIER

    class

    qualifier is the class that other classes subclass in order to represent various GLSL qualifiers.

  • SHADER-VARIABLE

    class

    This class is the superclass of input-variable, uniform-variable and output-variable.

    You can call the following functions on it to retrieve the data:

    • name
    • v-type-of
    • glsl-name

  • TESSELLATION-CONTROL-STAGE

    class

    tessellation-control-stage is the class that represents a uncompiled tessellation-control stage.

    compiled-tessellation-control-stage inherits from this class

  • TESSELLATION-EVALUATION-STAGE

    class

    tessellation-evaluation-stage is the class that represents a uncompiled tessellation-evaluation stage.

    compiled-tessellation-evaluation-stage inherits from this class

  • TRIANGLE-FAN

    class

    triangle-fan is the class that represents the similarly named GL primitive.

  • TRIANGLE-STRIP

    class

    triangle-strip is the class that represents the similarly named GL primitive.

  • TRIANGLE-STRIP-ADJACENCY

    class

    triangle-strip-adjacency is the class that represents the similarly named GL primitive.

  • TRIANGLES

    class

    triangles is the class that represents the similarly named GL primitive.

  • TRIANGLES-ADJACENCY

    class

    triangles-adjacency is the class that represents the similarly named GL primitive.

  • UNIFORM-VARIABLE

    class

    uniform-variable is a class which holds data about the uniform parameters to the stage

    You can call the following functions on it to retrieve the data:

    • name
    • v-type-of
    • glsl-name

  • VERTEX-STAGE

    class

    vertex-stage is the class that represents a uncompiled vertex stage.

    compiled-vertex-stage inherits from this class

  • ( CONTEXT OBJECT )

    accessor

    When passed an instance of stage this function returns a list of GLSL versions which this stage was/is to be compiled with

  • ( GLSL-CODE OBJECT )

    accessor

    When passed an instance of compiled-stage this function returns a string containing the glsl code that resulted from the compilation.

  • ( GLSL-NAME OBJECT )

    accessor

    When passed an instance of shader-variable this function returns a string containing the name that the variable was given in the glsl code.

  • ( IMPLICIT-UNIFORMS OBJECT )

    accessor

    When passed an instance of compiled-stage this function returns a list of instances of implicit-uniform-variable which represent the uniforms which were added implicitly during the compilation of the given stage.

  • ( INPUT-VARIABLES OBJECT )

    accessor

    When passed an instance of stage this function returns a list of input-variable objects which respresent the input paramaters to the stage

  • ( LISP-CODE OBJECT )

    accessor

    When passed an instance of stage, lisp-code returns the Vari code that acts as the body of the stage.

  • ( OUTPUT-VARIABLES OBJECT )

    accessor

    When passed an instance of compiled-stage this function returns a list of instances of output-variable which represent the data output from the given stage.

  • ( PRIMITIVE-IN PP )

    accessor

    When passed an instance of stage this function returns an instance of primitive or nil.

  • ( PRIMITIVE-OUT OBJECT )

    accessor

    When passed an instance of compiled-stage this function returns either NIL or an instance of 'primitive'. This represent the primitive that could/was be passed to the next stage.

  • ( STEMCELLS-ALLOWED OBJECT )

    accessor

    When passed an instance of stage this function returns a generalized-boolean

    If this argument is not NIL then the compiler will allow the capture of globally scoped variables from Common Lisp and use of add-lisp-form-as-uniform from within macros.

    For details on how to support 'global variable capture' please see the documentation for with-stemcell-infer-hook & with-constant-inject-hook

  • ( UNIFORM-VARIABLES OBJECT )

    accessor

    When passed an instance of stage this function returns a list of uniform-variable objects which respresent the uniform paramaters to the stage

  • ( USED-EXTERNAL-FUNCTIONS E )

    accessor

    When passed an instance of compiled-stage this function returns a list of external-function objects which were used by the given stage.

  • ( V-DIMENSIONS OBJECT )

    accessor

    v-dimensions given an instance of the v-array type object this returns the list of it's dimensions.

  • ( V-TYPE-OF FUNC )

    accessor

    When called with an instance of shader-variable this will return the Varjo type object which represents the variables Vari type.

  • ( ADD-ALTERNATE-TYPE-NAME ALT-TYPE-NAME SRC-TYPE-NAME )

    function

    add-alternate-type-name

  • ( EPHEMERAL-P OBJ )

    function

    ephemeral-p returns T is the Varjo type object represents an ephemeral type

  • ( FIND-MUTUAL-CAST-TYPE &REST TYPES )

    function

    find-mutual-cast-type when given a number of Varjo type objects, this function will return a type object that they can all mutually be cast to according to GLSL's rules.

  • ( MAKE-STAGE KIND IN-ARGS UNIFORMS CONTEXT CODE &OPTIONAL (STEMCELLS-ALLOWED T) PRIMITIVE )

    function

    make-stage is the function that create an object that can be passed to the translate function. It takes the following arguments:

    kind

    This must be one of the keywords in stage-names:

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

    in-args

    Must be a list of input parameters to the stage. These are the values to which change per element that is being processed, whether that be per vertex, fragment, patch, instance, etc.

    The input variables are defined as lists in the following fashion:

    (variable-name
     type-spec
     &rest optional-qualifier-designators ["explicit-glsl-name"])
    

    Usually this looks like:

    (vert :vec4)
    (data lighting-data)
    (length :int :flat) <- flat is the qualifier in this case
    

    If the last element of the list is a string, then that string is used as the name of the variable in the compiled GLSL. This is very rarely used and should generally be avoided.

    uniforms

    This is a list of the uniforms to stage. These are the values that stay the same (are uniform) for the duration of the pipeline.

    They are defined in the same way as the above 'in-args' except that, if the type-spec specified a struct type the following additional qualifiers are allowed:

    • :ssbo
    • :ubo
    • :std-140
    • :std-430

    The result of make-stage is an instance of one of the subclasses of the stage type.

    context

    The context argument must be a list that may contain any number of symbols from supported-versions. Context is used to specify the GLSL version to compile the stage.

    NOTE: The name 'context' is legacy at this point as it is only used to specify GLSL versions.

    code

    This must be a list containing the forms that make up the 'body' of the stage.

    It is not legal for this argument to be nil.

    stemcells-allowed (optional)

    If this argument is not NIL then the compiler will allow the capture of globally scoped variables from Common Lisp and use of add-lisp-form-as-uniform from within macros. For details on how to support 'global variable capture' please see the documentation for with-stemcell-infer-hook & with-constant-inject-hook

    primitive (optional)

    This can be nil, a instance of the type 'primitive or a valid 'primitive designator' as specified by the valid-primitive-name-p function.

    Primitive designators are either one of the following keywords..

    • :dynamic
    • :points
    • :lines
    • :iso-lines
    • :line-loop
    • :line-strip
    • :lines-adjacency
    • :line-strip-adjacency
    • :triangles
    • :triangle-fan
    • :triangle-strip
    • :triangles-adjacency
    • :triangle-strip-adjacency
    • :quads

    .. or a list whos first element is :patches and the second (and final) element is a positive integer that is greater than 1. This specifies the length of the patch.

    Whilst this is optional in make-stage it must be set before being passed to translate if the stage kind is one of the following:

    • tessellation-control-stage
    • tessellation-evaluation-stage
    • geometry-stage

    Or if it the first stage in the list of stages passed to rolling-translate and if some of the other stages are of the above kinds.

  • ( MAKE-TYPE-SET &REST MEMBERS )

    function

    make-type-set takes Varjo type objects or type-specs and returns an objects that respresents a set of types. type-sets are used by a number of internal Varjo functions.

  • ( ROLLING-TRANSLATE STAGES &OPTIONAL (COMPILE-FUNC (FUNCTION TRANSLATE)) )

    function

    When called with a list of stage objects, rolling-translate compiles them returning a list of compiled-stage objects.

    rolling-translate does not simply mapcar the list over translate it propegates information like the primitive and ensures that outputs of one stage match up with the inputs of the next. This means that you only have to specify the primitive on the vertex stage when compiling a whole pipeline and any geometry/tessellation stages in the list will receive the correct information.

  • ( TEST-TRANSLATE-FUNCTION-SPLIT-DETAILS NAME IN-ARGS UNIFORMS CONTEXT BODY &OPTIONAL (STAGE-KINDS *STAGE-NAMES*) (ALLOW-STEMCELLS T) )

    function

  • ( TYPE-SPECP SPEC )

    function

    type-specp returns T if the type-spec provided represents valid Vari type.

  • ( V-COMPILE UNIFORMS VERSION &KEY VERTEX TESSELLATION-CONTROL TESSELLATION-EVALUATION GEOMETRY FRAGMENT COMPUTE ALLOW-STEMCELLS DRAW-MODE (PRIMITIVE :TRIANGLES) )

    function

    NOTE: It is the authors recommendation to use make-stage & translate rather than this function

    This function takes lisp code as lists and returns the results of compiling that code to glsl.

    Each result is an object of type 'compiled-stage.

    The stages must be defined in the following way.

    • The first element of the list is the input args to the stage as pairs of names and types.
    • The rest of the list is the body code of that stage.

    Example:

    (v-compile '((a :float)) :330
               :vertex '(((pos :vec3))
                         (values (vec4 pos 1.0) a))
               :fragment '(((hmm :float))
                           (labels ((fun ((x :float))
                                      (* x x)))
                             (vec4 1.0 1.0 hmm (fun a)))))
    

  • ( V-ERRORP OBJ )

    function

    v-errorp returns T if the provided objects is of type v-error

  • ( VALID-PRIMITIVE-NAME-P NAME )

    function

    No docstring provided.

  • ( ADD-EQUIVALENT-NAME EXISTING-NAME NEW-NAME )

    generic

    add-equivalent-name

  • ( ADD-EXTERNAL-FUNCTION NAME IN-ARGS UNIFORMS CODE &OPTIONAL VALID-GLSL-VERSIONS )

    generic

    add-external-function is a function that takes the following:

    • a name as a symbol
    • a list of input parameters declartions in the form: (,name ,type-spec ,@qualifiers)
    • a list of uniforms in the form: (,name ,type-spec ,@qualifiers)
    • a list of forms that make up the body of the function
    • [optional] as list of glsl versions this function is valid for. nil means it is valid for all versions

    After doing basic checks on the arguments the function will be added to the 'external function registry' such that it call be called from any future compilation task (assuming appropriate glsl versions).

    Please note that this function does not attempt to validate the body of the function as doing so would require knowledge of the context in which it is used. If you need to test that the function could be valid, refer to the test-translate-function-split-details function.

  • ( ADD-LISP-FORM-AS-UNIFORM FORM TYPE-SPEC ENV &OPTIONAL NAME )

    generic

    add-lisp-form-as-uniform is an intersting beast. Its goal it to make it easy to inject uniforms into the resulting GLSL which will be populated by the result of a specific Common Lisp form.

    You provide: - a value which will be assumed to be a valid Common lisp form - a Vari type-spec which will be the type of the uniform - a Varjo environment object, which must have been obtained from the &environment paramater in a Vari macro. - an optional name

    Varjo will then add a uniform (as it would be using uniform list in make-stage). You can then use the symbol provided as the 'name' argument in your Vari code.

    When the compilation completes you can query the compiled-stage object using the implicit-uniforms function which will return a list of implicit-uniform-variable objects which can be queried using the following functions:

    • name - the vari name of the uniform
    • glsl-name - returns a string with the glsl name of the uniform variable
    • v-type-of - Returns the Varjo type object
    • cpu-side-transform - this is how you obtain the Common Lisp code that was passed to add-lisp-form-as-uniform

  • ( ALL-BOUND-SYMBOLS ENV )

    generic

    When given an environment object from a Vari macro all-bound-symbols returns a list of all the symbols currently bound.

  • ( ARGUMENT-IS-UNIFORM-P NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol that names one of the arguments to the compiler-macro, argument-is-uniform-p returns T if the value of the argument comes from a uniform variable.

  • ( ARGUMENT-TYPE NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol that names a variable bound in the current scope, argument-type returns the Varjo type object that represents the Vari type of that variable.

  • ( ARGUMENT-UNIFORM-NAME NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol that names an argument to the current compiler-macro, argument-uniform-name returns the the symbol which names the uniform in the stage if the value passed to the named paramater has come from a uniform.

  • ( BLOCK-NAME-STRING BLOCK-NAME )

    generic

    When passed an instance of output-variable this will return the name of the interface-block that contained the variable as a string.

  • ( COMBINE-METADATA META-A META-B )

    generic

    combine-metadata takes 2 metadata (or null) objects and attempts to combine them if possible. It is valid for the system to return nil for non-null arguments.

  • ( CORE-TYPEP OBJECT )

    generic

    core-typep returns T if the Varjo type object provided is a core GLSL type

  • ( CPU-SIDE-TRANSFORM OBJECT )

    generic

    When passed an instance of implicit-uniform-variable this returns the lisp code that was to be used to populate the implicit uniform.

    See add-lisp-form-as-uniform for more details.

  • ( DELETE-EXTERNAL-FUNCTION NAME IN-ARGS-TYPES )

    generic

    delete-external-function removes a function from the 'external function registry' such that any attempt to use it in a functure compilation task will fail.

    The 'in-arg-types' parameter expects a list of Vari type-specs.

  • ( FEEDBACK-GROUP OBJECT )

    generic

    feedback-group given an instance of feedback-qualifier this function returns the group ID from the qualifier.

  • ( LISP-NAME OBJECT )

    generic

    When passed an instance of primitive this function returns the keyword name of the primitive. This is the name one would pass to functions like make-stage.

  • ( LOCATION OBJECT )

    generic

    When called with an instance of output-variable this returns the location[0] of the variable. These will only be populated from output-variables from a fragment-stage.

    [0] For info on the fragment output locations please see: https://www.khronos.org/opengl/wiki/Fragment_Shader#Output_buffers

  • ( METADATA-FOR-ARGUMENT NAME METADATA-KEY ENV )

    generic

    When given an environment object from a Vari compiler-macro and a symbol that names one of the arguments to the macro[0], metadata-for-argument returns an object that holds the compile time metadata for the value

    [0] the argument cannot be the &whole or &environment argument.

  • ( METADATA-FOR-VARIABLE NAME METADATA-KEY ENV )

    generic

    When given an environment object from a Vari compiler-macro and a symbol that names a variable currently in scope to the macro[0], metadata-for-variable returns an object that holds the compile time metadata for the value bound to that variable.

    [0] the argument cannot be the &whole or &environment argument.

  • ( NAME OBJ )

    generic

    When passed an instance of qualfiier shader-variable orexternal-function` the function returns the name of the qualfiier/variable/function respectively.

  • ( QUALIFIERS OBJ )

    generic

    When passed an instance of shader-variable or Varjo type object this function returns a list of any qualifiers that apply to the value (of the variable or the value to which the type applies)

  • ( TRANSLATE STAGE )

    generic

    When called with an instance of stage translate compiles it, returning an instance of compiled-stage

  • ( TYPE->TYPE-SPEC TYPE )

    generic

    type->type-spec takes a Varjo type object and returns a Vari type-spec.

    As (during compilation) type objects can carry metadata that may not be representable in a type-spec this conversion can be 'lossy'.

  • ( TYPE-SPEC->TYPE SPEC &OPTIONAL FLOW-ID )

    generic

    type-spec->type takes a Vari type-spec and returns a new instance of Varjo type object that represents it.

  • ( V-CASTS-TO FROM-TYPE TO-TYPE )

    generic

    The poorly names v-casts-to takes 2 Varjo type objects and attempts to cast one to the other. If successful it returns the new type object and otherwise returns NIL.

  • ( V-CASTS-TO-P FROM-TYPE TO-TYPE )

    generic

    v-casts-to-p returns T if the first Varjo type object could be cast to the second

  • ( V-ELEMENT-TYPE OBJECT )

    generic

    v-element-type given an instance of the v-container type object this returns the type object of it elements.

  • ( V-GLSL-SIZE TYPE )

    generic

    Given a Varjo type object this function will return it's 'glsl size'. By this we mean the number of 'positions' the value would take up (for example when being passed into a vertex-stage)

  • ( V-SPECIAL-FUNCTIONP FUNC )

    generic

    v-special-functionp returns T if the Varjo function object provided is a special form.

  • ( V-TYPE-EQ A B )

    generic

    v-type-eq returns T if the Varjo type object provided represents the given Vari type.

    The second argument can be a Varjo type object or a Vari type-spec

  • ( V-TYPEP A B )

    generic

    v-typep returns T if the Varjo type object provided represents the given Vari type or a subtype of that type.

    The second argument can be a Varjo type object or a Vari type-spec

  • ( VARIABLE-IN-SCOPE-P NAME ENV )

    generic

    When given an environment object from a Vari compiler-macro and a symbol, variable-in-scope-p returns T if that symbol names a variable that is currently in scope.

  • ( VARIABLE-IS-UNIFORM-P NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol, variable-is-uniform-p returns T if that symbol names a uniform variable in the current scope, or it contains the value from a uniform variable.

  • ( VARIABLE-TYPE NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol that names a variable in the current scope, variable-type returns a Varjo type object that represents the Vari type of the value bound to the variable.

  • ( VARIABLE-UNIFORM-NAME NAME ENV )

    generic

    When given an environment object from a Vari macro and a symbol that names a variable whos value is taken from a uniform, argument-uniform-name returns the the symbol which names the uniform in the stage.

  • ( VARIABLES-IN-SCOPE ENV )

    generic

    When given an environment object from a Vari macro, variables-in-scope returns a list contains the names of all the variables currently in scope.

  • ( VERTEX-COUNT OBJECT )

    generic

    When passed an instance of primitive this function returns the number of vertices that make up this kind of primitive.

  • ( DEF-METADATA-INFER VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY )

    macro

    def-metadata-infer is the older syntax for define-metadata-infer.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( DEF-METADATA-KIND NAME (&KEY CONC-NAME (BINDS-TO :VALUE)) &BODY SLOT-NAMES )

    macro

    def-metadata-kind is the older syntax for define-metadata-kind.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( DEF-SHADOW-TYPE-CONSTRUCTOR SHADOW-TYPE FUNCTION-IDENTIFIER )

    macro

    def-shadow-type-constructor is the older syntax for define-shadow-type-constructor.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( DEFINE-ALTERNATE-TYPE-NAME CURRENT-TYPE-NAME ALTERNATE-TYPE-NAME )

    macro

    define-alternate-type-name lets you define

  • ( DEFINE-GLSL-TEMPLATE-FUNCTION NAME ARGS RETURN-SPEC TRANSFORM &KEY PURE )

    macro

    define-glsl-template-function which lets you define a snippet of glsl code as a function in Vari. Here is an example definition:

                                   [0]
                                    ↓
    (define-glsl-template-function my-func ((x :float)) ←[1]
      :float ←[2]
      "(1.0f / ~a)" ←[3]
      :pure t) ←[4]
    

    [0] Here we are defining a function called 'my-func'

    [1] It takes 1 argument, called 'x' which has the type :float

    [2] It returns a single :float value

    [3] The string pattern is what will be injected into the final glsl. It behaves as though this pattern and the glsl for the arguments were passed to format, e.g. (format nil "(1.0f / ~a)" "2.3f") assuming the glsl of the argument passed tox` was "2.3f".

      The glsl for the arguments is passed to format in the order specified
      in `[1]`
    
      As it currently uses `format` it is legal to use other `directives` such
      as `~s` but it is not advisable as this will result in invalid glsl.
    

  • ( DEFINE-METADATA-INFER VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY )

    macro

    define-metadata-infer lets you define

  • ( DEFINE-METADATA-KIND NAME (&KEY CONC-NAME (BINDS-TO :VALUE)) &BODY SLOT-NAMES )

    macro

    define-metadata-kind lets you define

  • ( DEFINE-SHADOW-TYPE-CONSTRUCTOR SHADOW-TYPE FUNCTION-IDENTIFIER )

    macro

    define-shadow-type-constructor lets you define

  • ( DEFINE-VARI-COMPILER-MACRO NAME LAMBDA-LIST &BODY BODY )

    macro

    define-vari-compiler-macro lets you define a compiler-macro that works in Vari.

    The parameters in the lambda-list must be defined in form (,name ,type-spec)

    The compiler macro will only expand for functions with an exactly matching name and lambda-list.

    Vari's compiler macros behave the same as regular Common Lisp compiler-macros with the exception that you can make queries against the environment to find data (such as type) from the arguments (See here for details).

    Due to having to compile the argument forms before being able to identify the compiler macro, any form returned from the compiler-macro (other than the value from &whole is going to result in recompilation. This make Vari's compiler macros more 'expensive' than Common Lisps in the general sense.

  • ( DEFINE-VARI-FUNCTION NAME ARGS &BODY BODY )

    macro

    define-vari-function lets you define a function that can be used in any Vari code compiled in the future.

    that takes the following:

    • a name as a symbol
    • a 'vari function lambda-list' (see here for details)
    • a body made of Vari code

    Please note that, other than performing some basic validation on the arguments, this function does not attempt any validation on the body of the function. Doing so would require knowledge of the context in which it is used.

    If you need to test that the function could be valid, refer to the test-translate-function-split-details & add-external-function functions.

  • ( DEFINE-VARI-MACRO NAME LAMBDA-LIST &BODY BODY )

    macro

    define-vari-macro lets you define a macro that can be used in any Vari code compiled in the future.

    Vari's macros behave the same as regular Common Lisp macros with the exception that you can make queries against the environment to find data (such as type) from the arguments (See here for details).

  • ( DEFINE-VARI-STRUCT NAME CONTEXT &BODY SLOTS )

    macro

    define-vari-struct lets you define

  • ( DEFINE-VARI-TYPE NAME ARGS TYPE-FORM &KEY VALID-METADATA-KINDS )

    macro

    define-vari-type lets you define

  • ( V-DEF-GLSL-TEMPLATE-FUN NAME ARGS TRANSFORM ARG-TYPES RETURN-SPEC &KEY V-PLACE-INDEX GLSL-NAME PURE )

    macro

    v-def-glsl-template-fun is the older syntax for define-glsl-template-function.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( V-DEFINE-COMPILER-MACRO NAME LAMBDA-LIST &BODY BODY )

    macro

    v-define-compiler-macro is the older syntax for define-vari-compiler-macro.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( V-DEFMACRO NAME LAMBDA-LIST &BODY BODY )

    macro

    v-defmacro is the older syntax for define-vari-macro.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( V-DEFSTRUCT NAME CONTEXT &BODY SLOTS )

    macro

    v-defstruct is the older syntax for define-vari-struct.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( V-DEFTYPE NAME ARGS TYPE-FORM &KEY VALID-METADATA-KINDS )

    macro

    v-deftype is the older syntax for define-vari-type.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( V-DEFUN NAME ARGS &BODY BODY )

    macro

    v-defun is the older syntax for define-vari-function.

    This macro is still exported in order to maintain compatibility with existing code.

  • ( WITH-CONSTANT-INJECT-HOOK FUNC &BODY BODY )

    macro

    When translate is called within the dynamic extern of the body of this form, if there is a use of a variable which is not in scope in the Vari code, but is boundp & constant in the Common Lisp environment then the user provided function will be called with the symbol naming the variable. The user provided function must return a Vari type-spec or throw an error to inform the user of the issue.

  • ( WITH-STEMCELL-INFER-HOOK FUNC &BODY BODY )

    macro

    When translate is called within the dynamic extern of the body of this form, if there is a use of a variable which is not in scope in the Vari code, but is boundp & not constant in the Common Lisp environment then the user provided function will be called with the symbol naming the variable. The user provided function must return a Vari type-spec or throw an error to inform the user of the issue.

  • ( WITH-UNKNOWN-FIRST-CLASS-FUNCTIONS-ALLOWED &BODY BODY )

    macro

    When translate is called within the dynamic extern of the body of this form, it will not throw an error if there is a use of function with an unknown function name/signature. In the event of such a use the compiler will generate a dummy function to satify the typechecker.

    This is only useful for testing and the resulting GLSL will (most likely) not be legal