AzurVeda Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

_LwoLayer
_LwoObject
_LwoPolygon
_LwoPolyToVertex
_LwoSortedTriangleSurface
_LwoVertex
backing_store_struct
BaseContext	You may also browse the BaseContext Related Documentations page sorted by theme. Class that manages a whole database as a set of Objects inheriting class BaseObject. BaseContext::Serialize_Out() and BaseContext::Serialize_In() will provide a quick and full persistent serialization of all features of a whole azurveda Context. When reading the context, the objects references will be resolved. In editable compilation mode you can use: Hook notifications for all events, useful for Graphical Interfaces: see AddGUIUpdateFunction() Merge serialization: simply melt as many context objects you want with MergeSerialize_In() Hability to destroy all objects that are useless to a given object with DestroyAllIndependantObjects(). Together with the merge method, it gives a complete control for large and complex contexts. automatic Undo/Redo stack functionnalities with Undo(), Redo(), SetMaximumNumberOfUndoableEvents(). This undoes affect the modification of any editable object members in the context. (BETA: currently,undo stack is flushed when an element is destroyed in a list.) Thread management withAddOneLockForThreadUse(),RemoveOneLockForThreadUse(). To use a context object, you first init a context by registering possible extended classes or packages, derived from BaseObject, with RegisterClassList(). In editable mode, you can create new BaseObjects using the BaseContext::NewObject(), and destroy them with BaseContext::DestroyObject(). Then you can initialize each objects using BaseObject::Create(), and close them with BaseObject::Close(). See BaseObject for more informations on Object Creation. After the context is created, you can provide a VirtualMachine with SetMachine(), it stands for the hardware-abstracted machine its objects will use.
BaseContext::UndoCell	Nested class used as cells of the undo stack:
BaseContext::UpdateFunctionListCell	Nested class used by BaseContext::m_GUIUpdateFunctionList to manage a list of functions to send updates when the context is edited
BaseContextTool	Base model for extending more Tool Methods to BaseContext
BaseObject	Virtual Base class for all objects managed in a BaseContext. To be used in such context, Each classes (virtual or not) inheriting BaseObject should be first registered to this context using BaseContext::RegisterClassList(), by passing the static descriptor m_description to it. You must not construct these objects with operator new and delete, but with public methods BaseContext::NewObject() and BaseContext::DestroyObject(). All Object Instances (and their serializable members) will then be serialized with the context. There is 2 levels of construction for objects managed by a context: You register your serializable member in the C++ constructor, but you write your construction code by ovverriding the protected virtual method CreateInternal(), and your destruction code must stand in an override of the protected virtual method CloseInternal(). It means, all allocation done in CreateInternal() must be close in CloseInternal(). To throw the creation of your object from outside the context, you must use the public Create(), and check its return code. To close it, use Close(). Destroying a BaseContext with the delete operator will delete all its BaseObjects. You can check the creation state of an object at any time with IsCreated(). The methods of your objects should only be used when the object is created with no error. Your object may have registered PackObjectReference members: they are dynamic pointers to other objects in the context. Your object will be dependant of the objects it points at. In fact, Create() assumes that if your object is successfully created, all its dependant objects are also created successfully. It means that, inside your CreateInternal() code, the pointer you get from your PackObjectReference members points objects that are already created succesfully. Look Create() for more. About GetName(): All BaseObject are named for convenience when edited, but this name isn't usually used to refer the objects. Extending a registerable BaseObject must be done by using a define macro in its header (.h) and a declaration macro in its (.cpp). These macros will automatise the code of the destructor, but the constructor must be coded. you must call the super constructor from it, and then register your serializable members in it. from class SimpleTest, you could have this SimpleTest.h:
BaseObject::ClassDescription	BaseObject Nested class that describes each BaseObject and inherited class statically. It is defined automaticaly by macros BASEOBJECT_DECLARE_CLASS in class definition
BaseObject::PreviewConfiguration	Through PreviewConfiguration, ProcessPreview() can read information from an editor, on how the object preview should look like. The data can be used (or not) in a way or another, and the way the editor change them may vary. It is a public nested class
BaseObject::ToolMethodCell	Register a tool method. It is a private Nested class that manage the known ToolMethod in edition mode
BaseType	Virtual class for all AzurVeda serializable types. It is the root of all serializable classes, and actually all classes in AzurVeda Inherit from it
BaseType::ObjectManager	Nested Class that manages events (TODO,When final, this will give more independances between Base types and Context class)
bitread_perm_state
bitread_working_state
BubbleGreyImage	Class able to build some grey, 2n-pixelSized, bubble Image..
c_derived_tbl
cdjpeg_progress_mgr
cjpeg_source_struct
ClassNode	Class used privately by BaseContext to represent a class node in its database tree. This tree has the shape of the inheritance hierarchy. It manages a special hierarchic serialization which can re-create the object recursively. Basically, there is 1 classnode by class and context: It is initialized using a static BaseObject::ClassDescription, when using BaseContext::RegisterClassList(). Again: It IS NOT a class that is instancied to make BaseObject objects, it just indicates the class in the class hierarchy of BaseContext, and BaseObjects are under it in a list. It is also used for the context database access, and management
d_derived_tbl
djpeg_dest_struct
Equ_XYZD_Particle	Equation For metaball class Object3DMarchCube
Equ_XYZD_ParticleCubes	Equation For metaball class Object3DMarchCube
Equ_XYZD_ShapeByEquation	Equation For metaballs class Object3DMarchCube, redirects classic VirtualEquation which match x=f(x,y,z,t)
Equ_XYZD_SinusWalls	Equation For metaball class Object3DMarchCube
Equ_XYZD_Tore	Equation For metaball class Object3DMarchCube
Equ_XYZD_Virtual	Virtual class Defining an equation of the form: result = func(x,y,z,time) for class Object3DMarchCube
EquationGamma	Color calibration equation, first made to calibrate colors images with Image RGBA Mixer. You can use this equation to calibrate brightness and contrast for example. It does an equation of the shape: Result.X=func(Input.X)
EquationList	Able to compute an equation according to a list of operators
EquationList::EquationLine	Nested class that describes a reference to an object3D, used as element in the list
EquationList::OperandType	Nested class used for operand combo,patching PackDynamicFloat
EquationSinus3D	DEPRECATED
EquationSoundSignal	Return the Machine's Sound signal output as an equation: Returns the machine's current stereo sound curve. You can define which terms of the result are affected. The length curve definition may vary, but is scaled along [0,1] by Input.X (see Equation List)
EquationSpline_X	Spline function for X
EquationSpline_X::waveInfo
EquationSpline_XY	Spline function for XY
EquationSpline_XYZ	Spline function for XYZ
GreyImage	1 byte component-per-pixel Images. Can then be used or mixed by RGBAImage for a color image. Still, it is virtual because size can then be given on classes that manage the type of size of the Bitmap
GreyImage2nSquareSized	Virtual Class for Grey Image that exactly size a 2-Power-N square sized image. Some image generation Algorythms implies to use such images
huffpair
huffquad
hufftable
Image2DEffectFire	Image that mix images of any size or color depth into a new RGBA one. it uses a layer list by source image. Each layers can affect a color channel, it can use a HSV->RGB mixer and manages alpha channel
ImageJPEG	Use JPEG file format to manage an image
ImplicitEquationImage	Virtual base Class able to define an image defined by an equation:
InterfacePrefObject	This class provide a unified way to stock preferences and states informations about a GUI that would edit a AzurVeda Context, so it is saved within a context. Basically, an editor should use Get()/Set() and serialization, to keep the current objects edited and previewed. It is not registered to BaseContext by default. you got to register it or not, according to your needs. Thus, it has to be registered first if you use inherited classes. ( through BaseContext::RegisterClassList() of course ). As editor preferences may be only useful during edition, it is of course possible to flush these objects from the context, like any other objects. This class has no sense in non editable mode and should just not be used in such compilation mode
InterfacePrefObject::Edited	Nested class that describes a reference to an object
InterfacePrefObject::PackObjectReferenceSpecial	Nested class to patch PackObjectReference so that If set to null pointer, it deletes
InterfacePrefObject::PackULong_Flags_Activate	Nested class to patch the activate flag edition
InterfacePrefObject::PreviewEdited	Nested class that describes a reference to an object preview
InterfacePrefObject::PreviewEdited::InterfacePreviewConfiguration	Fill a PreviewConfiguration class, to return the object contract for preview
InternalViewPort	Nested class that defines a viewport where to draw (screen, sub-screen,texture rendering screens.) It must be extented to other classes
InternalViewPort	Nested class that defines a viewport where to draw (screen, sub-screen,texture rendering screens.) It must be extented to other classes
JHUFF_TBL
jpeg_c_coef_controller
jpeg_c_main_controller
jpeg_c_prep_controller
jpeg_color_converter
jpeg_color_deconverter
jpeg_color_quantizer
jpeg_common_struct
jpeg_comp_master
jpeg_component_info
jpeg_compress_struct
jpeg_d_coef_controller
jpeg_d_main_controller
jpeg_d_post_controller
jpeg_decomp_master
jpeg_decompress_struct
jpeg_destination_mgr
jpeg_downsampler
jpeg_entropy_decoder
jpeg_entropy_encoder
jpeg_error_mgr
jpeg_forward_dct
jpeg_input_controller
jpeg_inverse_dct
jpeg_marker_reader
jpeg_marker_struct
jpeg_marker_writer
jpeg_memory_mgr
jpeg_progress_mgr
jpeg_scan_info
jpeg_source_mgr
jpeg_transform_info
jpeg_upsampler
JQUANT_TBL
LightModel	Describe a light model and provide some methods. (not final ATM. Experimental.)
LightModel::DifuseLight	Nested class that describes an element of the difuse light list
LightModel::LinearLight	Nested class that describes an element of the Linear Light list
LwoClip
LwoIndexedEnvelope
LwoMatrix
LwoMorphVertex
LwoTriangle
LwTexture
mad_bitptr
mad_decoder
mad_decoder_sync
mad_frame
mad_header
mad_pcm
mad_stream
mad_synth
mad_timer_t
MarchinCubeSpace	Define a Space Matrix Grid used by Object3DMarchCube to generate objects using a marching cube algorythm
MarchinCubeSpace::MarchCubeExtraValue
MarchinCubeSpace::MarchCubeIndex	Hold the creation of vertex on edges in pass2, and is read in pass3 at polygon creation
MatrixModel
Media3DView	Define a 3D view of any Object3DVirtual (it implies Object3DScene ,etc...) by linking camera movements, and an optional rendering 2D target. It is a VirtualMedia, and should be used for any 3D rendering
MediaAccess	Define which Media objects are the main media and the boot media in a context. Then static method MediaAccess::GetMainMedia() is a simple entry to a media in the context. There should be only one MediaAccess object per context
MediaSoundEquation	Create sounds using equations
MediaTimePattern	The class Defining a media pattern as a list of tracks of other media to mix. Each track is a suit of VirtualMedia reference to play. a MediaTimePattern can call other ones recursively
MediaTimePattern::PartToPlay	Nested class that describes something to play in a MediaTimePattern. It is used as the element of the script list, each reference another script:
ModifierObject3DColor	Modifier that would shade the color of an object in realtime
ModifierObject3DDisplace	Modifier able to deform an object in realtime
ModifierObject3DMapCoord	Modifier that would displace texture coordinates of an object in realtime
ModifierObject3DVirtual	Virtual Model for Modifier objects that would deform, or change in any way, a 3D Renderable Polygon object such as Object3DMeshVirtual
MorphSet
MP3SoundObject	Class defining a MP3SoundObject to play
MP3SoundObject::FrameReference
MP3SoundObject::RawFrame
NamedObject	Private use. Base type for all Chunk Named class: It is derived from PackStruct. Basically, all chunk starting with a jump-length, then a name, will use this. It is then derivated into ClassNode and BaseObject, which are different in their use
Object3DFontArial	Define a list of characters with 3D objects. This is a fast done font with a static shape
Object3DFontArial::FontBase	Type for m_pCharTable
Object3DFontBitmap	Define a list of characters with 3D objects. Do a fixed-width Font by subdividing an image from the texture. Fonts can be used by 3D Object Text
Object3DFontVirtual	Virtual base class for all collection of objects used as fonts for texts
Object3DFontVirtual::Shadow
Object3DGrid	Define an object with a list of vertex and polygons
Object3DLWOResource	Define an object with a Lightwave File resource. Lightwave is a commercial 3D Modeler from NewTek. We support .lwo object files with this class
Object3DLWOResource::LayerObject	Private use
Object3DLWOResource::sSortedTriangleSurface	Private nested struct used to index surface by texture at our level
Object3DMarchCube	Virtual Class defining a generic Object3D build with the technic of the marching cubes
Object3DMarchCube::EquationTerm	Nested class that describes an element of the list of terms used to define implicitly the object, in mSer_EquationTermList
Object3DMesh3D	Define an object with a list of vertex and polygons.(TODO)
Object3DMesh3D::PolygonList	Polygon list serialized shape
Object3DMeshVirtual	Define a renderable 3D object with a polygon mesh. The object can be defined in any way, so this class is still virtual
Object3DMeshVirtual::BoundingBox	Nested class used to calculkate the bouding bow of a 3D shape
Object3DMeshVirtual::Object3DBufferHandler
Object3DMultiplier	3D Object that Renders Multiple objects using a particle set
Object3DScene	Base class for all class that stands for a 3D Scene, which means an ensemble of Object3DVirtual, as a Object3DVirtual. It should look like an Object list, and some cinematic informations about how they move
Object3DScene::ChannelModifier	Nested class that describes a reference to Object3DVirtual, used as element in the list
Object3DScene::Object3DReference	Nested class that describes a reference to Object3DVirtual, used as element in the list
Object3DText
Object3DText::CharacterBase	Private nested class: precalculation
Object3DText::LetterState
Object3DText::PackDynamicTextShade
Object3DText::PackDynamicTextShadeIn
Object3DText::PackDynamicTextShadeOut
Object3DText::TextShadeComplex
Object3DVirtual	Virtual Class defining a generic renderable Object3D, it can be a polygon mesh, or even a whole scene. RenderObject() handles the rendering. for some classes, SetColor() can be used to define a general color for the object, before a call to RenderObject()
Object3DVirtual::ShapeModifier	Nested class that describes a vertex shape modifier , used as element in the list
Object3DVirtual::ShapeModifierList	Change a main color to render the object. An object cn use it or not according to the class. Nested class that describes a list of ShapeModifier to apply to a 3D object to modify its shape
Object3DVirtualDynamic	Virtual Class defining a Object3D Mesh which shape is dynamic or not, like Object3DVirtual, but which number of vertex and polygons may vary according to the shape. So this class ask 2 attributes members: a maximum number of vertex and a maximum number of polygons, so that it allocates these list once
OGLMachine	Defines a AzurVeda platform independant OpenGL Machine. Still, this class is virtual, doesn't manage screen opening, doesn't manage sounds, But unify all OpenGL code, for any machine willing to use OpenGL
OGLMachine::OGLInternalObject3DBuffer	Nested class that implements a 3D object as a vertex and a polygon list. You ask the creation of it with VirtualMachine::NewObject3DBuffer(), then defines its shape by filling the list you get with GetFirstVertex() and GetFirstTriangle(), then it can be rendered with VirtualMachine::RenderMesh(). In order to optimize a static shape, use VirtualMachine::CompileAsStatic() In edition mode, it can be destroyed with VirtualMachine::DeleteObject3DBuffer()
OGLMachine::OGLInternalTexture
OGLMachine::OGLInternalTexture::Layer	Nested class for private use
OGLMachine::OGLInternalViewPort
OGLMachineLinux	Defines a AzurVeda Machine for linux systems, using OGLMachine for 3D and OSS for the sound server
OGLMachineLinux::GLWindow
OGLMachineWinDxSound	Defines a AzurVeda Machine for Windows systems, using OGLMachine and OpenGL for 3D rendering, and DirectSound for the sound server
OGLMachineWinDxSound::MiniDirectSound
OGLMachineWinDxSound::RenderScreen
PackDynamicFloat	Base type that lets you choose between a constant scalar expression or a reference to an equation. It supports 1,2 or 3 vector like PackFloat, but is not extended from packfloat
PackDynamicType	PackDynamicType serializes and manages an enumeration number (like PackULong_Enums) that define the shape of what is serialized with. the different shapes have to be registered through RegisterShapeConstructors() at construction, so it has to be extended to be active. See exemple in VedaLibImage / PackDynamicFloat
PackFloat	Base type managing a serializable float value. a float type is serialized to 3 bytes, or 1 byte if value is 0.0f. once read, the 4th IEEE float byte is always set to 0, so that the mantissa is only 15 bit long, not 23 as usual. PackFloat, like all its inherited classes, can be inited with a special constructor where you use a VectorDimension enum. You can choose to init a PackFloat with PackFloat::vd_X if you need one dimension o represent a value, or use vd_XY, for example to define a 2D vector, vd_XYZ for a 3D vector, or vd_XYZD for a dated 3D vector. Note extension library VedaLibMath 's VirtualEquation::Compute() was based on float[4] parameters
PackFloat_FixedPoint	Base type managing a float, but serialized like a PackLong. You provide a const number at construction that fixes a number of bit after the point. For example, 1 bit after the point will make possible: 0.0f , 0.5f, 1.0f, 1.5f,... 2 bits after the point will manage: 0.0f,0.25f,0.5f,0.75f,1.0f,1.25f,..
PackFloatByte_Color	It specify PackFloatByte_Limits to express a R,G,B color. this specification is adressed with GetClassID() to interfaces. in non-editable mode, it is PackFloatByte_Limits typedef
PackFloatByte_Limits	Manage a float value, but serialize it in 1 byte, where the 256 value domain is scaled between 2 float given at inition. default ends are:[ 0.0f , 1.0f [
PackList	Base type managing a list of any PackSerializable (or inherited) Objects from the same class. In edition mode, you can grow or shorten the list. GetFirstCell() give you a first 'PackListCell', then you can scan the list element with PackListCell::GetNextBrotherCell() and PackListCell::GetManagedObject()
PackList_TimeBlockTrack	List that defines a set of TimeTrackElement extended objects. the difference with PackList_TimeTrack is that elements serialize block length and not dates..
PackList_TimeBlockTrack::TimeBlockTrackElement	Nested class that describe a dated element in the list. It has to be extended with new serializable members (ex: splines, scripts, music tracks..). It manages the fact that the time are kept sorted in edition mode
PackList_TimeBlockTrack::TimeBlockTrackElement::PackFloat_FixedPoint_TimeBlock	Nested class that patch the virtual PackFloat_FixedPoint::Set() in edition mode, in order to force a test to assure that the elements of the list are kept sorted by time date when edited. (yes, it is tricky, but private.)
PackList_TimeTrack	List that defines a set of TimeTrackElement extended objects. Each elements define when they begin, when they end, and an order number, which is different from zero if another element is in the same time range. The Goal with this class is to unify the ways to create timed lists, that can be managed by a single GUI gadget for script or spline management. It was actually made to be used in spline key list, a script manager this is only a simple serializable class
PackList_TimeTrack::TimeTrackElement	Nested class that describe a dated element in the list. It has to be extended with new serializable members (ex: splines, scripts, music tracks..). It manages the fact that the time are kept sorted in edition mode
PackList_TimeTrack::TimeTrackElement::PackFloat_FixedPoint_Time	Nested class that patch the virtual PackFloat_FixedPoint::Set() in edition mode, in order to force a test to assure that the elements of the list are kept sorted by time date when edited. (yes, it is tricky, but private.)
PackLong	Base type managing "28 bit relative integer", which serialize a number between [-(256Mb-1),256Mb-1], which can be written on 1, 2,3 or 4 bytes when needed. It is used for the automated serialization managed by class PackStruct. It outputs a "signed int" you access with Get()
PackLong_WithLimits	PackLong_WithLimits specialize PackLong to define a min and max value possible for this signed integer value. Specify these min,max after serialisation member registration. When compiled as non-editable, this class become a classic PackLong, nothing more is compiled
PackObjectReference	Base type managing a serializable reference to another object in the same context. a BaseObject can use a PackObjectReference as a member, and when registering it, you specify a pointable base class. Then the PackObjectReference will be able to point any object in the context that match this pointable class, or its inherited classes. You get the pointer with GetObjectPointer(). Getting NULL is valid, and simply means that nothing is pointed. You change the pointer with SetObjectPointer(), and you should check its enum_SetReferenceResult errorcode. Please, don't stock a pointer from GetObjectPointer() elsewhere between two functions, because PackObjectReference are dynamic pointers, that can change or become NULL during edition. Registering a PackObjectReference member in a BaseObject constructor can look like this:
PackResource	Base type managing a file as a resource. the file can be external, on the disk, or internal, which means linked into the serialized context. In all compilation modes, You get the resource with GetBinary(). In editable mode, you can set a binary file You Set() and Get() a file name relative to the executable path, and choose if it should be linked while serialized, or just read from the file at inition. In all cases, you get the binary with GetBinary() It is used for the automated serialization
PackString	Base type managing a zero-ended ascii string. It is used for the automated serialization
PackString_MultipleLines	Extension to PackString to manages long texts with multiple lines. When used in non editable compilation mode, it is cast as a PackString
PackStruct	Base type managing a suit of any PackSerializable (or inherited) Objects, which types are differents but can't be changed. To use a PackStruct, register a list of PackSerializable objects in construction. This objects must be already allocated. PackStruct doesn't manage the existance of the listed objects. It just allows to re-serialize their values. This list must not vary in the life of the object, so that it can be serialized in and out again and again. For a dynamic List handling objects from the same class, look: PackList
PackStruct::Cell	Nested class to PackStruct , stands for an element cell in the list
PackTreeCell	Base type managing a Tree database of any PackSerializable (or inherited) Objects. the object type managed is unique and defined at construction, by passing a function that do return a new object
PackULong	Base type managing "28 bit unsigned long", which serialize a number between [0,512Mb-1], which can be written on 1, 2,3 or 4 bytes when needed. It is used for the automated serialization managed by class PackStruct. It outputs an "unsigned int" you access with Get()
PackULong_Enums	PackULong_Enums specialize PackULong to define from 1 to 28 bit bitfield where each bit stands as a boolean value with a given meaning
PackULong_Flags	PackULong_Flags specialize PackULong to define from 1 to 28 bit bitfield where each bit stands as a boolean value with a given meaning
PackULong_RandomSeed	PackULong_RandomSeed specializes PackULong to express a random number seed generator, and provide a random function, for procedural purposes. PackULong is a base type managing "28 bit unsigned long", which serializes a number between [0,512Mb-1], which can be written on 1, 2,3 or 4 bytes when needed
ParticleSetEquation	Class defining a Particle set which moves according to a VirtualEquation
ParticleSetVirtual	Virtual Class defining a generic Particle set
ParticleSetVirtual::Particle
PerlinNoiseImage	Class able to build a grey, 2n-pixelSized, perlin noise Image
ProceduralImage	Virtual Base class for procedural Images. It manages a random number, and serialize its editable random seed number, which defines the whole shape
RenderTargetRectangle	Define a screen rectangle to draw on, as the son of another drawing rectangle, in a hierarchy of rectangles
RenderTargetTexture	Define a screen rectangle to draw on a texture, for multipass rendering
RenderTargetVirtual	Define a screen rectangle where to draw. It is the virtual version
RGBAImage	Image that mix images of any size or color depth into a new RGBA one. it uses a layer list by source image. Each layers can affect a color channel, it can use a HSV->RGB mixer and manages alpha channel
RGBAImage::ImageLayer	Nested class that describes a reference to an object3D, used as element in the list
Scene3D	Class that stands for a playable 3D Scene defined by a list of objects and their cinematics
sLwoLayer	Describes an Object Layer, which means a given shape in the file. Then the geometry is described under it
sLwoObject	Describe the whole lwo file To be used with ReadLwo()
sLwoPolygon	Describes a raw polygon as a N-gon, uner the form of a vertex reference list. that describe a convex polygon
sLwoPolyToVertex	Describes the reference of a polygon point to a given vertex in the vertex base. Informations can be discontinuous to the vertex, in which case they are here, or on the vertex, in which case they are in sLwoVertex
sLwoVertex	Manages a Vertex read from a lwo file. as a position vector, a computed normal vector, Texture UV coordinates, etc
sMatrix
st_Envelope
st_Key
TextLocalized	Define a text and possibly other localized versions
TextLocalized::LocalText
Texture3D	Manages a texture in order to render 3D objects
VedaMachineDreamcast	Defines a AzurVeda Machine targeted for the Sega Dreamcast hardware, using the free Developpement kit Kallistios, and other things. For the moment, the renderer is partly based on KGL
VedaMachineDreamcast::_translucentMeshToRender	32b aligned !!!
VedaMachineDreamcast::DCInternalObject3DBuffer	Nested class that implements a 3D object as a vertex and a polygon list. You ask the creation of it with VirtualMachine::NewObject3DBuffer(), then defines its shape by filling the list you get with GetFirstVertex() and GetFirstTriangle(), then it can be rendered with VirtualMachine::RenderMesh(). In order to optimize a static shape, use VirtualMachine::CompileObject3DBufferAsStatic() In edition mode, it can be destroyed with VirtualMachine::DeleteObject3DBuffer()
VedaMachineDreamcast::DCInternalTexture
VedaMachineDreamcast::DCInternalTexture::Layer	Nested class for private use
VedaMachineDreamcast::DCInternalViewPort
VirtualEquation	Virtual class Defining an equation of the form: result = func(x,y,z,time)
VirtualEquationSpline	Spline function virtual model, with no defined dimension depth
VirtualEquationSpline::SplineElement	Nested class that describes a reference to an object3D, used as element in the list
VirtualImage	Virtual Class defining a generic Image usable by effects. To this level, VirtualImage manages a generic memory allocation for the bitmap
VirtualMachine	Pure Virtual class for all machine specific methods. These methods should be completed for each machines in separate inherited libraries. This class will keep 100% independant from any other classes or API. This should be possible to only use a VirtualMachine for a whole program, to reach hardware abstraction. Methods documentation has been grouped by theme: the Init Methods the 3D Render Nested Classes and Methods the Sound Methods the Cultural Configuration Methods the Interface Methods the Disk Operating and System Methods
VirtualMachine::InternalObject3DBuffer	Nested class to define a 3D object as a vertex and a polygon list. You ask the creation of it with VirtualMachine::NewObject3DBuffer(), then defines its shape by filling the list you get with GetFirstVertex() and GetFirstTriangle(), then it can be rendered with RenderMesh(). In order to optimize a static shape, use CompileAsStatic() In edition mode, it can be destroyed with VirtualMachine::DeleteObject3DBuffer()
VirtualMachine::InternalTexture	Nested class that defines a texture to render an object with VirtualMachine::RenderMesh()
VirtualMachine::InternalTriangle	Nested class that defines a Triangle Polygon for use with InternalObject3DBuffer::GetFirstTriangle(). Note: this triangle definition should not change (no more member or virtual methods).sizeof(InternalTriangle) must always be 12 because it is sometimes used as a list element
VirtualMachine::InternalVertex	Nested class that defines a vertex for use with InternalObject3DBuffer::GetFirstVertex(). Note: this vertex definition should not change (no more member or virtual methods). It is sometimes used as a list element
VirtualMachine::InternalViewPort	Nested class that defines a viewport where to draw (screen, sub-screen,texture rendering screens.) This is a virtual class. Construction must be done by NewViewPortChild(), NewViewPortOnTexture() or InitMachine() for the default viewport accessible with VirtualMachine::GetDefaultViewPort() which stands for the main screen
VirtualMachine::SoundBufferToAddYourSignal	Defines the sound buffer to be mixed by SoundInterface::ProcessSoundInterupt()
VirtualMachine::SoundInterface	Virtual base class for any kind of object that need to generate a sound signal. You have to extend it and implement ProcessSoundInterupt(). (see exemple in VirtualMedia.cpp) For more informations, look VirtualMachine::EnableMediaSound()
VirtualMachine::SoundUpdateListCell	Nested class to manage update sound object list;
VirtualMedia	Base model for all class that plays a suit of animations and/or sounds. You should extend ProcessMedia() for animations, and ProcessSoundInterupt() for sounds, in any way. This example extends a VirtualMedia and plays it. Note this class is not registered to BaseContext by default. you got to register it or not, according to your needs. Thus, it got to be registered first if you use inherited classes. ( through BaseContext::RegisterClassList() ) Also note that VirtualMedia::ProcessSoundInterupt() manages the sound registration to the machine itself

---

      /\/\        4         N         k         !         N         D
                      _______  _ __ ___  _____            ___ _ _  ____
     ___________  __//___   /________  |/    / ___________\_______/    \
    /   _   _   \/   _     /    _   /      _/_/____/    _       __     /
   /    /   /       /     /    /    \      \/     /    /    \   \     /
  \\___/___/___/    ¯    _____/_____/       ______\___/_____/\________\\
               \________/_ ___ __ l____\      /elD!  
                 http://www.m4nkind.com \____/