(index ("make-scene" 0) ("delete-scene" 268) ("activate-scene" 364) ("deactivate-scene" 518) ("update-scenes" 626) ("add-node" 810) ("delete-node" 1166) ("unsafe-delete-node" 1166) ("node-scene" 1543) ("set-node-bounding-sphere!" 1653) ("node-bounding-sphere" 2001) ("set-node-position!" 2268) ("move-node!" 2462) ("node-position" 2599) ("node-rotation" 2811) ("node-needs-update!" 3284) ("node-transform" 3806) ("node-data" 4134) ("set-node-pool-size!" 4252) ("add-pipeline" 4704) ("delete-pipeline" 5066) ("make-camera" 5174) ("delete-camera" 6692) ("render-camera" 6792) ("update-camera" 8077) ("activate-camera" 8312) ("deactivate-camera" 8552) ("render-cameras" 8686) ("update-cameras" 8787) ("resize-cameras" 8888) ("set-camera-clip-planes!" 9436) ("set-camera-view-angle!" 9658) ("set-camera-viewport-ratio!" 9890) ("set-camera-viewport-dimensions!" 10328) ("set-camera-viewport-screen-position!" 10679) ("set-camera-viewport-offset!" 11089) ("move-camera!" 11602) ("set-camera-position!" 11801) ("camera-position" 12014) ("camera-rotation" 12201) ("camera-look-at!" 12662) ("set-camera-up!" 12849) ("yaw-camera!" 13036) ("set-camera-yaw!" 13207) ("pitch-camera!" 13389) ("set-camera-pitch!" 13566) ("roll-camera!" 13754) ("set-camera-roll!" 13928) ("zoom-camera" 14113) ("set-camera-zoom" 14257) ("move-camera-forward!" 14412) ("move-camera-up!" 14645) ("strafe-camera!" 14799) ("camera-projection" 15025) ("camera-view" 15166) ("camera-view-projection" 15289) ("current-camera-position" 15458) ("current-camera-view" 15639) ("current-camera-projection" 15796) ("current-camera-view-projection" 15971) ("current-camera-model-view-projection" 16174) ("current-inverse-transpose-model" 16395) ("partition-interface" 16770) ("set-partition-interface!" 16770) ("aabb-tree-interface" 17047) ("set-aabb-tree-pool-size!" 17920) ("activate-extension" 18254) ("lighting" 18420) ("max-lights" 18590) ("set-max-lights!" 18743) ("set-ambient-light!" 18940) ("add-light" 19158) ("set-light-color!" 19873) ("light-color" 20011) ("set-light-intensity!" 20136) ("light-intensity" 20267) ("set-light-direction!" 20381) ("light-direction" 20535) ("set-light-spot-angle!" 20672) ("light-spot-angle" 20828) ("n-current-lights" 20958) ("current-ambient-light" 21121) ("current-light-positions" 21311) ("current-light-colors" 21530) ("current-light-intensities" 21740) ("current-light-directions" 21939) ("make-material" 22182) ("set-material-specular-color!" 22486) ("set-material-shininess!" 22641) ("set-light-pool-size!" 22795))
(def (sig (procedure " (make-scene)" (id make-scene))) (p "Create a new scene. The scene’s space is partitioned with the " (int-link "#spatial-partitioning" "partition interface") " given by " (tt "partition-interface") ". New scenes are automatically activated."))
(def (sig (procedure " (delete-scene SCENE)" (id delete-scene))) (p "Delete the given scene."))
(def (sig (procedure " (activate-scene SCENE)" (id activate-scene))) (p "Activate the given scene. If the scene is already active, this has no effect."))
(def (sig (procedure " (deactivate-scene SCENE)" (id deactivate-scene))) (p "Deactivate the given scene."))
(def (sig (procedure " (update-scenes)" (id update-scenes))) (p "Update all active scenes. This must be called every frame in order to make sure all nodes are positioned correctly."))
(def (sig (procedure " (add-node PARENT DATA PIPELINE DELETE)" (id add-node))) (p "Create a new node with the given parent. " (tt "PARENT") " can either be a scene or another node. " (tt "DATA") " is a user supplied pointer to some data which is then passed to the " (tt "PIPELINE") " functions as well as to " (tt "DELETE") " when the node is deleted."))
(def (sig (procedure " (delete-node NODE)" (id delete-node)) (procedure " (unsafe-delete-node NODE)" (id unsafe-delete-node))) (p "Delete the given node, removing it from the scene and calling " (tt "DELETE") " on its " (tt "DATA") ". " (tt "unsafe-delete-node") " should only be called if the " (tt "DELETE") " function is a pure C function that not call back into Scheme."))
(def (sig (procedure " (node-scene NODE)" (id node-scene))) (p "Return the scene that the node belongs to."))
(def (sig (procedure " (set-node-bounding-sphere! NODE RADIUS)" (id set-node-bounding-sphere!))) (p "Set the radius of the node’s bounding sphere. This is important to set so that Hyperscene knows when the node is inside a camera’s bounding volume or not. When a node is created, the bounding sphere radius is initially set to " (tt "1") "."))
(def (sig (procedure " (node-bounding-sphere NODE)" (id node-bounding-sphere))) (p "Return the " (tt "#f32(x y z radius)") " bounding sphere of the node. The bounding sphere is positioned in world coordinates. Modifying the returned f32vector will have no effect."))
(def (sig (procedure " (set-node-position! NODE POINT)" (id set-node-position!))) (p "Set the position of the node, relative to its parent, to be the " (tt "#f32(x y z)") " " (tt "POINT") "."))
(def (sig (procedure " (move-node! NODE VECTOR)" (id move-node!))) (p "Move the node by the " (tt "#f32(x y z)") " " (tt "VECTOR") "."))
(def (sig (procedure " (node-position NODE)" (id node-position))) (p "Return the " (tt "#f32(x y z)") " position of the node relative to its parent. Modifying this value will not change the node’s position."))
(def (sig (procedure " (node-rotation NODE)" (id node-rotation))) (p "Return a pointer to the node’s quaternion " (tt "(x y z w)") " that describes the rotation of the node relative to its parent. Modifying this quaternion (e.g. with gl-math’s imperative " (link "http://wiki.call-cc.org/eggref/4/gl-math#quaternion-operations" "quaternion functions") ") will rotate the node. Make sure to call " (tt "node-needs-update!") " after modifying the returned quaternion."))
(def (sig (procedure " (node-needs-update! NODE)" (id node-needs-update!))) (p "Nodes need to be informed when they have been modified in such a way that they need to be updated. Most node modification functions (" (tt "set-node-position!") ", " (tt "move-node!") ", " (tt "set-node-bounding-sphere!") ") call this automatically, but Hyperscene cannot tell when a node’s rotation quaternion has been modified. Make sure to call " (tt "node-needs-update!") " after modifying " (tt "node-rotation") "’s return value."))
(def (sig (procedure " (node-transform NODE)" (id node-transform))) (p "Return a pointer to the 4x4 transform matrix that describes the position and orientation of the node in world space. Consecutive elements of the matrix represent columns. Any modifications to the transform matrix will be lost when the scene is updated."))
(def (sig (procedure " (node-data NODE)" (id node-data))) (p "Return a pointer to the node’s user supplied data."))
(def (sig (procedure " (set-node-pool-size! SIZE)" (id set-node-pool-size!))) (p "Hyperscene uses memory pools to store its data relating to nodes, which makes creation and deletion of nodes and scenes quick. For best performance, set the node pool size to be as large as the greatest number of nodes that will be needed for a scene. When a scene is created with " (tt "make-scene") " its node pool is set to this size. Defaults to " (tt "4096") "."))
(def (sig (procedure " (add-pipeline PRE-RENDER RENDER POST-RENDER [ALPHA])" (id add-pipeline))) (p "Create a new pipeline with the given " (link "http://wiki.call-cc.org/man/4/Callbacks" "callbacks") " (or pointers to pure C functions). " (tt "ALPHA?") " indicates whether or not the pipeline can render any transparent elements (defaults to " (tt "#f") ")."))
(def (sig (procedure " (delete-pipeline PIPELINE)" (id delete-pipeline))) (p "Delete the given pipeline."))
(def (sig (procedure " (make-camera TYPE STYLE SCENE [near: NEAR] [far: FAR] [angle: ANGLE] [width: WIDTH] [height: HEIGHT] [viewport-width-ratio: VIEWPORT-WIDTH-RATIO] [viewport-height-ratio: VIEWPORT-HEIGHT-RATIO] [static-viewport?: STATIC-VIEWPORT?])" (id make-camera))) (p "Create a new camera associated with the given scene. " (tt "TYPE") " must be one of " (tt "#:ortho") " or " (tt "#:perspective") " for an orthographic or a perspective camera, respectively. " (tt "STYLE") " must be one of " (tt "#:position") ", " (tt "#:look-at") ", " (tt "#:orbit") ", or " (tt "#:first-person") ". New cameras are automatically activated. " (tt "NEAR") " is the near plane of the camera, defaulting to " (tt "1") ". " (tt "FAR") " is the far plane of the camera, defaulting to " (tt "10000") ". " (tt "ANGLE") " is the view-angle, in degrees, for perspective cameras, defaulting to " (tt "70") ". " (tt "WIDTH") " and " (tt "HEIGHT") " should be initialized to the size of camera’s viewport. " (tt "VIEWPORT-WIDTH-RATIO") " and " (tt "VIEWPORT-HEIGHT-RATIO") " scale the camera’s viewport (its view frustum’s near plane) in the width and height direction. The effects of the scaling persist after " (tt "resize-cameras") " is called. If " (tt "STATIC-VIEWPORT?") " is " (tt "#t") ", the camera’s viewport dimensions will be fixed such that they won’t be changed by " (tt "resize-cameras") ", although " (tt "VIEWPORT-WIDTH-RATIO") " and " (tt "VIEWPORT-HEIGHT-RATIO") " still effect the final viewport size."))
(def (sig (procedure " (delete-camera CAMERA)" (id delete-camera))) (p "Delete the given camera."))
(def (sig (procedure " (render-camera CAMERA)" (id render-camera))) (p "Render the given camera. When cameras are rendered, all of the visible nodes are sorted: first into groups of nodes that have an alpha pipline or that don’t.") (p "Alpha nodes are sorted by decreasing distance from the camera and rendered last. There are two sorting schemes that may be employed. The first, and default, scheme is useful when working with one-dimensional alpha objects. It sorts the distance of nodes based only on their origin, not taking into account their bounding sphere. The second scheme, enabled by defining " (tt "#:volumetric-alpha") ", is useful when working with three-dimensional alpha objects, and sorts distance while taking the bounding sphere into account.") (p "Non-alpha nodes are sorted by pipeline. Each pipeline is then sorted again by increasing distance from the camera before they are rendered. By doing so, the things that are closest to the camera are drawn first (“reverse painter” sorting) which can help graphics hardware determine when later bits of the scene are hidden, thus saving some rendering time. Not all applications will benefit from this extra step, though, and it can be disabled by defining " (tt "#:no-reverse-painter") " at compilation time."))
(def (sig (procedure " (update-camera CAMERA)" (id update-camera))) (p "Update the given camera. This updates the view matrix of the camera to reflect any changes that may have occurred. This should always be done before rendering."))
(def (sig (procedure " (activate-camera CAMERA)" (id activate-camera))) (p "Add the camera to the list of active cameras (or push it to the back of the list, thus setting it to be rendered last). New cameras are automatically activated."))
(def (sig (procedure " (deactivate-camera CAMERA)" (id deactivate-camera))) (p "Remove the camera from the list of active cameras."))
(def (sig (procedure " (render-cameras)" (id render-cameras))) (p "Render all the active cameras."))
(def (sig (procedure " (update-cameras)" (id update-cameras))) (p "Update all the active cameras."))
(def (sig (procedure " (resize-cameras WIDTH HEIGHT)" (id resize-cameras))) (p "Modify the projection matrix of all cameras, based on the viewport dimensions " (tt "WIDTH") " and " (tt "HEIGHT") ". Should be called whenever the window is resized. The viewport dimensions of a camera are scaled by any values passed to " (tt "set-camera-viewport-ratio!") " or the " (tt "viewport-*-ratio") " keywords of " (tt "make-camera") ". If " (tt "static-viewport?") " was set to " (tt "#t") " when a camera was created, this function has no effect on it."))
(def (sig (procedure " (set-camera-clip-planes! CAMERA NEAR FAR)" (id set-camera-clip-planes!))) (p "Set the near and far clip planes of the camera. Nodes closer to or further away from these plans will not be visible."))
(def (sig (procedure " (set-camera-view-angle! CAMERA ANGLE)" (id set-camera-view-angle!))) (p "Set the viewing angle of the perspective camera to " (tt "angle") " degrees. This doesn’t have any effect on orthographic cameras."))
(def (sig (procedure " (set-camera-viewport-ratio! CAMERA WIDTH HEIGHT)" (id set-camera-viewport-ratio!))) (p "Scale " (tt "CAMERA") "’s viewport (its view frustum’s near plane) in the width and height direction by " (tt "WIDTH") " and " (tt "HEIGHT") ". The effects of the scaling persist after " (tt "resize-cameras") " is called. This is equivalent to setting the " (tt "viewport-*-ratio") " keywords of " (tt "make-camera") "."))
(def (sig (procedure " (set-camera-viewport-dimensions! CAMERA WIDTH HEIGHT)" (id set-camera-viewport-dimensions!))) (p "Set " (tt "CAMERA") "’s viewport (its view frustum’s near plane) dimensions to " (tt "WIDTH") " and " (tt "HEIGHT") ", and fixes these dimensions such that they will not be changed when " (tt "resize-cameras") " is called."))
(def (sig (procedure " (set-camera-viewport-screen-position! CAMERA LEFT RIGHT BOTTOM TOP)" (id set-camera-viewport-screen-position!))) (p "Set the area of the screen that " (tt "CAMERA") " renders to, defined by the rectangle of " (tt "LEFT") ", " (tt "RIGHT") ", " (tt "BOTTOM") ", " (tt "TOP") ". These default to the full screen, which is represented by values of " (tt "-1, 1, -1, 1") ", respectively."))
(def (sig (procedure " (set-camera-viewport-offset! CAMERA X Y)" (id set-camera-viewport-offset!))) (p "Move " (tt "CAMERA") "’s viewport (its view frustum’s near plane) by " (tt "(X, Y)") " expressed as a fraction of the viewport’s width and height. This is generally only useful for a perspective projection, when lines should converge not to the middle of the screen, but to another point. Setting " (tt "x") " to " (tt "0.5") ", for example, moves the focal centre to the right edge of the viewport."))
(def (sig (procedure " (move-camera! CAMERA VECTOR)" (id move-camera!))) (p "Move the position of the camera by the vector " (tt "#f32(x y z)") ". Cannot be called with an " (i "orbit") " camera."))
(def (sig (procedure " (set-camera-position! CAMERA POINT)" (id set-camera-position!))) (p "Set the position of the camera to the " (tt "#f32(x y z)") " point . Cannot be called with an " (i "orbit") " camera."))
(def (sig (procedure " (camera-position CAMERA)" (id camera-position))) (p "Return the " (tt "#f32(x y z)") " position of the camera. Modifying this vector will not affect the camera."))
(def (sig (procedure " (camera-rotation CAMERA)" (id camera-rotation))) (p "Return a pointer to the node’s quaternion " (tt "(x y z w)") " that describes the rotation of the camera. Modifying this quaternion (e.g. with gl-math’s imperative " (link "http://wiki.call-cc.org/eggref/4/gl-math#quaternion-operations" "quaternion functions") ") will rotate " (i "position") " cameras. The returned quaternion must not be modified for any other camera styles."))
(def (sig (procedure " (camera-look-at! CAMERA POINT)" (id camera-look-at!))) (p "Set the " (tt "#f32(x y z)") " point the " (i "look-at") " or " (i "orbit") " cameras are looking at."))
(def (sig (procedure " (set-camera-up! CAMERA UP)" (id set-camera-up!))) (p "Set the camera’s " (tt "#f32(x y z)") " up-vector. Cannot be called with a non-" (i "look-at") " camera."))
(def (sig (procedure " (yaw-camera! CAMERA ANGLE)" (id yaw-camera!))) (p "Add " (tt "ANGLE") " radians to the " (i "orbit") " or " (i "first-person") " camera’s yaw."))
(def (sig (procedure " (set-camera-yaw! CAMERA ANGLE)" (id set-camera-yaw!))) (p "Set the yaw of the " (i "orbit") " or " (i "first-person") " camera to " (tt "ANGLE") " radians."))
(def (sig (procedure " (pitch-camera! CAMERA ANGLE)" (id pitch-camera!))) (p "Add " (tt "ANGLE") " radians to the " (i "orbit") " or " (i "first-person") " camera’s pitch."))
(def (sig (procedure " (set-camera-pitch! CAMERA ANGLE)" (id set-camera-pitch!))) (p "Set the pitch of the " (i "orbit") " or " (i "first-person") " camera to " (tt "ANGLE") " radians."))
(def (sig (procedure " (roll-camera! CAMERA ANGLE)" (id roll-camera!))) (p "Add " (tt "ANGLE") " radians to the " (i "orbit") " or " (i "first-person") " camera’s roll."))
(def (sig (procedure " (set-camera-roll! CAMERA ANGLE)" (id set-camera-roll!))) (p "Set the roll of the " (i "orbit") " or " (i "first-person") " camera to " (tt "ANGLE") " radians."))
(def (sig (procedure " (zoom-camera CAMERA DISTANCE)" (id zoom-camera))) (p "Add " (tt "DISTANCE") " to the " (i "orbit") " camera’s zoom."))
(def (sig (procedure " (set-camera-zoom CAMERA DISTANCE)" (id set-camera-zoom))) (p "Set the zoom of the " (i "orbit") " camera to " (tt "DISTANCE") "."))
(def (sig (procedure " (move-camera-forward! CAMERA DISTANCE)" (id move-camera-forward!))) (p "Move the " (i "first-person") " camera forward by " (tt "DISTANCE") ". Only the camera’s yaw is taken into account for the movement."))
(def (sig (procedure " (move-camera-up! CAMERA DISTANCE)" (id move-camera-up!))) (p "Move the " (i "first-person") " camera up by " (tt "DISTANCE") "."))
(def (sig (procedure " (strafe-camera! CAMERA DISTANCE)" (id strafe-camera!))) (p "Move the " (i "first-person") " camera to the right by " (tt "DISTANCE") ". Only the camera’s yaw is taken into account for the movement."))
(def (sig (procedure " (camera-projection CAMERA)" (id camera-projection))) (p "Returns a pointer to the projection matrix of the camera."))
(def (sig (procedure " (camera-view CAMERA)" (id camera-view))) (p "Returns a pointer to the view matrix of the camera."))
(def (sig (procedure " (camera-view-projection CAMERA)" (id camera-view-projection))) (p "Returns a pointer to the " (tt "projection * view") " matrix of the camera."))
(def (sig (procedure " (current-camera-position)" (id current-camera-position))) (p "Returns a pointer to the " (tt "(x y z)") " position of the camera currently being rendered."))
(def (sig (procedure " (current-camera-view)" (id current-camera-view))) (p "Returns a pointer to the view matrix of the camera currently being rendered."))
(def (sig (procedure " (current-camera-projection)" (id current-camera-projection))) (p "Returns a pointer to the projection matrix of the camera currently being rendered."))
(def (sig (procedure " (current-camera-view-projection)" (id current-camera-view-projection))) (p "Returns a pointer to the " (tt "projection * view") " matrix of the camera currently being rendered."))
(def (sig (procedure " (current-camera-model-view-projection)" (id current-camera-model-view-projection))) (p "Returns a pointer to the " (tt "projection * view * model") " matrix of the node currently being rendered."))
(def (sig (procedure " (current-inverse-transpose-model)" (id current-inverse-transpose-model))) (p "Returns a pointer to the inverse transpose model matrix of the node currently being rendered. This matrix is useful for lighting. If it is not wanted, the calculation of this value can be omitted by defining the feature " (tt "#:no-inverse-transpose") " at compile time."))
(def (sig (procedure " (partition-interface)" (id partition-interface)) (procedure " (set-partition-interface! INTERFACE)" (id set-partition-interface!))) (p "Returns/sets the partition interface that scenes are initialized with. Defaults to " (tt "aabb-tree-interface") "."))
(def (sig (procedure " (aabb-tree-interface)" (id aabb-tree-interface))) (p (tt "aabb-tree-interface") " is a hybrid AABB ternary tree/nonatree/isoceptree inspired heavily by " (link "http://www.cs.nmsu.edu/~joshagam/Solace/papers/master-writeup-print.pdf" "Dynamic Spatial Partitioning for Real-Time Visibility Determination") ". When trees split, they try to split only along those axis where the nodes are most well dispersed. For example, if you have a 2D game, chances are nodes will be arranged along the " (tt "X") " and " (tt "Y") " axes, with little separation on the " (tt "Z") " axis. In this situation, when enough nodes are added to a given AABB tree, it will only split along those two axes. In doing so, it avoids extraneous tree creation. This can be taken advantage of most in 2D situations by not using too much (" (tt "Z") ") distance between layers."))
(def (sig (procedure " (set-aabb-tree-pool-size! SIZE)" (id set-aabb-tree-pool-size!))) (p "Set the memory pool size of the " (tt "aabb-tree-interface") ". This pool sets the number of trees in the partition interface’s pool, which is initialized for each scene when " (tt "make-scene") " is called. Defaults to " (tt "4096") "."))
(def (sig (procedure " (activate-extension SCENE EXTENSION)" (id activate-extension))) (p "Before an extension can be used in a given scene, it must be activated."))
(def (sig (procedure " (lighting)" (id lighting))) (p "Before lights can be used in a scene, " (tt "lighting") " must be activated with " (tt "activate-extension") "."))
(def (sig (procedure " (max-lights)" (id max-lights))) (p "Return the maximum number of lights that may be visible at once. Defaults to " (tt "8") "."))
(def (sig (procedure " (set-max-lights! N)" (id set-max-lights!))) (p "Set the maximum lights that may be visible at once. Must not be called after the first scene with lighting is initialized."))
(def (sig (procedure " (set-ambient-light! SCENE COLOR)" (id set-ambient-light!))) (p "Scenes that use the lighting extension have an " (tt "#f32(r g b)") " ambient light associated with them, set by this function."))
(def (sig (procedure " (add-light PARENT COLOR INTENSITY [direction: direction] [spot-angle: SPOT-ANGLE])" (id add-light))) (p "Adds a new light to the given " (tt "PARENT") " node (or scene) with " (tt "#f32(r g b)") " " (tt "COLOR") ". " (tt "INTENSITY") " is the floating point value associated with the brightness of the light. " (tt "DIRECTION") " is an " (tt "#f32(x y z)") " vector that indicates the direction that the light is pointing, defaulting to " (tt "#f32(0 0 0)") ". " (tt "SPOT-ANGLE") " indicates the angle in radians that the light is spread over (defaulting to " (tt "0") ", representing a non-spotlight source). A node is returned that can be moved, rotated, and sized like any other node."))
(def (sig (procedure " (set-light-color! LIGHT COLOR)" (id set-light-color!))) (p "Sets the " (tt "#f32(r g b)") " color of the light."))
(def (sig (procedure " (light-color LIGHT)" (id light-color))) (p "Returns the " (tt "#f32(r g b)") " color of the light."))
(def (sig (procedure " (set-light-intensity! LIGHT INTENSITY)" (id set-light-intensity!))) (p "Sets the intensity of the light."))
(def (sig (procedure " (light-intensity LIGHT)" (id light-intensity))) (p "Returns the intensity of the light."))
(def (sig (procedure " (set-light-direction! LIGHT DIRECTION)" (id set-light-direction!))) (p "Sets the " (tt "#f32(x y z)") " direction of the light."))
(def (sig (procedure " (light-direction LIGHT)" (id light-direction))) (p "Returns the " (tt "#f32(x y z)") " direction of the light."))
(def (sig (procedure " (set-light-spot-angle! LIGHT ANGLE)" (id set-light-spot-angle!))) (p "Sets the angle, in radians, over which the light is spread."))
(def (sig (procedure " (light-spot-angle LIGHT)" (id light-spot-angle))) (p "Returns the angle over which the light is spread."))
(def (sig (procedure " (n-current-lights)" (id n-current-lights))) (p "Returns a pointer to the number of visible lights in the scene currently being rendered."))
(def (sig (procedure " (current-ambient-light)" (id current-ambient-light))) (p "Returns a pointer to the " (tt "(r g b)") " color of ambient light in the scene currently being rendered."))
(def (sig (procedure " (current-light-positions)" (id current-light-positions))) (p "Returns a pointer to the array of packed " (tt "(x y z)") " positions of the visible lights in the scene currently being rendered."))
(def (sig (procedure " (current-light-colors)" (id current-light-colors))) (p "Returns a pointer to the array of packed " (tt "(r g b)") " colors of the visible lights in the scene currently being rendered."))
(def (sig (procedure " (current-light-intensities)" (id current-light-intensities))) (p "Returns a pointer to the array of intensities of the visible lights in the scene currently being rendered."))
(def (sig (procedure " (current-light-directions)" (id current-light-directions))) (p "Returns a pointer to the array of packed " (tt "(x y z spotAngle)") " directions and angles of the visible lights in the scene currently being rendered."))
(def (sig (procedure " (make-material R G B SHININESS)" (id make-material))) (p "Make a simple material definition consisting of an RGB color (specular color, perhaps) and shininess value. Returns a four element f32vector, located in non-garbage-collected memory. Intended for use as a uniform value."))
(def (sig (procedure " (set-material-specular-color! MATERIAL R G B)" (id set-material-specular-color!))) (p "Set the RGB values of the given material."))
(def (sig (procedure " (set-material-shininess! MATERIAL SHININESS)" (id set-material-shininess!))) (p "Set the shininess value of the given material."))
(def (sig (procedure " (set-light-pool-size! SIZE)" (id set-light-pool-size!))) (p "Every scene is given a pool from which to allocate lights, the size of which can be modified by calling this function before initialization (defaults to " (tt "1024") ")."))
