Z      !"#$%&'()*+,-./01234 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde f g h i j k l m n o p q r s t u v w x y z { | } ~                                                             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!"""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\$]$^%_%`%a%b%c%d%e%f%g%h%i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))************************************ * * * * *****++++++,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~--------------./000000111111111111111111111112222222222222333333333333345555555555555555555555555566666666666666666666666666666666666666666 6 6 6 6 6666666666778      !"#$%&'()*+,-./0    123456789:;<=>?@ABCDEFGH    IJKLMNOPQRSTUVWXYZ[\]^_`    $Starts the hardware occlusion query "Ends the hardware occlusion test. $Pulls the hardware occlusion query. ILets you know when query is done, or still be processed by the Hardware.      !"#$Locking options %8As HBL_NORMAL, except the application guarantees not to @ overwrite any region of the buffer which has already been used : in this frame, can allow some optimisation on some APIs. &9Lock the buffer for reading only. Not allowed in buffers = which are created with HBU_WRITE_ONLY. Mandatory on static ; buffers, i.e. those created without the HBU_DYNAMIC flag. '6Discards the entire buffer while locking; this allows A optimisation to be performed because synchronisation issues are ? relaxed. Only allowed on buffers created with the HBU_DYNAMIC  flag. (Normal mode, ie allows read/"write and contents are preserved. )*/Combination of HBU_DYNAMIC, HBU_WRITE_ONLY and  HBU_DISCARDABLE +:Combination of HBU_DYNAMIC and HBU_WRITE_ONLY. If you use  this, strongly consider using > HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE instead if you update the / entire contents of the buffer very regularly. ,-Combination of HBU_STATIC and HBU_WRITE_ONLY ->Indicates that the application will be refilling the contents @ of the buffer regularly (not just updating, but generating the < contents from scratch), and therefore does not mind if the 8 contents of the buffer are lost somehow and need to be @ recreated. This allows and additional level of optimisation on @ the buffer. This option only really makes sense when combined  with HBU_DYNAMIC_WRITE_ONLY. .>Indicates the application will never read the contents of the = buffer back, it will only ever write data. Locking a buffer ; with this flag will ALWAYS return a pointer to new, blank ? memory rather than the memory associated with the contents of ? the buffer; this avoids DMA stalls because you can write to a 7 new memory area while the previous one is being used. /;Indicates the application would like to modify this buffer A with the CPU fairly often. Buffers created with this flag will : typically end up in AGP memory rather than video memory. 09Static buffer which the application rarely modifies once ? created. Modifying the contents of this buffer will involve a  performance hit.  !"#$%&'()*+,-./0)0/.-,+*$('&% !"# !"# !"#$('&%%&'()0/.-,+**+,-./012312312312323 *456789;The list of vertex elements that makes up this declaration :;<IThe source vertex buffer, as bound to an index using VertexBufferBinding =5The offset in the buffer that this element starts at >The type of element ?The meaning of the element @IIndex of the item, only applicable for some elements like texture coords ALVertex element type, used to identify the base types of the vertex contents BGL style compact colour CD3D style compact colour DEFGHIJKLMQVertex element semantics, used to identify the meaning of vertex buffer contents N Tangent (X axis if normal is Z) O!Binormal (Y axis if normal is Z) PTexture coordinates QSpecular colours RDiffuse colours SNormal, 3 reals per vertex TBlending indices UBlending weights VPosition, 3 reals per vertex WX9Gets the size in bytes of a single vertex in this buffer Y*Get the number of vertices in this buffer Z0Utility method for helping to calculate offsets [AUtility method which returns the count of values in a given type \lSimple converter function which will turn a single-value type into a multi-value type based on a parameter. ]=Simple converter function which will convert a type into its : single-value equivalent to make switches on type easier. *456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]*WXYMVUTSRQPONALKJIHGFEDCB:;<=>?@Z[\]789456*4565678989:;<=>?@;<=>?@A LKJIHGFEDCBBCDEFGHIJKLM VUTSRQPONNOPQRSTUVWXYXYZ[\] ^_,Get the type of indexes used in this buffer `)Get the number of indexes in this buffer a$Get the size in bytes of each index bcd^_`abcdbdc^_`a^_`a_`abdccd efgRpointer to the HardwareIndexBuffer to use, must be specified if useIndexes = true h5index in the buffer to start from for this operation i-The number of indexes to use from the buffer jklsDeclaration of the vertex to be used in this operation. remarks Note that this is created for you on construction. mbThe vertex buffer bindings to be used. remarks Note that this is created for you on construction. n$The base vertex index to start from o.The number of vertices used in this operation efghijklmno jklmnoefghi efghifghijklmnoklmno 3pPixel component format q32 bit float per component r16 bit float per component s-Short per component (16 bit fixed 0.0..1.0)) t*Byte per component (8 bit fixed 0.0..1.0) uFlags defining some on/ off properties of pixel formats v`This is an intensity format instead of a RGB one. The luminance replaces R,G and B. (but not A) w|Format is in native endian. Generally true for the 16, 24 and 32 bits formats which can be represented as machine integers. x,This is a depth format (for depth textures) y This is a floating point format zThis format is compressed. This invalidates the values in elemBytes, elemBits and the bit counts as these might not be fixed in a compressed format. {!This format has an alpha channel |@The pixel format used for images, textures, and render surfaces }548-bit pixel format, 16 bits for red, green and blue ~.32-bit pixel format, 16-bit green, 16-bit red <64-bit pixel format, 16 bits for red, green, blue and alpha Depth texture format H64-bit, 2-channel floating point pixel format, 32-bit green, 32-bit red N32-bit, 2-channel s10e5 floating point pixel format, 16-bit green, 16-bit red ~128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha b96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue -16-bit pixel format, 16 bits (float) for red }64-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue, 16 bits (float) for alpha b48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue -16-bit pixel format, 16 bits (float) for red %DDS (DirectDraw Surface) DXT5 format %DDS (DirectDraw Surface) DXT4 format %DDS (DirectDraw Surface) DXT3 format %DDS (DirectDraw Surface) DXT2 format %DDS (DirectDraw Surface) DXT1 format H32-bit pixel format, 10 bits for blue, green and red, 2 bits for alpha. H32-bit pixel format, 2 bits for alpha, 10 bits for red, green and blue. w32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red; like PF_A8B8G8R8, but alpha will get discarded w32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue; like PF_A8R8G8B8, but alpha will get discarded <32-bit pixel format, 8 bits for red, green, blue and alpha. <32-bit pixel format, 8 bits for blue, green, red and alpha. <32-bit pixel format, 8 bits for blue, green, red and alpha. <32-bit pixel format, 8 bits for alpha, red, green and blue. 524-bit pixel format, 8 bits for blue, green and red. 524-bit pixel format, 8 bits for red, green and blue. B16-bit pixel format, 5 bits for blue, green, red and 1 for alpha. <16-bit pixel format, 4 bits for alpha, red, green and blue. ;8-bit pixel format, 2 bits blue, 3 bits green, 3 bits red. <16-bit pixel format, 5 bits red, 6 bits green, 5 bits blue. <16-bit pixel format, 5 bits red, 6 bits green, 5 bits blue. 42 byte pixel format, 1 byte luminance, 1 byte alpha 48-bit pixel format, 4 bits alpha, 4 bits luminance. $8-bit pixel format, all bits alpha.  | PF_BYTE_A = PF_A8 (16-bit pixel format, all bits luminace.  | PF_SHORT_L = PF_L16 '8-bit pixel format, all bits luminace.  | PF_BYTE_L = PF_L8 Unknown pixel format. 3pqrstuvwxyz{|}~3|~}u{zyxwvptsrq3ptsrqqrstu{zyxwvvwxyz{|&~}}~ BHas information about the size and the pixel format of the image. Image can be empty Image loader function A0Sort mode for billboard-set and particle-system !Sort by distance from the camera  Sort by direction of the camera *The polygon mode to use when rasterising. Solid polygons are rendered. Wireframe models are rendered. Only points are rendered. nPulse Width Modulation. Works like WFT_SQUARE, except the high to low transition is controlled by duty cycle. J With a duty cycle of 50% (0.5) will give the same output as WFT_SQUARE. cGradual steady decrease from max to min over the period, with an instant return to max at the end. bGradual steady increase from min to max over the period with an instant return to min at the end. WHalf of the time is spent at the min, half at the max with instant transition between. )An angular wave with a constant increase /$ decrease speed with pointed peaks. KStandard sine wave which smoothly changes from low to high and back again. .Manual culling modes based on vertex normals. <Cull triangles whose normal is pointing towards the camera. HCull triangles whose normal is pointing away from the camera (default). 2No culling so everything is sent to the hardware. yHardware culling modes based on vertex winding. This setting applies to how the hardware API culls triangles it is sent. NHardware culls triangles whose vertices are listed anticlockwise in the view. THardware culls triangles whose vertices are listed clockwise in the view (default). CHardware never culls triangles and renders everything it receives.  Fog modes. CFog density increases linearly between the start and end distances JFog density increases at the square of FOG_EXP, i.e. even quicker (fog = 1/e^(distance * density)^2) =Fog density increases exponentially from the camera (fog = 1/e^(distance * density))  No fog. Duh. Light shading modes. Filtering options for textures / mipmaps. ISimilar to FO_LINEAR, but compensates for the angle of the texture plane QAverage of a 2x2 pixel area, denotes bilinear for MIN and MAG, trilinear for MIP Use the closest pixel 7No filtering, used for FILT_MIP to turn off mipmapping ,The filter used when determining the mipmap *The filter used when magnifying a texture )The filter used when shrinking a texture AHigh-level filtering options providing shortcuts to settings the . minification, magnification and mip filters. @Equal to: min=FO_ANISOTROPIC, max=FO_ANISOTROPIC, mip=FO_LINEAR 6Equal to: min=FO_LINEAR, mag=FO_LINEAR, mip=FO_LINEAR 5Equal to: min=FO_LINEAR, mag=FO_LINEAR, mip=FO_POINT 2Equal to: min=FO_POINT, mag=FO_POINT, mip=FO_NONE 'Comparison functions used for the depth/stencil buffer operations  and others. AAA Vertex source data !The type of operation to perform .Index data - only valid if useIndexes is true .The interpretation of a sequence of vertices. VA fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that. XA strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that. .A list of triangles, 3 vertices per triangle. CA strip of connected lines, 1 vertex per line plus 1 start vertex. &A list of lines, 2 vertices per line. &A list of points, 1 vertex per point. ;The floating point type used throughout the engine. It is B recommended to use this synonym ubiquitously in code interfacing  with LambdaCube. abcdefghijklmnopqrstuvwxyz{|}~      !#Perspective transformation matrix. 0Near plane clipping distance (always positive). /Far plane clipping distance (always positive). )Field of view of the y axis, in radians. Aspect ratio, i.e. screen's width/height. 1Pure orientation matrix defined by Euler angles. Camera transformation matrix. Camera position. Target position. Upward direction. Light source description.      !Possible types of light sources. +Spotlights simulate a cone of light from a 0 source so require position and direction, plus  extra values for falloff. +Directional lights simulate parallel light ) beams from a distant source, hence have  direction but no position. +Point light sources give off light equally ) in all directions, so they require only  position but no direction.                      5Class encapsulating a set of AnimationState objects. !List of enabled animation states 9Represents the state of an animation and the weight of it' s influence.  remarks Z Other classes can hold instances of this class to store the state of any animations  they are using. -the blend mask (containing per bone weights)  !"#$ !"#$ !"#$ !"#$ !"#$A%EBlending operations controls how objects are blended into the scene. &'()*+?Blending factors for manually blending objects with the scene. ,-./0123456ATypes of blending that you can specify between an object and the ! existing contents of the scene. 79The default blend mode where source replaces destination 8 Multiply the 2 colours together 95Add the texture values to the existing scene content :_Make the object transparent based on the colour values in the texture (brighter = more opaque) ;KMake the object transparent based on the final alpha values in the texture <=>'The type of blending (colour or alpha) ?The operation to be applied @The first source of colour/alpha AThe second source of colour/alpha B'Manual colour value for manual source1 C'Manual colour value for manual source2 D&Manual alpha value for manual source1 E&Manual alpha value for manual source2 FManual blending factor G+Sources of values for blending operations. H2a colour supplied manually as a separate argument I3the interpolated specular colour from the vertices J2the interpolated diffuse colour from the vertices K;the colour derived from the texture assigned to this layer L,the colour as built up from previous stages M&Extended texture blending operations. Ncuse interpolated color values from vertices to scale source1, then add source2 scaled by (1-color) O!dot product of color1 and color2 PKas LBX_BLEND_DIFFUSE_ALPHA but use a constant manual blend value (0.0-1.0) QGas LBX_BLEND_DIFFUSE_ALPHA, but use current alpha from previous stages R7as LBX_BLEND_DIFFUSE_ALPHA, but use alpha from texture Sbuse interpolated alpha value from vertices to scale source1, then add source2 scaled by (1-alpha) Tsubtract source2 from source1 U.as LBX_ADD, but subtract product from the sum V-as LBX_ADD, but subtract 0.5 from the result W!add source1 and source2 together X2as LBX_MODULATE but brighten more afterwards (x4) Y-as LBX_MODULATE but brighten afterwards (x2) Z&multiply source1 and source2 together [!use source2 without modification \!use source1 without modification ]Texture blending operations. ^blend based on texture alpha _$multiply colour components together `add colour components together a3replace all colour with texture with no adjustment bType of texture blend mode. cde1Converts SceneBlendType to SceneBlendFactor pair A%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeAbdc]a`_^M\[ZYXWVUTSRQPONGLKJIH<=>?@ABCDEF6;:987+543210/.-,%*)('&eA%*)('&&'()*+ 543210/.-,,-./0123456;:987789:;< =>?@ABCDEF=>?@ABCDEFGLKJIHHIJKLM\[ZYXWVUTSRQPONNOPQRSTUVWXYZ[\]a`_^^_`abdccde$fghijklmnopqrstuvwxyz{|}~Use TextureManager default Generate mipmaps up to 1x1 =3D cube map, used in combination with 3D texture coordinates C3D volume texture, used in combination with 3D texture coordinates F2D texture, used in combination with 2D texture coordinates (default) <1D texture, used in combination with 1D texture coordinates 9mipmaps will be automatically generated for this texture this texture will be a render target, i.e. used as a target for render to texture setting this flag will ignore all other texture usages except TU_AUTOMIPMAP $fghijklmnopqrstuvwxyz{|}~$|~}fghijklmnopqrstuvwxyz{$fghijklmnopqrstuvwxyz{ghijklmnopqrstuvwxyz{|~}}~ 6The render operation type used to render this submesh SIndicates if this submesh shares vertex data with other meshes or whether it has it's own vertices. Face index data * , smExtremityPoints :: [FloatType3] (Name of the material this SubMesh uses.        The type of parameter %The target (physical) constant index The number of elements per individual entry in this constant Used in case people used packed elements smaller than 4 (e.g. GLSL) and bind an auto which is 4-element packed to it <The variability of this parameter (see GpuParamVariability) (The type of the constant in the program The type of any extra data -the auto constant requires data of type real ,the auto constant requires data of type int no data is required ?The types of automatically updated values that may be bound to E GpuProgram parameters, or used to modify parameters on a per-object  basis. 1Binds custom per-light constants to the shaders. Provides the current transform matrix of the texture unit (index determined by setAutoConstant call), as seen by the fixed-function pipeline. Provides packed texture size of the texture unit (index determined by setAutoConstant call). Packed as float4(width, height, 1  width, 1  height) qProvides inverse texture size of the texture unit (index determined by setAutoConstant call). Packed as float4(1  width, 1  height, 1 / depth, 1) Provides texture size of the texture unit (index determined by setAutoConstant call). Packed as float4(width, height, depth, 1) |Provides the fixed shadow colour as configured via SceneManager::setShadowColour; useful for integrated modulative shadows. +Provides a parametric animation value [0..1]B, only available where the renderable specifically implements it. provides the current iteration number of the pass. The iteration number is the number of times the current render operation has been drawn for the active pass. Kprovides the pass index number within the technique of the active materil. bThis variable provides the far clip distance as a floating point value. Equivalent to RenderMonkey's  FarClipPlane. cThis variable provides the near clip distance as a floating point value. Equivalent to RenderMonkey's  NearClipPlane. ^This variable provides the field of view as a floating point value. Equivalent to RenderMonkey's FOV. SThis variable provides the view up vector (world space). Equivalent to RenderMonkey's  ViewUpVector. UThis variable provides the view side vector (world space). Equivalent to RenderMonkey's ViewSideVector. ZThis variable provides the view direction vector (world space). Equivalent to RenderMonkey's  ViewDirection.  Packed of  ViewportWidth, ViewportHeight, ViewportWidthInverse, ViewportHeightInverse. This variable represents 1.0/*ViewportHeight. Equivalent to RenderMonkey's ViewportHeightInverse. This variable represents 1.0/)ViewportWidth. Equivalent to RenderMonkey's ViewportWidthInverse. WCurrent viewport height (in pixels) as floating point value. Equivalent to RenderMonkey's ViewportHeight. VCurrent viewport width (in pixels) as floating point value. Equivalent to RenderMonkey's  ViewportWidth. Oprovides the calculated frames per second, returned as a floating point value. Dprovides the scaled frame time, returned as a floating point value.  Vector of  Time0_2PI,  SinTime0_2PI,  CosTime0_2PI,  TanTime0_2PI. Equivalent to RenderMonkey's Time0_2PI_Packed.  Tangent of  Time0_2PI. Equivalent to RenderMonkey's  TanTime0_2PI. Sine of  Time0_2PI. Equivalent to RenderMonkey's  SinTime0_2PI.  Cosine of  Time0_2PI. Equivalent to RenderMonkey's  CosTime0_2PI. ?Single float value, which represents scaled time value [0..2*Pi]3, which repeats itself based on given as parameter  cycle time. Equivalent to RenderMonkey's  Time0_2PI.  Vector of Time0_1,  SinTime0_1,  CosTime0_1,  TanTime0_1. Equivalent to RenderMonkey's Time0_1_Packed.  Tangent of Time0_1. Equivalent to RenderMonkey's  TanTime0_1. Sine of Time0_1. Equivalent to RenderMonkey's  SinTime0_1.  Cosine of Time0_1. Equivalent to RenderMonkey's  CosTime0_1. <Single float value, which represents scaled time value [0..1]3, which repeats itself based on given as parameter  cycle time. Equivalent to RenderMonkey's Time0_1.  Vector of Time0_X,  SinTime0_X,  CosTime0_X,  TanTime0_X. Equivalent to RenderMonkey's Time0_X_Packed.  Tangent of Time0_X. Equivalent to RenderMonkey's  TanTime0_X. Sine of Time0_X. Equivalent to RenderMonkey's  SinTime0_X.  Cosine of Time0_X. Equivalent to RenderMonkey's  CosTime0_X. ESingle float value, which repeats itself based on given as parameter  cycle time. Equivalent to RenderMonkey's Time0_X. provides current elapsed time >A custom parameter which will come from the renderable, using 'data' as the identifier The view/bprojection matrix of a given spotlight projection frustum, combined with the current world matrix The view/'projection matrix of a given spotlight Array of worldview?projection matrices of the first n texture projection frustums The view/eprojection matrix of the assigned texture projection frustum, combined with the current world matrix  Array of view/?projection matrices of the first n texture projection frustums The view/=projection matrix of the assigned texture projection frustum The current camera's position in object space The current camera's position in world space VThe distance a shadow volume should be extruded when using finite extrusion programs. ZReturns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param) CArray of derived light specular colours (count set by extra param) BArray of derived light diffuse colours (count set by extra param) gArray of light power levels, a single scalar as set in Light::setPowerScale (count set by extra param) Array of distances of the lights from the center of the object a useful approximation as an alternative to per-vertex distance calculations. (count set by extra param) CArray of light directions in view space (count set by extra param) EArray of light directions in object space (count set by extra param) DArray of light directions in world space (count set by extra param) BArray of light positions in view space (count set by extra param) DArray of light positions in object space (count set by extra param) CArray of light positions in world space (count set by extra param) lArray of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra param) QArray of light specular colours scaled by light power (count set by extra param) PArray of light diffuse colours scaled by light power (count set by extra param)  ;Array of light specular colours (count set by extra param)  :Array of light diffuse colours (count set by extra param)  dLight specular colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)  cLight diffuse colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)  nLight power level, a single scalar as set in Light::setPowerScale (index determined by setAutoConstant call) The distance of the light from the center of the object a useful approximation as an alternative to per-vertex distance calculations. KA light direction in view space (index determined by setAutoConstant call) MA light direction in object space (index determined by setAutoConstant call) LA light direction in world space (index determined by setAutoConstant call) JA light position in view space (index determined by setAutoConstant call) LA light position in object space (index determined by setAutoConstant call) KA light position in world space (index determined by setAutoConstant call) HLight attenuation parameters, Vector4(range, constant, linear, quadric) ALight specular colour (index determined by setAutoConstant call) @Light diffuse colour (index determined by setAutoConstant call) *The ambient light colour set in the scene >The number of active light sources (better than gl_MaxLights) 0Surface shininess, as set in Pass::setShininess =Surface emissive colour, as set in Pass::setSelfIllumination 5Surface specular colour, as set in Pass::setSpecular 3Surface diffuse colour, as set in Pass::setDiffuse 3Surface ambient colour, as set in Pass::setAmbient  0Fog params: density, linear start, linear end, 1/ (end-start) ! Fog colour "01 if requires texture flipping, +1 otherwise. It'ts useful when you bypassed projection matrix transform, still able use this value to adjust transformed y position. #jProvides inverse transpose of concatenated world, view and projection matrices. Equivalent to RenderMonkey's #WorldViewProjectionInverseTranspose. $bProvides transpose of concatenated world, view and projection matrices. Equivalent to RenderMonkey's WorldViewProjectionTranspose. %`Provides inverse of concatenated world, view and projection matrices. Equivalent to RenderMonkey's WorldViewProjectionInverse. &The current world, view &" projection matrices concatenated 'The current world &+ view matrices concatenated, then inverted & transposed (VProvides transpose of concatenated world and view matrices. Equivalent to RenderMonkey's WorldViewTranspose. )The current world &+ view matrices concatenated, then inverted *The current world & view matrices concatenated +cProvides inverse transpose of concatenated view and projection matrices. Equivalent to RenderMonkey's ViewProjectionInverseTranspose. ,[Provides transpose of concatenated view and projection matrices. Equivalent to RenderMonkey's ViewProjectionTranspose. -YProvides inverse of concatenated view and projection matrices. Equivalent to RenderMonkey's ViewProjectionInverse. .The current view &" projection matrices concatenated /KProvides inverse transpose of projection matrix. Equivalent to RenderMonkey's ProjectionInverseTranspose. 0CProvides transpose of projection matrix. Equivalent to RenderMonkey's ProjectionTranspose. 1AProvides inverse of projection matrix. Equivalent to RenderMonkey's ProjectionInverse. 2The current projection matrix 3EProvides inverse transpose of view matrix. Equivalent to RenderMonkey's ViewInverseTranspose. 4=Provides transpose of view matrix. Equivalent to RenderMonkey's  ViewTranspose. 5"The current view matrix, inverted 6The current view matrix 77The current array of world matrices, used for blending 8HThe current array of world matrices, as a 3x4 matrix, used for blending 9#The current world matrix, inverted & transposed :>Provides transpose of world matrix. Equivalent to RenderMonkey's WorldTranspose. ;#The current world matrix, inverted <The current world matrix ==The usage of a set of shared parameters in a concrete set of  GpuProgramParameters. >?@A2Version of shared params we based the copydata on B=The list of physical mappings that we are going to bring in. CDEF?A group of manually updated parameters that are shared between  many parameter sets. GHIJKLKNot used when copying data, but might be useful to RS using shared buffers M1Version number of the definitions in this buffer N$Container to allow params to safely & update shared list of  logical buffer assignments OP3Map from logical index to physical buffer location Q'Shortcut to know the buffer size needs R>Structure recording the use of a physical buffer by a logical 4 parameter index. Only used for low-level programs. STPhysical buffer index U!Current physical size allocation V#How the contents of this slot vary W@Struct collecting together the information for named constants. XY(Total size of the float buffer required Z&Total size of the int buffer required [0Map of parameter names to GpuConstantDefinition \]0Information about predefined program constants. ^_ Data type `<Physical start index in buffer (either float or int buffer) aFLogical index - used to communicate this constant to the rendersystem bfNumber of raw buffer slots per element (some programs pack each array element to float4, some do not) cLength of array dIHow this parameter varies (bitwise combination of GpuProgramVariability) e@The variability of a GPU parameter, as derived from auto-params  targetting it. fg4No variation except by manual setting - the default hLVaries per object (based on an auto param usually), but not per light setup iVaries with light setup j"Varies with pass iteration number k5The types of constants we may encounter in programs. lmnopqrstuvwxyz{|}~?Get the element size of a given type, including whether to pad ? the elements into multiples of 4 (e.g. SM1 and D3D does, GLSL  doesn't)       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~k~}|{zyxwvutsrqponmlefghij]^_`abcdWXYZ[\RSTUVNOPQFGHIJKLMBCDE=>?@A<;:9876543210/.-,+*)('&%$#"!      }<;:9876543210/.-,+*)('&%$#"!            !"#$%&'()*+,-./0123456789:;<=>?@A>?@ABCDECDEFGHIJKLMGHIJKLMNOPQOPQRSTUVSTUVWXYZ[\XYZ[\]^_`abcd^_`abcdefghijfghijk~}|{zyxwvutsrqponmllmnopqrstuvwxyz{|}~The type of the program 8The name of the file to load source from (may be blank) $Syntax code e.g. arbvp1, vs_2_0 etc 7Does this (vertex) program include skeletal animation? 4Does this (vertex) program include morph animation? WDoes this (vertex) program include pose animation (count of number of poses supported) EDoes this (vertex) program require support for vertex texture fetch? <Does this (geometry) program require adjacency information? 0The default parameters for use with this object  V!Duration of animation in seconds 5is this a series of 6 2D textures to make up a cube? Request number of mipmaps !Texture filtering - minification "Texture filtering - magnification Texture filtering - mipmapping Texture anisotropy  Mipmap bias +Binding type (fragment or vertex pipeline) >Content type of texture (normal loaded texture, auto-texture) optional name for the TUS "optional alias for texture frames 0A shadow texture, automatically bound by engine "Normal texture identified by name >Vertex processing unit - indicates this unit will be used for  a vertex texture fetch. 0Regular fragment processing unit - the default. /Texture coordinates outside the range [0.0, 1.0] are set to the border colour Texture clamps at 1.0 *Texture mirrors (flips) at joins over 1.0 !Texture wraps at values over 1.0 :Envmap intended to supply normal vectors for cube mapping >Envmap intended to supply reflection vectors for cube mapping WEnvmap based on dot of vector from camera to vertex and vertex normal, good for curves PEnvmap based on vector from camera to vertex position, good for planar geometry More complex transform Constant rotation  Constant u/v scrolling effect Constant u scrolling effect  Constant u/v scrolling effect +Generate texture coords based on a frustum EGenerate all texture coords based on angle between camera and vertex VVV  Boptional name for the pass      YUsed to determine if separate alpha blending should be used for color and alpha channels VDetermines if we should use separate blending operations for color and alpha channels Transparent depth sorting !Transparent depth sorting forced  Lighting enabled? !Max simultaneous lights "Starting light index #;Run this pass once per light? Iterate per how many lights? $0Should it only be run for a certain light type? %Shading options & Polygon mode '()*+,-./0Vertex program details 1Fragment program details 2Geometry program details 34%number of pass iterations to perform 59point size, applies when not using per-vertex point size 6789:#constant, linear, quadratic coeffs ;Scissoring for the light? <User clip planes for light? =Illumination stage? >>Categorisation of passes for the purpose of additive lighting ?Not determined @Post-lighting rendering A-Part of the rendering which occurs per light BGPart of the rendering which occurs without any kind of direct lighting B      !"#$%&'()*+,-./0123456789:;<=>?@ABB>BA@?      !"#$%&'()*+,-./0123456789:;<=B<      !"#$%&'()*+,-./0123456789:;<=      !"#$%&'()*+,-./0123456789:;<=>BA@??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[CDEFGHIJKLMNOPQRSTUVWXYZ[XYZ[STUVWNOPQRIJKLMCDEFGHCDEFGHDEFGHIJKLMJKLMNOPQROPQRSTUVWTUVWXYZ[YZ[ \]^_`abcd \]^_`abcd \]^_`abcd \]^_`abcd Vefgh GPU Vendor i&The number of texture units available jThe stencil buffer bit depth kStores the capabilities flags. l8The name of the device as reported by the render system mXThe identifier associated with the render system for which these capabilities are valid n?The number of floating-point constants vertex programs support o8The number of integer constants vertex programs support p8The number of boolean constants vertex programs support qAThe number of floating-point constants geometry programs support r8The number of integer constants vertex geometry support s8The number of boolean constants vertex geometry support tAThe number of floating-point constants fragment programs support u:The number of integer constants fragment programs support v:The number of boolean constants fragment programs support w4The number of simultaneous render targets supported xThe maximum point size y'Are non-POW2 textures feature-limited? z-The number of vertex texture units supported {9Are vertex texture units shared with fragment processor? |CThe number of vertices a geometry program can emit in a single run }&The list of supported shader profiles ~Enumeration of GPU vendors. Apple Software Renderer 0Support for point parameters EXT implementation 0Support for point parameters ARB implementation 7Support for GL 1.5 but without HW occlusion workaround Support for PBuffer SSupport for Frame Buffer Objects ATI implementation (ARB FBO is higher precedence) WSupport for Frame Buffer Objects ARB implementation (regular FBO is higher precedence) (Support for Frame Buffer Objects (FBOs) !Supports openGL GLEW version 1.5 Is DirectX feature per stage constants supported *Supports Blending operations other than + !Supports Alpha to Coverage (A2C) (Supports MRTs with different bit depths !Supports fixed-function pipeline 1Supports compressed textures in the PVRTC format /Supports compressed textures in the VTC format 'Supports compressed textures in the DXT/ ST3C formats Supports compressed textures %Supports rendering to vertex buffers $Supports hardware geometry programs Supports mipmap LOD biasing Supports vertex texture fetch @Supports extra point parameters (minsize, maxsize, attenuation) &Supports basic point sprite rendering Supports 3d (volume) textures #Supports non-power of two textures +Supports float textures and render targets >Supports hardware render-to-texture (bigger than framebuffer) 'Supports infinite far plane projection ,Supports the VET_UBYTE4 vertex element type Supports user clipping planes $Supports hardware occlusion queries =Supports wrapping the stencil value at the range extremeties @Supports separate stencil updates for both front and back faces BSupports performing a scissor test to exclude areas of the screen +Supports fragment programs (pixel shaders) *Supports vertex programs (vertex shaders) +Supports hardware vertex and index buffers !Supports hardware stencil buffer Supports cube mapping +Supports fixed-function DOT3 texture blend 'Supports anisotropic texture filtering (Supports generating mipmaps in hardware Vefghijklmnopqrstuvwxyz{|}~V~efghijklmnopqrstuvwxyz{|}Vefghijklmnopqrstuvwxyz{|}fghijklmnopqrstuvwxyz{|}~ +!Y*Returns the name of the rendering system. <Create an object for performing hardware occlusion queries. Sets the colour &D strength of the ambient (global directionless) light in the world. =Sets the type of light shading required (default = Gouraud). !Sets the world transform matrix. Sets the view transform matrix %Sets the projection transform matrix &Invert the bits of the stencil buffer >Decrease the stencil value by 1, wrapping when decrementing 0 XIncrease the stencil value by 1, wrapping back to 0 when incrementing the maximum value /Decrease the stencil value by 1, clamping at 0 ?Increase the stencil value by 1, clamping at the maximum value -Set the stencil value to the reference value  Set the stencil value to zero  #Leave the stencil buffer unchanged   Projective texture  *Environment map based on vertex positions *Environment map based on vertex positions *Environment map based on vertex positions (Environment map based on vertex normals "No calculated texture coordinates Y     Y     Y>         ";Struct associating a single Pass with a single Renderable.  !"BStandard render queue priorities. Note that any enumeration type B can be used to specify render priorities (i.e. top-level drawing 1 order), this is just a simple convenience type. #$%&'()*#The default render queue priority. +,-./0 !"#$%&'()*+,-./0")('&%$#*+ !,-./0 ! !")('&%$##$%&'()*+,-./0#+1#Geometry with associated material. 23*The material associated with the submesh. 4/The type of primitives making up the geometry. 5DOptional vertex buffer (supplied by the containing mesh if absent). 6Optional index buffer. 79Multimaterial geometry, including a default geometry for  submeshes that don't provide their own. 89@The collection of single-material submeshes making up the mesh. : Default geometry for submeshes. ;<=Primitive buffer data >?@ABCDEFGHI The types of = without the data. JKLMNOPQRSTU%Extract the type of the vertex data. VWXYZ[+123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[+ITSRQPONMLKJ=HGFEDCBA@?><;789:123456UVWXYZ[+12345623456789:89:;<= HGFEDCBA@?>>?@ABCDEFGHI TSRQPONMLKJJKLMNOPQRSTUVWXYZ[$"\;Build a single mesh that represents the union of a list of D transformed meshes (given the orientation and translation for each @ constituent). The resulting mesh is optimised with respect to $ context switches during rendering. ];Build a single mesh that represents the union of a list of > transformed meshes (given the transformation matrix for each @ constituent). The resulting mesh is optimised with respect to $ context switches during rendering. #$%&'\]\]\]% ^_`abcdefgh ^_`abcdefgh ^_`abcdefgh ^_`abcdefgh&ijkList of primary passes l LOD level msScheme index, derived from scheme name but the names are held on MaterialManager, for speed an index is used here. n optional name for the technique opqrstuvwxyz{&Exclusive - do not support if present |$Inclusive - only support if present }~ijklmnopqrstuvwxyz{|}~}~z|{vwxyqrstuijklmnopijklmnopjklmnopqrsturstuvwxywxyz|{{|}~~' *All techniques, supported and unsupported !Supported techniques of any sort "distance list used to specify LOD "distance list used to specify LOD 9Text description of why any techniques are not supported    (JType of composition pass Identifier for this pass Material used for rendering   first,last> render queue to render this pass (in case of PT_RENDERSCENE) 2Clear buffers (in case of PT_CLEAR), hint: [colour] [depth] [stencil] #Clear colour (in case of PT_CLEAR) "Clear depth (in case of PT_CLEAR) *Clear stencil value (in case of PT_CLEAR) 2Inputs (for material used for rendering the quad) Stencil operation parameters +true if quad should not cover whole screen .quad positions in normalised coordinates [-1;1]x[-1;1] (in case of PT_RENDERQUAD)  Input name (local) output texture Passes OThis target pass is only executed initially after the effect has been enabled.  Visibility mask for this render LOD bias of this render Material scheme name Shadows option Local texture definitions Intermediate target passes %Output target pass (can be only one) Optional scheme name "Name (local) of the input texture  MRT surface index if applicable $Nothing means adapt to target width %Nothing means adapt to target height 5multiple of target width to use (if width = Nothing) 7multiple of target height to use (if height = Nothing) more than one means MRT SFSAA enabled; true = determine from main target (if render_scene), false = disable CDo sRGB gamma correction on write (only 8-bit per channel formats) ,whether to use shared textures for this one Input mode of a TargetPass (Output of previous Composition in chain  No input Render a full screen quad Render the scene or part of it Set stencil operation Clear target to one colour JJJ  )?The sub-parts of an Entity. Its primary function is to provide C the link between the Material which the SubEntity uses (which may B be the default Material for the SubMesh or may have been changed ( for this object) and the SubMesh data. Cached pointer to material. *Pointer to the SubMesh defining geometry. *-     -     -     -     +((The type of path leading to a resource. A zip compressed directory. An ordinary directory. )*+,-./,f !"#$%&'()*+,-./0123456789:;Camera description. <=The name of the camera. >Field of view in radians. ?Near plane clipping distance. @Far plane clipping distance. ACamera aspect ratio (width/ height). BRendering type. CDEFGHIJKLMNOPQRSTUVVList of Renderable information including WorldMatrix RenderQueueID and RenderPriority WXYZ[\AEmbed a LambdaCube program in IO. The embedding manages a world, E therefore it requires all the information to create one: the render % system and a list of image loaders. ]^_`abcdefghijklm$Add a new vector mesh to the world. #The name of the mesh in the world. The mesh to add. n/Retrieve a vector mesh from the world by name. opqrstu?Get the raw data for a resource in a lazy bytestring given its A path. The data is cached, so this does not necessarily require  disk I/O. vAGet the raw data for a resource in a strict bytestring given its A path. The data is cached, so this does not necessarily require  disk I/O. wxyCreate a new texture. The name of the texture. Width in texels. Height in texels. z0Specify the viewports to display in the window. The name of the window. #The width of the window in pixels. $The height of the window in pixels. -The actions describing the viewports to use. {4Create render textures, and setup compositor chain. |0Create a viewport and attach given compositors. Viewport x position. Viewport y position. Viewport width. Viewport height. )The camera associated with the viewport. 0The compositor chain to process the image with. }0Adjust the dimensions of a given render target. The target to adjust. The new width. The new height. f !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}fYZ[\]^_`abcTUVWXLMNOPQRSdefghijCDEFGHIJK;<=>?@ABk7:980123456%&'()*+,-./l !"#$mnopqrstuvwxyz{|}f !"#$!"#$% &'()*+,-./&'()*+,-./01234561234567:9889:;<=>?@AB<=>?@ABCDEFGHIJKDEFGHIJKLMNOPQRSMNOPQRSTUVWXUVWXYZ[Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}-~>Construct a scene object representing a camera with the given  specification. >Construct a scene object representing a basic camera with the  given name. >Construct a scene object representing a wireframe-mode camera  with the given name. >Construct a scene object representing a light source with the  given specification. <Construct a scene object representing a basic light source. 6Construct a scene object representing a polygon mesh. #Render queue priority (defaults to &). GThe list of materials to overried those supplied by the original mesh. +The name of the mesh to use as the source. *Construct a scene graph node description. The name of the parent node. The name of the node. CThe transformation to apply the subtree with the node in its root. )The scene objects that make up the node. -Add a list of new nodes to the global scene. 7Update the transformation matrices of the given nodes. 4Update the objects associated with the given nodes. Render the given target. 4The current time in seconds (needed for animation). The target to render. ~~~.;0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi/jklmnoShader pqrstuvwxyz{|Texture }~ TextureUnit %iteration count, n_light, light type Pass  Technique  Material Material Script 0BAdd a resource library (essentially a collection of paths) to the 2 current set of search paths stored in the world. 12 -Specialisation of HardwareIndexBuffer for GL    3 .Specialisation of HardwareVertexBuffer for GL    4567     7     7     7     784abcdefghijklmnopqrstuvwxyz{|}~      !     "#$%&'()*123456789:=>?@ABCDEFGHIJKLMNOPQRSTU\];<=>?@ABLY\mnuvyz|}fLY\uv     ;<=>?@AB")('&%$#*yz|}ITSRQPONMLKJ=HGFEDCBA@?>789:123456Umn9:;<=>?@ABCDDDEFGHIJJKLMNOPQRSTUVWXYZ[\]^_`abcdefggh i i j k k l m m n o p q r s t u v w x y z { | } ~                                                                                !"#$%&'()*+,-./01233456789:;<=>?@ABBCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_``abccdefghijjklmmnopqqrstuvvwxyz{|}}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXXYZ[\\]^_``abcddefghijklmno p p q r s t u v w x y z { | } ~                                                                      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!"""""" " "!"""#"$"%"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5#6#6#7#8#9#:#;#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^$_$`%a%b%c%h%d%e%f%g%h%i%j&k&k&l&m&n&o&p&q&r&r&s&t&u&v&v&w&x&y&z&{&|&}&~&''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))*********************************************++ + + + + ,,,,,,,,,,,,,,,,,,,,,, ,!,",#,#,$,%,&,',(,),*,+,,,-,-,.,/,0,1,2,3,4,4,5,6,7,8,9,:,;,<,<,=,>,?,@,A,B,C,C,D,E,F,G,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j-k-l-m-n-o-p-q-r-s-t-u-v-w-x.y/z0{0|0}0~001111111111111111111111122222222222223333333333333455555555555555555555555555666666666666666666666666666666666666666666666666666666677                !"#$%&'()*+,-./0123413565758595:5;5<5=5>5?5@ABACADEFEGEHEIEJEKELEMENEOEPEQERESETEUEVEWEXEYEZE[E\]^]_]`]a]b]c]d]e]f]g]h]i]j]k]l]m]nopoqorosotouovowoxoyozo{o|o}o~ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo$$$$$$++++++++........................................ . . . . ..............///// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6/7/8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/J/K/L//M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w//x/y/z/{/|/}/~////////////////// //////////lambdacube-engine-0.2.2Graphics.LambdaCube.Tree:Graphics.LambdaCube.Loader.Generated.ResourceScriptScanner:Graphics.LambdaCube.Loader.Generated.MaterialScriptScanner