| Home >> All >> org >> pqt >> [ autorib Javadoc ] |
| • | org.pqt.autorib.globals.* (1) | • | org.pqt.autorib.instr.* (55) | • | org.pqt.autorib.rib.* (37) |
| • | org.pqt.autorib.tokenizer.* (3) | • | org.pqt.autorib.util.* (11) |
• org.pqt.autorib: Javadoc index of package org.pqt.autorib.
Package Samples:
• org.pqt.autorib.globals
• org.pqt.autorib.instr
• org.pqt.autorib.rib
• org.pqt.autorib.tokenizer
• org.pqt.autorib.util
Classes:
• RIBStateRec: This class is the parent of classes to implement the reading and storage of RIB Options and Attributes. It distinguishes two sorts of options or attributes, normal and special, the latter being attributes or options that are not unique per object or file (e.g. multiple instances of 'Option' RIB requests), and the former being attributes where a new instance of the attribute supercedes the last (Color for example). It differentiates between different types of 'special' content, a feature that is used in the RIBAttributeRec subclass to separate Declare statements from the rest, so that they can be ...
• RIBGlobals: This class contains various globally needed definitions used to parse RIB in particular various arrays define valid requests, and identify which of these are options, attributes transforms and objects. To ensure AutoRIB recognises a new RIB request you must add it to the requests array. You must also define an integer constant corresponding to its position in the array. You should also include it in the arrays options, attributes, objects depending on which category the request is. Doing this will ensure that the request is recognised. For more sophisticated handling you will need to create a subclass ...
• Tokenizer: Reads Characters from a given stream, ignoring comments . It recognises the following kinds of input (which can be stored in a Token object): - a word; - a number; - a string (delimeted by "") comment characters are not recognized inside a string - but an error is raised if a newline is read - an array of numbers (enclosed in []) This class is not used directly - rather its subclasses RIBTokenizer and InstrTokenizer are used. The advantage of having this common superclass is that it makes it comparatively easy to read RIB from an instructions file. A count of the current line number is maintained, ...
• InstrBlockRequest: This class is the superclass of all block style requests, extending InstrRequest. It includes methods to process lights and objects ( which check if the block is applies to the given light or object and if so iterate through the instructions in the block) and filter (which is called by process and returns true if the block should be executed for the given light or object) Note that the read method of this class reads and stores all the instructions in the block
• RIBDefaultPrimitive: this handles all the primitives that do not have their own separate class, it handles everything correctly for primitives that obey the following rules: they are defined by "P" or "Pw" control points, their parameters may start with a string (such as subdivision mesh) but must contain no other strings as part of the main arguments (though arrays of strings are allowed and, of course, the general parameters contain strings as parameter names).
• Token: this class is used to store, at the most basic level, items read from a RIB or instructions file. It can hold a request (a RIB request call word or an instruction word), a string, a floating point number, an array (a list of strings or floating point numbers stored separated by spaces and enclosed in square brackets), and opening and closing curly braces (used for instruction blocks). It is used by Tokenizer and its subclasses
• RIBAttributeRec: Stores various attribute information for an object (color, shaders etc) it uses two types of special content = one for Declares and one for implementation dependent Attributes. Declare statements are, of course, not strictly attributes, but are treated as such in AutoRIB. Note also that Attribute "identifier" "name" is treated in a special way - it is stored in the name variable and must be written out separately.
• RIBOptionRec: stores options read from an RIB file, and is also used to store Objects defined in the RIB file. Options are things like Display, Format etc. as well as the standard 'Option' call. They are divided into two types those where a second instance supercedes the former (Format, for example) and those where two different instances can be valid at the same time (which is true for Options for example)
• InstrRequest: This class is the superclass of all classes that handle instructions. Most of the subclasses do little more than override the basic methods defined here for reading in the instruction, writing it out (used only for debugging) and processing objects and/or lights with it. Note the similarity to the RIBRequest class.
• PathSearch: A class to provide a path searching mechanism. It is sophisticated enough to be able to use both unix and windows style path separators across both systems. ie you could specify a path in windows using ':' as a path separator (providing you specify ':' explicitly in the constructor as a path separator
• NameGroupManager: This class manages a list of name groups. Name groups are a way for Autorib to recognise that although two primitives have different names (set by Attribute "identifier" "name" in the RIB) they should be treated for the purposes of numbering as the same, and will be allocated the same number
• InstrGroupEnvMap: A class to handle the GroupEnvMap instruction, which creates an environment map using bounding box information of a named group of objects to deduce the point from which to 'take' the environment pictures these objects have the name of the map added in a given parameter of the shader
• UniquePointList: A class for maintaining a unique list of points, and optionally the associated s,t values. A point is unique if either the point itself is different from other points on the list, or (if it has s,t data) the s,t data is different from an otherwise identical points
• InstrState: A class for storing state information for an instructions file, such as map format and the current list of objects to omit from maps. State information is local to a block, and so is maintained by the InstrWReader as a stack of instances of InstrState
• InstrForNames: A class for handling a name based filter of the form ForNames name name [name name] where names can contain wild cards * and ?. The filter is passed if the name matches on of the names given, and does not match one of the names given in square brackets.
• RIBObjectBegin: A class to handle object definitions although called ObjectBegin, it infact hanles the entire object definition. The content of the object definition being read in in the RIBWreader and added to the objectContent field. --unfinished capability--
• InstrAppendNumber: class to handle instruction to append a parameter to a shader. It also contains a number of static utility functions which are called by the various map creating instructions (e.g shadowdist) to append map names etc to objects
• InstrAppendParam: class to handle instruction to append a parameter to a shader. It also contains a number of static utility functions which are called by the various map creating instructions (e.g shadowdist) to append map names etc to objects
• NameNumberManager: This class allows you to allocate a number to an object, based on the object's name. It allows names to be grouped, so that even if the two names are different the number allocated to them will be the same
• RIBParams: A class to store parameters for a shader or other object. Parameters are in the form of a string name followed by a value e.g "Ks" .4, or "shadow" "myfile". Each name in the parameter list is unique.
• InstrSoftShadowSpot: Class for instruction to create the RIB to generate a soft shadowing spot light. This class has not been fully tested because the author does not have access to a renderer which does soft shadows.
• InstrWReader: This class provides routines for reading and writing Instr (instrutions) files, for storing their contents, and for applying them to RIB. The writing routines are used for debugging only.
• ProcessRIB: this class contains a single method - but it is the key method of the program. This will read in the RIB file, one frame at a time, apply the instructions to it and write the revised RIB out
• InstrForRequest: an abstract class from which all For.. classes derive - subclasses should overide not read, but readParams, as well as overriding the filter methods defined in InstrBlockRequest
• InstrEnvMapAuto: A class to handle the EnvMapAuto instruction, which creates an environment map using bounding box information to deduce the point from which to 'take' the environment pictures
| Home | Contact Us | Privacy Policy | Terms of Service |