FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial revision

Browse Source
This commit is contained in:
Don BURNS 2001-01-10 16:32:10 +00:00
parent 7c12eb9361
commit 70208ebc06
461 changed files with 70936 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
AUTHORS Normal file
View File

@ -0,0 +1,44 @@
# $Id$
#
# The is a list of authors and contributors to the project.
# Feel free to add your name and change list.
Robert Osfield <robertosfield@yahoo.co.uk>
- osg and osgUtil.
- pfb, gif, jpeg, tiff, tga, pic plugins.
- sgv, various revisions, now most of code in osgGLUT.
- documentation?!
- visual studio workspace files/unix makefiles.
- project adim & lead.
Don Burns <don_burns@sgi.com>
- libosg (particularily OpenGL)
- first version of sgv.
- fly database plugin.
- netscape plugin.
- unix makefiles.
Graeme Harkness <graeme@phys.strath.ac.uk>
- osg::Vec2,Vec3,Vec4 & osg::Quat classes.
- reworking of old sgv into osgGLUT and a slim line Demos/sgv.
- Demos/cube.
Neil Salter <neil@nackle.org>
- first incarnation of osgUtil, Camera and Manipulators.
- web site.
Brede Johansen <bredej@email.com>
- flt loader.
- osg::Point.
- bug fixes.
- assistance on visual studio workspace files.
Ben Discoe <ben@vterrain.org>
- png plugin.
- a couple of bug fixes and code submissions.
Karsten Weiss <knweiss@gmx.de>
- autoconfiscation of the project.
- rpm spec file.
- documentation.
- bug fixes.

481
COPYING Normal file
View File

@ -0,0 +1,481 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

1046
ChangeLog Normal file
View File

File diff suppressed because it is too large Load Diff

345
FAQ Normal file
View File

@ -0,0 +1,345 @@
o API's feature set
- scene graph based?
The scene graph is arranged with geometry nodes (osg::Geode's) as leaf
nodes and internal nodes such as osg::DCS's/Groups/LOD etc for position the
geometry objects within the scene and organising scene behaviour.
- culling techniques?
Currently view frustum culling, small feature culling, and OpenGL's
native backface culling. The OSG has been designed so it can be
easily extended, so if you have a favoured culling technique it
won't be difficult to utilise it in the OSG.
- terrain / indoor support
The osg::GeoSet encapsulates all the main OpenGL drawing primitive
so its possible to represent pretty well anything you can with straight
OpenGL including terrain and room objects and characters. More
details below.
However, if you wish to take advantage of specific optimization such
as adaptive meshing such as ROAM, or procedural culling such as when
entering a room or when racing round a track then the OSG's could be
easily extend to achieve this.
These features are not currently on the todo list for version 1.0 as
we intend to keep the OSG focused on the core scene graph. However,
you're more than welcome to take on the challenge yourself.
- etc, etc (the viz sim capabilities of it)
Key features of OpenGL are encapsulated such as Points, Lines, Triangle
and Quad Meshed primitives in osg::GeoSet, and Textures, Projected &
Environmental Textures, Transparency etc. in osg::GeoState.
The osgUtil::RenderVisitor currently implements the cull/draw traversal
placing objects to be rendered in either a transparency bin or a
opaque bin. The transparent bin is depth sorting w.r.t to the eye point
to ensure transparent objects appear correctly. The opaque bin
is sorted w.r.t to their osg::GeoState to minimize OpenGL state changes
to avoid cache misses in the rendering pipeline.
osg::Billboards can be used for rendering trees, or even particle
effects such a smoke, snow, explosions etc.
o What is the design philosophy behind the OSG.
(An extract from an email from Don Burns beginnings of the OSG.)
Thought I'd jot a couple of thoughts down regarding OSG. A full
simulation package should really be made up of four parts:
- Scene Graph
- Traversers (App, Cull, Draw)
- An MP harness
- Channel configuration
The Scene Graph is just that. It manages a tree structure of different
node types that allow management over the behaviour of graphical
objects. The Traversers allow us to use the scene graph to render
scenes in the most efficient manner, as well as providing maximum
functionality for a real-time simulation. The stages are (taken from
the Performer approach) :
App - This is the application part of the simulation that interfaces
with the outside world, that is control devices, pilot input, animation
engines, effects, event engines, etc, etc (there's much more). This is
also the stage that determines what the viewpoint is and consequently
the viewing frustum. App does a full traversal of the scene graph,
calling callbacks that may be attached to nodes.
Cull - This stage takes the information that has been updated by App
(mainly the viewing frustum) and effects a cull of all objects, based on
trivial accept or reject based on whether the bounds are contained in
the viewing frustum or not. Every node should have a bound associated
with it reflecting the bounds of all children under it. This way, Cull
can quickly prune a large section of the scene graph, during traversal.
It also implies that scene graphs should be organized spatially, such
that groups of objects that are close to each other should also be close
to each other on the scene graph. During traversal, Cull gathers all
leaf nodes that wind up being trivially accepted and creates a display
list of geosets with their geostates. These are then sorted by
geostate, binning things like states that contain transparencies, and
need to be sorted back to front and drawn last. Cull can also perform
accepts/rejects of geosets based on their bounding boxes. Note that
geosets have bounding boxes and geodes have bounding spheres. This for
efficiency.
Cull also needs to gather nodes that would cause any glcommands, such as
SCSs and DCSs which create transforms.
Draw- This does not traverse the scene graph, but rather, traverses the
resultant display list produced by Cull. Draw is to be as brain-dead as
possible since it has the bulk of compute time reserved for actually
drawing. (Unless, of course you have the luxury of an SGI machine that
does all transforms down in the graphics hardware... perhaps NV10 will
help a bit on this end).
The MP harness is a set of management routines for doing
multiprocessing. Ideally, you want to be able to run App, Cull and Draw
as separate processes on their own dedicated processors. Further, you
want to run one complete Draw process for every graphics subsystem that
you will be rendering to. In our case, we can assume that most of our
users will be on single processor PC's, in which case we stand to
benefit from Cull's capability to prune the scene graph, but not much
else. However, this day and age four processor PC's are not that
uncommon, and Linux does have pretty good support for this.
The MP issues include, process (or thread) management and
synchronization. Performer has several MP models. We also need to
consider that this software will probably run on seperate PCs
altogether, so that the SGI concept of a single machine with multiple
rendering pipes needs to be extended to include multiple PC's, which
need to be synchronized across Ethernet or something.
Note that each Draw process needs its own Cull process, but that there
can be only one App for multiple Cull/Draw pairs. This model might
extend quite nicely to a multiple PC environment, in which each PC runs
a Cull/Draw pair, and one central machine runs App, broadcasting the
viewing frustums for each viewing channel and synchronizing all.
Lastly, channel configuration. Currently we now do this by opening a
window, choosing a visual, size, etc. It is often desirable to have
multiple channels (or viewports) for one simulator. There is a whole
package of routines that can be written to set this up and initialize
it.
That all being said, as I write this my feeling is that we should limit
the scope of OSG to that of only the first item above. That is, Open
Scene Graph will be a Scene Graph and nothing more. Limiting the scope
will allow us to concentrate on quality and robust functionality. This
is one of the best software steps that was taken during the design of
OpenGL, in my opinion. I recall Iris GL and all of its end-all, be-all
approach, becoming very convoluted and confusing as it tried to be a
windowing system, an input device interface, an imaging package and so
forth. Once the spec defined it as being a rendering API and nothing
more, the picture got much clearer.
Once OSG is in place and it becomes useful, we can then write the
traversers, etc, but not limit our version of traversers. My thinking
is that we can publish examples and documents on How to Write an
OSG Traverser, or some such and sit back and watch the world develop
the best. This will also leave us flexible to use the OSG as a protocol
for doing 3D on the web, or whatever. We can write the viewers,
traversers, MP harnesses, and channel config software as separate
packages.
Further, I think this will help in the acceptability of OSG as a good
standard scene graph. One of Performer's biggest weaknesses is that it
is a huge API and the learning curve is so steep that many but the most
hearty are put off by it. We can make the Scene Graph that anyone can
use.
o Would the OSG be a good candidate for terrain visualisation.
Terrain is one of the great candidates for scene graphs. Two management
schemes will help you out : Level Of Detail management and Visibility
Culling.
LOD management consists of defining your visual database (including your
terrain) with differing levels of detail. The further away you are the
less detail your terrain needs to have and you can cut down on the amount
of polygons required to render it.
You can also do this with objects in your scene. For example from 10
meters, you'd like a barn to have all the details present, but from 1000
meters, you could probably get away with the lack of the silo, windows and
detail around the doors. From 10000 meters it could just as easily be a
square red box and at 15000 meters it might as well not be there since
its representation may be less than a pixel on the screen.
Visibility Culling is also important to high performance rendering,
especially if your visual database is large. All nodes on the scene graph
have a bounding sphere. Each parent node has a bounding sphere that
encompasses all of its children. The Cull process traverses the scene
graph and tests each node for whether any part of it is in the current
viewing frustum. If not it throws it away.
With this in mind, you can arrange your database to make best use of
culling. For example, if you have a lot of trees on your terrain. Rather
than having one Group node that contains all trees (in which case Cull
would have to test every tree for visibility), you arrange your trees in
a hierarchical fashion, such that trees are group by geographical
location. Then neighboring groups of trees can be parented together,
groups of groups can be parented together and so forth. This way Cull can
visit a high level node, determine that none of the trees under it are
visible and proceed to test the rest of the scene graph.
This also works for terrain. Rather than defining one large piece of
terrain, you should break it up into smaller sections. This way, what is
not in the viewing frustum can be discarded and the rendering pipeline
left unbothered by transforming and clipping polygons that would never
appear anyway.
One of the goals of OSG is to be, again, "Just a scene graph". Which
means that the Cull traversal would not be included as part of the
software. It would be up to the user to provide that, OR, we can add it
as a separate piece outside of the scene graph. We want users to not be
limited to what WE think might be the best cull traversal, but rather
leave it as an exercise to optimize, be creative and/or create specific
cull/draw traversals that best suit your needs.
One such traversal I can think of is a game in which you are on a track.
At any point on this track you can know exactly what is in view and what
is not. You could do something much more creative with this if you are
not limited to the implementation "hard coded" in the scene graph
software.
o What are the intended target platforms?
Any platform which supports OpenGL and Standard C++!
The real limit being the platforms available to the core developers,
if you have a platform which you need supported and have some time
to contribute please contact us.
o What platforms are currently supported?
The OSG is currently developed under Windows95, Linux and Irix. Platform
specific makedefs are provided for Linux and Irix, and VisualC++ 6.0
Workspace files for MS Windows platforms.
The OSG should also compile under Windows98/NT and 2000 but has not yet
been tested.
o What further platforms will be supported in the near future?
We will be developing autoconf makefiles to assist the porting to
other Unix's as well as improving things on Linux and Irix.
o I'm wondering when the OSG will be ready for release.
An alpha version has been available since May 2000. The current
version is very much a work in progress will the API still in flux.
Once the design converges to a stable API we will issue it as a beta,
depending on the various factors one would hope to have the API nailed
down during summer 2000.
A full release with stable API and implementation will be available...
Can't set any dates but we can be sure it'll be after then beta release :-)
o What are the dependencies of the OSG?
Kept to a minimum by design. The osg scene graph library simply requires OpenGL/Mesa
and compiler support for Standard C++. This means that there is not platform specific
depedancies, and should allow the OSG to be ported easily to new platforms.
The scene graph viewer sgv depends upon the osg library and GLUT, so should be portable
to any platform which GLUT can be ported to. The viewer can also be compiled with FLTK
using its GLUT compatibility code.
o Do you think Open Scene Graph could be a nice replacement for Inventor?
Depends what your want from your scene graph. If you primary interest
is a visual simulation application then the performance emphasis of the
OSG will be appropriate, if you want to develop a modeling
application and wish to take advantage out of the box UI tools then
Inventor may be better.
o What differentiation between the OSG and other OS projects such as OpenRM/
SGL/OpenSG/DDG Toolkit?
I have briefly looked both the SGL, DDG and the OpenSG. Both the SGL
are the OpenSG show some uncanny similarities with the OSG, especially
since they all were developed independently. The influence of sgi's Performer,
Inventor and Cosmo3D more than likely providing the starting place for designing
each of these scene graphs. DDG doesn't show quite the same heritage,
and possibly loses a little cleanness of design with it. OpenRM is
an attempt at a Object Orientated scene graph but it C... This is
about a close as I got with it, as IMHO C++ really is the best currently
language for a modern scene graph
The OSG is also strongly influenced by Performer, this a due to the
application which the OSG was first developed for : a Hang Gliding
Flight simulator which can use either Performer or the OSG for its
scene graph. The OSG does not try to implement the whole of Performer
though, just concentrating of the scene graph to keep the scope in
manageable proportions. The need for the OSG comes about because
Performer is only available on Irix with Linux only happening very
recently, and Performer is closed source of course.
The OSG also takes advantage of the features of Standard C++ and Design
Patterns to help make the library cleaner and improve its extensibility.
Many of the current scene graphs, including Inventor and its clones, don't
use STL so end up having define their own container and many common
algorithms. We're glad to say that Standard C++ compilers are now
common enough that we don't have to descend the lowest common denominator
like many older scene graphs.
The OpenSG design document looks like it describes a very powerful
scene graph design, taking on almost all what Performer tackles today.
However, this will mean that it will be big, and like the Inventor clones
will take *alot* of work to fully implement. If you need all the features
then the OpenSG may well be worth the wait. If you need less features then
the more humble goals of the OSG may well be right for you.
o Is there a class diagram for the OSG, or white paper on the projects goals?
The documentation in the distribution has been generated automatically
using the excellent Open Source tool doc++, which creates class diagrams.
We haven't written an official white paper on projects goals or a design
overview yet. Knowledge of Performer will help in understanding some of the basics
of design, as will a familiarity with Design Patterns.
o Do you need C++ coding support?
Yes, indeed! Check out the TODO list which comes with the distribution,
and email us with what you fancy contributing to.
o Any recommendations for useful programming books to read to help understand
and contribute to the OSG?
Good practices are suprisingly hard to come by. C and C++ give you so
much rope to hang yourself, but there's few books which really give a
developers the rule book of good coding practices. I found Effective
C++ a refreshing contribution to this end. The Design Patterns book can
be pretty useful as well.
o Is there a mailing list?
Yes indeed, hosted by source forge, so to subscribe head to :
http://sourceforge.net/projects/openscenegraph and follow the
'Lists' link and follow the intructions.
o How do I submit my contributions?
We will eventually be setting up CVS access, possibly with SourceForge.
Up till then send your changes, to <robert@openscenegraph.org>

204
Make/instrules Normal file
View File

@ -0,0 +1,204 @@
__install : $(TARGET) $(LIB)
@ [ -n "$(OSGHOME)" ] || echo Please define OSGHOME
@ [ -n "$(OSGHOME)" ] && echo > /dev/null;
@ [ `whoami` = "root" ] || echo YOU MUST BE ROOT to do this.
@ echo "`whoami`" | grep -q root
@ for dir in $(TARGET_DIRS);\
do\
[ -d $$dir ] || (echo Creating directory $$dir ... ; mkdir -m 755 $$dir)\
done
@ if [ -n "$(TARGET_LIB_FILES)" ] ;\
then\
for f in $(TARGET_LIB_FILES);\
do\
(echo copying $(OSGHOME)/lib/$$f to $(TARGET_LIB)/$$f; \
cp -f $(OSGHOME)/lib/$$f $(TARGET_LIB)/$$f;)\
done\
else\
echo No libraries installed...;\
fi
@ if [ -n "$(TARGET_BIN_FILES)" ] ;\
then\
for f in $(TARGET_BIN_FILES);\
do\
(echo copying $(OSGHOME)/bin/$$f to $(TARGET_BIN)/$$f; \
cp -f $(OSGHOME)/bin/$$f $(TARGET_BIN)/$$f) ;\
done \
else\
echo No executable binaries installed...;\
fi
@ if [ -n "$(TARGET_INCLUDE_FILES)" ] ;\
then\
for f in $(TARGET_INCLUDE_FILES);\
do\
if [ "`dirname $(TARGET_INCLUDE)/$$f`" != "$(TARGET_INCLUDE)" ];\
then\
(echo copying $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f; \
cp -f $(OSGHOME)/include/$$f $(TARGET_INCLUDE)/$$f;) \
else\
echo %%%%%%%%% PLEASE DO NOT PUT INCLUDE FILES DIRECTLY INTO $(TARGET_INCLUDE);\
echo Did not copy $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f;\
fi\
done\
else\
echo No header files installed ...;\
fi
@ if [ -n "$(TARGET_LOADER_FILES)" ] ;\
then\
for f in $(TARGET_LOADER_FILES);\
do\
if [ "`dirname $(TARGET_LIB)/$$f`" != "$(TARGET_LIB)" ];\
then\
(echo copying $(OSGHOME)/lib/$$f to $(TARGET_LIB)/$$f; \
cp -f $(OSGHOME)/lib/$$f $(TARGET_LIB)/$$f;) \
else\
echo %%%%%%%%% PLEASE DO NOT PUT LOADER FILES DIRECTLY INTO $(TARGET_LIB);\
echo Did not copy $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f;\
fi\
done\
else\
echo No loaders installed ...;\
fi
@if [ -n "$(TARGET_DATA_FILES)" ] ;\
then\
if [ -n "$(OSGDATA)" ] ;\
then\
for f in $(TARGET_DATA_FILES);\
do\
(echo copying $(OSGDATA)/$$f to $(TARGET_DATA)/$$f; \
cp -f $(OSGDATA)/$$f $(TARGET_DATA)/$$f; )\
done\
else\
echo;\
echo "-------------- > Please define OSGDATA";\
echo; \
[ -n "$(OSGDATA)" ] && echo > /dev/null;\
fi\
fi
__instlinks : $(TARGET) $(LIB)
@ [ -n "$(OSGHOME)" ] || echo Please define OSGHOME
@ [ -n "$(OSGHOME)" ] && echo > /dev/null;
@ [ `whoami` = "root" ] || echo YOU MUST BE ROOT to do this.
@ echo "`whoami`" | grep -q root
@ for dir in $(TARGET_DIRS);\
do\
[ -d $$dir ] || (echo Creating directory $$dir ... ; mkdir -m 755 $$dir)\
done
@ if [ -n "$(TARGET_LIB_FILES)" ] ;\
then\
for f in $(TARGET_LIB_FILES);\
do\
(echo Linking $(OSGHOME)/lib/$$f to $(TARGET_LIB)/$$f; \
ln -sf $(OSGHOME)/lib/$$f $(TARGET_LIB)/$$f;)\
done\
else\
echo No libraries linked...;\
fi
@ if [ -n "$(TARGET_BIN_FILES)" ] ;\
then\
for f in $(TARGET_BIN_FILES);\
do\
(echo Linking $(OSGHOME)/bin/$$f to $(TARGET_BIN)/$$f; \
ln -sf $(OSGHOME)/bin/$$f $(TARGET_BIN)/$$f) ;\
done \
else\
echo No executable binaries linked...;\
fi
@ if [ -n "$(TARGET_INCLUDE_FILES)" ] ;\
then\
for f in $(TARGET_INCLUDE_FILES);\
do\
if [ "`dirname $(TARGET_INCLUDE)/$$f`" != "$(TARGET_INCLUDE)" ];\
then\
(echo Linking $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f; \
ln -sf $(OSGHOME)/include/$$f $(TARGET_INCLUDE)/$$f;) \
else\
echo %%%%%%%%% PLEASE DO NOT PUT INCLUDE FILES DIRECTLY INTO /usr/include;\
echo Did not copy $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f;\
fi\
done\
else\
echo No header files linked ...;\
fi
@ if [ -n "$(TARGET_LOADER_FILES)" ] ;\
then\
for f in $(TARGET_LOADER_FILES);\
do\
if [ "`dirname $(TARGET_LIB)/$$f`" != "$(TARGET_LIB)" ];\
then\
(echo Linking $(OSGHOME)/lib/$$f to $(TARGET_LIB)/$$f; \
ln -sf $(OSGHOME)/lib/$$f $(TARGET_LIB)/$$f;) \
else\
echo %%%%%%%%% PLEASE DO NOT PUT LOADER FILES DIRECTLY INTO $(TARGET_LIB);\
echo Did not copy $(OSGHOME)/include/$$f to $(TARGET_INCLUDE)/$$f;\
fi\
done\
else\
echo No loaders installed ...;\
fi
@if [ -n "$(TARGET_DATA_FILES)" ] ;\
then\
if [ -n "$(OSGDATA)" ] ;\
then\
for f in $(TARGET_DATA_FILES);\
do\
(echo Linking $(OSGDATA)/$$f to $(TARGET_DATA)/$$f; \
ln -sf $(OSGDATA)/$$f $(TARGET_DATA)/$$f; )\
done\
else\
echo ;\
echo "-------------- > Please define OSGDATA ";\
echo ;\
[ -n "$(OSGDATA)" ] && echo > /dev/null;\
fi\
fi
__instclean :
@ [ `whoami` = "root" ] || echo YOU MUST BE ROOT to do this.
@ echo "`whoami`" | grep -q root
@ for dir in $(TARGET_DIRS);\
do\
[ -d $$dir ] && echo Removing $$dir; \
[ -d $$dir ] && rm -rf $$dir || echo > /dev/null; \
done
@ if [ -n "$(TARGET_LIB_FILES)" ] ;\
then\
for f in $(TARGET_LIB_FILES);\
do\
([ -L $(TARGET_LIB)/$$f ] || [ -e $(TARGET_LIB)/$$f ]) && \
(echo removing $(TARGET_LIB)/$$f; \
rm -f $(TARGET_LIB)/$$f;) || echo >/dev/null;\
done\
fi
@ if [ -n "$(TARGET_BIN_FILES)" ] ;\
then\
for f in $(TARGET_BIN_FILES);\
do\
([ -L $(TARGET_BIN)/$$f ] || [ -e $(TARGET_BIN)/$$f ]) && \
(echo removing $(TARGET_BIN)/$$f; \
rm -f $(TARGET_BIN)/$$f;) || echo > /dev/null;\
done\
fi
@ if [ -n "$(TARGET_INCLUDE_FILES)" ] ;\
then\
for f in $(TARGET_INCLUDE_FILES);\
do\
([ -L $(TARGET_BIN)/$$f ] || [ -e $(TARGET_BIN)/$$f ]) && \
(echo removing $(TARGET_INCLUDE)/$$f; \
rm -f $(TARGET_INCLUDE)/$$f;) || echo > /dev/null;\
done\
fi
@ if [ -n "$(TARGET_DATA_FILES)" ] ;\
then\
for f in $(TARGET_DATA_FILES);\
do\
([ -L $(TARGET_DATA)/$$f ] || [ -e $(TARGET_DATA)/$$f ]) && \
(echo removing $(TARGET_DATA)/$$f; \
rm -f $(TARGET_DATA)/$$f;) || echo > /dev/null;\
done\
fi

59
Make/makedefs.irix.nonstd Normal file
View File

@ -0,0 +1,59 @@
MAKEDIR = $(OSGHOME)/Make
INSTRULES = $(MAKEDIR)/instrules
MAKEDEPEND = Makedepend
OBJS = $(C++FILES:.cpp=.o) $(CFILES:.c=.o) $(YACCFILES:.y=.o) $(LEXFILES:.l=.o)
DEPFILES = $(OBJS:.o=.d)
C++ = CC
YFLAGS = -d
#CFLAGS = -O2 -n32 -MDupdate $(MAKEDEPEND)
CFLAGS = -O2 -n32 -DOSG_USE_IO_DOT_H -OPT:Olimit=0
C++FLAGS = ${CFLAGS}
CPPFLAGS = ${CFLAGS}
LDFLAGS = -O2 -n32 -OPT:Olimit=0
.SUFFIXES: .cpp .o
.cpp.o:
$(C++) $(C++FLAGS) -c $<
PFLIBS = -lpfdu -lpfutil -lpf -limage
#
# TARGET_DIRS are directories that would not exist on the system except
# for the presence of OpenSceneGraph. 'make instclean' removes these
# directories
#
TARGET_DIRS = \
/usr/include/osg \
/usr/include/osgUtil \
/usr/share/OpenSceneGraph\
/usr/share/OpenSceneGraph/data\
/usr/share/OpenSceneGraph/data/Images\
/usr/share/OpenSceneGraph/data/Test\
/usr/lib32/osgPlugins\
TARGET_BIN = /usr/bin
TARGET_LIB = /usr/lib32
TARGET_INCLUDE = /usr/include
TARGET_DATA = /usr/share/OpenSceneGraph/data
TARGET_LOADER_LIB = /usr/lib/osgPlugins
#
# This definitions are necessary for IRIX. The following statement
# does not work for smake using a sh:
#
# for variable in $(LIST); do ...; done
#
# .. if $(LIST) is a NULL variable. So we have to define 0 length
# strings and check for them inside the for loop
#
TARGET_LIB_FILES = ""
TARGET_BIN_FILES = ""
TARGET_INCLUDE_FILES = ""
TARGET_DATA_FILES = ""
TARGET_LOADER_FILES = ""

59
Make/makedefs.irix.std Normal file
View File

@ -0,0 +1,59 @@
MAKEDIR = $(OSGHOME)/Make
INSTRULES = $(MAKEDIR)/instrules
MAKEDEPEND = Makedepend
OBJS = $(C++FILES:.cpp=.o) $(CFILES:.c=.o) $(YACCFILES:.y=.o) $(LEXFILES:.l=.o)
DEPFILES = $(OBJS:.o=.d)
C++ = CC
YFLAGS = -d
#CFLAGS = -O2 -n32 -MDupdate $(MAKEDEPEND)
CFLAGS = -O2 -n32 -LANG:std -OPT:Olimit=0
C++FLAGS = ${CFLAGS}
CPPFLAGS = ${CFLAGS}
LDFLAGS = -O2 -n32 -LANG:std -OPT:Olimit=0
.SUFFIXES: .cpp .o
.cpp.o:
$(C++) $(C++FLAGS) -c $<
PFLIBS = -lpfdu -lpfutil -lpf -limage
#
# TARGET_DIRS are directories that would not exist on the system except
# for the presence of OpenSceneGraph. 'make instclean' removes these
# directories
#
TARGET_DIRS = \
/usr/include/osg \
/usr/include/osgUtil \
/usr/share/OpenSceneGraph\
/usr/share/OpenSceneGraph/data\
/usr/share/OpenSceneGraph/data/Images\
/usr/share/OpenSceneGraph/data/Test\
/usr/lib32/osgPlugins\
TARGET_BIN = /usr/bin
TARGET_LIB = /usr/lib32
TARGET_INCLUDE = /usr/include
TARGET_DATA = /usr/share/OpenSceneGraph/data
TARGET_LOADER_LIB = /usr/lib/osgPlugins
#
# This definitions are necessary for IRIX. The following statement
# does not work for smake using a sh:
#
# for variable in $(LIST); do ...; done
#
# .. if $(LIST) is a NULL variable. So we have to define 0 length
# strings and check for them inside the for loop
#
TARGET_LIB_FILES = ""
TARGET_BIN_FILES = ""
TARGET_INCLUDE_FILES = ""
TARGET_DATA_FILES = ""
TARGET_LOADER_FILES = ""

56
Make/makedefs.linux Normal file
View File

@ -0,0 +1,56 @@
MAKEDIR = $(OSGHOME)/Make
INSTRULES = $(MAKEDIR)/instrules
MAKEDEPEND = Makedepend
OBJS = $(C++FILES:.cpp=.o) $(CFILES:.c=.o) $(YACCFILES:.y=.o) $(LEXFILES:.l=.o)
DEPFILES = $(OBJS:.o=.d)
C++ = g++
YFLAGS = -d
LCINCS += -I/usr/X11R6/include
LC++INCS += ${LCINCS}
CFLAGS = -O2 -W -Wall $(LCINCS)
C++FLAGS = ${CFLAGS}
CPPFLAGS = ${CFLAGS}
LDFLAGS = -O2 -W -Wall
PFLIBS = -lpfdu -lpfutil -lpf -ldl
#
# TARGET_DIRS are directories that would not exist on the system except
# for the presence of OpenSceneGraph. 'make instclean' removes these
# directories
#
TARGET_DIRS = \
/usr/include/osg \
/usr/include/osgUtil \
/usr/share/OpenSceneGraph\
/usr/share/OpenSceneGraph/data\
/usr/share/OpenSceneGraph/data/Images\
/usr/share/OpenSceneGraph/data/Test\
/usr/lib/osgPlugins\
TARGET_BIN = /usr/bin
TARGET_LIB = /usr/lib
TARGET_INCLUDE = /usr/include
TARGET_DATA = /usr/share/OpenSceneGraph/data
#
# This definitions are necessary for IRIX. The following statement
# does not work for smake using a sh:
#
# for variable in $(LIST); do ...; done
#
# .. if $(LIST) is a NULL variable. So we have to define 0 length
# strings and check for them inside the for loop
#
TARGET_LIB_FILES = ""
TARGET_BIN_FILES = ""
TARGET_INCLUDE_FILES = ""
TARGET_DATA_FILES = ""
TARGET_LOADER_FILES = ""

58
Make/makerules.irix Normal file
View File

@ -0,0 +1,58 @@
all : $(TARGET) $(LIB)
$(TARGET) : $(OBJS)
$(C++) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
$(LIB) : $(OBJS)
$(C++) $(LDFLAGS) -shared $(OBJS) $(LIBS) -o $@
clean :
rm -rf $(OBJS) core so_locations ii_files $(TARGET) $(MAKEDEPEND)
touch $(MAKEDEPEND)
clobber : clean
rm -f $(TARGET) a.out $(LIB)
to_unix :
for f in *.cpp ; do to_unix $$f $$f; done
for f in *.h ; do to_unix $$f $$f; done
# force it
depend :
$(C++) $(C++FLAGS) -M $(C++FILES) $(CFILES) > $(MAKEDEPEND)
$(MAKEDEPEND) : $(C++FILES) $(CFILES)
$(C++) $(C++FLAGS) -M $(C++FILES) $(CFILES) > $(MAKEDEPEND)
%.o : %.cpp
$(C++) $(C++FLAGS) -c $*.cpp -o $*.o
docs:
[ "$(TARGET_BASENAME)" != "" ] && \
mkdir -p ../../doc/$(TARGET_BASENAME) && \
doc++ -d ../../doc/$(TARGET_BASENAME) -H -A ../../include/$(TARGET_BASENAME)/* && \
echo $(TARGET_BASENAME) HTML documentation created in ../../doc/$(TARGET_BASENAME)
install : home
@ make __install
instlinks : home
@ make __instlinks
instclean : home
@ make __instclean
home :
@ [ -n "$(OSGHOME)" ] || (echo ; echo "-------------> Please define OSGHOME"; echo)
@ [ -n "$(OSGHOME)" ]
sinclude $(INSTRULES)
include $(MAKEDEPEND)

53
Make/makerules.linux Normal file
View File

@ -0,0 +1,53 @@
all : $(MAKEDEPEND) $(TARGET) $(LIB)
$(TARGET) : $(OBJS)
$(C++) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
$(LIB) : $(OBJS)
$(C++) $(LDFLAGS) -shared $(OBJS) $(LIBS) -o $@
clean :
rm -f $(OBJS) core $(TARGET) $(MAKEDEPEND)
touch $(MAKEDEPEND)
clobber : clean
rm -f $(TARGET) a.out $(LIB)
to_unix :
for f in *.cpp ; do to_unix $$f $$f; done
for f in *.h ; do to_unix $$f $$f; done
# force it
depend :
$(C++) $(C++FLAGS) -M $(C++FILES) $(CFILES) > $(MAKEDEPEND)
$(MAKEDEPEND) : $(C++FILES) $(CFILES)
$(C++) $(C++FLAGS) -M $(C++FILES) $(CFILES) > $(MAKEDEPEND)
%.o : %.cpp
$(C++) $(C++FLAGS) -c $*.cpp -o $*.o
docs:
[ "$(TARGET_BASENAME)" != "" ] && \
mkdir -p ../../doc/$(TARGET_BASENAME) && \
doc++ -d ../../doc/$(TARGET_BASENAME) -H -A ../../include/$(TARGET_BASENAME)/* && \
echo $(TARGET_BASENAME) HTML documentation created in ../../doc/$(TARGET_BASENAME)
install : home
@ make __install
instlinks : home
@ make __instlinks
instclean : home
@ make __instclean
home :
@ [ -n "$(OSGHOME)" ] || (echo ; echo "-------------> Please define OSGHOME"; echo)
@ [ -n "$(OSGHOME)" ] && echo > /dev/null;
sinclude $(INSTRULES)
include $(MAKEDEPEND)

98
Makefile Normal file
View File

@ -0,0 +1,98 @@
#!smake
SHELL=/bin/sh
MAKE_PREP = Make/makedefs Make/makerules
DIRS = src
all : $(MAKE_PREP)
for f in $(DIRS) ; do cd $$f; make; cd ..; done
docs :
cd src; make docs;
Make/makedefs :
@ cd Make;\
case `uname` in\
IRIX|IRIX64) \
ln -sf makedefs.irix.nonstd makedefs ;;\
Linux) \
ln -sf makedefs.linux makedefs;;\
esac
Make/makerules :
@ cd Make;\
case `uname` in\
IRIX|IRIX64) \
ln -sf makerules.irix makerules ;; \
Linux) \
ln -sf makerules.linux makerules ;;\
esac
linux:
cd Make;\
ln -sf makedefs.linux makedefs;\
ln -sf makerules.linux makerules
make
irix:
cd Make;\
ln -sf makedefs.irix.nonstd makedefs ;\
ln -sf makerules.irix makerules
make
irix.std:
cd Make;\
ln -sf makedefs.irix.std makedefs ;\
ln -sf makerules.irix makerules
make
help :
@echo Usage :
@echo \ make
@echo \ make linux
@echo \ make irix.std
@echo \ make irix.nonstd
@echo \ make depend
@echo \ make clean
@echo \ make clobber
@echo \ make doc
@echo \ make snapshot
@echo \ make install
@echo \ make instlinks
@echo \ make instclean
clean : $(MAKE_PREP)
for f in $(DIRS) ; do cd $$f; make clean; cd ..; done
find lib -type f -exec rm {} \;
rm -f bin/*
clobber : $(MAKE_PREP) clean
for f in $(DIRS) ; do cd $$f; make clobber; cd ..; done
rm -f $(MAKE_PREP)
depend : $(MAKE_PREP)
for f in $(DIRS) ; do cd $$f; make depend; cd ..; done
to_unix :
for f in $(DIRS) ; do cd $$f; to_unix Makefile Makefile; cd ..; done
for f in $(DIRS) ; do cd $$f; make to_unix; cd ..; done
cd include/OSG; for f in *.h ; do to_unix $$f $$f; done
snapshot:
make doc;
make clobber;
(cd ..; tar cvf - OpenSceneGraph-0.8 | gzip > osg_src-`date "+%Y%m%d"`.tar.gz)
install :
for f in $(DIRS) ; do cd $$f; make install; cd ..; done
instlinks :
for f in $(DIRS) ; do cd $$f; make instlinks; cd ..; done
instclean :
for f in $(DIRS) ; do cd $$f; make instclean; cd ..; done

22
NEWS Normal file
View File

@ -0,0 +1,22 @@
OSG News (most significant items from ChangeLog)
================================================
6th December 2000 - osg_src-0.8-34.tar.gz
o New osgGLUT library assist writing of osg demos.
o New cube demo.
o Improved handling of image sizes which arn't a power of 2.
o Performer plugin can now work as of plugin to Performer or the
OSG (with a few caveates:)
22nd December 2000 - osg_src-0.8-33.tar.gz
o Integrated Don's work on adding glVertexArrays etc to osg::GeoSet.
o Incorportated the following image loaders from the simage library.
src/osgPlugins/gif
/jpeg
/pic
/tga
/tiff

178
README Normal file
View File

@ -0,0 +1,178 @@
The following is a very basic intro of how to get the OSG going under Linux,
IRIX and Windows. Each intro mentions OpenSceneGraph-Data, it is recommended
that you also download it alongside this source distribution.
The scene graph depends upon Standard C++, STL and OpenGL so you need a C++
compiler up to the task and OpenGL or Mesa installed. The viewer depends upon
GLUT which you'll need to download and install from the GLUT website. The
OSG has it own native ascii file format, and .rgb image reader inbuilt which
allows you read the example data with any dependancies othe then C++, STL and
OpenGL.
The OSG also has several plug-ins which support non-native 3d database and
image formats, several have no dependancies on external libraries (flt,fly,
tga & pic), while others (pfb,jpeg,gif,tiff) require other libraries to be
installed to compile them. If you don't already have them installed then
don't worry, you'll still be able to use the OSG. The core osg library and
viewer is designed has been designed to load the plug-ins at run-time only
and if they are required to load a specific data set. If you don't need them
for your datasets then it won't matter that you havn't been able to compile
all the plug-ins. A full list of dependancies and where to download the
required libraries are near the bottom of this file.
If you're comming across the OSG for the first time and want to get started
quickly, go right ahead and follow the compilation instructions. You can always
later download the libraries which the plug-ins require if you eventually need
them.
If you havn't already checked it out, for a list of distribution contents,
contacts and links to documentation check out index.html.
Compiling under Linux :
-----------------------
Add the following to your .cshrc :
setenv OSGHOME <location of OSG root>
setenv OSGDATA <location of OSG data root>
setenv OSGFILEPATH ./:${OSGDATA}:${OSGDATA}/Images:
setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:${OSGHOME}/lib
setenv PATH ${PATH}:${OSGHOME}/bin
Or the following if you're using a sh compatible shell :
export OSGHOME=<location of OSG root>
export OSGDATA=<location of OSG data root>
export OSGFILEPATH=./:${OSGDATA}:${OSGDATA}/Images:
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${OSGHOME}/lib
export PATH=${PATH}:${OSGHOME}/bin
To compile, from the OSG root directory, type :
make
Note, make should automatically detect linux and copy the
Make/makerules.linux and Make/makedefs.linux over the
default Make/makerules and Make/makedefs. If autodetection
does not work type 'make linux'.
Compiling under IRIX :
----------------------
Add the following to your .cshrc :
setenv OSGHOME <location of OSG root>
setenv OSGDATA <location of OSG data root>
setenv OSGFILEPATH ./:${OSGDATA}:${OSGDATA}/Images:
setenv LD_LIBRARYN32_PATH ${LD_LIBRARYN32_PATH}:${OSGHOME}/lib
setenv PATH ${PATH}:$OSGHOME/bin
Or the following if you're using a sh compatible shell :
export OSGHOME=<location of OSG root>
export OSGDATA=<location of OSG data root>
export OSGFILEPATH=./:${OSGDATA}:${OSGDATA}/Images:
export LD_LIBRARYN32_PATH=${LD_LIBRARYN32_PATH}:${OSGHOME}/lib
export PATH=${PATH}:$OSGHOME/bin
Since the OSG uses Standard C++ features such as STL it is important
to have an up to date version of the MIPSPro compilers. The library
has been tested under MIPSPro7.3 & MIPSPro7.2.1, and *may* compile
under previous versions but has yet to be tested. It is recommened
to use MIPSPro7.3.1.1m.
To compile, from the OSG root directory, type :
make
Note, make should automatically detect IRIX and copy the
Make/makerules.irix and Make/makedefs.irix over the
default Make/makerules and Make/makedefs. If autodetection
does not work type 'make linux'.
Compiling under Windows :
-------------------------
The Microsoft Visual C++ 6.0 workspace file is VisualStudio.dsw located
in the VisualStudio\ below the OSG this root directory. The OSG will
compile with the basic VisualC++6.0, but its recommended that you use
Service Pack 4 to fix MS compiler bugs which affect the OSG.
To execute the viewer the file path for the .dll's and .exe, both compiled
into the OSG's bin directory, need to be setup, such as by adding the PATH
to your autoexec.bat, its also useful to add the OSGFILEPATH to your
autoexec.bat to help the location of datafiles. For example :
SET OSGFILEPATH=D:\OpenSceneGraph-Data;D:\OpenSceneGraph-Data\Images
SET PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:\Oglsdk\lib;D:\OpenSceneGraph-0.8\bin;
Running the viewer
------------------
To run the viewer demo type (you made need to type rehash first under Unix) :
sgv dumptruck.osg
sgv cow.osg
sgv e-s-bike.osg
sgv flight_park.fly
sgv lz.rgb
Other run other demos type
cube
(Note: the file is picked up by checking the directories pointed to
by $OSGFILEPATH)
Plug-in dependancies
--------------------
src/osgPlugins/pfb
There is Peformer plugin in this distribution for converting from
Performer to OSG and from OSG to Performer. This plugin requires
Performer to be installed and therefore is not compiled by default.
If you have Performer (available under Linux and IRIX) then edit
src/osgPlugins/Make to compile under the plugin. Performer can be
downloaded from http://sgi.com
For further information about the Performer plugin please read the
src/osgPlugin/pfb/READEME.txt.
src/osgPlugins/png
The png plugin depends upon the libpng and zlib (for compression)
libraries, if you don't already have it installed, you'll need to
download, compile and install it.
Project home pages are:
http://www.libpng.org/pub/png/libpng.html
http://www.info-zip.org/pub/infozip/zlib/
src/osgPlugins/gif
The gif plugin depends upon the libungif library, if you don't already
have it installed, you'll need to download, compile and install it.
Project home page is:
http://prtr-13.ucsc.edu/~badger/software/libungif/
Ftp download at :
ftp://prtr-13.ucsc.edu/pub/libungif/
src/osgPlugins/jpeg
The jpeg plugin depends upon the libjpeg library, if you don't already
have it installed, you'll need to download, compile and install it.
Project home page is:
http://www.ijg.org
src/osgPlugins/tiff
The tiff plugin depends upon the libtiff library, if you don't already
have it installed, you'll need to download, compile and install it.
Project home page is:
http://www.libtiff.org

141
TODO Normal file
View File

@ -0,0 +1,141 @@
OSG TODO List
=============
Main categories
===============
o Core OSG Library
- the core OSG library itself (include/OSG and src/)
o Reader/writer plug-ins
- the reader/writers plug-ins for third party file formats.
o Viewers & Application plug-ins
- osg viewers and plug-ins to third party applications such as Netscape.
o Under development
- listing of TODO items which are currently under developement.
o Work completed
- listing of TODO items which have been done and hence removed
from the above TODO catagories.
--
o Core OSG Library
================
- General
. Header & code documentation/reference guide.
. Programming guide.
. Naming conventions.
. mutli-threading/shared memory support.
- Maths
. full maths support in osg::Matrix class.
. double matrix class.
. osg::Plane class.
- Nodes
. create a base class to provide interface to objects which can render,
derive osg::GeoSet from this.
. add osg::Sequence for basic animation.
. add osg::Morph for interpolating between geometries.
. add support for Multi-texturing into osg::GeoSet/osg::GeoState.
. add support for multi-pass rendering.
. utilise stl vectors for osg::GeoSets?
. improve osg::GeoState.
. add osg::State for mainting image of the OpenGL state.
. add osg::Terrain node.
. add osg::EarthSky class for rendering earth and sky backgrounds.
. add proxy node for lazy loading of nodes, when needed.
. implement visual proximity to assist loading of proxied data
when the view frustum nears an unloaded proxy node, and deleting
of unused proxied data.
. implement support for modified status/lazy evaluation of node data
and observer style pattern.
. manipulator decoration nodes?
. spacial subdivision decoration nodes?
- Visitors
. improve state sorting of opaque bins in osg::RenderVistor.
. add statistics visitor for logging the stats of the scene graph.
. add OpenGL picking visitor.
- IO/Plug-in support
. improve the ascii parsing class osg::Field, osg::FieldReader etc.
. change the osg::Registry to timestamp registrations of objects/RW's.
. add support for file path logging into osg::Input.
. add binary data reading and writing into osg::Input/osg::Output to
support part binary .osg files.
. return error messages of on failed loading/saving.
o Reader/writer plug-ins
=======================
- .iv/.wrl Inventor/VRML ascii.
- .obj Alias wavefront's format.
- .dxf Autocads ascii format.
- .3ds 3D Studio format.
- .dem digital elevation map.
- .d3d? MS's Direct 3D file formats if they have one..
- .bmp Windows Bitmap files.
- .gz Automatic unzipping of GNU zipped files.
- .zip Automatic unzipping of windows zipped files.
- .Z Automatic unzipping of Unix Compress files.
- .tar Automatic unpacking of directories and loading of contents.
o Viewers & Application plug-ins
===============================
- OSG scene graph viewer - sgv.
. add command line reading for specifying data search paths and data,
-D for data search path, -d for data.
. add command line reading for specifying library search paths and
libraries/plug-ins, -D for library search path, -l for libraries.
- Internet Explorer plug-in.
- .osg to Inventor file plug-in.
- Tutorials example programs.
o Under development
=================
Sign up here if would like to take on a task :-)
- add osg::Billboard for trees etc.
- .pfb loader for Performer binary files.
- full maths support in osg::Matrix class.
- Netscape plug-in.
- add osg::Channel/sgCamera class.
- .flt Open Flight format.
- autoconf/configure support to aid portabilty to other unix's.
- CVS support for when source is made fully public.
o Work completed
==============
- osg namespace implemented.
- reduce the STL platform specific #ifdef's.
- remove using namespace from all header files, so not to pollute user space.
- remove the sg prefix from sgNode etc, now that the osg namespaces exits.
- FAQ for distribution and web site.
- full maths support in osg::Vec2, osg::Vec3 and osg::Vec4.
- change the osg::Registry to use plug-in RW's on loading a plug-in
instead of the plug-in functions found in sg.cxx.
- add support for removal of plug-ins from osg::Registry,
- add .osg support into DCS node.
- clean up inheritance relationship between osg::Node, osg::Object etc.
- add osg::Switch for handling optional rendering of children.
- add osg::LOD (level of detail) group node for load management.
- add view frustrum culling into osg::RenderVisitor.
- add support for mutliply referenced nodes into osg::Input.
- add a quaternion class.
- improve osg::BoundingBox and osg::BoundingSphere.
- add hit and intersect classes for collision detection.
- add intersect visitor.
- add camera manipualotors for trackball, drive and flight mouse control.
- add compile OpenGL display lists visitor (currently in sgv).
- library version and description functions.
- add support for OpenGL Vertex Array into osg::GeoSet.
- .gif GIF Images!
- .jpg JPEG Images.
- .tiff TIFF Images.
- .png PNG Images.
- .tga TGA Images.
- .pic PIC Images.
- add timing/timestamp class.
- document how to get the OSG compiled and running under all
platforms, Win32 being priority as it's the least obvious.

97
VisualStudio/Demos/cube/cube.dsp Executable file
View File

@ -0,0 +1,97 @@
# Microsoft Developer Studio Project File - Name="cube" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=cube - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "cube.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "cube.mak" CFG="cube - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "cube - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "cube - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "cube - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 osgGLUT.lib osgUtil.lib osg.lib glut32.lib glu32.lib opengl32.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"../../../bin/cube.exe" /libpath:"../../../lib"
!ELSEIF "$(CFG)" == "cube - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /Gm /vd0 /GR /GX /ZI /Od /I "../../../include" /D "_CONSOLE" /D "_MBCS" /D "WIN32" /D "_DEBUG" /D "FL_DLL" /FR /YX /FD /c
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgGLUTd.lib osgUtild.lib osgd.libglut32.lib glu32.lib opengl32.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"libcmt" /out:"../../../bin/cubed.exe" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /incremental:no
!ENDIF
# Begin Target
# Name "cube - Win32 Release"
# Name "cube - Win32 Debug"
# Begin Source File
SOURCE=..\..\..\src\Demos\cube\cube.cpp
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

96
VisualStudio/Demos/sgv/sgv.dsp Executable file
View File

@ -0,0 +1,96 @@
# Microsoft Developer Studio Project File - Name="sgv" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=sgv - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "sgv.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "sgv.mak" CFG="sgv - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "sgv - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "sgv - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "sgv - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 osgGLUT.lib osgUtil.lib osg.lib glut32.lib glu32.lib opengl32.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"../../../bin/sgv.exe" /libpath:"../../../lib"
!ELSEIF "$(CFG)" == "sgv - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /Gm /vd0 /GR /GX /ZI /Od /I "../../../include" /D "_CONSOLE" /D "_MBCS" /D "WIN32" /D "_DEBUG" /D "FL_DLL" /FR /YX /FD /c
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgGLUTd.lib osgUtild.lib osgd.lib glut32.lib glu32.lib opengl32.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"libcmt" /out:"../../../bin/sgvd.exe" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /incremental:no
!ENDIF
# Begin Target
# Name "sgv - Win32 Release"
# Name "sgv - Win32 Debug"
# Begin Source File
SOURCE=..\..\..\src\Demos\sgv\sgv.cpp
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

224
VisualStudio/VisualStudio.dsw Normal file
View File

@ -0,0 +1,224 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "sgv"=".\Demos\sgv\sgv.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
Begin Project Dependency
Project_Dep_Name osgUtil
End Project Dependency
Begin Project Dependency
Project_Dep_Name osgGLUT
End Project Dependency
}}}
###############################################################################
Project: "cube"=".\Demos\cube\cube.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
Begin Project Dependency
Project_Dep_Name osgUtil
End Project Dependency
Begin Project Dependency
Project_Dep_Name osgGLUT
End Project Dependency
}}}
###############################################################################
Project: "flt"=".\osgPlugins\flt\flt.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "fly"=".\osgPlugins\fly\fly.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "gif"=".\osgPlugins\gif\gif.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "jpeg"=".\osgPlugins\jpeg\jpeg.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "pic"=".\osgPlugins\pic\pic.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "png"=".\osgPlugins\png\png.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "tga"=".\osgPlugins\tga\tga.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "tiff"=".\osgPlugins\tiff\tiff.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "osgGLUT"=".\osgGLUT\osgGLUT.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
Begin Project Dependency
Project_Dep_Name osgUtil
End Project Dependency
}}}
###############################################################################
Project: "osgUtil"=".\osgUtil\osgUtil.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name osg
End Project Dependency
}}}
###############################################################################
Project: "osg"=".\osg\osg.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

525
VisualStudio/osg/osg.dsp Executable file
View File

@ -0,0 +1,525 @@
# Microsoft Developer Studio Project File - Name="osg" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=osg - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "osg.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "osg.mak" CFG="osg - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "osg - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "osg - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "osg - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBSCENEGRAPH_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "SG_LIBRARY" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo /o"../../lib/osg.bsc"
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osg.pdb" /machine:I386 /out:"../../bin/osg.dll"
# SUBTRACT LINK32 /pdb:none
!ELSEIF "$(CFG)" == "osg - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBSCENEGRAPH_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "SG_LIBRARY" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo /o"../../lib/osg.bsc"
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osgd.pdb" /debug /machine:I386 /out:"../../bin/osgd.dll" /pdbtype:sept
# SUBTRACT LINK32 /pdb:none /incremental:no
!ENDIF
# Begin Target
# Name "osg - Win32 Release"
# Name "osg - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\Src\Osg\AlphaFunc.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Billboard.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\BoundingBox.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\BoundingSphere.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Camera.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\CullFace.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\DCS.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\DynamicLibrary.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\ExtensionSupported.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Field.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\FieldReader.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\FieldReaderIterator.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\FileNameUtils.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Fog.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Geode.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\GeoSet.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\GeoSet_ogl.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\GeoState.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Group.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Image.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Input.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Light.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\LightSource.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Lighting.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\LOD.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Material.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Matrix.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Node.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\NodeVisitor.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Notify.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Object.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\OSG.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Output.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Point.cpp
# End Source File
# Begin Source File
SOURCE=..\..\src\osg\PolygonOffset.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Quat.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\ReaderWriterOSG.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\ReaderWriterRGB.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Registry.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Scene.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Seg.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Sequence.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Switch.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\TexEnv.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\TexGen.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\TexMat.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Texture.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Timer.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Version.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\Osg\Transparency.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter ";h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\..\Include\Osg\AlphaFunc
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Billboard
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\BoundingBox
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\BoundingSphere
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Camera
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\CullFace
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Dcs
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\DynamicLibrary
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Export
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\ExtensionSupported
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Field
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\FieldReader
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\FieldReaderIterator
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\FileNameUtils
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Fog
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Geode
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\GeoSet
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\GeoState
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Gl
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Group
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Image
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Input
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Light
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\LightSource
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Lighting
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Lod
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Material
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Matrix
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Node
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\NodeVisitor
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Notify
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Object
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Osg
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Output
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Point
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\PolygonOffset
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Quat
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Referenced
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Registry
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Scene
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Seg
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Sequence
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\State
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Switch
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\TexEnv
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\TexGen
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\TexMat
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Texture
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Timer
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Transparency
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Types
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Vec2
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Vec3
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Version
# End Source File
# Begin Source File
SOURCE=..\..\Include\Osg\Vec4
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

135
VisualStudio/osgGLUT/osgGLUT.dsp Executable file
View File

@ -0,0 +1,135 @@
# Microsoft Developer Studio Project File - Name="osgGLUT" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=osgGLUT - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "osgGLUT.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "osgGLUT.mak" CFG="osgGLUT - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "osgGLUT - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "osgGLUT - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "osgGLUT - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "../../lib"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBOSGGLUT_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /vd1 /GR /GX /O2 /I "../../include" /D "NDEBUG" /D "_MBCS" /D "_USRDLL" /D "LIBOSGGLUT_EXPORTS" /D "OSGGLUT_LIBRARY" /D "WIN32" /D "_WINDOWS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osgUtil.lib osg.lib opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osgGLUT.pdb" /machine:I386 /out:"../../bin/osgGLUT.dll" /libpath:"../../lib"
# SUBTRACT LINK32 /pdb:none
!ELSEIF "$(CFG)" == "osgGLUT - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBOSGGLUT_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../include" /D "_DEBUG" /D "OSGGLUT_LIBRARY" /D "WIN32" /D "_WINDOWS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgUtild.lib osgd.lib opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osgGLUTd.pdb" /debug /machine:I386 /out:"../../bin/osgGLUTd.dll" /pdbtype:sept /libpath:"../../lib"
# SUBTRACT LINK32 /pdb:none
!ENDIF
# Begin Target
# Name "osgGLUT - Win32 Release"
# Name "osgGLUT - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\Src\osgGLUT\GLUTEventAdapter.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgGLUT\Viewer.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgGLUT\Version.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter ";h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\..\Include\osgGLUT\GLUTEventAdapter
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgGLUT\Viewer
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgGLUT\Export
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgGLUT\Version
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

404
VisualStudio/osgPlugins/flt/flt.dsp Normal file
View File

@ -0,0 +1,404 @@
# Microsoft Developer Studio Project File - Name="flt" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=flt - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "flt.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "flt.mak" CFG="flt - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "flt - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "flt - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "flt - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLT_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLT_LIBRARY" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x414 /d "NDEBUG"
# ADD RSC /l 0x417 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib opengl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:none /machine:I386 /out:"../../../bin/osgdb_flt.dll" /libpath:"../../../lib"
!ELSEIF "$(CFG)" == "flt - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLT_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLT_LIBRARY" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x414 /d "_DEBUG"
# ADD RSC /l 0x417 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib glut32.lib glu32.lib opengl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../../bin/osgdb_fltd.pdb" /debug /machine:I386 /out:"../../../bin/osgdb_fltd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /pdb:none /incremental:no
!ENDIF
# Begin Target
# Name "flt - Win32 Release"
# Name "flt - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\BoundingVolumeRecords.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ColorPaletteRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\CommentRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ControlRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\DofRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ExtensionRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ExternalRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\FaceRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\flt.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\flt2osg.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\FltFile.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\GeoSetBuilder.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\GroupRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\HeaderRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Input.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\InstanceRecords.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightPointRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightSourcePaletteRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightSourceRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LodRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LongIDRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\MaterialPaletteRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ObjectRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\OldVertexRecords.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Pool.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ReaderWriterFLT.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Record.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\RecordVisitor.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Registry.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\SwitchRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TextureMappingPaletteRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TexturePaletteRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TransformationRecords.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\UnknownRecord.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\VertexPoolRecords.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl;"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\BoundingVolumeRecords.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ColorPaletteRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\CommentRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ControlRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\DofRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\export.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ExtensionRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ExternalRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\FaceRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\flt.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\flt2osg.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\FltFile.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\FltRecords.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\GeoSetBuilder.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\GroupRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\HeaderRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Input.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\InstanceRecords.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightPointRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightSourcePaletteRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LightSourceRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LodRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\LongIDRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\MaterialPaletteRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ObjectRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\OldVertexRecords.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\opcodes.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Pool.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\ReaderWriterFLT.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Record.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\RecordVisitor.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Referenced.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\Registry.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\SwitchRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TextureMappingPaletteRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TexturePaletteRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\TransformationRecords.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\UnknownRecord.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\VertexPoolRecords.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\flt\license.txt
# End Source File
# End Group
# End Target
# End Project

155
VisualStudio/osgPlugins/fly/fly.dsp Executable file
View File

@ -0,0 +1,155 @@
# Microsoft Developer Studio Project File - Name="fly" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=fly - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "fly.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "fly.mak" CFG="fly - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "fly - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "fly - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "fly - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLY_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLY_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_fly.dll" /libpath:"../../../lib"
!ELSEIF "$(CFG)" == "fly - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLY_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FLY_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib glu32.lib opengl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_flyd.dll" /pdbtype:sept /libpath:"../../../lib"
!ENDIF
# Begin Target
# Name "fly - Win32 Release"
# Name "fly - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Base.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Fly.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Hat.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Matrix.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Sky.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Tank.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Terrain.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Trees.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Vector.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Hat.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Matrix.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\terrain_data.h
# End Source File
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\Fly\Vector.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/gif/gif.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="gif" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=gif - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "gif.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "gif.mak" CFG="gif - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "gif - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "gif - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "gif - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "gif_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "gif_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC ungif.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_gif.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "gif - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "gif_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GIF_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC ungif.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_gifd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "gif - Win32 Release"
# Name "gif - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\gif\ReaderWriterGIF.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/jpeg/jpeg.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="jpeg" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=jpeg - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "jpeg.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "jpeg.mak" CFG="jpeg - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "jpeg - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "jpeg - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "jpeg - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "jpeg_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "jpeg_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_jpeg.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "jpeg - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "jpeg_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "JPEG_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_jpegd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "jpeg - Win32 Release"
# Name "jpeg - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\jpeg\ReaderWriterJPEG.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/pic/pic.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="pic" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=pic - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "pic.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "pic.mak" CFG="pic - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "pic - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "pic - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "pic - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "pic_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "pic_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_pic.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "pic - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "pic_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PIC_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_picd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "pic - Win32 Release"
# Name "pic - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\pic\ReaderWriterPIC.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/png/png.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="png" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=png - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "png.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "png.mak" CFG="png - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "png - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "png - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "png - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "png_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "png_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC libpng.lib zlibstat.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_png.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "png - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "png_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PNG_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC libpng.lib zlibstat.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_pngd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "png - Win32 Release"
# Name "png - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\png\ReaderWriterPNG.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/tga/tga.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="tga" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=tga - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "tga.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "tga.mak" CFG="tga - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "tga - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "tga - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "tga - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tga_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tga_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_tga.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "tga - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tga_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TGA_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_tgad.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "tga - Win32 Release"
# Name "tga - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\tga\ReaderWriterTGA.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

109
VisualStudio/osgPlugins/tiff/tiff.dsp Executable file
View File

@ -0,0 +1,109 @@
# Microsoft Developer Studio Project File - Name="tiff" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=tiff - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "tiff.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "tiff.mak" CFG="tiff - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "tiff - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "tiff - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "tiff - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tiff_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GR /GX /O2 /I "../../../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tiff_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib /NODEFAULTLIB:LIBC tiff.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"../../../bin/osgdb_tiff.dll" /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ELSEIF "$(CFG)" == "tiff - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "tiff_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TIFF_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib /NODEFAULTLIB:LIBC tiff.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"../../../bin/osgdb_tiffd.dll" /pdbtype:sept /libpath:"../../../lib"
# SUBTRACT LINK32 /nodefaultlib
!ENDIF
# Begin Target
# Name "tiff - Win32 Release"
# Name "tiff - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\src\osgPlugins\tiff\ReaderWriterTIFF.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

189
VisualStudio/osgUtil/osgUtil.dsp Executable file
View File

@ -0,0 +1,189 @@
# Microsoft Developer Studio Project File - Name="osgUtil" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=osgUtil - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "osgUtil.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "osgUtil.mak" CFG="osgUtil - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "osgUtil - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "osgUtil - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "osgUtil - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "../../lib"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBOSGUTIL_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /vd1 /GR /GX /O2 /I "../../include" /D "NDEBUG" /D "_MBCS" /D "_USRDLL" /D "LIBOSGUTIL_EXPORTS" /D "OSGUTIL_LIBRARY" /D "WIN32" /D "_WINDOWS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 osg.lib opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osgUtil.pdb" /machine:I386 /out:"../../bin/osgUtil.dll" /libpath:"../../lib"
# SUBTRACT LINK32 /pdb:none
!ELSEIF "$(CFG)" == "osgUtil - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "../../lib"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LIBOSGUTIL_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /vmg /vd0 /GR /GX /ZI /Od /I "../../include" /D "_DEBUG" /D "OSGUTIL_LIBRARY" /D "WIN32" /D "_WINDOWS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 osgd.lib opengl32.lib glu32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /pdb:"../../bin/osgUtild.pdb" /debug /machine:I386 /out:"../../bin/osgUtild.dll" /pdbtype:sept /libpath:"../../lib"
# SUBTRACT LINK32 /pdb:none
!ENDIF
# Begin Target
# Name "osgUtil - Win32 Release"
# Name "osgUtil - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\Src\osgUtil\CameraManipulator.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\DisplayListVisitor.cpp
# End Source File
# Begin Source File
SOURCE=..\..\src\osgUtil\DriveManipulator.cpp
# End Source File
# Begin Source File
SOURCE=..\..\src\osgUtil\FlightManipulator.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\IntersectVisitor.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\RenderVisitor.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\SceneView.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\Version.cpp
# End Source File
# Begin Source File
SOURCE=..\..\Src\osgUtil\TrackballManipulator.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter ";h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\..\Include\osgUtil\CameraManipulator
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\DisplayListVisitor
# End Source File
# Begin Source File
SOURCE=..\..\include\osgUtil\DriveManipulator
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\Export
# End Source File
# Begin Source File
SOURCE=..\..\include\osgUtil\FlightManipulator
# End Source File
# Begin Source File
SOURCE=..\..\include\osgUtil\GUIActionAdapter
# End Source File
# Begin Source File
SOURCE=..\..\include\osgUtil\GUIEventAdapter
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\IntersectVisitor
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\RenderVisitor
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\SceneView
# End Source File
# Begin Source File
SOURCE=..\..\Include\osgUtil\Version
# End Source File
# Begin Source File
SOURCE=..\..\include\osgUtil\TrackballManipulator
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

BIN
dist/.osg.spec.swp vendored Normal file
View File

Binary file not shown.

16
dist/Irix/Makefile vendored Normal file
View File

@ -0,0 +1,16 @@
SHELL = /bin/sh
all : irixdist tardist
irixdist :
cd ${OSGHOME}; [ -d irixdist ] || mkdir irixdist
cd ${OSGHOME}; \
/usr/sbin/gendist -sbase ${OSGHOME} -idb dist/Irix/osg.idb -spec dist/Irix/osg.spec -dist irixdist -all
tardist : irixdist
cd ${OSGHOME}/irixdist;\
tar cvf osg.tardist osg osg.idb osg.sw

80
dist/Irix/osg.idb vendored Normal file
View File

@ -0,0 +1,80 @@
f 0755 root sys usr/bin/sgv bin/sgv osg.sw.base
d 0755 root sys usr/include/osg include/osg osg.sw.base
f 0666 root sys usr/include/osg/AlphaFunc include/osg/AlphaFunc osg.sw.base
f 0666 root sys usr/include/osg/Billboard include/osg/Billboard osg.sw.base
f 0666 root sys usr/include/osg/BoundingBox include/osg/BoundingBox osg.sw.base
f 0666 root sys usr/include/osg/BoundingSphere include/osg/BoundingSphere osg.sw.base
f 0666 root sys usr/include/osg/Camera include/osg/Camera osg.sw.base
f 0666 root sys usr/include/osg/CullFace include/osg/CullFace osg.sw.base
f 0666 root sys usr/include/osg/DCS include/osg/DCS osg.sw.base
f 0666 root sys usr/include/osg/DynamicLibrary include/osg/DynamicLibrary osg.sw.base
f 0666 root sys usr/include/osg/Export include/osg/Export osg.sw.base
f 0666 root sys usr/include/osg/ExtensionSupported include/osg/ExtensionSupported osg.sw.base
f 0666 root sys usr/include/osg/Field include/osg/Field osg.sw.base
f 0666 root sys usr/include/osg/FieldReader include/osg/FieldReader osg.sw.base
f 0666 root sys usr/include/osg/FieldReaderIterator include/osg/FieldReaderIterator osg.sw.base
f 0666 root sys usr/include/osg/FileNameUtils include/osg/FileNameUtils osg.sw.base
f 0666 root sys usr/include/osg/Fog include/osg/Fog osg.sw.base
f 0666 root sys usr/include/osg/GL include/osg/GL osg.sw.base
f 0666 root sys usr/include/osg/GeoSet include/osg/GeoSet osg.sw.base
f 0666 root sys usr/include/osg/GeoState include/osg/GeoState osg.sw.base
f 0666 root sys usr/include/osg/Geode include/osg/Geode osg.sw.base
f 0666 root sys usr/include/osg/Group include/osg/Group osg.sw.base
f 0666 root sys usr/include/osg/Image include/osg/Image osg.sw.base
f 0666 root sys usr/include/osg/Input include/osg/Input osg.sw.base
f 0666 root sys usr/include/osg/LOD include/osg/LOD osg.sw.base
f 0666 root sys usr/include/osg/Light include/osg/Light osg.sw.base
f 0666 root sys usr/include/osg/LightSource include/osg/LightSource osg.sw.base
f 0666 root sys usr/include/osg/Lighting include/osg/Lighting osg.sw.base
f 0666 root sys usr/include/osg/Material include/osg/Material osg.sw.base
f 0666 root sys usr/include/osg/Matrix include/osg/Matrix osg.sw.base
f 0666 root sys usr/include/osg/Node include/osg/Node osg.sw.base
f 0666 root sys usr/include/osg/NodeVisitor include/osg/NodeVisitor osg.sw.base
f 0666 root sys usr/include/osg/Notify include/osg/Notify osg.sw.base
f 0666 root sys usr/include/osg/OSG include/osg/OSG osg.sw.base
f 0666 root sys usr/include/osg/Object include/osg/Object osg.sw.base
f 0666 root sys usr/include/osg/Output include/osg/Output osg.sw.base
f 0666 root sys usr/include/osg/Point include/osg/Point osg.sw.base
f 0666 root sys usr/include/osg/PolygonOffset include/osg/PolygonOffset osg.sw.base
f 0666 root sys usr/include/osg/Quat include/osg/Quat osg.sw.base
f 0666 root sys usr/include/osg/Referenced include/osg/Referenced osg.sw.base
f 0666 root sys usr/include/osg/Registry include/osg/Registry osg.sw.base
f 0666 root sys usr/include/osg/Scene include/osg/Scene osg.sw.base
f 0666 root sys usr/include/osg/Seg include/osg/Seg osg.sw.base
f 0666 root sys usr/include/osg/Sequence include/osg/Sequence osg.sw.base
f 0666 root sys usr/include/osg/State include/osg/State osg.sw.base
f 0666 root sys usr/include/osg/Switch include/osg/Switch osg.sw.base
f 0666 root sys usr/include/osg/TexEnv include/osg/TexEnv osg.sw.base
f 0666 root sys usr/include/osg/TexGen include/osg/TexGen osg.sw.base
f 0666 root sys usr/include/osg/TexMat include/osg/TexMat osg.sw.base
f 0666 root sys usr/include/osg/Texture include/osg/Texture osg.sw.base
f 0666 root sys usr/include/osg/Timer include/osg/Timer osg.sw.base
f 0666 root sys usr/include/osg/Transparency include/osg/Transparency osg.sw.base
f 0666 root sys usr/include/osg/Types include/osg/Types osg.sw.base
f 0666 root sys usr/include/osg/Vec2 include/osg/Vec2 osg.sw.base
f 0666 root sys usr/include/osg/Vec3 include/osg/Vec3 osg.sw.base
f 0666 root sys usr/include/osg/Vec4 include/osg/Vec4 osg.sw.base
f 0666 root sys usr/include/osg/Version include/osg/Version osg.sw.base
d 0750 root sys usr/include/osgUtil include/osgUtil osg.sw.base
f 0666 root sys usr/include/osgUtil/CameraManipulator include/osgUtil/CameraManipulator osg.sw.base
f 0666 root sys usr/include/osgUtil/DisplayListVisitor include/osgUtil/DisplayListVisitor osg.sw.base
f 0666 root sys usr/include/osgUtil/DriveManipulator include/osgUtil/DriveManipulator osg.sw.base
f 0666 root sys usr/include/osgUtil/Export include/osgUtil/Export osg.sw.base
f 0666 root sys usr/include/osgUtil/FlightManipulator include/osgUtil/FlightManipulator osg.sw.base
f 0666 root sys usr/include/osgUtil/GUIActionAdapter include/osgUtil/GUIActionAdapter osg.sw.base
f 0666 root sys usr/include/osgUtil/GUIEventAdapter include/osgUtil/GUIEventAdapter osg.sw.base
f 0666 root sys usr/include/osgUtil/IntersectVisitor include/osgUtil/IntersectVisitor osg.sw.base
f 0666 root sys usr/include/osgUtil/RenderVisitor include/osgUtil/RenderVisitor osg.sw.base
f 0666 root sys usr/include/osgUtil/SceneView include/osgUtil/SceneView osg.sw.base
f 0666 root sys usr/include/osgUtil/TrackballManipulator include/osgUtil/TrackballManipulator osg.sw.base
f 0666 root sys usr/include/osgUtil/Version include/osgUtil/Version osg.sw.base
f 0755 root sys usr/lib32/libosg.so lib/libosg.so osg.sw.base
f 0755 root sys usr/lib32/libosgUtil.so lib/libosgUtil.so osg.sw.base
d 0755 root sys usr/lib32/osgPlugins lib/osgPlugins osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_flt.so lib/osgPlugins/osgdb_flt.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_fly.so lib/osgPlugins/osgdb_fly.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_jpg.so lib/osgPlugins/osgdb_jpg.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_osgtgz.so lib/osgPlugins/osgdb_osgtgz.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_pic.so lib/osgPlugins/osgdb_pic.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_tga.so lib/osgPlugins/osgdb_tga.so osg.sw.base
f 0755 root sys usr/lib32/osgPlugins/osgdb_tif.so lib/osgPlugins/osgdb_tif.so osg.sw.base

13
dist/Irix/osg.spec vendored Normal file
View File

@ -0,0 +1,13 @@
product osg
id "OpenSceneGraph"
image sw
id "Software"
version 1
order 9999
subsys base default
id "Base Software"
replaces self
exp osg.sw.base
endsubsys
endimage
endproduct

29
dist/RedHatRPM/Makefile vendored Normal file
View File

@ -0,0 +1,29 @@
SHELL = /bin/sh
BINDIRS = \
OpenSceneGraph-${OSGVERSION}/bin/\
OpenSceneGraph-${OSGVERSION}/include/\
OpenSceneGraph-${OSGVERSION}/lib/\
all :: rpm
rpm : osg.spec tardist
rpm -bb --clean osg.spec
osg.spec : makespec
makespec
tardist :
@[ -n "${OSGHOME}" ] || (echo Please define OSGHOME; exit 3)
@[ -n "${OSGVERSION}" ] || (echo Please define OSGVERSION; exit 4)
@[ -n "${OSGRELEASE}" ] || (echo Please define OSGRELEASE; exit 5)
@[ "`whoami`" = "root" ] || (echo Must be ROOT; exit 6)
(cd ${OSGHOME}/..; \
tar cf - ${BINDIRS} | gzip > \
/usr/src/redhat/SOURCES/osg-${OSGVERSION}-${OSGRELEASE}.tar.gz)
clean :
rm -f osg.spec

84
dist/RedHatRPM/makespec vendored Executable file
View File

@ -0,0 +1,84 @@
#!/bin/sh
list_install_files()
{
for d in \
${OSGHOME}/bin\
${OSGHOME}/lib\
${OSGHOME}/include
do
dd=`basename $d`
for f in `ls -1 $d`
do
echo cp -rf \
/usr/src/redhat/BUILD/OpenSceneGraph-"$OSGVERSION"/$dd/$f /usr/$dd/$f
done
done
}
list_attr_files()
{
for d in \
${OSGHOME}/bin\
${OSGHOME}/lib
do
dd=`basename $d`
for f in $d/*
do
ff=`basename $f`
echo "%attr(755, root, root) /usr/$dd/$ff"
done
done
for f in ${OSGHOME}/include/osg/*
do
ff=`basename $f`
echo "%attr(444, root, root) /usr/include/osg/$ff"
done
}
[ -z "$OSGHOME" ] && (echo Please define OSGHOME; exit 1)
[ -z "$OSGVERSION" ] && (echo Please define OSGVERSION; exit 1)
[ -z "$OSGRELEASE" ] && (echo Please define OSGRELEASE; exit 1)
cat <<-LEOF > osg.spec
Summary: Open Scene Graph
Name: OpenSceneGraph
Version: $OSGVERSION
Release: $OSGRELEASE
Copyright: GLPL
Group: Graphics
Source: osg-$OSGVERSION-$OSGRELEASE.tar.gz
URL: http://www.openscenegraph.org
Packager: `awk -f - /etc/passwd <<-EOF
BEGIN { FS=":"}
{
if( \\$1 == "$LOGNAME" )
print \\$5
}
EOF`
%description
Open Scene Graph is an open-source scene graph API.
%prep
%setup
%build
%install
`list_install_files`
# ---------------------
# FILES Sections
%files
`list_attr_files`
LEOF

32
dist/RedHatRPM/osg.spec vendored Normal file
View File

@ -0,0 +1,32 @@
Summary: Open Scene Graph
Name: OpenSceneGraph
Version: 0.8
Release: 2
Copyright: GLPL
Group: Graphics
Source: osg-0.8-2.tar.gz
URL: http://www.openscenegraph.org
Packager: Robert Osfield
%description
Open Scene Graph is an open-source scene graph API.
%prep
%setup
%build
%install
# ---------------------
# FILES Sections
%files
%attr(755, root, root) /usr/bin/*
%attr(755, root, root) /usr/lib/*
%attr(444, root, root) /usr/include/osg/*

708
doc/Doxyfile Normal file
View File

@ -0,0 +1,708 @@
# Doxyfile 1.2.2
# This file describes the settings to be used by doxygen for a project
#
# All text after a hash (#) is considered a comment and will be ignored
# The format is:
# TAG = value [value, ...]
# For lists items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ")
#---------------------------------------------------------------------------
# General configuration options
#---------------------------------------------------------------------------
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.
PROJECT_NAME = "OpenSceneGraph & Utility Toolkit"
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = 0.8-26
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.
OUTPUT_DIRECTORY = $(OSGHOME)/docs/doxygen
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Dutch, French, Italian, Czech, Swedish, German, Finnish, Japanese,
# Korean, Hungarian, Spanish, Romanian, Russian, Croatian, Polish, and
# Portuguese.
OUTPUT_LANGUAGE = English
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
EXTRACT_ALL = YES
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
EXTRACT_PRIVATE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
EXTRACT_STATIC = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_MEMBERS = NO
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these class will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_CLASSES = NO
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
REPEAT_BRIEF = YES
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.
ALWAYS_DETAILED_SEC = NO
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.
FULL_PATH_NAMES = NO
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. It is allowed to use relative paths in the argument list.
STRIP_FROM_PATH =
# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.
INTERNAL_DOCS = NO
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a class diagram (in Html and LaTeX) for classes with base or
# super classes. Setting the tag to NO turns the diagrams off.
CLASS_DIAGRAMS = YES
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C and C++ comments will always remain visible.
STRIP_CODE_COMMENTS = YES
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower case letters. If set to YES upper case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# users are adviced to set this option to NO.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.
HIDE_SCOPE_NAMES = NO
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.
VERBATIM_HEADERS = YES
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put list of the files that are included by a file in the documentation
# of that file.
SHOW_INCLUDE_FILES = YES
# If the JAVADOC_AUTOBRIEF tag is set to YES (the default) then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the Javadoc-style will
# behave just like the Qt-style comments.
JAVADOC_AUTOBRIEF = YES
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# reimplements.
INHERIT_DOCS = YES
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.
SORT_MEMBER_DOCS = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
DISTRIBUTE_GROUP_DOC = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.
TAB_SIZE = 8
# The ENABLE_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.
ENABLED_SECTIONS =
# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.
GENERATE_TODOLIST = YES
# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.
GENERATE_TESTLIST = YES
# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.
ALIASES =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.
QUIET = NO
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.
WARNINGS = YES
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.
WARN_IF_UNDOCUMENTED = YES
# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text.
WARN_FORMAT = "$file:$line: $text"
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = $(OSGHOME)
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
FILE_PATTERNS = */include/* */src/*/*.cpp
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.
RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE =
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories.
EXCLUDE_PATTERNS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).
EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
EXAMPLE_PATTERNS =
# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH =
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command <filter> <input-file>, where <filter>
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
INPUT_FILTER =
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = YES
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.
GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.
HTML_OUTPUT = html
# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet
HTML_STYLESHEET =
# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
# files or namespaces will be aligned in HTML using tables. If set to
# NO a bullet list will be used.
HTML_ALIGN_MEMBERS = YES
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
# of the generated HTML documentation.
GENERATE_HTMLHELP = NO
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
# top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it.
DISABLE_INDEX = NO
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.
GENERATE_LATEX = NO
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.
LATEX_OUTPUT = latex
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, a4wide, letter, legal and
# executive. If left blank a4wide will be used.
PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.
EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!
LATEX_HEADER =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.
PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.
USE_PDFLATEX = NO
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimised for Word 97 and may not look very pretty with
# other RTF readers or editors.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using a WORD or other.
# programs which support those fields.
# Note: wordpad (write) and others do not support links.
RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assigments. You only have to provide
# replacements, missing definitions are set to their default value.
RTF_STYLESHEET_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages
GENERATE_MAN = YES
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)
MAN_EXTENSION = .3
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation. Warning: This feature
# is still experimental and very incomplete.
GENERATE_XML = NO
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = NO
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_PREDEFINED tags.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# in the INCLUDE_PATH (see below) will be search if a #include is found.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.
INCLUDE_PATH =
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.
INCLUDE_FILE_PATTERNS =
# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed.
PREDEFINED =
# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition.
EXPAND_AS_DEFINED =
#---------------------------------------------------------------------------
# Configuration::addtions related to external references
#---------------------------------------------------------------------------
# The TAGFILES tag can be used to specify one or more tagfiles.
TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.
GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.
ALLEXTERNALS = NO
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)
HAVE_DOT = YES
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# the CLASS_DIAGRAMS tag to NO.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.
COLLABORATION_GRAPH = YES
# If the ENABLE_PREPROCESSING, INCLUDE_GRAPH, and HAVE_DOT tags are set to
# YES then doxygen will generate a graph for each documented file showing
# the direct and indirect include dependencies of the file with other
# documented files.
INCLUDE_GRAPH = YES
# If the ENABLE_PREPROCESSING, INCLUDED_BY_GRAPH, and HAVE_DOT tags are set to
# YES then doxygen will generate a graph for each documented header file showing
# the documented files that directly or indirectly include this file
INCLUDED_BY_GRAPH = YES
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will graphical hierarchy of all classes instead of a textual one.
GRAPHICAL_HIERARCHY = YES
# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found on the path.
DOT_PATH =
# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
# this value, doxygen will try to truncate the graph, so that it fits within
# the specified constraint. Beware that most browsers cannot cope with very
# large images.
MAX_DOT_GRAPH_WIDTH = 1024
# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
# this value, doxygen will try to truncate the graph, so that it fits within
# the specified constraint. Beware that most browsers cannot cope with very
# large images.
MAX_DOT_GRAPH_HEIGHT = 1024
#---------------------------------------------------------------------------
# Configuration::addtions related to the search engine
#---------------------------------------------------------------------------
# The SEARCHENGINE tag specifies whether or not a search engine should be
# used. If set to NO the values of all tags below this one will be ignored.
SEARCHENGINE = NO
# The CGI_NAME tag should be the name of the CGI script that
# starts the search engine (doxysearch) with the correct parameters.
# A script with this name will be generated by doxygen.
CGI_NAME = search.cgi
# The CGI_URL tag should be the absolute URL to the directory where the
# cgi binaries are located. See the documentation of your http daemon for
# details.
CGI_URL =
# The DOC_URL tag should be the absolute URL to the directory where the
# documentation is located. If left blank the absolute path to the
# documentation, with file:// prepended to it, will be used.
DOC_URL =
# The DOC_ABSPATH tag should be the absolute path to the directory where the
# documentation is located. If left blank the directory on the local machine
# will be used.
DOC_ABSPATH =
# The BIN_ABSPATH tag must point to the directory where the doxysearch binary
# is installed.
BIN_ABSPATH = /usr/local/bin/
# The EXT_DOC_PATHS tag can be used to specify one or more paths to
# documentation generated for other projects. This allows doxysearch to search
# the documentation for these projects as well.
EXT_DOC_PATHS =

BIN
doc/MindMaps/DesignPatterns.mmp Normal file
View File

Binary file not shown.

BIN
doc/MindMaps/DesignPatterns/DesignPatterns.gif Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

16
doc/MindMaps/DesignPatterns/DesignPatterns.html Executable file
View File

@ -0,0 +1,16 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="generator" content="MindManager v4.0.60">
<meta name="author" content="Mindjet LLC">
<title>Design Patterns</title></head>
<body bgcolor="#ffffff">
<!-- To copy the MindManager image map please begin here (with next <center> tag) -->
<center><img src="DesignPatterns.gif" border="0" usemap="#mindmap"></center><map name="mindmap">
</map>
<!-- Copy until here (including the </map> tag) -->
</body></html>

BIN
doc/MindMaps/Mission.mmp Normal file
View File

Binary file not shown.

BIN
doc/MindMaps/Mission/Mission.gif Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

16
doc/MindMaps/Mission/Mission.html Executable file
View File

@ -0,0 +1,16 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="generator" content="MindManager v4.0.60">
<meta name="author" content="">
<title>Mission</title></head>
<body bgcolor="#ffffff">
<!-- To copy the MindManager image map please begin here (with next <center> tag) -->
<center><img src="Mission.gif" border="0" usemap="#mindmap"></center><map name="mindmap">
</map>
<!-- Copy until here (including the </map> tag) -->
</body></html>

BIN
doc/UML/osg.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 69 KiB

BIN
doc/UML/osgutils.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB

35
doc/index.html Normal file
View File

@ -0,0 +1,35 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="GENERATOR" content="Mozilla/4.6 [en-gb]C-CCK-MCD NetscapeOnline.co.uk (Win95; I) [Netscape]">
<title>OSG Documentation</title>
</head>
<body>
<center>
<h1>
<b><i><u>Open Scene Graph Documentation</u></i></b></h1></center>
The documentation on the OSG is still in its early stages, and far from
complete. If you can't find your answers in what documentation there currently
is, please feel free to post the question on the OSG mailing list.<u></u>
<p><u><a href="../index.html">Introduction, distribution contents and contacts</a></u><u></u>
<p><u>Reference guides (automatically generated using doc++)</u>
<blockquote><a href="osg/HIER.html">osg/</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
core scene graph reference guide.
<br><a href="osgUtil/HIER.html">osgUtil/</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
scene graph utilities reference guide.
<br><a href="osgGLUT/HIER.html">osgGLUT/</a>&nbsp;&nbsp;&nbsp;&nbsp; simple
GLUT based viewer base classes reference guide.</blockquote>
<u>UML Diagrams</u>
<blockquote><a href="UML/osg.png">osg</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
UML diagram of the osg core library
<br><a href="UML/osgutils.png">osgUtil</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
UML diagram of the osg utilities library</blockquote>
<u>Mind Maps</u>
<blockquote><a href="MindMaps/DesignPatterns/DesignPatterns.html">Design
Pattern used in the OSG.</a>
<br><a href="MindMaps/Mission/Mission.html">Mission Statement for OSG.</a></blockquote>
</body>
</html>

245
doc/osg/AlphaFunc.html Normal file
View File

@ -0,0 +1,245 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::AlphaFunc</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::AlphaFunc</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Encapsulte OpenGL glAlphaFunc</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CAlphaFunc,MAlphaFunc.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.1.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>ComparisonFunction</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.1.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>AlphaFunc</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="AlphaFunc.html#DOC.2.1.2">AlphaFunc</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFunction</B>(<!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> func, float <!1><A HREF="Referenced.html#DOC.2.43.1">ref</A>)
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> <B>getFunction</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getRefrenceValue</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.1.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> <B>_comparisonFunc</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_referenceValue</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.1.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~AlphaFunc</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchFuncStr</B>(const char* str, <!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A>&amp; func)
<DD><I></I>
<DT>
<A HREF="#DOC.2.1.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>getFuncStr</B>(<!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> func)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Encapsulte OpenGL glAlphaFunc</BLOCKQUOTE>
<DL>
<A NAME="ComparisonFunction">
<A NAME="DOC.2.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum ComparisonFunction</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="NEVER">
<A NAME="DOC.2.1.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NEVER</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LESS">
<A NAME="DOC.2.1.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LESS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="EQUAL">
<A NAME="DOC.2.1.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> EQUAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LEQUAL">
<A NAME="DOC.2.1.1.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LEQUAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="GREATER">
<A NAME="DOC.2.1.1.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GREATER</B></TT>
<DL><DT><DD></DL><P>
<A NAME="NOTEQUAL">
<A NAME="DOC.2.1.1.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NOTEQUAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="GEQUAL">
<A NAME="DOC.2.1.1.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GEQUAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ALWAYS">
<A NAME="DOC.2.1.1.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ALWAYS</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="AlphaFunc">
<A NAME="DOC.2.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> AlphaFunc()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="AlphaFunc.html#DOC.2.1.2">AlphaFunc</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.1.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.1.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.1.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setFunction">
<A NAME="DOC.2.1.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFunction(<!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> func, float <!1><A HREF="Referenced.html#DOC.2.43.1">ref</A>)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFunction">
<A NAME="DOC.2.1.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> getFunction() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getRefrenceValue">
<A NAME="DOC.2.1.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getRefrenceValue() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="enable">
<A NAME="DOC.2.1.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.1.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.1.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~AlphaFunc">
<A NAME="DOC.2.1.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~AlphaFunc()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.1.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.1.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchFuncStr">
<A NAME="DOC.2.1.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchFuncStr(const char* str, <!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A>&amp; func)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFuncStr">
<A NAME="DOC.2.1.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* getFuncStr(<!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> func)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_comparisonFunc">
<A NAME="DOC.2.1.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="AlphaFunc.html#DOC.2.1.1">ComparisonFunction</A> _comparisonFunc</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_referenceValue">
<A NAME="DOC.2.1.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _referenceValue</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

394
doc/osg/Billboard.html Normal file
View File

@ -0,0 +1,394 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Billboard</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Billboard</A>: public <!1><A HREF="Geode.html#DOC.2.17.10">Geode</A></H2>
<BLOCKQUOTE>Billboard - a Geode which orientates its child osg::GeoSet's to face the eye point.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=155>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGeode,MGeode.html,CBillboard,MBillboard.html">
<param name=before value="M,M,M,M,M">
<param name=after value="Md_SPSPSP,Md_SPSP,Md_SP,Md_,M">
<param name=indent value="0,1,2,3,4">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.2.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>Mode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.2.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Billboard</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAxis</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; axis)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>getAxis</B>(<!1><A HREF="Vec3.html">Vec3</A>&amp; axis) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setMode</B>(<!1><A HREF="Billboard.html#DOC.2.2.1">Mode</A> mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getMode</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setPos</B>(int i, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>getPos</B>(int i, <!1><A HREF="Vec3.html">Vec3</A>&amp; pos) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>addGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )
<DD><I>Add GeoSet to Billboard with default position(0,0,0); If gset not NULL and is not contained in Billboard then increment its reference count, and dirty the bounding box to cause it to recompute on next getBound() and return true for success.</I>
<DT>
<A HREF="#DOC.2.2.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>addGeoSet</B>(<!1><A HREF="GeoSet.html">GeoSet</A> *gset, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos)
<DD><I>Add GeoSet to Geode at position pos.</I>
<DT>
<A HREF="#DOC.2.2.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>removeGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )
<DD><I>Remove GeoSet and associated position from Billboard.</I>
<DT>
<A HREF="#DOC.2.2.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>calcRotation</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos_local, <!1><A HREF="Matrix.html">Matrix</A>&amp; mat)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>calcTransform</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos_local, <!1><A HREF="Matrix.html">Matrix</A>&amp; mat)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.2.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Billboard.html#DOC.2.2.1">Mode</A> <B>_mode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_axis</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Billboard.html#DOC.2.2.22">PositionList</A> <B>_positionList</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.2.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Billboard</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.2.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>computeBound</B>( void )
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected</H3><DD><DT>
<A HREF="#DOC.2.2.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="Vec3.html">Vec3</A>&gt; <B>PositionList</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Geode.html">Geode</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>replaceGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *origGset, <!1><A HREF="GeoSet.html">GeoSet</A> *newGset )
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumGeosets</B>( void ) const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="GeoSet.html">GeoSet</A>* <B>getGeoSet</B>( int i )
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>containsGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)
<DT>
<IMG ALT="o" SRC=icon2.gif>GeoSetList::iterator <B>findGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>compileGeoSets</B>( void )
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt; <!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="GeoSet.html">GeoSet</A>&gt; &gt; <B>GeoSetList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Geode.html#DOC.2.17.9">GeoSetList</A> <B>_geosets</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Billboard - a Geode which orientates its child osg::GeoSet's to face
the eye point.
Typical uses are for trees, or particle explosions.</BLOCKQUOTE>
<DL>
<A NAME="Mode">
<A NAME="DOC.2.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum Mode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="AXIAL_ROT">
<A NAME="DOC.2.2.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> AXIAL_ROT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POINT_ROT_EYE">
<A NAME="DOC.2.2.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POINT_ROT_EYE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POINT_ROT_WORLD">
<A NAME="DOC.2.2.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POINT_ROT_WORLD</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="Billboard">
<A NAME="DOC.2.2.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Billboard()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.2.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.2.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.2.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.2.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setAxis">
<A NAME="DOC.2.2.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAxis(const <!1><A HREF="Vec3.html">Vec3</A>&amp; axis)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getAxis">
<A NAME="DOC.2.2.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void getAxis(<!1><A HREF="Vec3.html">Vec3</A>&amp; axis) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setMode">
<A NAME="DOC.2.2.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setMode(<!1><A HREF="Billboard.html#DOC.2.2.1">Mode</A> mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getMode">
<A NAME="DOC.2.2.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getMode() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setPos">
<A NAME="DOC.2.2.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setPos(int i, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getPos">
<A NAME="DOC.2.2.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void getPos(int i, <!1><A HREF="Vec3.html">Vec3</A>&amp; pos) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="addGeoSet">
<A NAME="DOC.2.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool addGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )</B></TT>
<DD>Add GeoSet to Billboard with default position(0,0,0);
If gset not NULL and is not contained in Billboard then increment its
reference count, and dirty the bounding box to cause it to recompute on
next getBound() and return true for success. Otherwise return false.
<DL><DT><DD></DL><P>
<A NAME="addGeoSet">
<A NAME="DOC.2.2.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool addGeoSet(<!1><A HREF="GeoSet.html">GeoSet</A> *gset, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos)</B></TT>
<DD>Add GeoSet to Geode at position pos.
If gset not NULL and is not contained in Billboard then increment its
reference count, and dirty the bounding box to cause it to recompute on
next getBound() and return true for success. Otherwise return false.
<DL><DT><DD></DL><P>
<A NAME="removeGeoSet">
<A NAME="DOC.2.2.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool removeGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )</B></TT>
<DD>Remove GeoSet and associated position from Billboard.
If gset is contained in Billboard then remove it from the geoset
list and decrement its reference count, and dirty the
bounding box to cause it to recompute on next getBound() and
return true for success. If gset is not found then return false
and do not the reference count of gset is left unchanged.
<DL><DT><DD></DL><P>
<A NAME="calcRotation">
<A NAME="DOC.2.2.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void calcRotation(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos_local, <!1><A HREF="Matrix.html">Matrix</A>&amp; mat)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="calcTransform">
<A NAME="DOC.2.2.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void calcTransform(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, const <!1><A HREF="Vec3.html">Vec3</A>&amp; pos_local, <!1><A HREF="Matrix.html">Matrix</A>&amp; mat)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Billboard">
<A NAME="DOC.2.2.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Billboard()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.2.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.2.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.2.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool computeBound( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="PositionList">
<A NAME="DOC.2.2.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="Vec3.html">Vec3</A>&gt; PositionList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_mode">
<A NAME="DOC.2.2.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Billboard.html#DOC.2.2.1">Mode</A> _mode</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_axis">
<A NAME="DOC.2.2.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _axis</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_positionList">
<A NAME="DOC.2.2.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Billboard.html#DOC.2.2.22">PositionList</A> _positionList</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

234
doc/osg/BoundingBox.html Normal file
View File

@ -0,0 +1,234 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::BoundingBox</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::BoundingBox</A></H2>
<BLOCKQUOTE>General purpose axis-aligned bounding box class for enclosing objects/vertices.</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.3.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_min</B>
<DD><I>The corner with the smallest values for each coordinate of the bounding box</I>
<DT>
<A HREF="#DOC.2.3.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_max</B>
<DD><I>The corner with the largest values for each coordinate of the bounding box</I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.3.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>BoundingBox</B>()
<DD><I>construct to invalid values to represent an unset bounding box</I>
<DT>
<A HREF="#DOC.2.3.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>init</B>()
<DD><I>initialize to invalid values to represent an unset bounding box</I>
<DT>
<A HREF="#DOC.2.3.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isValid</B>() const
<DD><I>return true if the bounding box contains valid values, false if the bounding box is effectively unset/empty</I>
<DT>
<A HREF="#DOC.2.3.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>xMin</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>xMin</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>yMin</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>yMin</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>zMin</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>zMin</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>xMax</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>xMax</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>yMax</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>yMax</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>zMax</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>zMax</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.3.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>center</B>() const
<DD><I>Calculate and return the center of the bounding box</I>
<DT>
<A HREF="#DOC.2.3.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>radius</B>() const
<DD><I>Calculate and return the radius of the bounding box</I>
<DT>
<A HREF="#DOC.2.3.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>radius2</B>() const
<DD><I>Calculate and return the radius squared of the bounding box.</I>
<DT>
<A HREF="#DOC.2.3.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>corner</B>(unsigned int pos) const
<DD><I>return the corner of the bounding box.</I>
<DT>
<A HREF="#DOC.2.3.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandBy</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)
<DD><I>If the vertex is outwith the box expand to ecompass vertex.</I>
<DT>
<A HREF="#DOC.2.3.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandBy</B>(const <!1><A HREF="BoundingBox.html#DOC.2.3.3">BoundingBox</A>&amp; bb)
<DD><I>If incomming box is outwith the box expand to ecompass incomming box.</I>
<DT>
<A HREF="#DOC.2.3.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandBy</B>(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; sh)
<DD><I>If incomming sphere is outwith the box expand to ecompass incomming sphere.</I>
<DT>
<A HREF="#DOC.2.3.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>contains</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)
<DD><I>return true is vertex v is within the box</I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>General purpose axis-aligned bounding box class for enclosing objects/vertices.
Used to bounding the leaf objects in the scene,
i.e. osg::GeoSet's to assist in view frustum culling etc.</BLOCKQUOTE>
<DL>
<A NAME="_min">
<A NAME="DOC.2.3.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _min</B></TT>
<DD>The corner with the smallest values for each coordinate of the
bounding box
<DL><DT><DD></DL><P>
<A NAME="_max">
<A NAME="DOC.2.3.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _max</B></TT>
<DD>The corner with the largest values for each coordinate of the
bounding box
<DL><DT><DD></DL><P>
<A NAME="BoundingBox">
<A NAME="DOC.2.3.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BoundingBox()</B></TT>
<DD>construct to invalid values to represent an unset bounding box
<DL><DT><DD></DL><P>
<A NAME="init">
<A NAME="DOC.2.3.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void init()</B></TT>
<DD>initialize to invalid values to represent an unset bounding box
<DL><DT><DD></DL><P>
<A NAME="isValid">
<A NAME="DOC.2.3.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isValid() const </B></TT>
<DD>return true if the bounding box contains valid values,
false if the bounding box is effectively unset/empty
<DL><DT><DD></DL><P>
<A NAME="xMin">
<A NAME="DOC.2.3.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; xMin()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="xMin">
<A NAME="DOC.2.3.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float xMin() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="yMin">
<A NAME="DOC.2.3.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; yMin()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="yMin">
<A NAME="DOC.2.3.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float yMin() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="zMin">
<A NAME="DOC.2.3.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; zMin()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="zMin">
<A NAME="DOC.2.3.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float zMin() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="xMax">
<A NAME="DOC.2.3.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; xMax()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="xMax">
<A NAME="DOC.2.3.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float xMax() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="yMax">
<A NAME="DOC.2.3.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; yMax()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="yMax">
<A NAME="DOC.2.3.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float yMax() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="zMax">
<A NAME="DOC.2.3.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; zMax()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="zMax">
<A NAME="DOC.2.3.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float zMax() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="center">
<A NAME="DOC.2.3.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> center() const </B></TT>
<DD>Calculate and return the center of the bounding box
<DL><DT><DD></DL><P>
<A NAME="radius">
<A NAME="DOC.2.3.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float radius() const </B></TT>
<DD>Calculate and return the radius of the bounding box
<DL><DT><DD></DL><P>
<A NAME="radius2">
<A NAME="DOC.2.3.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float radius2() const </B></TT>
<DD>Calculate and return the radius squared of the bounding box.
Note, radius2() is faster to calculate than radius().
<DL><DT><DD></DL><P>
<A NAME="corner">
<A NAME="DOC.2.3.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> corner(unsigned int pos) const </B></TT>
<DD>return the corner of the bounding box.
Position (pos) is specfied by a number between 0 and 7,
the first bit toggles between x min and x max, second
bit toggles between y min and y max, third bit toggles
between z min and z max.
<DL><DT><DD></DL><P>
<A NAME="expandBy">
<A NAME="DOC.2.3.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandBy(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)</B></TT>
<DD>If the vertex is outwith the box expand to ecompass vertex.
If this box is empty then move set this box's min max to vertex.
<DL><DT><DD></DL><P>
<A NAME="expandBy">
<A NAME="DOC.2.3.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandBy(const <!1><A HREF="BoundingBox.html#DOC.2.3.3">BoundingBox</A>&amp; bb)</B></TT>
<DD>If incomming box is outwith the box expand to ecompass incomming box.
If this box is empty then move set this box to incomming box.
<DL><DT><DD></DL><P>
<A NAME="expandBy">
<A NAME="DOC.2.3.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandBy(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; sh)</B></TT>
<DD>If incomming sphere is outwith the box expand to ecompass incomming sphere.
If this box is empty then move set this box to encompass the sphere.
<DL><DT><DD></DL><P>
<A NAME="contains">
<A NAME="DOC.2.3.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool contains(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)</B></TT>
<DD>return true is vertex v is within the box
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

169
doc/osg/BoundingSphere.html Normal file
View File

@ -0,0 +1,169 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::BoundingSphere</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::BoundingSphere</A></H2>
<BLOCKQUOTE>General purpose bounding sphere class for enclosing nodes/objects/vertices.</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.4.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_center</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.4.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_radius</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.4.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>BoundingSphere</B>()
<DD><I>construct to invalid values to represent an unset bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>init</B>()
<DD><I>initialize to invalid values to represent an unset bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isValid</B>() const
<DD><I>return true if the bounding sphere contains valid values, false if the bounding sphere is effectively unset</I>
<DT>
<A HREF="#DOC.2.4.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>center</B>() const
<DD><I>return the const center of the bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A>&amp; <B>center</B>()
<DD><I>return the center of the bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>radius</B>() const
<DD><I>return the const radius of the bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float&amp; <B>radius</B>()
<DD><I>return the radius of the bounding sphere</I>
<DT>
<A HREF="#DOC.2.4.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>radius2</B>() const
<DD><I>return the radius squared.</I>
<DT>
<A HREF="#DOC.2.4.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandBy</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)
<DD><I>If the vertex is outwith the sphere expand to ecompass vertex.</I>
<DT>
<A HREF="#DOC.2.4.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandRadiusBy</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)
<DD><I>If the vertex is outwith the sphere expand radius to ecompass vertex.</I>
<DT>
<A HREF="#DOC.2.4.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandBy</B>(const <!1><A HREF="BoundingSphere.html#DOC.2.4.1">BoundingSphere</A>&amp; sh)
<DD><I>If incomming sphere is outwith the sphere expand to ecompass incomming sphere.</I>
<DT>
<A HREF="#DOC.2.4.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>expandRadiusBy</B>(const <!1><A HREF="BoundingSphere.html#DOC.2.4.1">BoundingSphere</A>&amp; sh)
<DD><I>If incomming sphere is outwith the sphere expand radius to ecompass incomming sphere.</I>
<DT>
<A HREF="#DOC.2.4.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>contains</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)
<DD><I>return true is vertex v is within the sphere</I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>General purpose bounding sphere class for enclosing nodes/objects/vertices.
Used to bound internal osg::Node's in the scene,
to assist in view frustrum culling etc. Similar in function to BoundingBox
but is quicker for evaluating culling, but generally encloses a greater volume
than a BoundingBox so will not cull so aggressively.</BLOCKQUOTE>
<DL>
<A NAME="_center">
<A NAME="DOC.2.4.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _center</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_radius">
<A NAME="DOC.2.4.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _radius</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BoundingSphere">
<A NAME="DOC.2.4.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BoundingSphere()</B></TT>
<DD>construct to invalid values to represent an unset bounding sphere
<DL><DT><DD></DL><P>
<A NAME="init">
<A NAME="DOC.2.4.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void init()</B></TT>
<DD>initialize to invalid values to represent an unset bounding sphere
<DL><DT><DD></DL><P>
<A NAME="isValid">
<A NAME="DOC.2.4.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isValid() const </B></TT>
<DD>return true if the bounding sphere contains valid values,
false if the bounding sphere is effectively unset
<DL><DT><DD></DL><P>
<A NAME="center">
<A NAME="DOC.2.4.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; center() const </B></TT>
<DD>return the const center of the bounding sphere
<DL><DT><DD></DL><P>
<A NAME="center">
<A NAME="DOC.2.4.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A>&amp; center()</B></TT>
<DD>return the center of the bounding sphere
<DL><DT><DD></DL><P>
<A NAME="radius">
<A NAME="DOC.2.4.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float radius() const </B></TT>
<DD>return the const radius of the bounding sphere
<DL><DT><DD></DL><P>
<A NAME="radius">
<A NAME="DOC.2.4.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float&amp; radius()</B></TT>
<DD>return the radius of the bounding sphere
<DL><DT><DD></DL><P>
<A NAME="radius2">
<A NAME="DOC.2.4.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float radius2() const </B></TT>
<DD>return the radius squared.
Note, for performance reasons, assumes the calling method has ensured
that the sphere is valid before calling radius2(), i.e. has _radius>=0.0,
as it does not check th validity of sphere and will eroneously return a positive value.
<DL><DT><DD></DL><P>
<A NAME="expandBy">
<A NAME="DOC.2.4.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandBy(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)</B></TT>
<DD>If the vertex is outwith the sphere expand to ecompass vertex.
Calculates the combination of movement of center and radius which
minimizes the radius increase. If this sphere is empty then
move the centrer to v and set radius to 0.
<DL><DT><DD></DL><P>
<A NAME="expandRadiusBy">
<A NAME="DOC.2.4.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandRadiusBy(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)</B></TT>
<DD>If the vertex is outwith the sphere expand radius to ecompass vertex.
Unlike update, does not move the center, just increasing the radius.
If this sphere is empty then move the centrer to v and set radius to 0
<DL><DT><DD></DL><P>
<A NAME="expandBy">
<A NAME="DOC.2.4.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandBy(const <!1><A HREF="BoundingSphere.html#DOC.2.4.1">BoundingSphere</A>&amp; sh)</B></TT>
<DD>If incomming sphere is outwith the sphere expand to ecompass incomming sphere.
calculates the combination of movement of center and radius which
minimizes the radius increase. If this sphere is empty then
move the centrer to v and set radius to 0.
<DL><DT><DD></DL><P>
<A NAME="expandRadiusBy">
<A NAME="DOC.2.4.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void expandRadiusBy(const <!1><A HREF="BoundingSphere.html#DOC.2.4.1">BoundingSphere</A>&amp; sh)</B></TT>
<DD>If incomming sphere is outwith the sphere expand radius to ecompass incomming sphere.
Unlike update, does not move the center, just increasing the radius.
If this sphere is empty then move the centrer to v and set radius to 0.
<DL><DT><DD></DL><P>
<A NAME="contains">
<A NAME="DOC.2.4.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool contains(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v)</B></TT>
<DD>return true is vertex v is within the sphere
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

260
doc/osg/Camera.html Normal file
View File

@ -0,0 +1,260 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Camera</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Camera</A>: public <!1><A HREF="Referenced.html">osg::Referenced</A></H2>
<BLOCKQUOTE>Camera class for encapsulating the view position and orientation.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CCamera,MCamera.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.5.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Camera</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Camera</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFieldOfView</B>(double fovy, double aspectRatio)
<DD><I> Set field of view and window aspect ratio.</I>
<DT>
<A HREF="#DOC.2.5.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFieldOfViewY</B>(double fovy)
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>double <B>getFieldOfViewY</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAspectRatio</B>(double aspectRatio)
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>double <B>getAspectRatio</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.5.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>home</B>()
<DD><I> hardwired home view for now, looking straight down the Z axis at the origin, with 'up' being the y axis</I>
<DT>
<A HREF="#DOC.2.5.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setView</B>(<!1><A HREF="Vec3.html">Vec3</A> eyePoint, <!1><A HREF="Vec3.html">Vec3</A> lookPoint, <!1><A HREF="Vec3.html">Vec3</A> upVector)
<DD><I> Set the View, the up vector should be orthogonal to the look vector</I>
<DT>
<A HREF="#DOC.2.5.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getEyePoint</B>() const
<DD><I>get the eyepoint.</I>
<DT>
<A HREF="#DOC.2.5.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getLookPoint</B>() const
<DD><I>get the lookpoint.</I>
<DT>
<A HREF="#DOC.2.5.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getUpVector</B>() const
<DD><I>which way is up?</I>
<DT>
<A HREF="#DOC.2.5.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>getSideVector</B>() const
<DD><I>calculate side vector</I>
<DT>
<A HREF="#DOC.2.5.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>getLookVector</B>() const
<DD><I>calculate look vector</I>
<DT>
<A HREF="#DOC.2.5.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getFocalDistance</B>() const
<DD><I>calculate focal distance</I>
<DT>
<A HREF="#DOC.2.5.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNearPlane</B>(double nearPlane)
<DD><I>set the near plane.</I>
<DT>
<A HREF="#DOC.2.5.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>double <B>getNearPlane</B>() const
<DD><I>get the near plane.</I>
<DT>
<A HREF="#DOC.2.5.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFarPlane</B>(double farPlane)
<DD><I>set the far plane.</I>
<DT>
<A HREF="#DOC.2.5.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>double <B>getFarPlane</B>() const
<DD><I>get the far plane.</I>
<DT>
<A HREF="#DOC.2.5.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>draw_PROJECTION</B>() const
<DD><I>Set up the OpenGL GL_PROJECTION matrix.</I>
<DT>
<A HREF="#DOC.2.5.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>draw_MODELVIEW</B>() const
<DD><I>Set up the OpenGL GL_MODELVIEW matrix.</I>
<DT>
<A HREF="#DOC.2.5.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>mult</B>(const <!1><A HREF="Camera.html#DOC.2.5.18">Camera</A>&amp; camera, const <!1><A HREF="Matrix.html">Matrix</A>&amp; m)
<DD><I>post multiply a camera by matrix</I>
<DT>
<A HREF="#DOC.2.5.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>mult</B>(const <!1><A HREF="Matrix.html">Matrix</A>&amp; m, const <!1><A HREF="Camera.html#DOC.2.5.18">Camera</A>&amp; camera)
<DD><I>pre multiply a camera by matrix</I>
<DT>
<A HREF="#DOC.2.5.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>ensureOrthogonalUpVector</B>()
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Camera class for encapsulating the view position and orientation.
This is the first implementation of osg::Camera class and
currently is a perspective camera, but in future will be
a base class from which PerpsectivCamera,FrustumCamera and OrthoCamera
will be derived.</BLOCKQUOTE>
<DL>
<A NAME="Camera">
<A NAME="DOC.2.5.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Camera()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Camera">
<A NAME="DOC.2.5.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Camera()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setFieldOfView">
<A NAME="DOC.2.5.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFieldOfView(double fovy, double aspectRatio)</B></TT>
<DD>
Set field of view and window aspect ratio.
The parameters have the same meaning as their counterparts
in gluPerspective(fovy,aspectRatio
<DL><DT><DD></DL><P>
<A NAME="setFieldOfViewY">
<A NAME="DOC.2.5.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFieldOfViewY(double fovy)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFieldOfViewY">
<A NAME="DOC.2.5.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>double getFieldOfViewY() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setAspectRatio">
<A NAME="DOC.2.5.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAspectRatio(double aspectRatio)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getAspectRatio">
<A NAME="DOC.2.5.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>double getAspectRatio() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="home">
<A NAME="DOC.2.5.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void home()</B></TT>
<DD>
hardwired home view for now, looking straight down the
Z axis at the origin, with 'up' being the y axis
<DL><DT><DD></DL><P>
<A NAME="setView">
<A NAME="DOC.2.5.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setView(<!1><A HREF="Vec3.html">Vec3</A> eyePoint, <!1><A HREF="Vec3.html">Vec3</A> lookPoint, <!1><A HREF="Vec3.html">Vec3</A> upVector)</B></TT>
<DD>
Set the View, the up vector should be orthogonal to the
look vector
<DL><DT><DD></DL><P>
<A NAME="getEyePoint">
<A NAME="DOC.2.5.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getEyePoint() const </B></TT>
<DD>get the eyepoint.
<DL><DT><DD></DL><P>
<A NAME="getLookPoint">
<A NAME="DOC.2.5.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getLookPoint() const </B></TT>
<DD>get the lookpoint.
<DL><DT><DD></DL><P>
<A NAME="getUpVector">
<A NAME="DOC.2.5.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getUpVector() const </B></TT>
<DD>which way is up?
<DL><DT><DD></DL><P>
<A NAME="getSideVector">
<A NAME="DOC.2.5.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> getSideVector() const </B></TT>
<DD>calculate side vector
<DL><DT><DD></DL><P>
<A NAME="getLookVector">
<A NAME="DOC.2.5.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> getLookVector() const </B></TT>
<DD>calculate look vector
<DL><DT><DD></DL><P>
<A NAME="getFocalDistance">
<A NAME="DOC.2.5.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getFocalDistance() const </B></TT>
<DD>calculate focal distance
<DL><DT><DD></DL><P>
<A NAME="setNearPlane">
<A NAME="DOC.2.5.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNearPlane(double nearPlane)</B></TT>
<DD>set the near plane.
<DL><DT><DD></DL><P>
<A NAME="getNearPlane">
<A NAME="DOC.2.5.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>double getNearPlane() const </B></TT>
<DD>get the near plane.
<DL><DT><DD></DL><P>
<A NAME="setFarPlane">
<A NAME="DOC.2.5.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFarPlane(double farPlane)</B></TT>
<DD>set the far plane.
<DL><DT><DD></DL><P>
<A NAME="getFarPlane">
<A NAME="DOC.2.5.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>double getFarPlane() const </B></TT>
<DD>get the far plane.
<DL><DT><DD></DL><P>
<A NAME="draw_PROJECTION">
<A NAME="DOC.2.5.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void draw_PROJECTION() const </B></TT>
<DD>Set up the OpenGL GL_PROJECTION matrix.
Enters the GL_PROJECTION mode, sets up matrix, then
resets model GL_MODELVIEW, which is by OpenGL convention the default.
<DL><DT><DD></DL><P>
<A NAME="draw_MODELVIEW">
<A NAME="DOC.2.5.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void draw_MODELVIEW() const </B></TT>
<DD>Set up the OpenGL GL_MODELVIEW matrix.
Enters the GL_MODELVIEW mode, sets matrix to identity
and then sets matrix up according to camera, eye point, center
point and upvector.
<DL><DT><DD></DL><P>
<A NAME="mult">
<A NAME="DOC.2.5.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void mult(const <!1><A HREF="Camera.html#DOC.2.5.18">Camera</A>&amp; camera, const <!1><A HREF="Matrix.html">Matrix</A>&amp; m)</B></TT>
<DD>post multiply a camera by matrix
<DL><DT><DD></DL><P>
<A NAME="mult">
<A NAME="DOC.2.5.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void mult(const <!1><A HREF="Matrix.html">Matrix</A>&amp; m, const <!1><A HREF="Camera.html#DOC.2.5.18">Camera</A>&amp; camera)</B></TT>
<DD>pre multiply a camera by matrix
<DL><DT><DD></DL><P>
<A NAME="ensureOrthogonalUpVector">
<A NAME="DOC.2.5.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void ensureOrthogonalUpVector()</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

BIN
doc/osg/ClassGraph.class Normal file
View File

Binary file not shown.

BIN
doc/osg/ClassGraphPanel.class Normal file
View File

Binary file not shown.

BIN
doc/osg/ClassLayout.class Normal file
View File

Binary file not shown.

193
doc/osg/CullFace.html Normal file
View File

@ -0,0 +1,193 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::CullFace</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::CullFace</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Class to globally enable/disable OpenGL's polygon culling mode (GL_CULL_FACE)</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CCullFace,MCullFace.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.6.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>Mode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.6.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>CullFace</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="CullFace.html#DOC.2.6.4">CullFace</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setMode</B>(<!1><A HREF="CullFace.html#DOC.2.6.1">Mode</A> mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>()
<DD><I>Enable the polygon culling mode</I>
<DT>
<A HREF="#DOC.2.6.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>()
<DD><I>Disable the polygon culling mode</I>
<DT>
<A HREF="#DOC.2.6.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.6.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="CullFace.html#DOC.2.6.1">Mode</A> <B>_mode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.6.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~CullFace</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.6.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Class to globally enable/disable OpenGL's polygon culling mode
(GL_CULL_FACE)</BLOCKQUOTE>
<DL>
<A NAME="Mode">
<A NAME="DOC.2.6.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum Mode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="FRONT">
<A NAME="DOC.2.6.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FRONT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BACK">
<A NAME="DOC.2.6.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BACK</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FRONT_AND_BACK">
<A NAME="DOC.2.6.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FRONT_AND_BACK</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="CullFace">
<A NAME="DOC.2.6.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> CullFace()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.6.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="CullFace.html#DOC.2.6.4">CullFace</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.6.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.6.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.6.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setMode">
<A NAME="DOC.2.6.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setMode(<!1><A HREF="CullFace.html#DOC.2.6.1">Mode</A> mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="enable">
<A NAME="DOC.2.6.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable()</B></TT>
<DD>Enable the polygon culling mode
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.6.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable()</B></TT>
<DD>Disable the polygon culling mode
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.6.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~CullFace">
<A NAME="DOC.2.6.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~CullFace()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.6.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.6.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_mode">
<A NAME="DOC.2.6.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="CullFace.html#DOC.2.6.1">Mode</A> _mode</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

293
doc/osg/DCS.html Normal file
View File

@ -0,0 +1,293 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::DCS</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::DCS</A>: public <!1><A HREF="Group.html#DOC.2.18.9">Group</A></H2>
<BLOCKQUOTE>DCS - Dynamic Coordinate System a is group which all children are transformed by the the DCS's osg::Matrix.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=155>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGroup,MGroup.html,CDCS,MDCS.html">
<param name=before value="M,M,M,M,M">
<param name=after value="Md_SPSPSP,Md_SPSP,Md_SP,Md_,M">
<param name=indent value="0,1,2,3,4">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.7.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>DCS</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>DCS</B>(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setMatrix</B>(const <!1><A HREF="Matrix.html">Matrix</A>&amp; mat )
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>getMatrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preTranslate</B>( float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preRotate</B>( float deg, float x, float y, float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>computeBound</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.7.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>_mat</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.7.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~DCS</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.7.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Group.html">Group</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>addChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>removeChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>replaceChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *origChild, <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* newChild )
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumChildren</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>getChild</B>( int i )
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>containsNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
<DT>
<IMG ALT="o" SRC=icon2.gif>ChildList::iterator <B>findNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html#DOC.2.30.1">Node</A>&gt; &gt; <B>ChildList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Group.html#DOC.2.18.8">ChildList</A> <B>_children</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>DCS - Dynamic Coordinate System a is group which all children
are transformed by the the DCS's osg::Matrix. Typical uses
of the DCS is for positioning objects within a scene or
producing trakerball functionality.</BLOCKQUOTE>
<DL>
<A NAME="DCS">
<A NAME="DOC.2.7.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> DCS()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="DCS">
<A NAME="DOC.2.7.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> DCS(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.7.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.7.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.7.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.7.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setMatrix">
<A NAME="DOC.2.7.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setMatrix(const <!1><A HREF="Matrix.html">Matrix</A>&amp; mat )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getMatrix">
<A NAME="DOC.2.7.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* getMatrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preTranslate">
<A NAME="DOC.2.7.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preTranslate( float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preRotate">
<A NAME="DOC.2.7.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preRotate( float deg, float x, float y, float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.7.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool computeBound()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~DCS">
<A NAME="DOC.2.7.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~DCS()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.7.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.7.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_mat">
<A NAME="DOC.2.7.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* _mat</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

167
doc/osg/DynamicLibrary.html Normal file
View File

@ -0,0 +1,167 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::DynamicLibrary</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::DynamicLibrary</A>: public <!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A></H2>
<BLOCKQUOTE>DynamicLibrary - encapsulates the loading and unloading of dynamic libraries, typically used for loading ReaderWriter plug-ins</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CDynamicLibrary,MDynamicLibrary.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.8.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="DynamicLibrary.html#DOC.2.8.10">DynamicLibrary</A>* <B>loadLibrary</B>(const std::string&amp; libraryName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const std::string&amp; <B>getName</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const std::string&amp; <B>getFullName</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> <B>getHandle</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="DynamicLibrary.html#DOC.2.8.2">PROC_ADDRESS</A> <B>getProcAddress</B>(const std::string&amp; procName)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.8.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef void* <B>HANDLE</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef void* <B>PROC_ADDRESS</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef void* <B>HANDLE</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef void* <B>PROC_ADDRESS</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.8.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> <B>_handle</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string <B>_name</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string <B>_fullName</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.8.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>DynamicLibrary</B>(const std::string&amp; name, <!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> handle)
<DD><I></I>
<DT>
<A HREF="#DOC.2.8.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~DynamicLibrary</B>()
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>DynamicLibrary - encapsulates the loading and unloading of dynamic libraries,
typically used for loading ReaderWriter plug-ins</BLOCKQUOTE>
<DL>
<A NAME="HANDLE">
<A NAME="DOC.2.8.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef void* HANDLE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="PROC_ADDRESS">
<A NAME="DOC.2.8.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef void* PROC_ADDRESS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="HANDLE">
<A NAME="DOC.2.8.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef void* HANDLE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="PROC_ADDRESS">
<A NAME="DOC.2.8.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef void* PROC_ADDRESS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="loadLibrary">
<A NAME="DOC.2.8.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="DynamicLibrary.html#DOC.2.8.10">DynamicLibrary</A>* loadLibrary(const std::string&amp; libraryName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getName">
<A NAME="DOC.2.8.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const std::string&amp; getName() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFullName">
<A NAME="DOC.2.8.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const std::string&amp; getFullName() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getHandle">
<A NAME="DOC.2.8.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> getHandle() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getProcAddress">
<A NAME="DOC.2.8.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="DynamicLibrary.html#DOC.2.8.2">PROC_ADDRESS</A> getProcAddress(const std::string&amp; procName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="DynamicLibrary">
<A NAME="DOC.2.8.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> DynamicLibrary(const std::string&amp; name, <!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> handle)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~DynamicLibrary">
<A NAME="DOC.2.8.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~DynamicLibrary()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_handle">
<A NAME="DOC.2.8.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="DynamicLibrary.html#DOC.2.8.1">HANDLE</A> _handle</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_name">
<A NAME="DOC.2.8.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string _name</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fullName">
<A NAME="DOC.2.8.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string _fullName</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

22
doc/osg/ExtensionSupported.html Normal file
View File

@ -0,0 +1,22 @@
<HTML>
<HEAD>
<TITLE>SG_EXPORT extern bool osg::ExtensionSupported</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>SG_EXPORT extern bool <A HREF="#DOC.DOCU">osg::ExtensionSupported</A>(const char *extension)</H2>
<BLOCKQUOTE>return true if OpenGL "extension" is supported.</BLOCKQUOTE>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>return true if OpenGL "extension" is supported.
note: Must only called within a valid OpenGL context,
undefined behaviour may occur otherwise.</BLOCKQUOTE>
<DL>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

392
doc/osg/Field.html Normal file
View File

@ -0,0 +1,392 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Field</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Field</A></H2>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.10.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B></B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>FieldType</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.10.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Field</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Field</B>(const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; field)
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Field</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; <B>operator = </B>(const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; ic)
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>reset</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>addChar</B>(char c)
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNoCharacters</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setWithinQuotes</B>(bool withinQuotes=true)
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getWithinQuotes</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNoNestedBrackets</B>(int no)
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNoNestedBrackets</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> <B>getFieldType</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isValid</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isOpenBracket</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isCloseBracket</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isWord</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchWord</B>(const char* str) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchWord</B>(const char* str, int noCharacters) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isString</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchString</B>(const char* str) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchString</B>(const char* str, int noCharacters) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isQuotedString</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>getStr</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>char* <B>takeStr</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isInt</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchInt</B>(int i) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getInt</B>(int&amp; i) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isFloat</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchFloat</B>(float f) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getFloat</B>(float&amp; f) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isDouble</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchDouble</B>(double f) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getDouble</B>(double&amp; d) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> <B>calculateFieldType</B>(const char* str, bool withinQuotes=false)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.10.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_fieldCacheCapacity</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_fieldCacheSize</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>char* <B>_fieldCache</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>mutable <!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> <B>_fieldType</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_withinQuotes</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.45"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_noNestedBrackets</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.10.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>_init</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>_free</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.10.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>_copy</B>(const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; ic)
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="">
<A NAME="DOC.2.10.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum </B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="MIN_CACHE_SIZE">
<A NAME="DOC.2.10.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> MIN_CACHE_SIZE</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="Field">
<A NAME="DOC.2.10.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Field()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Field">
<A NAME="DOC.2.10.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Field(const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; field)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Field">
<A NAME="DOC.2.10.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Field()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.10.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; operator = (const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="reset">
<A NAME="DOC.2.10.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void reset()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addChar">
<A NAME="DOC.2.10.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void addChar(char c)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNoCharacters">
<A NAME="DOC.2.10.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNoCharacters() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setWithinQuotes">
<A NAME="DOC.2.10.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setWithinQuotes(bool withinQuotes=true)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getWithinQuotes">
<A NAME="DOC.2.10.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getWithinQuotes()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setNoNestedBrackets">
<A NAME="DOC.2.10.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNoNestedBrackets(int no)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNoNestedBrackets">
<A NAME="DOC.2.10.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNoNestedBrackets()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FieldType">
<A NAME="DOC.2.10.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum FieldType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="OPEN_BRACKET">
<A NAME="DOC.2.10.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OPEN_BRACKET</B></TT>
<DL><DT><DD></DL><P>
<A NAME="CLOSE_BRACKET">
<A NAME="DOC.2.10.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> CLOSE_BRACKET</B></TT>
<DL><DT><DD></DL><P>
<A NAME="STRING">
<A NAME="DOC.2.10.2.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> STRING</B></TT>
<DL><DT><DD></DL><P>
<A NAME="WORD">
<A NAME="DOC.2.10.2.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> WORD</B></TT>
<DL><DT><DD></DL><P>
<A NAME="REAL">
<A NAME="DOC.2.10.2.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> REAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="INTEGER">
<A NAME="DOC.2.10.2.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> INTEGER</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BLANK">
<A NAME="DOC.2.10.2.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BLANK</B></TT>
<DL><DT><DD></DL><P>
<A NAME="UNINTIALISED">
<A NAME="DOC.2.10.2.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> UNINTIALISED</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="getFieldType">
<A NAME="DOC.2.10.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> getFieldType() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isValid">
<A NAME="DOC.2.10.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isValid() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isOpenBracket">
<A NAME="DOC.2.10.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isOpenBracket() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isCloseBracket">
<A NAME="DOC.2.10.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isCloseBracket() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isWord">
<A NAME="DOC.2.10.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isWord() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchWord">
<A NAME="DOC.2.10.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchWord(const char* str) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchWord">
<A NAME="DOC.2.10.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchWord(const char* str, int noCharacters) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isString">
<A NAME="DOC.2.10.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isString() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchString">
<A NAME="DOC.2.10.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchString(const char* str) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchString">
<A NAME="DOC.2.10.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchString(const char* str, int noCharacters) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isQuotedString">
<A NAME="DOC.2.10.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isQuotedString() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getStr">
<A NAME="DOC.2.10.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* getStr() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="takeStr">
<A NAME="DOC.2.10.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>char* takeStr()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isInt">
<A NAME="DOC.2.10.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isInt() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchInt">
<A NAME="DOC.2.10.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchInt(int i) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getInt">
<A NAME="DOC.2.10.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getInt(int&amp; i) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isFloat">
<A NAME="DOC.2.10.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isFloat() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchFloat">
<A NAME="DOC.2.10.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchFloat(float f) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFloat">
<A NAME="DOC.2.10.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getFloat(float&amp; f) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isDouble">
<A NAME="DOC.2.10.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isDouble() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchDouble">
<A NAME="DOC.2.10.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchDouble(double f) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getDouble">
<A NAME="DOC.2.10.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getDouble(double&amp; d) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="calculateFieldType">
<A NAME="DOC.2.10.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> calculateFieldType(const char* str, bool withinQuotes=false)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_init">
<A NAME="DOC.2.10.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void _init()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_free">
<A NAME="DOC.2.10.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void _free()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_copy">
<A NAME="DOC.2.10.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void _copy(const <!1><A HREF="Field.html#DOC.2.10.4">Field</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fieldCacheCapacity">
<A NAME="DOC.2.10.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _fieldCacheCapacity</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fieldCacheSize">
<A NAME="DOC.2.10.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _fieldCacheSize</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fieldCache">
<A NAME="DOC.2.10.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>char* _fieldCache</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fieldType">
<A NAME="DOC.2.10.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>mutable <!1><A HREF="Field.html#DOC.2.10.2">FieldType</A> _fieldType</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_withinQuotes">
<A NAME="DOC.2.10.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _withinQuotes</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_noNestedBrackets">
<A NAME="DOC.2.10.45">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _noNestedBrackets</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

99
doc/osg/FieldReader.html Normal file
View File

@ -0,0 +1,99 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::FieldReader</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::FieldReader</A></H2>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.11.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FieldReader</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FieldReader</B>(const <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; ic)
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~FieldReader</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; <B>operator = </B>(const <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; ic)
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>attach</B>(istream* input)
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>detach</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>eof</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>readField</B>(<!1><A HREF="Field.html">Field</A>&amp; fieldPtr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>ignoreField</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.11.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNoNestedBrackets</B>() const
<DD><I>no of unmatched `{' encounterd so far in file</I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="FieldReader">
<A NAME="DOC.2.11.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FieldReader()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FieldReader">
<A NAME="DOC.2.11.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FieldReader(const <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~FieldReader">
<A NAME="DOC.2.11.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~FieldReader()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.11.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; operator = (const <!1><A HREF="FieldReader.html#DOC.2.11.2">FieldReader</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="attach">
<A NAME="DOC.2.11.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void attach(istream* input)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="detach">
<A NAME="DOC.2.11.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void detach()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="eof">
<A NAME="DOC.2.11.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool eof() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="readField">
<A NAME="DOC.2.11.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool readField(<!1><A HREF="Field.html">Field</A>&amp; fieldPtr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ignoreField">
<A NAME="DOC.2.11.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void ignoreField()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNoNestedBrackets">
<A NAME="DOC.2.11.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNoNestedBrackets() const </B></TT>
<DD>no of unmatched `{' encounterd so far in file
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

184
doc/osg/FieldReaderIterator.html Normal file
View File

@ -0,0 +1,184 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::FieldReaderIterator</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::FieldReaderIterator</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CFieldReaderIterator,MFieldReaderIterator.html,CInput,MInput.html">
<param name=before value="M,M^_">
<param name=after value="M,M">
<param name=indent value="0,0">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.12.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B></B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.12.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FieldReaderIterator</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FieldReaderIterator</B>(const <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; ic)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~FieldReaderIterator</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator = </B>(const <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; ic)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>attach</B>(istream* input)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>detach</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>eof</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="FieldReader.html">FieldReader</A>&amp; <B>getFieldReader</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>insert</B>(int pos, <!1><A HREF="Field.html">Field</A>* <!1><A HREF="FieldReaderIterator.html#DOC.2.12.14">field</A>)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>insert</B>(int pos, const char* str)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Field.html">Field</A>&amp; <B>operator [] </B>(int pos)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Field.html">Field</A>&amp; <B>field</B>(int pos)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator ++ </B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator += </B>(int no)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>advanceOverCurrentFieldOrBlock</B>()
<DD><I>increments the itetor of the next simple field or whole block if the current field[0] is an open bracket </I>
<DT>
<A HREF="#DOC.2.12.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>advanceToEndOfCurrentBlock</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>advanceToEndOfBlock</B>(int noNestBrackets)
<DD><I></I>
<DT>
<A HREF="#DOC.2.12.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchSequence</B>(const char* str)
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="">
<A NAME="DOC.2.12.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum </B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="MINIMUM_FIELD_READER_QUEUE_SIZE">
<A NAME="DOC.2.12.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> MINIMUM_FIELD_READER_QUEUE_SIZE</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="FieldReaderIterator">
<A NAME="DOC.2.12.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FieldReaderIterator()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FieldReaderIterator">
<A NAME="DOC.2.12.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FieldReaderIterator(const <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~FieldReaderIterator">
<A NAME="DOC.2.12.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~FieldReaderIterator()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.12.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; operator = (const <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; ic)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="attach">
<A NAME="DOC.2.12.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void attach(istream* input)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="detach">
<A NAME="DOC.2.12.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void detach()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="eof">
<A NAME="DOC.2.12.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool eof() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFieldReader">
<A NAME="DOC.2.12.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="FieldReader.html">FieldReader</A>&amp; getFieldReader()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="insert">
<A NAME="DOC.2.12.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void insert(int pos, <!1><A HREF="Field.html">Field</A>* <!1><A HREF="FieldReaderIterator.html#DOC.2.12.14">field</A>)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="insert">
<A NAME="DOC.2.12.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void insert(int pos, const char* str)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator [] ">
<A NAME="DOC.2.12.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Field.html">Field</A>&amp; operator [] (int pos)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="field">
<A NAME="DOC.2.12.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Field.html">Field</A>&amp; field(int pos)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator ++ ">
<A NAME="DOC.2.12.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; operator ++ ()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator += ">
<A NAME="DOC.2.12.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; operator += (int no)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="advanceOverCurrentFieldOrBlock">
<A NAME="DOC.2.12.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void advanceOverCurrentFieldOrBlock()</B></TT>
<DD>increments the itetor of the next simple field or
whole block if the current field[0] is an open bracket
<DL><DT><DD></DL><P>
<A NAME="advanceToEndOfCurrentBlock">
<A NAME="DOC.2.12.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void advanceToEndOfCurrentBlock()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="advanceToEndOfBlock">
<A NAME="DOC.2.12.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void advanceToEndOfBlock(int noNestBrackets)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchSequence">
<A NAME="DOC.2.12.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchSequence(const char* str)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="Input.html">Input</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

267
doc/osg/Fog.html Normal file
View File

@ -0,0 +1,267 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Fog</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Fog</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Fog - encapsulates OpenGL fog state.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CFog,MFog.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.13.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>FogMode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.13.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Fog</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Fog.html#DOC.2.13.2">Fog</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setMode</B>( <!1><A HREF="osg.html#DOC.2.89">uint</A> mode )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.89">uint</A> <B>getMode</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setDensity</B>( float density )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getDensity</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setStart</B>( float start )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getStart</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setEnd</B>( float end )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getEnd</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setColor</B>( <!1><A HREF="Vec4.html">Vec4</A> &amp;color )
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.13.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.89">uint</A> <B>_mode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_density</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_start</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_end</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.13.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_color</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.13.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Fog</B>( void )
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp;)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Fog - encapsulates OpenGL fog state. </BLOCKQUOTE>
<DL>
<A NAME="FogMode">
<A NAME="DOC.2.13.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum FogMode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="LINEAR">
<A NAME="DOC.2.13.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LINEAR</B></TT>
<DL><DT><DD></DL><P>
<A NAME="EXP">
<A NAME="DOC.2.13.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> EXP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="EXP2">
<A NAME="DOC.2.13.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> EXP2</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="Fog">
<A NAME="DOC.2.13.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Fog( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.13.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Fog.html#DOC.2.13.2">Fog</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.13.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.13.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.13.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="enable">
<A NAME="DOC.2.13.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.13.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.13.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setMode">
<A NAME="DOC.2.13.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setMode( <!1><A HREF="osg.html#DOC.2.89">uint</A> mode )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getMode">
<A NAME="DOC.2.13.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.89">uint</A> getMode( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setDensity">
<A NAME="DOC.2.13.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setDensity( float density )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getDensity">
<A NAME="DOC.2.13.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getDensity( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setStart">
<A NAME="DOC.2.13.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setStart( float start )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getStart">
<A NAME="DOC.2.13.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getStart( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setEnd">
<A NAME="DOC.2.13.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setEnd( float end )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getEnd">
<A NAME="DOC.2.13.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getEnd( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setColor">
<A NAME="DOC.2.13.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setColor( <!1><A HREF="Vec4.html">Vec4</A> &amp;color )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Fog">
<A NAME="DOC.2.13.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Fog( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_mode">
<A NAME="DOC.2.13.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.89">uint</A> _mode</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_density">
<A NAME="DOC.2.13.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _density</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_start">
<A NAME="DOC.2.13.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _start</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_end">
<A NAME="DOC.2.13.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _end</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_color">
<A NAME="DOC.2.13.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _color</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

489
doc/osg/General.html Normal file
View File

@ -0,0 +1,489 @@
<HTML>
<HEAD>
<TITLE>General Bits</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<DL>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_ALPHAFUNC"></A>
<B>OSG_ALPHAFUNC</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_BILLBOARD"></A>
<B>OSG_BILLBOARD</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_BOUNDINGBOX"></A>
<B>OSG_BOUNDINGBOX</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_BOUNDINGSPHERE"></A>
<B>OSG_BOUNDINGSPHERE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_CAMERA"></A>
<B>OSG_CAMERA</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_CULLFACE"></A>
<B>OSG_CULLFACE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_DCS"></A>
<B>OSG_DCS</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_DYNAMICLIBRARY"></A>
<B>OSG_DYNAMICLIBRARY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_EXPORT"></A>
<B>OSG_EXPORT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="NULL"></A>
<B>NULL</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="NULL"></A>
<B>NULL</B>((void *)<DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="SG_EXPORT"></A>
<B>SG_EXPORT</B>(dllexport)<DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="SG_EXPORT"></A>
<B>SG_EXPORT</B>(dllimport)<DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_EXTENSIONSUPPORTED"></A>
<B>OSG_EXTENSIONSUPPORTED</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_FIELD"></A>
<B>OSG_FIELD</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_FIELDREADER"></A>
<B>OSG_FIELDREADER</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_FIELDREADERITERATOR"></A>
<B>OSG_FIELDREADERITERATOR</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_FILENAMEUTILS"></A>
<B>OSG_FILENAMEUTILS</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_FOG"></A>
<B>OSG_FOG</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_GL"></A>
<B>OSG_GL</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="WIN32_LEAN_AND_MEAN"></A>
<B>WIN32_LEAN_AND_MEAN</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="GLUT_APIENTRY_DEFINED"></A>
<B>GLUT_APIENTRY_DEFINED</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="APIENTRY"></A>
<B>APIENTRY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="APIENTRY"></A>
<B>APIENTRY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="CALLBACK"></A>
<B>CALLBACK</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="CALLBACK"></A>
<B>CALLBACK</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="GLUT_WINGDIAPI_DEFINED"></A>
<B>GLUT_WINGDIAPI_DEFINED</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="WINGDIAPI"></A>
<B>WINGDIAPI</B>(dllimport)<DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>typedef unsigned short<A NAME="wchar_t"></A>
<B>wchar_t</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="_WCHAR_T_DEFINED"></A>
<B>_WCHAR_T_DEFINED</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="GL_GLEXT_LEGACY"></A>
<B>GL_GLEXT_LEGACY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_GEOSET"></A>
<B>OSG_GEOSET</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_GEOSTATE"></A>
<B>OSG_GEOSTATE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_GEODE"></A>
<B>OSG_GEODE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_GROUP"></A>
<B>OSG_GROUP</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_IMAGE"></A>
<B>OSG_IMAGE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_INPUT"></A>
<B>OSG_INPUT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_LOD"></A>
<B>OSG_LOD</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_LIGHT"></A>
<B>OSG_LIGHT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_LIGHTSOURCE"></A>
<B>OSG_LIGHTSOURCE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_LIGHTING"></A>
<B>OSG_LIGHTING</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_MATERIAL"></A>
<B>OSG_MATERIAL</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_MATRIX"></A>
<B>OSG_MATRIX</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_NODE"></A>
<B>OSG_NODE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_NODEVISITOR"></A>
<B>OSG_NODEVISITOR</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_NOTIFY"></A>
<B>OSG_NOTIFY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_OSG"></A>
<B>OSG_OSG</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_OBJECT"></A>
<B>OSG_OBJECT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_OUTPUT"></A>
<B>OSG_OUTPUT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_POINT"></A>
<B>OSG_POINT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_POLYGONOFFSET"></A>
<B>OSG_POLYGONOFFSET</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_QUAT"></A>
<B>OSG_QUAT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_REFERENCED"></A>
<B>OSG_REFERENCED</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_REGISTRY"></A>
<B>OSG_REGISTRY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_SCENE"></A>
<B>OSG_SCENE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_SEG"></A>
<B>OSG_SEG</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_SEQUENCE"></A>
<B>OSG_SEQUENCE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_STATE"></A>
<B>OSG_STATE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_SWITCH"></A>
<B>OSG_SWITCH</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TEXENV"></A>
<B>OSG_TEXENV</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TEXGEN"></A>
<B>OSG_TEXGEN</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TEXMAT"></A>
<B>OSG_TEXMAT</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TEXTURE"></A>
<B>OSG_TEXTURE</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TIMER"></A>
<B>OSG_TIMER</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TRANSPARENCY"></A>
<B>OSG_TRANSPARENCY</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_TYPES"></A>
<B>OSG_TYPES</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_VEC2"></A>
<B>OSG_VEC2</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_VEC3"></A>
<B>OSG_VEC3</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_VEC4"></A>
<B>OSG_VEC4</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif>#define<A NAME="OSG_VERSION"></A>
<B>OSG_VERSION</B><DD><I></I>
<DT>
<IMG ALT="o" BORDER=0 SRC=icon1.gif><A NAME=""></A>
<B></B><DD><I></I>
</DL>
<I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">Hierarchy of classes</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

713
doc/osg/GeoSet.html Normal file
View File

@ -0,0 +1,713 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::GeoSet</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::GeoSet</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Encapsulates OpenGL drawing primitives, geometry and optional binding of normal, color and texture coordinates.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CGeoSet,MGeoSet.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.14.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>PrimitiveType</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>BindingType</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>InterleaveArrayType</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.14.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>GeoSet</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.45"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNumPrims</B>( int n )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.46"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumPrims</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.47"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setPrimType</B>( <!1><A HREF="GeoSet.html#DOC.2.14.1">PrimitiveType</A> type )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.48"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html#DOC.2.14.1">PrimitiveType</A> <B>getPrimType</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.49"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setPrimLengths</B>( int *lens )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.50"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int* <B>getPrimLengths</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.51"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>computeNumVerts</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumCoords</B>()
<DD><I>get the number of coords required by the defined primitives.</I>
<DT>
<A HREF="#DOC.2.14.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A>* <B>getCoords</B>()
<DD><I>get a pointer to Vec3 coord array.</I>
<DT>
<A HREF="#DOC.2.14.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumIndices</B>()
<DD><I>get the number of indices required by the defined primitives.</I>
<DT>
<A HREF="#DOC.2.14.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.90">ushort</A>* <B>getCIndex</B>()
<DD><I>get the coord index array.</I>
<DT>
<A HREF="#DOC.2.14.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setCoords</B>( <!1><A HREF="Vec3.html">Vec3</A> *cp )
<DD><I>set the coords (ie the geometry) of the geoset</I>
<DT>
<A HREF="#DOC.2.14.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setCoords</B>( <!1><A HREF="Vec3.html">Vec3</A> *cp, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ci )
<DD><I>set the coords (ie the geometry) and indices of the geoset</I>
<DT>
<A HREF="#DOC.2.14.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumNormals</B>()
<DD><I>get the number of normals required by the defined primitives and normals binding</I>
<DT>
<A HREF="#DOC.2.14.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A>* <B>getNormals</B>()
<DD><I>get a pointer to Vec3 normal array.</I>
<DT>
<A HREF="#DOC.2.14.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumNIndices</B>()
<DD><I>get the number of normal indices required by the defined primitives and normals binding</I>
<DT>
<A HREF="#DOC.2.14.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.90">ushort</A>* <B>getNIndex</B>()
<DD><I>get the normal index array.</I>
<DT>
<A HREF="#DOC.2.14.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNormals</B>( <!1><A HREF="Vec3.html">Vec3</A> *np )
<DD><I>set the normals of the geoset</I>
<DT>
<A HREF="#DOC.2.14.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNormals</B>( <!1><A HREF="Vec3.html">Vec3</A> *np, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ni )
<DD><I>set the normals and normal indices of the geoset</I>
<DT>
<A HREF="#DOC.2.14.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNormalBinding</B>( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )
<DD><I>set the normals binding to the vertices/primitives/overall</I>
<DT>
<A HREF="#DOC.2.14.52"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> <B>getNormalBinding</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumColors</B>()
<DD><I>get the number of colors required by the defined primitives and color binding</I>
<DT>
<A HREF="#DOC.2.14.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A>* <B>getColors</B>()
<DD><I>get a pointer to Vec4 color array.</I>
<DT>
<A HREF="#DOC.2.14.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumCIndices</B>()
<DD><I>get the number of colors indices required by the defined primitives and color binding</I>
<DT>
<A HREF="#DOC.2.14.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.90">ushort</A>* <B>getColIndex</B>()
<DD><I>get the color index array.</I>
<DT>
<A HREF="#DOC.2.14.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setColors</B>( <!1><A HREF="Vec4.html">Vec4</A> *lp )
<DD><I>set the colors of the geoset</I>
<DT>
<A HREF="#DOC.2.14.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setColors</B>( <!1><A HREF="Vec4.html">Vec4</A> *lp, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *li )
<DD><I>set the colors and color indices of the geoset</I>
<DT>
<A HREF="#DOC.2.14.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setColorBinding</B>( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )
<DD><I>set the color binding to the vertices/primitives/overall</I>
<DT>
<A HREF="#DOC.2.14.53"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> <B>getColorBinding</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumTCoords</B>()
<DD><I>get the number of texture coords required by the defined primitives and textures binding</I>
<DT>
<A HREF="#DOC.2.14.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec2.html">Vec2</A>* <B>getTCoords</B>()
<DD><I>get a pointer to Vec4 color array.</I>
<DT>
<A HREF="#DOC.2.14.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumTIndices</B>()
<DD><I>get the number of texture coord indices required by the defined primitives and texture binding</I>
<DT>
<A HREF="#DOC.2.14.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="osg.html#DOC.2.90">ushort</A>* <B>getTIndex</B>()
<DD><I>get the texture index array.</I>
<DT>
<A HREF="#DOC.2.14.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTextureCoords</B>( <!1><A HREF="Vec2.html">Vec2</A> *tc )
<DD><I>set the texture coords of the geoset</I>
<DT>
<A HREF="#DOC.2.14.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTextureCoords</B>( <!1><A HREF="Vec2.html">Vec2</A> *tc, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ti )
<DD><I>set the texture coords and texture coord indices of the geoset</I>
<DT>
<A HREF="#DOC.2.14.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTextureBinding</B>( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )
<DD><I>set the texture coord binding to the vertices/primitives/overall</I>
<DT>
<A HREF="#DOC.2.14.54"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> <B>getTextureBinding</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.55"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setInterleavedArray</B>( <!1><A HREF="GeoSet.html#DOC.2.14.3">InterleaveArrayType</A> format, float *ia )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.56"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setInterleavedArray</B>( <!1><A HREF="GeoSet.html#DOC.2.14.3">InterleaveArrayType</A> format, float *ia, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *iai )
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.57"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setGeoState</B>(<!1><A HREF="GeoState.html">GeoState</A> *state)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.58"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html">GeoState</A>* <B>getGeoState</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setUseDisplayList</B>(bool flag)
<DD><I>When set to true, force the draw method to use OpenGL Display List for rendering.</I>
<DT>
<A HREF="#DOC.2.14.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getUseDisplayList</B>()
<DD><I>Return whether OpenGL display lists are being used for rendering</I>
<DT>
<A HREF="#DOC.2.14.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>dirtyDisplayList</B>()
<DD><I>Force a recompile on next draw() of any OpenGL display list associated with this geoset</I>
<DT>
<A HREF="#DOC.2.14.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; <B>getBound</B>()
<DD><I>get bounding box of geoset.</I>
<DT>
<A HREF="#DOC.2.14.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>draw</B>( void )
<DD><I>draw geoset.</I>
<DT>
<A HREF="#DOC.2.14.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>drawImmediateMode</B>()
<DD><I>draw geoset directly ignoring an OpenGL display list which could be attached.</I>
<DT>
<A HREF="#DOC.2.14.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>compile</B>( void )
<DD><I>Immediately compile this geoset into an OpenGL Display List, set _useDisplayList to true</I>
<DT>
<A HREF="#DOC.2.14.59"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>check</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.14.60"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>GeoSet</B>(const <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.61"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp; <B>operator = </B>(const <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.62"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~GeoSet</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.63"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchBindingTypeStr</B>(const char* str, <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A>&amp; mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.64"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>getBindingTypeStr</B>(<!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.65"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.14.66"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Encapsulates OpenGL drawing primitives, geometry and
optional binding of normal, color and texture coordinates. Used
for representing the visible objects in the scene. State attributes
for a GeoSet are maintained in GeoState which the GeoSet maintains
a referenced counted pointer to. Both GeoSet's and GeoState's can
be shared for optimal memory usage and graphics performance.</BLOCKQUOTE>
<DL>
<A NAME="PrimitiveType">
<A NAME="DOC.2.14.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum PrimitiveType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="NO_TYPE">
<A NAME="DOC.2.14.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NO_TYPE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POINTS">
<A NAME="DOC.2.14.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POINTS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LINES">
<A NAME="DOC.2.14.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LINES</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LINE_STRIP">
<A NAME="DOC.2.14.1.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LINE_STRIP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FLAT_LINE_STRIP">
<A NAME="DOC.2.14.1.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FLAT_LINE_STRIP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LINE_LOOP">
<A NAME="DOC.2.14.1.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LINE_LOOP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRIANGLES">
<A NAME="DOC.2.14.1.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRIANGLES</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRIANGLE_STRIP">
<A NAME="DOC.2.14.1.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRIANGLE_STRIP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FLAT_TRIANGLE_STRIP">
<A NAME="DOC.2.14.1.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FLAT_TRIANGLE_STRIP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRIANGLE_FAN">
<A NAME="DOC.2.14.1.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRIANGLE_FAN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FLAT_TRIANGLE_FAN">
<A NAME="DOC.2.14.1.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FLAT_TRIANGLE_FAN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="QUADS">
<A NAME="DOC.2.14.1.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> QUADS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="QUAD_STRIP">
<A NAME="DOC.2.14.1.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> QUAD_STRIP</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POLYGON">
<A NAME="DOC.2.14.1.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POLYGON</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="BindingType">
<A NAME="DOC.2.14.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum BindingType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="BIND_OFF">
<A NAME="DOC.2.14.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BIND_OFF</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BIND_OVERALL">
<A NAME="DOC.2.14.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BIND_OVERALL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BIND_PERPRIM">
<A NAME="DOC.2.14.2.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BIND_PERPRIM</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BIND_PERVERTEX">
<A NAME="DOC.2.14.2.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BIND_PERVERTEX</B></TT>
<DL><DT><DD></DL><P>
<A NAME="BIND_DEFAULT">
<A NAME="DOC.2.14.2.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> BIND_DEFAULT</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="InterleaveArrayType">
<A NAME="DOC.2.14.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum InterleaveArrayType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="IA_OFF">
<A NAME="DOC.2.14.3.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_OFF</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_V2F">
<A NAME="DOC.2.14.3.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_V2F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_V3F">
<A NAME="DOC.2.14.3.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_C4UB_V2F">
<A NAME="DOC.2.14.3.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_C4UB_V2F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_C4UB_V3F">
<A NAME="DOC.2.14.3.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_C4UB_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_C3F_V3F">
<A NAME="DOC.2.14.3.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_C3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_N3F_V3F">
<A NAME="DOC.2.14.3.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_N3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_C4F_N3F_V3F">
<A NAME="DOC.2.14.3.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_C4F_N3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T2F_V3F">
<A NAME="DOC.2.14.3.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T2F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T4F_V4F">
<A NAME="DOC.2.14.3.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T4F_V4F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T2F_C4UB_V3F">
<A NAME="DOC.2.14.3.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T2F_C4UB_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T2F_C3F_V3F">
<A NAME="DOC.2.14.3.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T2F_C3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T2F_N3F_V3F">
<A NAME="DOC.2.14.3.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T2F_N3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T2F_C4F_N3F_V3F">
<A NAME="DOC.2.14.3.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T2F_C4F_N3F_V3F</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IA_T4F_C4F_N3F_V4F">
<A NAME="DOC.2.14.3.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IA_T4F_C4F_N3F_V4F</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="GeoSet">
<A NAME="DOC.2.14.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GeoSet()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.14.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.14.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.14.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.14.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setNumPrims">
<A NAME="DOC.2.14.45">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNumPrims( int n )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumPrims">
<A NAME="DOC.2.14.46">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumPrims( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setPrimType">
<A NAME="DOC.2.14.47">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setPrimType( <!1><A HREF="GeoSet.html#DOC.2.14.1">PrimitiveType</A> type )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getPrimType">
<A NAME="DOC.2.14.48">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html#DOC.2.14.1">PrimitiveType</A> getPrimType( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setPrimLengths">
<A NAME="DOC.2.14.49">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setPrimLengths( int *lens )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getPrimLengths">
<A NAME="DOC.2.14.50">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int* getPrimLengths( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeNumVerts">
<A NAME="DOC.2.14.51">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void computeNumVerts()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumCoords">
<A NAME="DOC.2.14.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumCoords()</B></TT>
<DD>get the number of coords required by the defined primitives.
<DL><DT><DD></DL><P>
<A NAME="getCoords">
<A NAME="DOC.2.14.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A>* getCoords()</B></TT>
<DD>get a pointer to Vec3 coord array.
<DL><DT><DD></DL><P>
<A NAME="getNumIndices">
<A NAME="DOC.2.14.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumIndices()</B></TT>
<DD>get the number of indices required by the defined primitives.
<DL><DT><DD></DL><P>
<A NAME="getCIndex">
<A NAME="DOC.2.14.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.90">ushort</A>* getCIndex()</B></TT>
<DD>get the coord index array.
<DL><DT><DD></DL><P>
<A NAME="setCoords">
<A NAME="DOC.2.14.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setCoords( <!1><A HREF="Vec3.html">Vec3</A> *cp )</B></TT>
<DD>set the coords (ie the geometry) of the geoset
<DL><DT><DD></DL><P>
<A NAME="setCoords">
<A NAME="DOC.2.14.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setCoords( <!1><A HREF="Vec3.html">Vec3</A> *cp, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ci )</B></TT>
<DD>set the coords (ie the geometry) and indices of the geoset
<DL><DT><DD></DL><P>
<A NAME="getNumNormals">
<A NAME="DOC.2.14.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumNormals()</B></TT>
<DD>get the number of normals required by the defined primitives and normals binding
<DL><DT><DD></DL><P>
<A NAME="getNormals">
<A NAME="DOC.2.14.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A>* getNormals()</B></TT>
<DD>get a pointer to Vec3 normal array.
<DL><DT><DD></DL><P>
<A NAME="getNumNIndices">
<A NAME="DOC.2.14.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumNIndices()</B></TT>
<DD>get the number of normal indices required by the defined primitives and normals binding
<DL><DT><DD></DL><P>
<A NAME="getNIndex">
<A NAME="DOC.2.14.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.90">ushort</A>* getNIndex()</B></TT>
<DD>get the normal index array.
<DL><DT><DD></DL><P>
<A NAME="setNormals">
<A NAME="DOC.2.14.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNormals( <!1><A HREF="Vec3.html">Vec3</A> *np )</B></TT>
<DD>set the normals of the geoset
<DL><DT><DD></DL><P>
<A NAME="setNormals">
<A NAME="DOC.2.14.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNormals( <!1><A HREF="Vec3.html">Vec3</A> *np, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ni )</B></TT>
<DD>set the normals and normal indices of the geoset
<DL><DT><DD></DL><P>
<A NAME="setNormalBinding">
<A NAME="DOC.2.14.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNormalBinding( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )</B></TT>
<DD>set the normals binding to the vertices/primitives/overall
<DL><DT><DD></DL><P>
<A NAME="getNormalBinding">
<A NAME="DOC.2.14.52">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> getNormalBinding()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumColors">
<A NAME="DOC.2.14.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumColors()</B></TT>
<DD>get the number of colors required by the defined primitives and color binding
<DL><DT><DD></DL><P>
<A NAME="getColors">
<A NAME="DOC.2.14.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A>* getColors()</B></TT>
<DD>get a pointer to Vec4 color array.
<DL><DT><DD></DL><P>
<A NAME="getNumCIndices">
<A NAME="DOC.2.14.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumCIndices()</B></TT>
<DD>get the number of colors indices required by the defined primitives and color binding
<DL><DT><DD></DL><P>
<A NAME="getColIndex">
<A NAME="DOC.2.14.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.90">ushort</A>* getColIndex()</B></TT>
<DD>get the color index array.
<DL><DT><DD></DL><P>
<A NAME="setColors">
<A NAME="DOC.2.14.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setColors( <!1><A HREF="Vec4.html">Vec4</A> *lp )</B></TT>
<DD>set the colors of the geoset
<DL><DT><DD></DL><P>
<A NAME="setColors">
<A NAME="DOC.2.14.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setColors( <!1><A HREF="Vec4.html">Vec4</A> *lp, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *li )</B></TT>
<DD>set the colors and color indices of the geoset
<DL><DT><DD></DL><P>
<A NAME="setColorBinding">
<A NAME="DOC.2.14.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setColorBinding( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )</B></TT>
<DD>set the color binding to the vertices/primitives/overall
<DL><DT><DD></DL><P>
<A NAME="getColorBinding">
<A NAME="DOC.2.14.53">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> getColorBinding()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumTCoords">
<A NAME="DOC.2.14.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumTCoords()</B></TT>
<DD>get the number of texture coords required by the defined primitives and textures binding
<DL><DT><DD></DL><P>
<A NAME="getTCoords">
<A NAME="DOC.2.14.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec2.html">Vec2</A>* getTCoords()</B></TT>
<DD>get a pointer to Vec4 color array.
<DL><DT><DD></DL><P>
<A NAME="getNumTIndices">
<A NAME="DOC.2.14.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumTIndices()</B></TT>
<DD>get the number of texture coord indices required by the defined primitives and texture binding
<DL><DT><DD></DL><P>
<A NAME="getTIndex">
<A NAME="DOC.2.14.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="osg.html#DOC.2.90">ushort</A>* getTIndex()</B></TT>
<DD>get the texture index array.
<DL><DT><DD></DL><P>
<A NAME="setTextureCoords">
<A NAME="DOC.2.14.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTextureCoords( <!1><A HREF="Vec2.html">Vec2</A> *tc )</B></TT>
<DD>set the texture coords of the geoset
<DL><DT><DD></DL><P>
<A NAME="setTextureCoords">
<A NAME="DOC.2.14.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTextureCoords( <!1><A HREF="Vec2.html">Vec2</A> *tc, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *ti )</B></TT>
<DD>set the texture coords and texture coord indices of the geoset
<DL><DT><DD></DL><P>
<A NAME="setTextureBinding">
<A NAME="DOC.2.14.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTextureBinding( <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> binding )</B></TT>
<DD>set the texture coord binding to the vertices/primitives/overall
<DL><DT><DD></DL><P>
<A NAME="getTextureBinding">
<A NAME="DOC.2.14.54">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> getTextureBinding()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setInterleavedArray">
<A NAME="DOC.2.14.55">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setInterleavedArray( <!1><A HREF="GeoSet.html#DOC.2.14.3">InterleaveArrayType</A> format, float *ia )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setInterleavedArray">
<A NAME="DOC.2.14.56">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setInterleavedArray( <!1><A HREF="GeoSet.html#DOC.2.14.3">InterleaveArrayType</A> format, float *ia, <!1><A HREF="osg.html#DOC.2.90">ushort</A> *iai )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setGeoState">
<A NAME="DOC.2.14.57">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setGeoState(<!1><A HREF="GeoState.html">GeoState</A> *state)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getGeoState">
<A NAME="DOC.2.14.58">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html">GeoState</A>* getGeoState() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setUseDisplayList">
<A NAME="DOC.2.14.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setUseDisplayList(bool flag)</B></TT>
<DD>When set to true, force the draw method to use OpenGL Display List for rendering.
If false rendering directly. If the display list has not been already
compile the next call to draw will automatically create the display list.
<DL><DT><DD></DL><P>
<A NAME="getUseDisplayList">
<A NAME="DOC.2.14.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getUseDisplayList()</B></TT>
<DD>Return whether OpenGL display lists are being used for rendering
<DL><DT><DD></DL><P>
<A NAME="dirtyDisplayList">
<A NAME="DOC.2.14.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void dirtyDisplayList()</B></TT>
<DD>Force a recompile on next draw() of any OpenGL display list associated with this geoset
<DL><DT><DD></DL><P>
<A NAME="getBound">
<A NAME="DOC.2.14.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; getBound()</B></TT>
<DD>get bounding box of geoset.
Note, now made virtual to make it possible to implement user-drawn
objects albiet so what crudely, to be improved later.
<DL><DT><DD></DL><P>
<A NAME="draw">
<A NAME="DOC.2.14.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void draw( void )</B></TT>
<DD>draw geoset.
If the geoset has _useDisplayList set to true then use an OpenGL display
list, automatically compiling one if required.
Otherwise call drawImmediateMode().
Note, draw method should not be overiden in subclasses as it
manages the optional display list.
<DL><DT><DD></DL><P>
<A NAME="drawImmediateMode">
<A NAME="DOC.2.14.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void drawImmediateMode()</B></TT>
<DD>draw geoset directly ignoring an OpenGL display list which could be attached.
This is the internal draw method which does the drawing itself,
and is the method to override when deriving from GeoSet for user-drawn objects.
<DL><DT><DD></DL><P>
<A NAME="compile">
<A NAME="DOC.2.14.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void compile( void )</B></TT>
<DD>Immediately compile this geoset into an OpenGL Display List, set _useDisplayList to true
<DL><DT><DD></DL><P>
<A NAME="check">
<A NAME="DOC.2.14.59">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool check()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="GeoSet">
<A NAME="DOC.2.14.60">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GeoSet(const <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.14.61">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp; operator = (const <!1><A HREF="GeoSet.html#DOC.2.14.40">GeoSet</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~GeoSet">
<A NAME="DOC.2.14.62">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~GeoSet()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchBindingTypeStr">
<A NAME="DOC.2.14.63">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchBindingTypeStr(const char* str, <!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A>&amp; mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getBindingTypeStr">
<A NAME="DOC.2.14.64">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* getBindingTypeStr(<!1><A HREF="GeoSet.html#DOC.2.14.2">BindingType</A> mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.14.65">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.14.66">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

501
doc/osg/GeoState.html Normal file
View File

@ -0,0 +1,501 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::GeoState</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::GeoState</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE> Encapsulates OpenGL state modes and attributes.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CGeoState,MGeoState.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.16.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>AttributeType</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>AttributeMode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.16.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>GeoState</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setGlobalDefaults</B>()
<DD><I>set all the modes to on or off so that it defines a complete state, typically used for a default global state</I>
<DT>
<A HREF="#DOC.2.16.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAllToInherit</B>()
<DD><I>set all the modes to inherit, typically used to signifiy nodes which inherit all of their modes for the global state</I>
<DT>
<A HREF="#DOC.2.16.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setMode</B>(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type, <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>getMode</B>(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAttribute</B>(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type, <!1><A HREF="Object.html#DOC.2.36.1">Object</A> *attribute)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>getAttribute</B>(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isTransparent</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>(<!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* global, <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* prev)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>check</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>combineMode</B>(const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> g, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> p, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> c)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>mergeMode</B>(const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> lhs, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> rhs)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.16.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_transparencing</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_face_culling</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_lighting</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_texturing</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_fogging</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_texgening</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_antialiasing</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_colortable</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_pointSmoothing</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_polygonOffsetting</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> <B>_alphaTesting</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Texture.html">Texture</A>&gt; <B>_texture</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexGen.html">TexGen</A>&gt; <B>_texgen</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Material.html">Material</A>&gt; <B>_material</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexEnv.html">TexEnv</A>&gt; <B>_texenv</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Transparency.html">Transparency</A>&gt; <B>_transparency</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexMat.html">TexMat</A>&gt; <B>_texmat</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Fog.html">Fog</A>&gt; <B>_fog</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.45"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Point.html">Point</A>&gt; <B>_point</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.46"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="PolygonOffset.html">PolygonOffset</A>&gt; <B>_polygonOffset</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.47"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="CullFace.html">CullFace</A>&gt; <B>_cullFace</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.48"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="AlphaFunc.html">AlphaFunc</A>&gt; <B>_alphaFunc</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.16.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~GeoState</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>GeoState</B>(const <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp; <B>operator = </B>(const <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchModeStr</B>(const char* str, <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A>&amp; mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.16.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>getModeStr</B>(<!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> flag)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
Encapsulates OpenGL state modes and attributes.
Used to specificy textures etc of osg::GeoSet's which hold references
to a single osg::GeoState. GeoState can be shared between GeoSet's
and is recommend if possible as it minimize expensive state changes
in the graphics pipeline.</BLOCKQUOTE>
<DL>
<A NAME="AttributeType">
<A NAME="DOC.2.16.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum AttributeType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="ANTIALIAS">
<A NAME="DOC.2.16.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ANTIALIAS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FACE_CULL">
<A NAME="DOC.2.16.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FACE_CULL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FOG">
<A NAME="DOC.2.16.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FOG</B></TT>
<DL><DT><DD></DL><P>
<A NAME="LIGHTING">
<A NAME="DOC.2.16.1.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LIGHTING</B></TT>
<DL><DT><DD></DL><P>
<A NAME="MATERIAL">
<A NAME="DOC.2.16.1.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> MATERIAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POINT">
<A NAME="DOC.2.16.1.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POINT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="POLYGON_OFFSET">
<A NAME="DOC.2.16.1.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> POLYGON_OFFSET</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TEXENV">
<A NAME="DOC.2.16.1.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TEXENV</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TEXGEN">
<A NAME="DOC.2.16.1.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TEXGEN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TEXMAT">
<A NAME="DOC.2.16.1.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TEXMAT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TEXTURE">
<A NAME="DOC.2.16.1.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TEXTURE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRANSPARENCY">
<A NAME="DOC.2.16.1.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRANSPARENCY</B></TT>
<DL><DT><DD></DL><P>
<A NAME="WIREFRAME">
<A NAME="DOC.2.16.1.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> WIREFRAME</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ALPHAFUNC">
<A NAME="DOC.2.16.1.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ALPHAFUNC</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="AttributeMode">
<A NAME="DOC.2.16.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum AttributeMode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="INHERIT">
<A NAME="DOC.2.16.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> INHERIT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OFF">
<A NAME="DOC.2.16.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OFF</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ON">
<A NAME="DOC.2.16.2.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ON</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OVERRIDE_OFF">
<A NAME="DOC.2.16.2.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OVERRIDE_OFF</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OVERRIDE_ON">
<A NAME="DOC.2.16.2.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OVERRIDE_ON</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="GeoState">
<A NAME="DOC.2.16.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GeoState()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.16.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.16.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.16.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.16.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setGlobalDefaults">
<A NAME="DOC.2.16.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setGlobalDefaults()</B></TT>
<DD>set all the modes to on or off so that it defines a
complete state, typically used for a default global state
<DL><DT><DD></DL><P>
<A NAME="setAllToInherit">
<A NAME="DOC.2.16.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAllToInherit()</B></TT>
<DD>set all the modes to inherit, typically used to signifiy
nodes which inherit all of their modes for the global state
<DL><DT><DD></DL><P>
<A NAME="setMode">
<A NAME="DOC.2.16.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setMode(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type, <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getMode">
<A NAME="DOC.2.16.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> getMode(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setAttribute">
<A NAME="DOC.2.16.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAttribute(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type, <!1><A HREF="Object.html#DOC.2.36.1">Object</A> *attribute)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getAttribute">
<A NAME="DOC.2.16.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Object.html#DOC.2.36.1">Object</A>* getAttribute(<!1><A HREF="GeoState.html#DOC.2.16.1">AttributeType</A> type) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isTransparent">
<A NAME="DOC.2.16.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isTransparent()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.16.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.16.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply(<!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* global, <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>* prev)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="check">
<A NAME="DOC.2.16.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool check()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="combineMode">
<A NAME="DOC.2.16.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> combineMode(const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> g, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> p, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> c)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="mergeMode">
<A NAME="DOC.2.16.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> mergeMode(const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> lhs, const <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> rhs)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~GeoState">
<A NAME="DOC.2.16.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~GeoState()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="GeoState">
<A NAME="DOC.2.16.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> GeoState(const <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.16.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp; operator = (const <!1><A HREF="GeoState.html#DOC.2.16.5">GeoState</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.16.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.16.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchModeStr">
<A NAME="DOC.2.16.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchModeStr(const char* str, <!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A>&amp; mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getModeStr">
<A NAME="DOC.2.16.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* getModeStr(<!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> flag)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_transparencing">
<A NAME="DOC.2.16.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _transparencing</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_face_culling">
<A NAME="DOC.2.16.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _face_culling</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_lighting">
<A NAME="DOC.2.16.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _lighting</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texturing">
<A NAME="DOC.2.16.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _texturing</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fogging">
<A NAME="DOC.2.16.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _fogging</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texgening">
<A NAME="DOC.2.16.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _texgening</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_antialiasing">
<A NAME="DOC.2.16.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _antialiasing</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_colortable">
<A NAME="DOC.2.16.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _colortable</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_pointSmoothing">
<A NAME="DOC.2.16.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _pointSmoothing</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_polygonOffsetting">
<A NAME="DOC.2.16.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _polygonOffsetting</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_alphaTesting">
<A NAME="DOC.2.16.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html#DOC.2.16.2">AttributeMode</A> _alphaTesting</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texture">
<A NAME="DOC.2.16.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Texture.html">Texture</A>&gt; _texture</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texgen">
<A NAME="DOC.2.16.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexGen.html">TexGen</A>&gt; _texgen</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_material">
<A NAME="DOC.2.16.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Material.html">Material</A>&gt; _material</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texenv">
<A NAME="DOC.2.16.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexEnv.html">TexEnv</A>&gt; _texenv</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_transparency">
<A NAME="DOC.2.16.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Transparency.html">Transparency</A>&gt; _transparency</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_texmat">
<A NAME="DOC.2.16.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="TexMat.html">TexMat</A>&gt; _texmat</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fog">
<A NAME="DOC.2.16.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Fog.html">Fog</A>&gt; _fog</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_point">
<A NAME="DOC.2.16.45">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Point.html">Point</A>&gt; _point</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_polygonOffset">
<A NAME="DOC.2.16.46">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="PolygonOffset.html">PolygonOffset</A>&gt; _polygonOffset</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_cullFace">
<A NAME="DOC.2.16.47">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="CullFace.html">CullFace</A>&gt; _cullFace</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_alphaFunc">
<A NAME="DOC.2.16.48">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="AlphaFunc.html">AlphaFunc</A>&gt; _alphaFunc</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

317
doc/osg/Geode.html Normal file
View File

@ -0,0 +1,317 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Geode</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Geode</A>: public <!1><A HREF="Node.html#DOC.2.30.1">Node</A></H2>
<BLOCKQUOTE>Leaf Node for grouping GeoSets</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=155>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGeode,MGeode.html,CBillboard,MBillboard.html">
<param name=before value="M,M,M,M,M^_">
<param name=after value="Md_SPSP,Md_SP,Md_,M,M">
<param name=indent value="0,1,2,3,3">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.17.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Geode</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>addGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )
<DD><I>Add GeoSet to Geode.</I>
<DT>
<A HREF="#DOC.2.17.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>removeGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )
<DD><I>Remove GeoSet from Geode.</I>
<DT>
<A HREF="#DOC.2.17.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>replaceGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A> *origGset, <!1><A HREF="GeoSet.html">GeoSet</A> *newGset )
<DD><I>Replace specified GeoSet with another GeoSet.</I>
<DT>
<A HREF="#DOC.2.17.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumGeosets</B>( void ) const
<DD><I>return the number of geoset's</I>
<DT>
<A HREF="#DOC.2.17.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html">GeoSet</A>* <B>getGeoSet</B>( int i )
<DD><I>return geoset at position i</I>
<DT>
<A HREF="#DOC.2.17.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>containsGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)
<DD><I>return true is geoset is contained within Geode</I>
<DT>
<A HREF="#DOC.2.17.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>GeoSetList::iterator <B>findGeoSet</B>( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)
<DD><I>return the iterator postion for specified GeoSet.</I>
<DT>
<A HREF="#DOC.2.17.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>compileGeoSets</B>( void )
<DD><I>complile OpenGL Display List for each geoset</I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.17.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt; <!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="GeoSet.html">GeoSet</A>&gt; &gt; <B>GeoSetList</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.17.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Geode.html#DOC.2.17.9">GeoSetList</A> <B>_geosets</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.17.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Geode</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.17.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>computeBound</B>( void )
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Leaf Node for grouping GeoSets</BLOCKQUOTE>
<DL>
<A NAME="GeoSetList">
<A NAME="DOC.2.17.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt; <!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="GeoSet.html">GeoSet</A>&gt; &gt; GeoSetList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Geode">
<A NAME="DOC.2.17.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Geode()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.17.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.17.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.17.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.17.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addGeoSet">
<A NAME="DOC.2.17.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool addGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )</B></TT>
<DD>Add GeoSet to Geode.
If gset is not NULL and is not contained in Geode then increment its
reference count, add it to the geosets list and dirty the bounding
sphere to force it to recompute on next getBound() and return true for success.
Otherwise return false.
<DL><DT><DD></DL><P>
<A NAME="removeGeoSet">
<A NAME="DOC.2.17.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool removeGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A> *gset )</B></TT>
<DD>Remove GeoSet from Geode.
If gset is contained in Geode then remove it from the geoset
list and decrement its reference count, and dirty the
bounding sphere to force it to recompute on next getBound() and
return true for success. If gset is not found then return false
and do not change the reference count of gset.
<DL><DT><DD></DL><P>
<A NAME="replaceGeoSet">
<A NAME="DOC.2.17.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool replaceGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A> *origGset, <!1><A HREF="GeoSet.html">GeoSet</A> *newGset )</B></TT>
<DD>Replace specified GeoSet with another GeoSet.
Decrement the reference count origGSet and increments the
reference count of newGset, and dirty the bounding sphere
to force it to recompute on next getBound() and returns true.
If origGeoSet is not found then return false and do not
add newGset. If newGset is NULL then return false and do
not remove origGset.
<DL><DT><DD></DL><P>
<A NAME="getNumGeosets">
<A NAME="DOC.2.17.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumGeosets( void ) const </B></TT>
<DD>return the number of geoset's
<DL><DT><DD></DL><P>
<A NAME="getGeoSet">
<A NAME="DOC.2.17.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html">GeoSet</A>* getGeoSet( int i )</B></TT>
<DD>return geoset at position i
<DL><DT><DD></DL><P>
<A NAME="containsGeoSet">
<A NAME="DOC.2.17.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool containsGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)</B></TT>
<DD>return true is geoset is contained within Geode
<DL><DT><DD></DL><P>
<A NAME="findGeoSet">
<A NAME="DOC.2.17.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>GeoSetList::iterator findGeoSet( <!1><A HREF="GeoSet.html">GeoSet</A>* gset)</B></TT>
<DD>return the iterator postion for specified GeoSet.
return _geoset.end() if gset not is contained in Geode.
<DL><DT><DD></DL><P>
<A NAME="compileGeoSets">
<A NAME="DOC.2.17.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void compileGeoSets( void )</B></TT>
<DD>complile OpenGL Display List for each geoset
<DL><DT><DD></DL><P>
<A NAME="~Geode">
<A NAME="DOC.2.17.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Geode()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.17.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.17.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.17.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool computeBound( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_geosets">
<A NAME="DOC.2.17.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Geode.html#DOC.2.17.9">GeoSetList</A> _geosets</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="Billboard.html">Billboard</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

318
doc/osg/Group.html Normal file
View File

@ -0,0 +1,318 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Group</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Group</A>: public <!1><A HREF="Node.html#DOC.2.30.1">Node</A></H2>
<BLOCKQUOTE>General group node which maintains a list of children.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=275>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGroup,MGroup.html,CSwitch,MSwitch.html,CSequence,MSequence.html,CScene,MScene.html,CLOD,MLOD.html,CDCS,MDCS.html">
<param name=before value="M,M,M,M,M|_,MR_,MR_,MR_,Mr_">
<param name=after value="Md_SPSP,Md_SP,Md_,M,M,M,M,M,M">
<param name=indent value="0,1,2,3,3,3,3,3,3">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.18.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Group</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>addChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DD><I>Add Node to Group.</I>
<DT>
<A HREF="#DOC.2.18.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>removeChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DD><I>Remove Node from Group.</I>
<DT>
<A HREF="#DOC.2.18.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>replaceChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *origChild, <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* newChild )
<DD><I>Replace specified Node with another Node.</I>
<DT>
<A HREF="#DOC.2.18.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumChildren</B>( void )
<DD><I>return the number of chilren nodes</I>
<DT>
<A HREF="#DOC.2.18.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>getChild</B>( int i )
<DD><I>return child node at position i</I>
<DT>
<A HREF="#DOC.2.18.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>containsNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
<DD><I>return true is node is contained within Group</I>
<DT>
<A HREF="#DOC.2.18.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>ChildList::iterator <B>findNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
<DD><I>return the iterator postion for specified Node.</I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.18.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html#DOC.2.30.1">Node</A>&gt; &gt; <B>ChildList</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.18.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Group.html#DOC.2.18.8">ChildList</A> <B>_children</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.18.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Group</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>computeBound</B>( void )
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>General group node which maintains a list of children.
Children are reference counted to allow children to be shared
with memory management handled automatically via osg::Referenced.</BLOCKQUOTE>
<DL>
<A NAME="ChildList">
<A NAME="DOC.2.18.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html#DOC.2.30.1">Node</A>&gt; &gt; ChildList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Group">
<A NAME="DOC.2.18.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Group()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.18.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.18.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.18.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.18.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="traverse">
<A NAME="DOC.2.18.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void traverse(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addChild">
<A NAME="DOC.2.18.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool addChild( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )</B></TT>
<DD>Add Node to Group.
If node is not NULL and is not contained in Group then increment its
reference count, add it to the child list and dirty the bounding
sphere to force it to recompute on next getBound() and return true for success.
Otherwise return false.
<DL><DT><DD></DL><P>
<A NAME="removeChild">
<A NAME="DOC.2.18.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool removeChild( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )</B></TT>
<DD>Remove Node from Group.
If Node is contained in Group then remove it from the child
list, decrement its reference count, and dirty the
bounding sphere to force it to recompute on next getBound() and
return true for success. If Node is not found then return false
and do not change the reference count of the Node.
<DL><DT><DD></DL><P>
<A NAME="replaceChild">
<A NAME="DOC.2.18.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool replaceChild( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *origChild, <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* newChild )</B></TT>
<DD>Replace specified Node with another Node.
Decrement the reference count origNode and increments the
reference count of newNode, and dirty the bounding sphere
to force it to recompute on next getBound() and returns true.
If origNode is not found then return false and do not
add newNode. If newNode is NULL then return false and do
not remove origNode.
<DL><DT><DD></DL><P>
<A NAME="getNumChildren">
<A NAME="DOC.2.18.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumChildren( void )</B></TT>
<DD>return the number of chilren nodes
<DL><DT><DD></DL><P>
<A NAME="getChild">
<A NAME="DOC.2.18.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* getChild( int i )</B></TT>
<DD>return child node at position i
<DL><DT><DD></DL><P>
<A NAME="containsNode">
<A NAME="DOC.2.18.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool containsNode( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )</B></TT>
<DD>return true is node is contained within Group
<DL><DT><DD></DL><P>
<A NAME="findNode">
<A NAME="DOC.2.18.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>ChildList::iterator findNode( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )</B></TT>
<DD>return the iterator postion for specified Node.
return _chilren.end() if node is not contained in Group.
<DL><DT><DD></DL><P>
<A NAME="~Group">
<A NAME="DOC.2.18.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Group()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.18.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.18.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_children">
<A NAME="DOC.2.18.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Group.html#DOC.2.18.8">ChildList</A> _children</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.18.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool computeBound( void )</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="Switch.html">Switch</A><BR>
<A HREF="Sequence.html">Sequence</A><BR>
<A HREF="Scene.html">Scene</A><BR>
<A HREF="LOD.html">LOD</A><BR>
<A HREF="DCS.html">DCS</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

80
doc/osg/HIER.html Normal file
View File

@ -0,0 +1,80 @@
<HTML>
<HEAD>
<TITLE>Hierarchy of Classes</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H1>Hierarchy of Classes</H1>
<UL>
<LI><A HREF="BoundingBox.html">osg::BoundingBox</A>
<LI><A HREF="BoundingSphere.html">osg::BoundingSphere</A>
<LI><A HREF="Field.html">osg::Field</A>
<LI><A HREF="FieldReader.html">osg::FieldReader</A>
<LI><A HREF="FieldReaderIterator.html">osg::FieldReaderIterator</A><UL>
<LI><A HREF="Input.html">osg::Input</A></UL>
<LI><A HREF="Lighting.html">osg::Lighting</A>
<LI><A HREF="NotifyInit.html">osg::NotifyInit</A>
<LI><A HREF="Output.html">osg::Output</A>
<LI><A HREF="Quat.html">osg::Quat</A>
<LI><A HREF="Referenced.html">osg::Referenced</A><UL>
<LI><A HREF="Camera.html">osg::Camera</A>
<LI><A HREF="DynamicLibrary.html">osg::DynamicLibrary</A>
<LI><A HREF="MemoryAdapter.html">osg::MemoryAdapter</A>
<LI><A HREF="NodeVisitor.html">osg::NodeVisitor</A>
<LI><A HREF="Object.html">osg::Object</A><UL>
<LI><A HREF="AlphaFunc.html">osg::AlphaFunc</A>
<LI><A HREF="CullFace.html">osg::CullFace</A>
<LI><A HREF="Fog.html">osg::Fog</A>
<LI><A HREF="GeoSet.html">osg::GeoSet</A>
<LI><A HREF="GeoState.html">osg::GeoState</A>
<LI><A HREF="Image.html">osg::Image</A>
<LI><A HREF="Light.html">osg::Light</A>
<LI><A HREF="Material.html">osg::Material</A>
<LI><A HREF="Matrix.html">osg::Matrix</A><UL>
<LI><A HREF="TexMat.html">osg::TexMat</A></UL>
<LI><A HREF="Node.html">osg::Node</A><UL>
<LI><A HREF="Geode.html">osg::Geode</A><UL>
<LI><A HREF="Billboard.html">osg::Billboard</A></UL>
<LI><A HREF="Group.html">osg::Group</A><UL>
<LI><A HREF="DCS.html">osg::DCS</A>
<LI><A HREF="LOD.html">osg::LOD</A>
<LI><A HREF="Scene.html">osg::Scene</A>
<LI><A HREF="Sequence.html">osg::Sequence</A>
<LI><A HREF="Switch.html">osg::Switch</A></UL>
<LI><A HREF="LightSource.html">osg::LightSource</A></UL>
<LI><A HREF="Point.html">osg::Point</A>
<LI><A HREF="PolygonOffset.html">osg::PolygonOffset</A>
<LI><A HREF="TexEnv.html">osg::TexEnv</A>
<LI><A HREF="TexGen.html">osg::TexGen</A>
<LI><A HREF="Texture.html">osg::Texture</A>
<LI><A HREF="Transparency.html">osg::Transparency</A></UL>
<LI><A HREF="ReaderWriter.html">osg::ReaderWriter</A>
<LI><A HREF="Seg.html">osg::Seg</A></UL>
<LI><A HREF="RegisterObjectProxy.html">osg::RegisterObjectProxy</A>
<LI><A HREF="RegisterReaderWriterProxy.html">osg::RegisterReaderWriterProxy</A>
<LI><A HREF="Registry.html">osg::Registry</A>
<LI><A HREF="State.html">osg::State</A>
<LI><A HREF="Timer.html">osg::Timer</A>
<LI><A HREF="Vec2.html">osg::Vec2</A>
<LI><A HREF="Vec3.html">osg::Vec3</A>
<LI><A HREF="Vec4.html">osg::Vec4</A>
<LI><A HREF="ref_ptr.html">osg::ref_ptr</A></UL>
<I><A HREF="index.html">Alphabetic index</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

146
doc/osg/HIERjava.html Normal file
View File

@ -0,0 +1,146 @@
<HTML>
<HEAD>
<TITLE>Hierarchy of Classes</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H1>Hierarchy of classes</H1>
<UL>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CBoundingBox,MBoundingBox.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CBoundingSphere,MBoundingSphere.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CField,MField.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CFieldReader,MFieldReader.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CFieldReaderIterator,MFieldReaderIterator.html,CInput,MInput.html">
<param name=before value="M,M^_">
<param name=after value="M,M">
<param name=indent value="0,0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CLighting,MLighting.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CNotifyInit,MNotifyInit.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="Mofstream,M,COutput,MOutput.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CQuat,MQuat.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=1025>
<param name=classes value="CReferenced,MReferenced.html,CSeg,MSeg.html,CReaderWriter,MReaderWriter.html,CObject,MObject.html,CTransparency,MTransparency.html,CTexture,MTexture.html,CTexGen,MTexGen.html,CTexEnv,MTexEnv.html,CPolygonOffset,MPolygonOffset.html,CPoint,MPoint.html,CNode,MNode.html,CLightSource,MLightSource.html,CGroup,MGroup.html,CSwitch,MSwitch.html,CSequence,MSequence.html,CScene,MScene.html,CLOD,MLOD.html,CDCS,MDCS.html,CGeode,MGeode.html,CBillboard,MBillboard.html,CMatrix,MMatrix.html,CTexMat,MTexMat.html,CMaterial,MMaterial.html,CLight,MLight.html,CImage,MImage.html,CGeoState,MGeoState.html,CGeoSet,MGeoSet.html,CFog,MFog.html,CCullFace,MCullFace.html,CAlphaFunc,MAlphaFunc.html,CNodeVisitor,MNodeVisitor.html,CMemoryAdapter,MMemoryAdapter.html,CDynamicLibrary,MDynamicLibrary.html,CCamera,MCamera.html">
<param name=before value="M,M|_,MR_,MR_,M|||_,M||R_,M||R_,M||R_,M||R_,M||R_,M||R_,M|||||_,M||||R_,M|||||||_,M||||||R_,M||||||R_,M||||||R_,M||||||r_,M||||r_,M||||SP^_,M||R_,M||||^_,M||R_,M||R_,M||R_,M||R_,M||R_,M||R_,M||R_,M||r_,MR_,MR_,MR_,Mr_">
<param name=after value="M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M">
<param name=indent value="0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CRegisterObjectProxy,MRegisterObjectProxy.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CRegisterReaderWriterProxy,MRegisterReaderWriterProxy.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CRegistry,MRegistry.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CState,MState.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CTimer,MTimer.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CVec2,MVec2.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CVec3,MVec3.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="CVec4,MVec4.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=35>
<param name=classes value="Cref_ptr,Mref_ptr.html">
<param name=before value="M">
<param name=after value="M">
<param name=indent value="0">
<param name=arrowdir value="down">
</APPLET>
</UL>
<I><A HREF="index.html"> alphabetic index</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

173
doc/osg/Hit.html Normal file
View File

@ -0,0 +1,173 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Hit</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Hit</A>: public <!1><A HREF="Referenced.html#DOC.2.35.4">Referenced</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CHit,MHit.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.19.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_ratio</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Seg.html">Seg</A>* <B>_originalSeg</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Seg.html">Seg</A>* <B>_localSeg</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodePath.html">NodePath</A> <B>_nodePath</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Geode.html">Geode</A>* <B>_geode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoSet.html">GeoSet</A>* <B>_geoset</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>_matrix</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Hit.html#DOC.2.19.5">VecIndexList</A> <B>_vecIndexList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_primitiveIndex</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_intersectPoint</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.19.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Hit</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Hit</B>(const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~Hit</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; <B>operator = </B>(const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>operator < </B>(const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit) const
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.19.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;int&gt; <B>VecIndexList</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_reference</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="Hit">
<A NAME="DOC.2.19.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Hit()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Hit">
<A NAME="DOC.2.19.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Hit(const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Hit">
<A NAME="DOC.2.19.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~Hit()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.19.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; operator = (const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="VecIndexList">
<A NAME="DOC.2.19.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;int&gt; VecIndexList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator < ">
<A NAME="DOC.2.19.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool operator < (const <!1><A HREF="Hit.html#DOC.2.19.1">Hit</A>&amp; hit) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="_ratio">
<A NAME="DOC.2.19.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _ratio</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_originalSeg">
<A NAME="DOC.2.19.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Seg.html">Seg</A>* _originalSeg</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_localSeg">
<A NAME="DOC.2.19.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Seg.html">Seg</A>* _localSeg</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_nodePath">
<A NAME="DOC.2.19.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodePath.html">NodePath</A> _nodePath</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_geode">
<A NAME="DOC.2.19.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Geode.html">Geode</A>* _geode</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_geoset">
<A NAME="DOC.2.19.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoSet.html">GeoSet</A>* _geoset</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_matrix">
<A NAME="DOC.2.19.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* _matrix</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_vecIndexList">
<A NAME="DOC.2.19.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Hit.html#DOC.2.19.5">VecIndexList</A> _vecIndexList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_primitiveIndex">
<A NAME="DOC.2.19.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _primitiveIndex</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_intersectPoint">
<A NAME="DOC.2.19.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _intersectPoint</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

272
doc/osg/Image.html Normal file
View File

@ -0,0 +1,272 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Image</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Image</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Image class for encapsulating the storage texture image data</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CImage,MImage.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.19.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Image</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>getFileName</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFileName</B>(const char* fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setImage</B>(int <!1><A HREF="Image.html#DOC.2.19.1">s</A>, int <!1><A HREF="Image.html#DOC.2.19.2">t</A>, int <!1><A HREF="Image.html#DOC.2.19.3">r</A>, int <!1><A HREF="Image.html#DOC.2.19.14">internalFormat</A>, unsigned int <!1><A HREF="Image.html#DOC.2.19.15">pixelFormat</A>, unsigned int <!1><A HREF="Image.html#DOC.2.19.16">dataType</A>, unsigned char *<!1><A HREF="Image.html#DOC.2.19.4">data</A>)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>s</B>()
<DD><I>Width of image</I>
<DT>
<A HREF="#DOC.2.19.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>t</B>()
<DD><I>Height of image</I>
<DT>
<A HREF="#DOC.2.19.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>r</B>()
<DD><I>Depth of image</I>
<DT>
<A HREF="#DOC.2.19.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>internalFormat</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned int <B>pixelFormat</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned int <B>dataType</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned char* <B>data</B>()
<DD><I>raw image data</I>
<DT>
<A HREF="#DOC.2.19.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>scaleImage</B>(int <!1><A HREF="Image.html#DOC.2.19.1">s</A>, int <!1><A HREF="Image.html#DOC.2.19.2">t</A>, int <!1><A HREF="Image.html#DOC.2.19.3">r</A>)
<DD><I>Scale image to specified size.</I>
<DT>
<A HREF="#DOC.2.19.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>ensureDimensionsArePowerOfTwo</B>()
<DD><I>Ensure image dimensions are a power of two.</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.19.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>char* <B>_fileName</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_s</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_t</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_r</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_internalFormat</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned int <B>_pixelFormat</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned int <B>_dataType</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>unsigned char* <B>_data</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.19.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Image</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.19.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Image class for encapsulating the storage texture image data</BLOCKQUOTE>
<DL>
<A NAME="Image">
<A NAME="DOC.2.19.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Image()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.19.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.19.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.19.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getFileName">
<A NAME="DOC.2.19.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* getFileName()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setFileName">
<A NAME="DOC.2.19.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFileName(const char* fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setImage">
<A NAME="DOC.2.19.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setImage(int <!1><A HREF="Image.html#DOC.2.19.1">s</A>, int <!1><A HREF="Image.html#DOC.2.19.2">t</A>, int <!1><A HREF="Image.html#DOC.2.19.3">r</A>, int <!1><A HREF="Image.html#DOC.2.19.14">internalFormat</A>, unsigned int <!1><A HREF="Image.html#DOC.2.19.15">pixelFormat</A>, unsigned int <!1><A HREF="Image.html#DOC.2.19.16">dataType</A>, unsigned char *<!1><A HREF="Image.html#DOC.2.19.4">data</A>)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="s">
<A NAME="DOC.2.19.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int s()</B></TT>
<DD>Width of image
<DL><DT><DD></DL><P>
<A NAME="t">
<A NAME="DOC.2.19.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int t()</B></TT>
<DD>Height of image
<DL><DT><DD></DL><P>
<A NAME="r">
<A NAME="DOC.2.19.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int r()</B></TT>
<DD>Depth of image
<DL><DT><DD></DL><P>
<A NAME="internalFormat">
<A NAME="DOC.2.19.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int internalFormat()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="pixelFormat">
<A NAME="DOC.2.19.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned int pixelFormat()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="dataType">
<A NAME="DOC.2.19.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned int dataType()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="data">
<A NAME="DOC.2.19.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned char* data()</B></TT>
<DD>raw image data
<DL><DT><DD></DL><P>
<A NAME="scaleImage">
<A NAME="DOC.2.19.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void scaleImage(int <!1><A HREF="Image.html#DOC.2.19.1">s</A>, int <!1><A HREF="Image.html#DOC.2.19.2">t</A>, int <!1><A HREF="Image.html#DOC.2.19.3">r</A>)</B></TT>
<DD>Scale image to specified size.
<DL><DT><DD></DL><P>
<A NAME="ensureDimensionsArePowerOfTwo">
<A NAME="DOC.2.19.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void ensureDimensionsArePowerOfTwo()</B></TT>
<DD>Ensure image dimensions are a power of two.
Mip Mapped texture require the image dimensions to be
power of two.
<DL><DT><DD></DL><P>
<A NAME="~Image">
<A NAME="DOC.2.19.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Image()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.19.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.19.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fileName">
<A NAME="DOC.2.19.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>char* _fileName</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_s">
<A NAME="DOC.2.19.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _s</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_t">
<A NAME="DOC.2.19.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _t</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_r">
<A NAME="DOC.2.19.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _r</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_internalFormat">
<A NAME="DOC.2.19.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _internalFormat</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_pixelFormat">
<A NAME="DOC.2.19.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned int _pixelFormat</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_dataType">
<A NAME="DOC.2.19.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned int _dataType</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_data">
<A NAME="DOC.2.19.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>unsigned char* _data</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

151
doc/osg/Input.html Normal file
View File

@ -0,0 +1,151 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Input</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Input</A>: public <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A></H2>
<BLOCKQUOTE>Class for managing the reading of ASCII osg files</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CFieldReaderIterator,MFieldReaderIterator.html,CInput,MInput.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.22.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Input</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Input</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html">Object</A>* <B>readObject</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html">Object</A>* <B>readObject</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Image.html">Image</A>* <B>readImage</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Image.html">Image</A>* <B>readImage</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Node.html">Node</A>* <B>readNode</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Node.html">Node</A>* <B>readNode</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html">Object</A>* <B>getObjectForUniqueID</B>(const std::string&amp; uniqueID)
<DD><I></I>
<DT>
<A HREF="#DOC.2.22.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>regisiterUniqueIDForObject</B>(const std::string&amp; uniqueID, <!1><A HREF="Object.html">Object</A>* obj)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="FieldReaderIterator.html">FieldReaderIterator</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>enum <B></B>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator = </B>(const <!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; ic)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>attach</B>(istream* input)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>detach</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>eof</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="FieldReader.html">FieldReader</A>&amp; <B>getFieldReader</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>insert</B>(int pos, <!1><A HREF="Field.html">Field</A>* <!1><A HREF="FieldReaderIterator.html#DOC.2.12.14">field</A>)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>insert</B>(int pos, const char* str)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Field.html">Field</A>&amp; <B>operator [] </B>(int pos)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Field.html">Field</A>&amp; <B>field</B>(int pos)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator ++ </B>()
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="FieldReaderIterator.html#DOC.2.12.3">FieldReaderIterator</A>&amp; <B>operator += </B>(int no)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>advanceOverCurrentFieldOrBlock</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>advanceToEndOfCurrentBlock</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>advanceToEndOfBlock</B>(int noNestBrackets)
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>matchSequence</B>(const char* str)
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Class for managing the reading of ASCII osg files</BLOCKQUOTE>
<DL>
<A NAME="Input">
<A NAME="DOC.2.22.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Input()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Input">
<A NAME="DOC.2.22.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Input()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readObject">
<A NAME="DOC.2.22.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html">Object</A>* readObject()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readObject">
<A NAME="DOC.2.22.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html">Object</A>* readObject(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readImage">
<A NAME="DOC.2.22.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Image.html">Image</A>* readImage()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readImage">
<A NAME="DOC.2.22.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Image.html">Image</A>* readImage(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readNode">
<A NAME="DOC.2.22.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Node.html">Node</A>* readNode()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readNode">
<A NAME="DOC.2.22.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Node.html">Node</A>* readNode(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getObjectForUniqueID">
<A NAME="DOC.2.22.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html">Object</A>* getObjectForUniqueID(const std::string&amp; uniqueID)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="regisiterUniqueIDForObject">
<A NAME="DOC.2.22.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void regisiterUniqueIDForObject(const std::string&amp; uniqueID, <!1><A HREF="Object.html">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

143
doc/osg/IntersectState.html Normal file
View File

@ -0,0 +1,143 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::IntersectState</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::IntersectState</A>: public <!1><A HREF="Referenced.html#DOC.2.35.4">Referenced</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CIntersectState,MIntersectState.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.18.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>_matrix</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>_inverse</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectState.html#DOC.2.18.4">SegList</A> <B>_segList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectState.html#DOC.2.18.7">SegmentMaskStack</A> <B>_segmentMaskStack</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.18.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>IntersectState</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isCulled</B>(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; bs, <!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&amp; segMaskOut)
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isCulled</B>(const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; bb, <!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&amp; segMaskOut)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.18.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt; std::pair&lt;<!1><A HREF="Seg.html">Seg</A>*,<!1><A HREF="Seg.html">Seg</A>*&gt; &gt; <B>SegList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef unsigned int <B>SegmentMask</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.18.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&gt; <B>SegmentMaskStack</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.18.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~IntersectState</B>()
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.35.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.35.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_reference</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="IntersectState">
<A NAME="DOC.2.18.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IntersectState()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_matrix">
<A NAME="DOC.2.18.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* _matrix</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_inverse">
<A NAME="DOC.2.18.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* _inverse</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SegList">
<A NAME="DOC.2.18.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt; std::pair&lt;<!1><A HREF="Seg.html">Seg</A>*,<!1><A HREF="Seg.html">Seg</A>*&gt; &gt; SegList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_segList">
<A NAME="DOC.2.18.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectState.html#DOC.2.18.4">SegList</A> _segList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SegmentMask">
<A NAME="DOC.2.18.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef unsigned int SegmentMask</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SegmentMaskStack">
<A NAME="DOC.2.18.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&gt; SegmentMaskStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_segmentMaskStack">
<A NAME="DOC.2.18.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectState.html#DOC.2.18.7">SegmentMaskStack</A> _segmentMaskStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isCulled">
<A NAME="DOC.2.18.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isCulled(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; bs, <!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&amp; segMaskOut)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isCulled">
<A NAME="DOC.2.18.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isCulled(const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; bb, <!1><A HREF="IntersectState.html#DOC.2.18.6">SegmentMask</A>&amp; segMaskOut)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~IntersectState">
<A NAME="DOC.2.18.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~IntersectState()</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

309
doc/osg/IntersectVisitor.html Normal file
View File

@ -0,0 +1,309 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::IntersectVisitor</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::IntersectVisitor</A>: public <!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A></H2>
<BLOCKQUOTE>Basic visitor for ray based collisions of a scene.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CNodeVisitor,MNodeVisitor.html,CIntersectVisitor,MIntersectVisitor.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.20.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>HitReportingMode</B>
<DD><I>Modes to control how IntersectVisitor reports hits.</I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.20.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>IntersectVisitor</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~IntersectVisitor</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>reset</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>addSeg</B>(<!1><A HREF="Seg.html">Seg</A>* seg)
<DD><I>Add a line segment to use for intersection testing during scene traversal</I>
<DT>
<A HREF="#DOC.2.20.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setHitReportingMode</B>(<!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> hrm)
<DD><I>Set the mode of how hits should reported back from a traversal</I>
<DT>
<A HREF="#DOC.2.20.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> <B>getHitReportingMode</B>()
<DD><I>Get the mode of how hits should reported back from a traversal</I>
<DT>
<A HREF="#DOC.2.20.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectVisitor.html#DOC.2.20.8">HitList</A>&amp; <B>getHitList</B>(<!1><A HREF="Seg.html">Seg</A>* seg)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumHits</B>(<!1><A HREF="Seg.html">Seg</A>* seg)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>hits</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Node.html">Node</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Geode.html">Geode</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Group.html">Group</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="DCS.html">DCS</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Switch.html">Switch</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="LOD.html">LOD</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Scene.html">Scene</A>&amp; node)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.20.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::multiset&lt;<!1><A HREF="Hit.html">Hit</A>&gt; <B>HitList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::map&lt;<!1><A HREF="Seg.html">Seg</A>*,<!1><A HREF="IntersectVisitor.html#DOC.2.20.8">HitList</A> &gt; <B>SegHitListMap</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.20.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectVisitor.html#DOC.2.20.26">IntersectStateStack</A> <B>_intersectStateStack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodePath.html">NodePath</A> <B>_nodePath</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> <B>_hitReportingMode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="IntersectVisitor.html#DOC.2.20.9">SegHitListMap</A> <B>_segHitList</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.20.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>intersect</B>(<!1><A HREF="GeoSet.html">GeoSet</A>&amp; gset)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>pushMatrix</B>(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matrix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>popMatrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>enterNode</B>(<!1><A HREF="Node.html">Node</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.20.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>leaveNode</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected</H3><DD><DT>
<A HREF="#DOC.2.20.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="IntersectState.html">IntersectState</A>*&gt; <B>IntersectStateStack</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="NodeVisitor.html">NodeVisitor</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>enum <B>TraversalMode</B>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setTraverseMode</B>(<!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> mode)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> <B>getTraverseMode</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setTraverseVisitor</B>(<!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* nv)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* <B>getTraverseVisitor</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>traverse</B>(<!1><A HREF="Node.html">Node</A>&amp; node)
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* <B>_traverseVisitor</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> <B>_traverseMode</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Basic visitor for ray based collisions of a scene.
Note, still in development, current version has not
pratical functionality!</BLOCKQUOTE>
<DL>
<A NAME="IntersectVisitor">
<A NAME="DOC.2.20.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> IntersectVisitor()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~IntersectVisitor">
<A NAME="DOC.2.20.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~IntersectVisitor()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="reset">
<A NAME="DOC.2.20.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void reset()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addSeg">
<A NAME="DOC.2.20.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void addSeg(<!1><A HREF="Seg.html">Seg</A>* seg)</B></TT>
<DD>Add a line segment to use for intersection testing during scene traversal
<DL><DT><DD></DL><P>
<A NAME="HitReportingMode">
<A NAME="DOC.2.20.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum HitReportingMode</B></TT>
<DD>Modes to control how IntersectVisitor reports hits.
<DL><DT><DD></DL><P><DL>
<A NAME="ONLY_NEAREST_HIT">
<A NAME="DOC.2.20.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ONLY_NEAREST_HIT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ALL_HITS">
<A NAME="DOC.2.20.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ALL_HITS</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="setHitReportingMode">
<A NAME="DOC.2.20.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setHitReportingMode(<!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> hrm)</B></TT>
<DD>Set the mode of how hits should reported back from a traversal
<DL><DT><DD></DL><P>
<A NAME="getHitReportingMode">
<A NAME="DOC.2.20.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> getHitReportingMode()</B></TT>
<DD>Get the mode of how hits should reported back from a traversal
<DL><DT><DD></DL><P>
<A NAME="HitList">
<A NAME="DOC.2.20.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::multiset&lt;<!1><A HREF="Hit.html">Hit</A>&gt; HitList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SegHitListMap">
<A NAME="DOC.2.20.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::map&lt;<!1><A HREF="Seg.html">Seg</A>*,<!1><A HREF="IntersectVisitor.html#DOC.2.20.8">HitList</A> &gt; SegHitListMap</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getHitList">
<A NAME="DOC.2.20.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectVisitor.html#DOC.2.20.8">HitList</A>&amp; getHitList(<!1><A HREF="Seg.html">Seg</A>* seg)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumHits">
<A NAME="DOC.2.20.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumHits(<!1><A HREF="Seg.html">Seg</A>* seg)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="hits">
<A NAME="DOC.2.20.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool hits()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Node.html">Node</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Geode.html">Geode</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Group.html">Group</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="DCS.html">DCS</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Switch.html">Switch</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="LOD.html">LOD</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.20.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Scene.html">Scene</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="intersect">
<A NAME="DOC.2.20.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool intersect(<!1><A HREF="GeoSet.html">GeoSet</A>&amp; gset)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="pushMatrix">
<A NAME="DOC.2.20.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void pushMatrix(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matrix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="popMatrix">
<A NAME="DOC.2.20.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void popMatrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="enterNode">
<A NAME="DOC.2.20.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool enterNode(<!1><A HREF="Node.html">Node</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="leaveNode">
<A NAME="DOC.2.20.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void leaveNode()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="IntersectStateStack">
<A NAME="DOC.2.20.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="IntersectState.html">IntersectState</A>*&gt; IntersectStateStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_intersectStateStack">
<A NAME="DOC.2.20.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectVisitor.html#DOC.2.20.26">IntersectStateStack</A> _intersectStateStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_nodePath">
<A NAME="DOC.2.20.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodePath.html">NodePath</A> _nodePath</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_hitReportingMode">
<A NAME="DOC.2.20.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectVisitor.html#DOC.2.20.2">HitReportingMode</A> _hitReportingMode</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_segHitList">
<A NAME="DOC.2.20.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="IntersectVisitor.html#DOC.2.20.9">SegHitListMap</A> _segHitList</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

341
doc/osg/LOD.html Normal file
View File

@ -0,0 +1,341 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::LOD</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::LOD</A>: public <!1><A HREF="Group.html#DOC.2.18.9">Group</A></H2>
<BLOCKQUOTE>LOD - Level Of Detail group node which allows switching between children depending on distance from eye point.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=155>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGroup,MGroup.html,CLOD,MLOD.html">
<param name=before value="M,M,M,M,M">
<param name=after value="Md_SPSPSP,Md_SPSP,Md_SP,Md_,M">
<param name=indent value="0,1,2,3,4">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.23.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>LOD</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setRange</B>(unsigned int index, float range)
<DD><I>Sets the value of range list element index to range which is a floating point distance specified in world coordinates.</I>
<DT>
<A HREF="#DOC.2.23.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getRange</B>(unsigned int index)
<DD><I>pfLOD::getRange returns the range element index</I>
<DT>
<A HREF="#DOC.2.23.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumRanges</B>()
<DD><I>returns the number of ranges currently set</I>
<DT>
<A HREF="#DOC.2.23.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setCenter</B>(const <!1><A HREF="Vec3.html">Vec3</A> &amp;center)
<DD><I>Sets the object-space point which defines the center of the osg::LOD.</I>
<DT>
<A HREF="#DOC.2.23.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getCenter</B>()
<DD><I>return the LOD center point.</I>
<DT>
<A HREF="#DOC.2.23.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>evaluate</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, float bias=1.0f)
<DD><I>return the child to traverse.</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.23.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="LOD.html#DOC.2.23.16">RangeList</A> <B>_rangeList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="LOD.html#DOC.2.23.16">RangeList</A> <B>_rangeList2</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_center</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.23.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~LOD</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.23.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected</H3><DD><DT>
<A HREF="#DOC.2.23.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;float&gt; <B>RangeList</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Group.html">Group</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>addChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>removeChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>replaceChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *origChild, <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* newChild )
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumChildren</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>getChild</B>( int i )
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>containsNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
<DT>
<IMG ALT="o" SRC=icon2.gif>ChildList::iterator <B>findNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html#DOC.2.30.1">Node</A>&gt; &gt; <B>ChildList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Group.html#DOC.2.18.8">ChildList</A> <B>_children</B>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>computeBound</B>( void )
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>LOD - Level Of Detail group node which allows switching between children
depending on distance from eye point.
Typical uses are for load balancing - objects further away from
the eye point are rendered at a lower level of detail, and at times
of high stress on the graphics pipeline lower levels of detail can
also be chosen.</BLOCKQUOTE>
<DL>
<A NAME="LOD">
<A NAME="DOC.2.23.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LOD()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.23.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.23.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.23.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.23.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="traverse">
<A NAME="DOC.2.23.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void traverse(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setRange">
<A NAME="DOC.2.23.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setRange(unsigned int index, float range)</B></TT>
<DD>Sets the value of range list element index to range which
is a floating point distance specified in world coordinates.
Range list automatically expands to accomodate values beyond
the current getNumRanges().
<DL><DT><DD></DL><P>
<A NAME="getRange">
<A NAME="DOC.2.23.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getRange(unsigned int index)</B></TT>
<DD>pfLOD::getRange returns the range element index
<DL><DT><DD></DL><P>
<A NAME="getNumRanges">
<A NAME="DOC.2.23.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumRanges()</B></TT>
<DD>returns the number of ranges currently set
<DL><DT><DD></DL><P>
<A NAME="setCenter">
<A NAME="DOC.2.23.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setCenter(const <!1><A HREF="Vec3.html">Vec3</A> &amp;center)</B></TT>
<DD>Sets the object-space point which defines the center of the osg::LOD.
center is affected by any transforms in the hierarchy above the osg::LOD.
<DL><DT><DD></DL><P>
<A NAME="getCenter">
<A NAME="DOC.2.23.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getCenter()</B></TT>
<DD>return the LOD center point.
<DL><DT><DD></DL><P>
<A NAME="evaluate">
<A NAME="DOC.2.23.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int evaluate(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye_local, float bias=1.0f)</B></TT>
<DD>return the child to traverse.
Selected by the distance between the eye point in local
coordinates and the LOD center, mutliplied by the bias.
<DL><DT><DD></DL><P>
<A NAME="~LOD">
<A NAME="DOC.2.23.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~LOD()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.23.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.23.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="RangeList">
<A NAME="DOC.2.23.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;float&gt; RangeList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_rangeList">
<A NAME="DOC.2.23.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="LOD.html#DOC.2.23.16">RangeList</A> _rangeList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_rangeList2">
<A NAME="DOC.2.23.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="LOD.html#DOC.2.23.16">RangeList</A> _rangeList2</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_center">
<A NAME="DOC.2.23.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _center</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

441
doc/osg/Light.html Normal file
View File

@ -0,0 +1,441 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Light</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Light</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Light state class which encapsulates OpenGL glLight() functionality</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CLight,MLight.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.24.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Light</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Light.html#DOC.2.24.31">Light</A>* <B>instance</B>()
<DD><I>return a static instance of an osg::Light, to be used as prototype for loading lights</I>
<DT>
<A HREF="#DOC.2.24.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I>return a shallow copy of a node, with Object* return type</I>
<DT>
<A HREF="#DOC.2.24.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I>return the name of the node's class type</I>
<DT>
<A HREF="#DOC.2.24.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>on</B>( void )
<DD><I> Turn the light on.</I>
<DT>
<A HREF="#DOC.2.24.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>off</B>( void )
<DD><I> Turn the light off.</I>
<DT>
<A HREF="#DOC.2.24.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>( void )
<DD><I>Enable OpenGL's Lighting mode.</I>
<DT>
<A HREF="#DOC.2.24.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>( void )
<DD><I>Disable OpenGL's Lighting mode.</I>
<DT>
<A HREF="#DOC.2.24.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>( void )
<DD><I>Apply the light's state to the OpenGL state machine.</I>
<DT>
<A HREF="#DOC.2.24.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAmbient</B>( const <!1><A HREF="Vec4.html">Vec4</A>&amp; ambient )
<DD><I>Set the ambient component of the light.</I>
<DT>
<A HREF="#DOC.2.24.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getAmbient</B>() const
<DD><I>Get the ambient component of the light.</I>
<DT>
<A HREF="#DOC.2.24.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setDiffuse</B>( const <!1><A HREF="Vec4.html">Vec4</A>&amp; diffuse )
<DD><I>Set the diffuse component of the light.</I>
<DT>
<A HREF="#DOC.2.24.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getDiffuse</B>() const
<DD><I>Get the diffuse component of the light.</I>
<DT>
<A HREF="#DOC.2.24.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setSpecular</B>( const <!1><A HREF="Vec4.html">Vec4</A>&amp; specular )
<DD><I>Set the specular component of the light.</I>
<DT>
<A HREF="#DOC.2.24.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getSpecular</B>() const
<DD><I>Get the specular component of the light.</I>
<DT>
<A HREF="#DOC.2.24.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setPosition</B>( const <!1><A HREF="Vec4.html">Vec4</A>&amp; position )
<DD><I>Set the position of the light.</I>
<DT>
<A HREF="#DOC.2.24.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getPosition</B>() const
<DD><I>Get the position of the light.</I>
<DT>
<A HREF="#DOC.2.24.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setDirection</B>( const <!1><A HREF="Vec3.html">Vec3</A>&amp; direction )
<DD><I>Set the direction of the light.</I>
<DT>
<A HREF="#DOC.2.24.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getDirection</B>() const
<DD><I>Get the direction of the light.</I>
<DT>
<A HREF="#DOC.2.24.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setConstantAttenuation</B>( float constant_attenuation )
<DD><I>Set the constant attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>setConstantAttenuation</B>() const
<DD><I>Get the constant attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setLinearAttenuation</B>( float linear_attenuation )
<DD><I>Set the linear attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getLinearAttenuation</B>() const
<DD><I>Get the linear attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setQuadraticAttenuation</B>( float quadratic_attenuation )
<DD><I>Set the quadratic attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getQuadraticAttenuation</B>() const
<DD><I>Get the quadratic attenuation of the light.</I>
<DT>
<A HREF="#DOC.2.24.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setSpotExponent</B>( float spot_exponent )
<DD><I>Set the spot exponent of the light.</I>
<DT>
<A HREF="#DOC.2.24.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getSpotExponent</B>() const
<DD><I>Get the spot exponent of the light.</I>
<DT>
<A HREF="#DOC.2.24.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setSpotCutoff</B>( float spot_cutoff )
<DD><I>Set the spot cutoff of the light.</I>
<DT>
<A HREF="#DOC.2.24.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getSpotCutoff</B>()
<DD><I>Get the spot cutoff of the light.</I>
<DT>
<A HREF="#DOC.2.24.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>captureLightState</B>()
<DD><I> Capture the lighting settings of the current OpenGL state and store them in this object</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.24.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_lightnum</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_on</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_ambient</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_diffuse</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_specular</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_position</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_direction</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_constant_attenuation</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_linear_attenuation</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_quadratic_attenuation</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_spot_exponent</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.45"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_spot_cutoff</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.46"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static int <B>_currentLightNum</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.24.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Light</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.24.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>init</B>( void )
<DD><I>Initialize the light's settings with some decent defaults.</I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp;)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Light state class which encapsulates OpenGL glLight() functionality</BLOCKQUOTE>
<DL>
<A NAME="Light">
<A NAME="DOC.2.24.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Light()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.24.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Light.html#DOC.2.24.31">Light</A>* instance()</B></TT>
<DD>return a static instance of an osg::Light, to be used as prototype
for loading lights
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.24.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DD>return a shallow copy of a node, with Object* return type
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.24.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.24.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DD>return the name of the node's class type
<DL><DT><DD></DL><P>
<A NAME="on">
<A NAME="DOC.2.24.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void on( void )</B></TT>
<DD>
Turn the light on.
Calling this method doesn't directly affect OpenGL's lighting mode.
<DL><DT><DD></DL><P>
<A NAME="off">
<A NAME="DOC.2.24.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void off( void )</B></TT>
<DD>
Turn the light off.
Calling this method doesn't directly affect OpenGL's lighting mode.
<DL><DT><DD></DL><P>
<A NAME="enable">
<A NAME="DOC.2.24.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable( void )</B></TT>
<DD>Enable OpenGL's Lighting mode.
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.24.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable( void )</B></TT>
<DD>Disable OpenGL's Lighting mode.
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.24.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply( void )</B></TT>
<DD>Apply the light's state to the OpenGL state machine.
<DL><DT><DD></DL><P>
<A NAME="setAmbient">
<A NAME="DOC.2.24.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAmbient( const <!1><A HREF="Vec4.html">Vec4</A>&amp; ambient )</B></TT>
<DD>Set the ambient component of the light.
<DL><DT><DD></DL><P>
<A NAME="getAmbient">
<A NAME="DOC.2.24.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getAmbient() const </B></TT>
<DD>Get the ambient component of the light.
<DL><DT><DD></DL><P>
<A NAME="setDiffuse">
<A NAME="DOC.2.24.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setDiffuse( const <!1><A HREF="Vec4.html">Vec4</A>&amp; diffuse )</B></TT>
<DD>Set the diffuse component of the light.
<DL><DT><DD></DL><P>
<A NAME="getDiffuse">
<A NAME="DOC.2.24.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getDiffuse() const </B></TT>
<DD>Get the diffuse component of the light.
<DL><DT><DD></DL><P>
<A NAME="setSpecular">
<A NAME="DOC.2.24.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setSpecular( const <!1><A HREF="Vec4.html">Vec4</A>&amp; specular )</B></TT>
<DD>Set the specular component of the light.
<DL><DT><DD></DL><P>
<A NAME="getSpecular">
<A NAME="DOC.2.24.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getSpecular() const </B></TT>
<DD>Get the specular component of the light.
<DL><DT><DD></DL><P>
<A NAME="setPosition">
<A NAME="DOC.2.24.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setPosition( const <!1><A HREF="Vec4.html">Vec4</A>&amp; position )</B></TT>
<DD>Set the position of the light.
<DL><DT><DD></DL><P>
<A NAME="getPosition">
<A NAME="DOC.2.24.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getPosition() const </B></TT>
<DD>Get the position of the light.
<DL><DT><DD></DL><P>
<A NAME="setDirection">
<A NAME="DOC.2.24.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setDirection( const <!1><A HREF="Vec3.html">Vec3</A>&amp; direction )</B></TT>
<DD>Set the direction of the light.
<DL><DT><DD></DL><P>
<A NAME="getDirection">
<A NAME="DOC.2.24.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getDirection() const </B></TT>
<DD>Get the direction of the light.
<DL><DT><DD></DL><P>
<A NAME="setConstantAttenuation">
<A NAME="DOC.2.24.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setConstantAttenuation( float constant_attenuation )</B></TT>
<DD>Set the constant attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="setConstantAttenuation">
<A NAME="DOC.2.24.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float setConstantAttenuation() const </B></TT>
<DD>Get the constant attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="setLinearAttenuation">
<A NAME="DOC.2.24.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setLinearAttenuation( float linear_attenuation )</B></TT>
<DD>Set the linear attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="getLinearAttenuation">
<A NAME="DOC.2.24.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getLinearAttenuation() const </B></TT>
<DD>Get the linear attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="setQuadraticAttenuation">
<A NAME="DOC.2.24.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setQuadraticAttenuation( float quadratic_attenuation )</B></TT>
<DD>Set the quadratic attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="getQuadraticAttenuation">
<A NAME="DOC.2.24.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getQuadraticAttenuation() const </B></TT>
<DD>Get the quadratic attenuation of the light.
<DL><DT><DD></DL><P>
<A NAME="setSpotExponent">
<A NAME="DOC.2.24.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setSpotExponent( float spot_exponent )</B></TT>
<DD>Set the spot exponent of the light.
<DL><DT><DD></DL><P>
<A NAME="getSpotExponent">
<A NAME="DOC.2.24.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getSpotExponent() const </B></TT>
<DD>Get the spot exponent of the light.
<DL><DT><DD></DL><P>
<A NAME="setSpotCutoff">
<A NAME="DOC.2.24.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setSpotCutoff( float spot_cutoff )</B></TT>
<DD>Set the spot cutoff of the light.
<DL><DT><DD></DL><P>
<A NAME="getSpotCutoff">
<A NAME="DOC.2.24.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getSpotCutoff()</B></TT>
<DD>Get the spot cutoff of the light.
<DL><DT><DD></DL><P>
<A NAME="captureLightState">
<A NAME="DOC.2.24.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void captureLightState()</B></TT>
<DD>
Capture the lighting settings of the current OpenGL state
and store them in this object
<DL><DT><DD></DL><P>
<A NAME="~Light">
<A NAME="DOC.2.24.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Light( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="init">
<A NAME="DOC.2.24.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void init( void )</B></TT>
<DD>Initialize the light's settings with some decent defaults.
<DL><DT><DD></DL><P>
<A NAME="_lightnum">
<A NAME="DOC.2.24.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _lightnum</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_on">
<A NAME="DOC.2.24.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _on</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_ambient">
<A NAME="DOC.2.24.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _ambient</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_diffuse">
<A NAME="DOC.2.24.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _diffuse</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_specular">
<A NAME="DOC.2.24.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _specular</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_position">
<A NAME="DOC.2.24.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _position</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_direction">
<A NAME="DOC.2.24.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _direction</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_constant_attenuation">
<A NAME="DOC.2.24.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _constant_attenuation</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_linear_attenuation">
<A NAME="DOC.2.24.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _linear_attenuation</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_quadratic_attenuation">
<A NAME="DOC.2.24.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _quadratic_attenuation</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_spot_exponent">
<A NAME="DOC.2.24.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _spot_exponent</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_spot_cutoff">
<A NAME="DOC.2.24.45">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _spot_cutoff</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_currentLightNum">
<A NAME="DOC.2.24.46">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static int _currentLightNum</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

241
doc/osg/LightSource.html Normal file
View File

@ -0,0 +1,241 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::LightSource</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::LightSource</A>: public <!1><A HREF="Node.html#DOC.2.30.1">Node</A></H2>
<BLOCKQUOTE>Leaf Node for defining a light in the scene</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=125>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CLightSource,MLightSource.html">
<param name=before value="M,M,M,M">
<param name=after value="Md_SPSP,Md_SP,Md_,M">
<param name=indent value="0,1,2,3">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.25.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>LightSource</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setLight</B>(<!1><A HREF="Light.html">Light</A>* light)
<DD><I>Set the attached light</I>
<DT>
<A HREF="#DOC.2.25.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Light.html">Light</A>* <B>getLight</B>()
<DD><I>Get the attached light</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.25.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Light.html">Light</A>&gt; <B>_light</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.25.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~LightSource</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.25.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>computeBound</B>( void )
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Leaf Node for defining a light in the scene</BLOCKQUOTE>
<DL>
<A NAME="LightSource">
<A NAME="DOC.2.25.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LightSource()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.25.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.25.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.25.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.25.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setLight">
<A NAME="DOC.2.25.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setLight(<!1><A HREF="Light.html">Light</A>* light)</B></TT>
<DD>Set the attached light
<DL><DT><DD></DL><P>
<A NAME="getLight">
<A NAME="DOC.2.25.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Light.html">Light</A>* getLight()</B></TT>
<DD>Get the attached light
<DL><DT><DD></DL><P>
<A NAME="~LightSource">
<A NAME="DOC.2.25.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~LightSource()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.25.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.25.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.25.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool computeBound( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_light">
<A NAME="DOC.2.25.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Light.html">Light</A>&gt; _light</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

46
doc/osg/Lighting.html Normal file
View File

@ -0,0 +1,46 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Lighting</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Lighting</A></H2>
<BLOCKQUOTE>Class to globally control OpenGL's lighting</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.26.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>()
<DD><I>Enable lighting</I>
<DT>
<A HREF="#DOC.2.26.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>()
<DD><I>Disable lighting</I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Class to globally control OpenGL's lighting</BLOCKQUOTE>
<DL>
<A NAME="enable">
<A NAME="DOC.2.26.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable()</B></TT>
<DD>Enable lighting
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.26.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable()</B></TT>
<DD>Disable lighting
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

424
doc/osg/Material.html Normal file
View File

@ -0,0 +1,424 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Material</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Material</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CMaterial,MMaterial.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.27.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>MaterialFace</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>ColorMode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.27.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Material</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Material.html#DOC.2.27.3">Material</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setColorMode</B>(<!1><A HREF="Material.html#DOC.2.27.2">ColorMode</A> mode)
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setAmbient</B>( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; ambient )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getAmbient</B>(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getAmbientFrontAndBack</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setDiffuse</B>( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; diffuse )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getDiffuse</B>(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getDiffuseFrontAndBack</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setSpecular</B>( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; specular )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getSpecular</B>(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getSpecularFrontAndBack</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setEmission</B>( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; emission )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec4.html">Vec4</A>&amp; <B>getEmission</B>(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getEmissionFrontAndBack</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setShininess</B>( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, float shininess )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getShininess</B>(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getShininessFrontAndBack</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.27.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Material.html#DOC.2.27.2">ColorMode</A> <B>_colorMode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_ambientFrontAndBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_ambientFront</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_ambientBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_diffuseFrontAndBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_diffuseFront</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_diffuseBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_specularFrontAndBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_specularFront</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_specularBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_emissionFrontAndBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_emissionFront</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_emissionBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_shininessFrontAndBack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_shininessFront</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_shininessBack</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.27.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Material</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.27.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>matchFaceAndColor</B>(<!1><A HREF="Input.html">Input</A>&amp; fr, const char* name, <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A>&amp; mf, <!1><A HREF="Vec4.html">Vec4</A>&amp; color)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="MaterialFace">
<A NAME="DOC.2.27.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum MaterialFace</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="FACE_FRONT">
<A NAME="DOC.2.27.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FACE_FRONT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FACE_BACK">
<A NAME="DOC.2.27.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FACE_BACK</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FACE_FRONT_AND_BACK">
<A NAME="DOC.2.27.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FACE_FRONT_AND_BACK</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="ColorMode">
<A NAME="DOC.2.27.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum ColorMode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="AMBIENT">
<A NAME="DOC.2.27.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> AMBIENT</B></TT>
<DL><DT><DD></DL><P>
<A NAME="DIFFUSE">
<A NAME="DOC.2.27.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> DIFFUSE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SPECULAR">
<A NAME="DOC.2.27.2.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> SPECULAR</B></TT>
<DL><DT><DD></DL><P>
<A NAME="EMISSION">
<A NAME="DOC.2.27.2.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> EMISSION</B></TT>
<DL><DT><DD></DL><P>
<A NAME="AMBIENT_AND_DIFFUSE">
<A NAME="DOC.2.27.2.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> AMBIENT_AND_DIFFUSE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OFF">
<A NAME="DOC.2.27.2.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OFF</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="Material">
<A NAME="DOC.2.27.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Material( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.27.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Material.html#DOC.2.27.3">Material</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.27.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.27.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.27.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.27.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setColorMode">
<A NAME="DOC.2.27.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setColorMode(<!1><A HREF="Material.html#DOC.2.27.2">ColorMode</A> mode)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setAmbient">
<A NAME="DOC.2.27.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setAmbient( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; ambient )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getAmbient">
<A NAME="DOC.2.27.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getAmbient(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getAmbientFrontAndBack">
<A NAME="DOC.2.27.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getAmbientFrontAndBack()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setDiffuse">
<A NAME="DOC.2.27.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setDiffuse( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; diffuse )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getDiffuse">
<A NAME="DOC.2.27.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getDiffuse(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getDiffuseFrontAndBack">
<A NAME="DOC.2.27.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getDiffuseFrontAndBack()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setSpecular">
<A NAME="DOC.2.27.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setSpecular( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; specular )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getSpecular">
<A NAME="DOC.2.27.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getSpecular(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getSpecularFrontAndBack">
<A NAME="DOC.2.27.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getSpecularFrontAndBack()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setEmission">
<A NAME="DOC.2.27.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setEmission( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, const <!1><A HREF="Vec4.html">Vec4</A>&amp; emission )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getEmission">
<A NAME="DOC.2.27.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec4.html">Vec4</A>&amp; getEmission(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getEmissionFrontAndBack">
<A NAME="DOC.2.27.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getEmissionFrontAndBack()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setShininess">
<A NAME="DOC.2.27.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setShininess( <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face, float shininess )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getShininess">
<A NAME="DOC.2.27.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getShininess(<!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A> face) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="getShininessFrontAndBack">
<A NAME="DOC.2.27.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getShininessFrontAndBack()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Material">
<A NAME="DOC.2.27.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Material( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.27.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.27.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="matchFaceAndColor">
<A NAME="DOC.2.27.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool matchFaceAndColor(<!1><A HREF="Input.html">Input</A>&amp; fr, const char* name, <!1><A HREF="Material.html#DOC.2.27.1">MaterialFace</A>&amp; mf, <!1><A HREF="Vec4.html">Vec4</A>&amp; color)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_colorMode">
<A NAME="DOC.2.27.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Material.html#DOC.2.27.2">ColorMode</A> _colorMode</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_ambientFrontAndBack">
<A NAME="DOC.2.27.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _ambientFrontAndBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_ambientFront">
<A NAME="DOC.2.27.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _ambientFront</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_ambientBack">
<A NAME="DOC.2.27.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _ambientBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_diffuseFrontAndBack">
<A NAME="DOC.2.27.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _diffuseFrontAndBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_diffuseFront">
<A NAME="DOC.2.27.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _diffuseFront</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_diffuseBack">
<A NAME="DOC.2.27.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _diffuseBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_specularFrontAndBack">
<A NAME="DOC.2.27.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _specularFrontAndBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_specularFront">
<A NAME="DOC.2.27.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _specularFront</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_specularBack">
<A NAME="DOC.2.27.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _specularBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_emissionFrontAndBack">
<A NAME="DOC.2.27.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _emissionFrontAndBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_emissionFront">
<A NAME="DOC.2.27.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _emissionFront</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_emissionBack">
<A NAME="DOC.2.27.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _emissionBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_shininessFrontAndBack">
<A NAME="DOC.2.27.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _shininessFrontAndBack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_shininessFront">
<A NAME="DOC.2.27.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _shininessFront</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_shininessBack">
<A NAME="DOC.2.27.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _shininessBack</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

356
doc/osg/Matrix.html Normal file
View File

@ -0,0 +1,356 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Matrix</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Matrix</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>4x4 Matrix for storage & manipulation of transformations in scene graph.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=125>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CMatrix,MMatrix.html,CTexMat,MTexMat.html">
<param name=before value="M,M,M,M^_">
<param name=after value="Md_SP,Md_,M,M">
<param name=indent value="0,1,2,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.28.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_mat</B>[4][4]
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.28.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Matrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Matrix</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Matrix</B>( float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; <B>operator = </B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Matrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeIdent</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>set</B>(const float* m)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>copy</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeScale</B>(float sx, float sy, float sz)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preScale</B>( float sx, float sy, float sz, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postScale</B>( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float sx, float sy, float sz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preScale</B>( float sx, float sy, float sz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postScale</B>( float sx, float sy, float sz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeTrans</B>( float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preTrans</B>( float tx, float ty, float tz, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postTrans</B>( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preTrans</B>( float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postTrans</B>( float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeRot</B>( float deg, float x, float y, float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preRot</B>( float deg, float x, float y, float z, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postRot</B>( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float deg, float x, float y, float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preRot</B>( float deg, float x, float y, float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postRot</B>( float deg, float x, float y, float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTrans</B>( float tx, float ty, float tz )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTrans</B>( const <!1><A HREF="Vec3.html">Vec3</A>&amp; v )
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>getTrans</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>preMult</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>postMult</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>mult</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; lhs, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; rhs)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A> <B>operator * </B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Vec3.html">Vec3</A> <B>operator * </B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline friend <!1><A HREF="Vec3.html">Vec3</A> <B>operator * </B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; v, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>invert</B>(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.28.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.28.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>4x4 Matrix for storage & manipulation of transformations in scene graph.
Provides basic maths operations, IO and via osg::Object reference counting.</BLOCKQUOTE>
<DL>
<A NAME="Matrix">
<A NAME="DOC.2.28.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Matrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Matrix">
<A NAME="DOC.2.28.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Matrix(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Matrix">
<A NAME="DOC.2.28.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Matrix( float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.28.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; operator = (const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Matrix">
<A NAME="DOC.2.28.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Matrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.28.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.28.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.28.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.28.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeIdent">
<A NAME="DOC.2.28.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeIdent()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="set">
<A NAME="DOC.2.28.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void set(const float* m)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="copy">
<A NAME="DOC.2.28.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void copy(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; matrix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeScale">
<A NAME="DOC.2.28.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeScale(float sx, float sy, float sz)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preScale">
<A NAME="DOC.2.28.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preScale( float sx, float sy, float sz, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postScale">
<A NAME="DOC.2.28.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postScale( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float sx, float sy, float sz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preScale">
<A NAME="DOC.2.28.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preScale( float sx, float sy, float sz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postScale">
<A NAME="DOC.2.28.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postScale( float sx, float sy, float sz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeTrans">
<A NAME="DOC.2.28.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeTrans( float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preTrans">
<A NAME="DOC.2.28.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preTrans( float tx, float ty, float tz, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postTrans">
<A NAME="DOC.2.28.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postTrans( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preTrans">
<A NAME="DOC.2.28.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preTrans( float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postTrans">
<A NAME="DOC.2.28.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postTrans( float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeRot">
<A NAME="DOC.2.28.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeRot( float deg, float x, float y, float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preRot">
<A NAME="DOC.2.28.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preRot( float deg, float x, float y, float z, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postRot">
<A NAME="DOC.2.28.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postRot( const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m, float deg, float x, float y, float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="preRot">
<A NAME="DOC.2.28.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preRot( float deg, float x, float y, float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postRot">
<A NAME="DOC.2.28.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postRot( float deg, float x, float y, float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setTrans">
<A NAME="DOC.2.28.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTrans( float tx, float ty, float tz )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setTrans">
<A NAME="DOC.2.28.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTrans( const <!1><A HREF="Vec3.html">Vec3</A>&amp; v )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getTrans">
<A NAME="DOC.2.28.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> getTrans() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="preMult">
<A NAME="DOC.2.28.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void preMult(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="postMult">
<A NAME="DOC.2.28.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void postMult(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="mult">
<A NAME="DOC.2.28.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void mult(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; lhs, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; rhs)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator * ">
<A NAME="DOC.2.28.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A> operator * (const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator * ">
<A NAME="DOC.2.28.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Vec3.html">Vec3</A> operator * (const <!1><A HREF="Vec3.html">Vec3</A>&amp; v) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator * ">
<A NAME="DOC.2.28.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline friend <!1><A HREF="Vec3.html">Vec3</A> operator * (const <!1><A HREF="Vec3.html">Vec3</A>&amp; v, const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="invert">
<A NAME="DOC.2.28.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool invert(const <!1><A HREF="Matrix.html#DOC.2.28.1">Matrix</A>&amp; m)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_mat">
<A NAME="DOC.2.28.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _mat[4][4]</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.28.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.28.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="TexMat.html">TexMat</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

122
doc/osg/MemoryAdapter.html Normal file
View File

@ -0,0 +1,122 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::MemoryAdapter</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::MemoryAdapter</A>: public <!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A></H2>
<BLOCKQUOTE>Class for adapting the memory management of external data.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CMemoryAdapter,MMemoryAdapter.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.29.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>MemoryAdapter</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.29.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>incrementReference</B>(void* )
<DD><I>Increment the reference count of the userData</I>
<DT>
<A HREF="#DOC.2.29.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>decrementReference</B>(void* )
<DD><I>Decrement the reference count of the userData.</I>
<DT>
<A HREF="#DOC.2.29.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void* <B>clone</B>(void* )
<DD><I>not current used, but will be used in future</I>
<DT>
<A HREF="#DOC.2.29.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; , void* )
<DD><I>not current used, but will be used in future</I>
<DT>
<A HREF="#DOC.2.29.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>read</B>(<!1><A HREF="Input.html">Input</A>&amp; , void* )
<DD><I>not current used, but will be used in future</I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.29.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~MemoryAdapter</B>()
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Class for adapting the memory management of external data.
Typically used to specify the memory management of user data
which can be attached to osg::Node.</BLOCKQUOTE>
<DL>
<A NAME="MemoryAdapter">
<A NAME="DOC.2.29.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> MemoryAdapter()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="incrementReference">
<A NAME="DOC.2.29.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void incrementReference(void* )</B></TT>
<DD>Increment the reference count of the userData
<DL><DT><DD></DL><P>
<A NAME="decrementReference">
<A NAME="DOC.2.29.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void decrementReference(void* )</B></TT>
<DD>Decrement the reference count of the userData.
Is usually implemented such that if reference count
is decremented to zero the userData should be
deleted. However, this is entirely up to the
discression of the user who is extending this base class.
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.29.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void* clone(void* )</B></TT>
<DD>not current used, but will be used in future
<DL><DT><DD></DL><P>
<A NAME="write">
<A NAME="DOC.2.29.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool write(<!1><A HREF="Output.html">Output</A>&amp; , void* )</B></TT>
<DD>not current used, but will be used in future
<DL><DT><DD></DL><P>
<A NAME="read">
<A NAME="DOC.2.29.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool read(<!1><A HREF="Input.html">Input</A>&amp; , void* )</B></TT>
<DD>not current used, but will be used in future
<DL><DT><DD></DL><P>
<A NAME="~MemoryAdapter">
<A NAME="DOC.2.29.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~MemoryAdapter()</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

BIN
doc/osg/NavigatorButton.class Normal file
View File

Binary file not shown.

444
doc/osg/Node.html Normal file
View File

@ -0,0 +1,444 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Node</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Node</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<BLOCKQUOTE>Base class for all internal nodes in the scene graph.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=185>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CLightSource,MLightSource.html,CGroup,MGroup.html,CGeode,MGeode.html">
<param name=before value="M,M,M,M|_,MR_,Mr_">
<param name=after value="Md_SP,Md_,M,M,M,M">
<param name=indent value="0,1,2,2,2,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.30.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Node</B>()
<DD><I>Construct a node.</I>
<DT>
<A HREF="#DOC.2.30.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I>return a shallow copy of a node, with Object* return type</I>
<DT>
<A HREF="#DOC.2.30.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DD><I>return a shallow copy of a node, with Node* return type</I>
<DT>
<A HREF="#DOC.2.30.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I>return true if this and obj are of the same kind of object</I>
<DT>
<A HREF="#DOC.2.30.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I>return the name of the node's class type</I>
<DT>
<A HREF="#DOC.2.30.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I>Visitor Pattern : calls the apply method of a NodeVisitor with this node's type</I>
<DT>
<A HREF="#DOC.2.30.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I>Traverse upwards : calls parents' accept method with NodeVisitor</I>
<DT>
<A HREF="#DOC.2.30.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; )
<DD><I>Traverse downwards : calls children's accept method with NodeVisitor</I>
<DT>
<A HREF="#DOC.2.30.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setName</B>( const std::string&amp; name )
<DD><I>Set the name of node using C++ style string</I>
<DT>
<A HREF="#DOC.2.30.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setName</B>( const char* name )
<DD><I>Set the name of node using a C style string</I>
<DT>
<A HREF="#DOC.2.30.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const std::string&amp; <B>getName</B>( void )
<DD><I>Get the name of node</I>
<DT>
<A HREF="#DOC.2.30.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DD><I>Get the parent list of node.</I>
<DT>
<A HREF="#DOC.2.30.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DD><I> Get a single parent of node.</I>
<DT>
<A HREF="#DOC.2.30.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumParents</B>() const
<DD><I> Get the number of parents of node.</I>
<DT>
<A HREF="#DOC.2.30.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DD><I> Set user data.</I>
<DT>
<A HREF="#DOC.2.30.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void* <B>getUserData</B>() const
<DD><I>Get user data</I>
<DT>
<A HREF="#DOC.2.30.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DD><I>Get the memory adapter associated with _userData</I>
<DT>
<A HREF="#DOC.2.30.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DD><I>Set the node mask.</I>
<DT>
<A HREF="#DOC.2.30.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DD><I>Get the node Mask.</I>
<DT>
<A HREF="#DOC.2.30.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DD><I>Get the description list of the const node</I>
<DT>
<A HREF="#DOC.2.30.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DD><I>Get the description list of the const node</I>
<DT>
<A HREF="#DOC.2.30.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const std::string&amp; <B>getDescription</B>(int i) const
<DD><I>Get a single const description of the const node</I>
<DT>
<A HREF="#DOC.2.30.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string&amp; <B>getDescription</B>(int i)
<DD><I>Get a single description of the node</I>
<DT>
<A HREF="#DOC.2.30.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumDescriptions</B>() const
<DD><I>Get the number of descriptions of the node</I>
<DT>
<A HREF="#DOC.2.30.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>addDescription</B>(const std::string&amp; desc)
<DD><I>Add a description string to the node</I>
<DT>
<A HREF="#DOC.2.30.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DD><I>get the bounding sphere of node.</I>
<DT>
<A HREF="#DOC.2.30.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>dirtyBound</B>()
<DD><I>Mark this node's bounding sphere dirty.</I>
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<A HREF="#DOC.2.30.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DD><I>A vector of osg::Group pointers which is used to store the parent(s) of node</I>
<DT>
<A HREF="#DOC.2.30.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef unsigned int <B>NodeMask</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
<DD><I>A vector of std::string's which are used to describe the object</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.30.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_bsphere_computed</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string <B>_name</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>friend <B>Group</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void* <B>_userData</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.30.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.30.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Node</B>()
<DD><I>Node destructor.</I>
<DT>
<A HREF="#DOC.2.30.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I> Template Method Pattern : read local data from osg file.</I>
<DT>
<A HREF="#DOC.2.30.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I> Template Method Pattern : read local data from osg file.</I>
<DT>
<A HREF="#DOC.2.30.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>computeBound</B>( void )
<DD><I>Compute the bounding sphere around Node's geometry or children.</I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Base class for all internal nodes in the scene graph.
Provides interface for most common node operations (Composite Pattern).</BLOCKQUOTE>
<DL>
<A NAME="Node">
<A NAME="DOC.2.30.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Node()</B></TT>
<DD>Construct a node.
Initialize the parent list to empty, node name to "" and
bounding sphere dirty flag to true.
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.30.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DD>return a shallow copy of a node, with Object* return type
<DL><DT><DD></DL><P>
<A NAME="cloneNode">
<A NAME="DOC.2.30.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* cloneNode() const </B></TT>
<DD>return a shallow copy of a node, with Node* return type
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.30.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DD>return true if this and obj are of the same kind of object
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.30.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DD>return the name of the node's class type
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.30.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DD>Visitor Pattern : calls the apply method of a NodeVisitor with this node's type
<DL><DT><DD></DL><P>
<A NAME="ascend">
<A NAME="DOC.2.30.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void ascend(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DD>Traverse upwards : calls parents' accept method with NodeVisitor
<DL><DT><DD></DL><P>
<A NAME="traverse">
<A NAME="DOC.2.30.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void traverse(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; )</B></TT>
<DD>Traverse downwards : calls children's accept method with NodeVisitor
<DL><DT><DD></DL><P>
<A NAME="setName">
<A NAME="DOC.2.30.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setName( const std::string&amp; name )</B></TT>
<DD>Set the name of node using C++ style string
<DL><DT><DD></DL><P>
<A NAME="setName">
<A NAME="DOC.2.30.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setName( const char* name )</B></TT>
<DD>Set the name of node using a C style string
<DL><DT><DD></DL><P>
<A NAME="getName">
<A NAME="DOC.2.30.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const std::string&amp; getName( void )</B></TT>
<DD>Get the name of node
<DL><DT><DD></DL><P>
<A NAME="ParentList">
<A NAME="DOC.2.30.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; ParentList</B></TT>
<DD>A vector of osg::Group pointers which is used to store the parent(s) of node
<DL><DT><DD></DL><P>
<A NAME="getParents">
<A NAME="DOC.2.30.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; getParents() const </B></TT>
<DD>Get the parent list of node.
<DL><DT><DD></DL><P>
<A NAME="getParent">
<A NAME="DOC.2.30.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* getParent(int i) const </B></TT>
<DD>
Get a single parent of node.
<DL><DT><DT><B>Parameters:</B><DD><B>i</B> - index of the parent to get.
<BR><DT><B>Returns:</B><DD> the parent i.<BR><DD></DL><P>
<A NAME="getNumParents">
<A NAME="DOC.2.30.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumParents() const </B></TT>
<DD>
Get the number of parents of node.
<DL><DT><DT><B>Returns:</B><DD> the number of parents of this node.<BR><DD></DL><P>
<A NAME="setUserData">
<A NAME="DOC.2.30.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setUserData(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)</B></TT>
<DD>
Set user data. See MemoryAdapter documention for details
of how to specify memory managament of _userData.
<DL><DT><DD></DL><P>
<A NAME="getUserData">
<A NAME="DOC.2.30.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void* getUserData() const </B></TT>
<DD>Get user data
<DL><DT><DD></DL><P>
<A NAME="getMemoryAdapter">
<A NAME="DOC.2.30.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* getMemoryAdapter() const </B></TT>
<DD>Get the memory adapter associated with _userData
<DL><DT><DD></DL><P>
<A NAME="NodeMask">
<A NAME="DOC.2.30.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef unsigned int NodeMask</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setNodeMask">
<A NAME="DOC.2.30.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNodeMask(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)</B></TT>
<DD>Set the node mask. Note, node mask is will be replaced by TraversalMask.
<DL><DT><DD></DL><P>
<A NAME="getNodeMask">
<A NAME="DOC.2.30.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> getNodeMask()</B></TT>
<DD>Get the node Mask. Note, node mask is will be replaced by TraversalMask.
<DL><DT><DD></DL><P>
<A NAME="DescriptionList">
<A NAME="DOC.2.30.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;std::string&gt; DescriptionList</B></TT>
<DD>A vector of std::string's which are used to describe the object
<DL><DT><DD></DL><P>
<A NAME="getDescriptions">
<A NAME="DOC.2.30.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; getDescriptions() const </B></TT>
<DD>Get the description list of the const node
<DL><DT><DD></DL><P>
<A NAME="getDescriptions">
<A NAME="DOC.2.30.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; getDescriptions()</B></TT>
<DD>Get the description list of the const node
<DL><DT><DD></DL><P>
<A NAME="getDescription">
<A NAME="DOC.2.30.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const std::string&amp; getDescription(int i) const </B></TT>
<DD>Get a single const description of the const node
<DL><DT><DD></DL><P>
<A NAME="getDescription">
<A NAME="DOC.2.30.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string&amp; getDescription(int i)</B></TT>
<DD>Get a single description of the node
<DL><DT><DD></DL><P>
<A NAME="getNumDescriptions">
<A NAME="DOC.2.30.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumDescriptions() const </B></TT>
<DD>Get the number of descriptions of the node
<DL><DT><DD></DL><P>
<A NAME="addDescription">
<A NAME="DOC.2.30.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void addDescription(const std::string&amp; desc)</B></TT>
<DD>Add a description string to the node
<DL><DT><DD></DL><P>
<A NAME="getBound">
<A NAME="DOC.2.30.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; getBound()</B></TT>
<DD>get the bounding sphere of node.
Using lazy evaluation computes the bounding sphere if it is 'dirty'.
<DL><DT><DD></DL><P>
<A NAME="dirtyBound">
<A NAME="DOC.2.30.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void dirtyBound()</B></TT>
<DD>Mark this node's bounding sphere dirty.
Forcing it to be computed on the next call to getBound().
<DL><DT><DD></DL><P>
<A NAME="~Node">
<A NAME="DOC.2.30.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Node()</B></TT>
<DD>Node destructor. Note, is protected so that Nodes cannot
be deleted other than by being dereferenced and the reference
count being zero (see osg::Referenced), preventing the deletion
of nodes which are still in use. This also means that
Node's cannot be created on stack i.e Node node will not compile,
forcing all nodes to be created on the heap i.e Node* node
= new Node().
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.30.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DD>
Template Method Pattern : read local data from osg file.
Note should be implemented in derived classes, which
call their parent class's readLocalData.
<DL><DT><DT><B>Returns:</B><DD> true if the input iterator has been advanced, otherwise false.<BR><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.30.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DD>
Template Method Pattern : read local data from osg file.
Note should be implemented in derivied classes, which
call their parent class's writeLocalData.
<DL><DT><DT><B>Returns:</B><DD> true if data has been written out, otherwise false.<BR><DD></DL><P>
<A NAME="computeBound">
<A NAME="DOC.2.30.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool computeBound( void )</B></TT>
<DD>Compute the bounding sphere around Node's geometry or children.
This method is automatically called by getBound() when the bounding
sphere has been marked dirty via dirtyBound().
<DL><DT><DD></DL><P>
<A NAME="_bsphere">
<A NAME="DOC.2.30.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="BoundingSphere.html">BoundingSphere</A> _bsphere</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_bsphere_computed">
<A NAME="DOC.2.30.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _bsphere_computed</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_name">
<A NAME="DOC.2.30.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string _name</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_parents">
<A NAME="DOC.2.30.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> _parents</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Group">
<A NAME="DOC.2.30.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>friend Group</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_userData">
<A NAME="DOC.2.30.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void* _userData</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_memoryAdapter">
<A NAME="DOC.2.30.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; _memoryAdapter</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_nodeMask">
<A NAME="DOC.2.30.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> _nodeMask</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_descriptions">
<A NAME="DOC.2.30.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> _descriptions</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="LightSource.html">LightSource</A><BR>
<A HREF="Group.html">Group</A><BR>
<A HREF="Geode.html">Geode</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

53
doc/osg/NodeAcceptOp.html Normal file
View File

@ -0,0 +1,53 @@
<HTML>
<HEAD>
<TITLE>struct osg::NodeAcceptOp</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>struct <A HREF="#DOC.DOCU">osg::NodeAcceptOp</A></H2>
<BLOCKQUOTE>Convinience functor for assisting visiting of arrays of osg::Node's</BLOCKQUOTE>
<HR>
<P><DL>
<DT>
<A HREF="#DOC.2.33.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; <B>_nv</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.33.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>NodeAcceptOp</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.33.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>operator () </B>(<!1><A HREF="Node.html">Node</A>* node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.33.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>operator () </B>(<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html">Node</A>&gt; node)
<DD><I></I>
</DL></P>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Convinience functor for assisting visiting of arrays of osg::Node's</BLOCKQUOTE>
<DL>
<A NAME="_nv">
<A NAME="DOC.2.33.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; _nv</B></TT>
<DL><DT><DD></DL><P>
<A NAME="NodeAcceptOp">
<A NAME="DOC.2.33.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NodeAcceptOp(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator () ">
<A NAME="DOC.2.33.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void operator () (<!1><A HREF="Node.html">Node</A>* node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator () ">
<A NAME="DOC.2.33.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void operator () (<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html">Node</A>&gt; node)</B></TT>
<DL><DT><DD></DL><P></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

20
doc/osg/NodePath.html Normal file
View File

@ -0,0 +1,20 @@
<HTML>
<HEAD>
<TITLE>typedef std::vector<Node*> osg::NodePath</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>typedef std::vector&lt;<!1><A HREF="Node.html">Node</A>*&gt; <A HREF="#DOC.DOCU">osg::NodePath</A></H2>
<BLOCKQUOTE>A vector of Nodes pointers which is used to describe the path from a root node to a descendant</BLOCKQUOTE>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>A vector of Nodes pointers which is used to describe the path from a root node to a descendant</BLOCKQUOTE>
<DL>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

241
doc/osg/NodeVisitor.html Normal file
View File

@ -0,0 +1,241 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::NodeVisitor</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::NodeVisitor</A>: public <!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A></H2>
<BLOCKQUOTE>Visitor for type safe operations on osg::Node's.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CNodeVisitor,MNodeVisitor.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.32.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>TraversalMode</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.32.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>NodeVisitor</B>(<!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> tm=TRAVERSE_NONE)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~NodeVisitor</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTraverseMode</B>(<!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> mode)
<DD><I>Set the traversal mode for Node::traverse() to use when deciding which children of a node to traverse.</I>
<DT>
<A HREF="#DOC.2.32.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> <B>getTraverseMode</B>()
<DD><I>Get the traversal mode</I>
<DT>
<A HREF="#DOC.2.32.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTraverseVisitor</B>(<!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* nv)
<DD><I>Set a visitor to handle traversal.</I>
<DT>
<A HREF="#DOC.2.32.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* <B>getTraverseVisitor</B>()
<DD><I>Get the traverse visitor, returns NULL if none is attached</I>
<DT>
<A HREF="#DOC.2.32.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>traverse</B>(<!1><A HREF="Node.html">Node</A>&amp; node)
<DD><I>Inline method for passing handling traversal of a nodes.</I>
<DT>
<A HREF="#DOC.2.32.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Node.html">Node</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Geode.html">Geode</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="LightSource.html">LightSource</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Group.html">Group</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="DCS.html">DCS</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Switch.html">Switch</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Sequence.html">Sequence</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="LOD.html">LOD</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Scene.html">Scene</A>&amp; node)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.32.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* <B>_traverseVisitor</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> <B>_traverseMode</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Visitor for type safe operations on osg::Node's.
Based on GOF's Visitor pattern.</BLOCKQUOTE>
<DL>
<A NAME="TraversalMode">
<A NAME="DOC.2.32.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum TraversalMode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="TRAVERSE_NONE">
<A NAME="DOC.2.32.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRAVERSE_NONE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRAVERSE_PARENTS">
<A NAME="DOC.2.32.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRAVERSE_PARENTS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRAVERSE_ALL_CHILDREN">
<A NAME="DOC.2.32.1.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRAVERSE_ALL_CHILDREN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRAVERSE_ACTIVE_CHILDREN">
<A NAME="DOC.2.32.1.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRAVERSE_ACTIVE_CHILDREN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TRAVERSE_VISITOR">
<A NAME="DOC.2.32.1.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> TRAVERSE_VISITOR</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="NodeVisitor">
<A NAME="DOC.2.32.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NodeVisitor(<!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> tm=TRAVERSE_NONE)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~NodeVisitor">
<A NAME="DOC.2.32.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~NodeVisitor()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setTraverseMode">
<A NAME="DOC.2.32.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTraverseMode(<!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> mode)</B></TT>
<DD>Set the traversal mode for Node::traverse() to use when
deciding which children of a node to traverse. If a
NodeVisitor has been attached via setTraverseVisitor()
and the new mode is not TRAVERSE_VISITOR then the attached
visitor is detached. Default mode is TRAVERSE_NONE.
<DL><DT><DD></DL><P>
<A NAME="getTraverseMode">
<A NAME="DOC.2.32.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> getTraverseMode()</B></TT>
<DD>Get the traversal mode
<DL><DT><DD></DL><P>
<A NAME="setTraverseVisitor">
<A NAME="DOC.2.32.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTraverseVisitor(<!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* nv)</B></TT>
<DD>Set a visitor to handle traversal.
Overides the traverse mode setting it to TRAVERSE_VISITOR.
<DL><DT><DD></DL><P>
<A NAME="getTraverseVisitor">
<A NAME="DOC.2.32.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* getTraverseVisitor()</B></TT>
<DD>Get the traverse visitor, returns NULL if none is attached
<DL><DT><DD></DL><P>
<A NAME="traverse">
<A NAME="DOC.2.32.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void traverse(<!1><A HREF="Node.html">Node</A>&amp; node)</B></TT>
<DD>Inline method for passing handling traversal of a nodes.
If you intend to use the visitor for actively traversing
the scene graph then make sure the accept() methods call
this method unless they handle traversal directly.
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Node.html">Node</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Geode.html">Geode</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="LightSource.html">LightSource</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Group.html">Group</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="DCS.html">DCS</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Switch.html">Switch</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Sequence.html">Sequence</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="LOD.html">LOD</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.32.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Scene.html">Scene</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_traverseVisitor">
<A NAME="DOC.2.32.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodeVisitor.html#DOC.2.32.7">NodeVisitor</A>* _traverseVisitor</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_traverseMode">
<A NAME="DOC.2.32.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="NodeVisitor.html#DOC.2.32.1">TraversalMode</A> _traverseMode</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

42
doc/osg/NotifyInit.html Normal file
View File

@ -0,0 +1,42 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::NotifyInit</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::NotifyInit</A></H2>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.35.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>NotifyInit</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.35.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~NotifyInit</B>()
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="NotifyInit">
<A NAME="DOC.2.35.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NotifyInit()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~NotifyInit">
<A NAME="DOC.2.35.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~NotifyInit()</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

72
doc/osg/NotifySeverity.html Normal file
View File

@ -0,0 +1,72 @@
<HTML>
<HEAD>
<TITLE>enum osg::NotifySeverity</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>enum <A HREF="#DOC.DOCU">osg::NotifySeverity</A></H2>
<HR>
<P><DL>
<DT>
<A HREF="#DOC.2.34.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>ALWAYS</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FATAL</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>WARN</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>NOTICE</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>INFO</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>DEBUG</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.34.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>FP_DEBUG</B>
<DD><I></I>
</DL></P>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="ALWAYS">
<A NAME="DOC.2.34.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ALWAYS</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FATAL">
<A NAME="DOC.2.34.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FATAL</B></TT>
<DL><DT><DD></DL><P>
<A NAME="WARN">
<A NAME="DOC.2.34.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> WARN</B></TT>
<DL><DT><DD></DL><P>
<A NAME="NOTICE">
<A NAME="DOC.2.34.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> NOTICE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="INFO">
<A NAME="DOC.2.34.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> INFO</B></TT>
<DL><DT><DD></DL><P>
<A NAME="DEBUG">
<A NAME="DOC.2.34.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> DEBUG</B></TT>
<DL><DT><DD></DL><P>
<A NAME="FP_DEBUG">
<A NAME="DOC.2.34.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> FP_DEBUG</B></TT>
<DL><DT><DD></DL><P></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

175
doc/osg/Object.html Normal file
View File

@ -0,0 +1,175 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Object</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Object</A>: public <!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A></H2>
<BLOCKQUOTE>Base class/standard interface for objects which require IO support, cloning and reference counting.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=545>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CTransparency,MTransparency.html,CTexture,MTexture.html,CTexGen,MTexGen.html,CTexEnv,MTexEnv.html,CPolygonOffset,MPolygonOffset.html,CPoint,MPoint.html,CNode,MNode.html,CMatrix,MMatrix.html,CMaterial,MMaterial.html,CLight,MLight.html,CImage,MImage.html,CGeoState,MGeoState.html,CGeoSet,MGeoSet.html,CFog,MFog.html,CCullFace,MCullFace.html,CAlphaFunc,MAlphaFunc.html">
<param name=before value="M,M,M|_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,MR_,Mr_">
<param name=after value="Md_,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M">
<param name=indent value="0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.36.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Object</B>()
<DD><I>Construct an object.</I>
<DT>
<A HREF="#DOC.2.36.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I>return a shallow copy of a node, with Object* return type.</I>
<DT>
<A HREF="#DOC.2.36.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>*)
<DD><I></I>
<DT>
<A HREF="#DOC.2.36.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I>return the name of the object's class type.</I>
<DT>
<A HREF="#DOC.2.36.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I>Template Method/Prototype Pattern : create a clone and read Object data from Input.</I>
<DT>
<A HREF="#DOC.2.36.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I>Template Method Pattern : write out Object data to Output.</I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.36.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Object</B>()
<DD><I>Object destructor.</I>
<DT>
<A HREF="#DOC.2.36.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp;)
<DD><I>Template Method Pattern : read local data from osg file.</I>
<DT>
<A HREF="#DOC.2.36.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp;)
<DD><I>Template Method Pattern : write local data to osg file.</I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Base class/standard interface for objects which require IO support,
cloning and reference counting.
Based on GOF Composite, Prototype and Template Method patterns.</BLOCKQUOTE>
<DL>
<A NAME="Object">
<A NAME="DOC.2.36.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Object()</B></TT>
<DD>Construct an object. Note Object is a pure virtual base class
and therefore cannot be constructed on its own, only derived
classes which overide the clone and className methods are
concrete classes and can be constructed.
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.36.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DD>return a shallow copy of a node, with Object* return type.
Must be defined by derived classes.
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.36.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>*)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.36.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DD>return the name of the object's class type. Must be defined
by derived classes.
<DL><DT><DD></DL><P>
<A NAME="readClone">
<A NAME="DOC.2.36.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* readClone(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DD>Template Method/Prototype Pattern : create a clone and read
Object data from Input. Reads Input and if it matches this
objects className() then create a clone and match '{' brackets
and repeating calling Object::readLocalData() until the
matching ']' is read.
<DL><DT><DD></DL><P>
<A NAME="write">
<A NAME="DOC.2.36.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool write(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DD>Template Method Pattern : write out Object data to Output.
Sequence of output is className() followed by Open '{'
and then call Object::writeLocalData() and complete with '}'.
<DL><DT><DD></DL><P>
<A NAME="~Object">
<A NAME="DOC.2.36.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Object()</B></TT>
<DD>Object destructor. Note, is protected so that Objects cannot
be deleted other than by being derefernced and the reference
count being zero (see osg::Referenced), preventing the deletion
of nodes which are still in use. This also means that
Node's cannot be created on stack i.e Node node will not compile,
forcing all nodes to be created on the heap i.e Node* node
= new Node().
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.36.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp;)</B></TT>
<DD>Template Method Pattern : read local data from osg file.
Note should be implemented in derivied classes, which
call their parent class's readLocalData. Returns
true if the input iterator has been advanced, otherwise false.
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.36.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp;)</B></TT>
<DD>Template Method Pattern : write local data to osg file.
Note should be implemented in derivied classes, which
call their parent class's writeLocalData. Returns
true if data has been written out, otherwise false.
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="Transparency.html">Transparency</A><BR>
<A HREF="Texture.html">Texture</A><BR>
<A HREF="TexGen.html">TexGen</A><BR>
<A HREF="TexEnv.html">TexEnv</A><BR>
<A HREF="PolygonOffset.html">PolygonOffset</A><BR>
<A HREF="Point.html">Point</A><BR>
<A HREF="Node.html">Node</A><BR>
<A HREF="Matrix.html">Matrix</A><BR>
<A HREF="Material.html">Material</A><BR>
<A HREF="Light.html">Light</A><BR>
<A HREF="Image.html">Image</A><BR>
<A HREF="GeoState.html">GeoState</A><BR>
<A HREF="GeoSet.html">GeoSet</A><BR>
<A HREF="Fog.html">Fog</A><BR>
<A HREF="CullFace.html">CullFace</A><BR>
<A HREF="AlphaFunc.html">AlphaFunc</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

211
doc/osg/Output.html Normal file
View File

@ -0,0 +1,211 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Output</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Output</A>: public ofstream</H2>
<BLOCKQUOTE>ofstream wrapper class for adding support for indenting.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="Mofstream,M,COutput,MOutput.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.37.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Output</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Output</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp; <B>indent</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getIndentStep</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setIndentStep</B>(int step)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getIndent</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setIndent</B>(int <!1><A HREF="Output.html#DOC.2.37.3">indent</A>)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>getNumIndicesPerLine</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setNumIndicesPerLine</B>(int num)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>moveIn</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>moveOut</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getUniqueIDForObject</B>(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>createUniqueIDForObject</B>(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>registerUniqueIDForObject</B>(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.37.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_indent</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_indentStep</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_numIndicesPerLine</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Output.html#DOC.2.37.22">UniqueIDToLabelMapping</A> <B>_objectToUniqueIDMap</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.37.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Output</B>(const <!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp; <B>operator = </B>(const <!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>_init</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.37.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>_free</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected</H3><DD><DT>
<A HREF="#DOC.2.37.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::map&lt;<!1><A HREF="Object.html">Object</A>*,std::string&gt; <B>UniqueIDToLabelMapping</B>
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>ofstream wrapper class for adding support for indenting.
Used in output of .osg ASCII files to improve their readability.</BLOCKQUOTE>
<DL>
<A NAME="Output">
<A NAME="DOC.2.37.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Output()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Output">
<A NAME="DOC.2.37.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Output()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="indent">
<A NAME="DOC.2.37.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp; indent()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getIndentStep">
<A NAME="DOC.2.37.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getIndentStep() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setIndentStep">
<A NAME="DOC.2.37.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setIndentStep(int step)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getIndent">
<A NAME="DOC.2.37.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getIndent() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setIndent">
<A NAME="DOC.2.37.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setIndent(int <!1><A HREF="Output.html#DOC.2.37.3">indent</A>)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getNumIndicesPerLine">
<A NAME="DOC.2.37.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int getNumIndicesPerLine() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setNumIndicesPerLine">
<A NAME="DOC.2.37.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setNumIndicesPerLine(int num)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="moveIn">
<A NAME="DOC.2.37.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void moveIn()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="moveOut">
<A NAME="DOC.2.37.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void moveOut()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getUniqueIDForObject">
<A NAME="DOC.2.37.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getUniqueIDForObject(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="createUniqueIDForObject">
<A NAME="DOC.2.37.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool createUniqueIDForObject(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="registerUniqueIDForObject">
<A NAME="DOC.2.37.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool registerUniqueIDForObject(<!1><A HREF="Object.html">Object</A>* obj, std::string&amp; uniqueID)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Output">
<A NAME="DOC.2.37.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Output(const <!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.37.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp; operator = (const <!1><A HREF="Output.html#DOC.2.37.1">Output</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_init">
<A NAME="DOC.2.37.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void _init()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_free">
<A NAME="DOC.2.37.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void _free()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_indent">
<A NAME="DOC.2.37.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _indent</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_indentStep">
<A NAME="DOC.2.37.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _indentStep</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_numIndicesPerLine">
<A NAME="DOC.2.37.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _numIndicesPerLine</B></TT>
<DL><DT><DD></DL><P>
<A NAME="UniqueIDToLabelMapping">
<A NAME="DOC.2.37.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::map&lt;<!1><A HREF="Object.html">Object</A>*,std::string&gt; UniqueIDToLabelMapping</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_objectToUniqueIDMap">
<A NAME="DOC.2.37.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Output.html#DOC.2.37.22">UniqueIDToLabelMapping</A> _objectToUniqueIDMap</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

199
doc/osg/Point.html Normal file
View File

@ -0,0 +1,199 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Point</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Point</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CPoint,MPoint.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.38.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Point</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Point.html#DOC.2.38.1">Point</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setSize</B>(float size)
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setFadeThresholdSize</B>(float fadeThresholdSize)
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setDistanceAttenuation</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; distanceAttenuation)
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enableSmooth</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disableSmooth</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>init_GL_EXT</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.38.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_size</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_fadeThresholdSize</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_distanceAttenuation</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.38.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Point</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.38.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="Point">
<A NAME="DOC.2.38.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Point()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.38.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Point.html#DOC.2.38.1">Point</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.38.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.38.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.38.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setSize">
<A NAME="DOC.2.38.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setSize(float size)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setFadeThresholdSize">
<A NAME="DOC.2.38.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setFadeThresholdSize(float fadeThresholdSize)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setDistanceAttenuation">
<A NAME="DOC.2.38.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setDistanceAttenuation(const <!1><A HREF="Vec3.html">Vec3</A>&amp; distanceAttenuation)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="enableSmooth">
<A NAME="DOC.2.38.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enableSmooth( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="disableSmooth">
<A NAME="DOC.2.38.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disableSmooth( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.38.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="init_GL_EXT">
<A NAME="DOC.2.38.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void init_GL_EXT()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~Point">
<A NAME="DOC.2.38.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Point()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.38.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.38.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_size">
<A NAME="DOC.2.38.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _size</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fadeThresholdSize">
<A NAME="DOC.2.38.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _fadeThresholdSize</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_distanceAttenuation">
<A NAME="DOC.2.38.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _distanceAttenuation</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

171
doc/osg/PolygonOffset.html Normal file
View File

@ -0,0 +1,171 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::PolygonOffset</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::PolygonOffset</A>: public <!1><A HREF="Object.html#DOC.2.36.1">Object</A></H2>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=95>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CPolygonOffset,MPolygonOffset.html">
<param name=before value="M,M,M">
<param name=after value="Md_SP,Md_,M">
<param name=indent value="0,1,2">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.39.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>PolygonOffset</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="PolygonOffset.html#DOC.2.39.1">PolygonOffset</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setOffset</B>(float factor, float units)
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>enable</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static void <B>disable</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>apply</B>( void )
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.39.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_factor</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_units</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.39.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~PolygonOffset</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.39.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<DL>
<A NAME="PolygonOffset">
<A NAME="DOC.2.39.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> PolygonOffset()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.39.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="PolygonOffset.html#DOC.2.39.1">PolygonOffset</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.39.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.39.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.39.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="setOffset">
<A NAME="DOC.2.39.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setOffset(float factor, float units)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="enable">
<A NAME="DOC.2.39.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void enable( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="disable">
<A NAME="DOC.2.39.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static void disable( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.39.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void apply( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~PolygonOffset">
<A NAME="DOC.2.39.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~PolygonOffset()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.39.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.39.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_factor">
<A NAME="DOC.2.39.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _factor</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_units">
<A NAME="DOC.2.39.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _units</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

286
doc/osg/Quat.html Normal file
View File

@ -0,0 +1,286 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Quat</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Quat</A></H2>
<BLOCKQUOTE>A quaternion class.</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Fields</H3><DD><DT>
<A HREF="#DOC.2.40.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec4.html">Vec4</A> <B>_fv</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.40.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Quat</B>( void )
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Quat</B>( float x, float y, float z, float w )
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Quat</B>( const <!1><A HREF="Vec4.html">Vec4</A>&amp; vec )
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Vec4.html">Vec4</A> <B>asVec4</B>( void ) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Vec3.html">Vec3</A> <B>asVec3</B>( void ) const
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator * </B>(const float&amp; rhs) const
<DD><I>Multiply by scalar </I>
<DT>
<A HREF="#DOC.2.40.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator *= </B>(const float&amp; rhs)
<DD><I>Unary multiply by scalar </I>
<DT>
<A HREF="#DOC.2.40.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator*</B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const
<DD><I>Binary multiply </I>
<DT>
<A HREF="#DOC.2.40.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator*=</B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)
<DD><I>Unary multiply </I>
<DT>
<A HREF="#DOC.2.40.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator / </B>(const float&amp; rhs) const
<DD><I>Divide by scalar </I>
<DT>
<A HREF="#DOC.2.40.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator /= </B>(const float&amp; rhs)
<DD><I>Unary divide by scalar </I>
<DT>
<A HREF="#DOC.2.40.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator/</B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; denom) const
<DD><I>Binary divide </I>
<DT>
<A HREF="#DOC.2.40.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator/=</B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; denom)
<DD><I>Unary divide </I>
<DT>
<A HREF="#DOC.2.40.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator + </B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const
<DD><I>Binary addition </I>
<DT>
<A HREF="#DOC.2.40.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator += </B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)
<DD><I>Unary addition</I>
<DT>
<A HREF="#DOC.2.40.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator - </B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const
<DD><I>Binary subtraction </I>
<DT>
<A HREF="#DOC.2.40.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; <B>operator -= </B>(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)
<DD><I>Unary subtraction </I>
<DT>
<A HREF="#DOC.2.40.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>operator - </B>() const
<DD><I>Negation operator - returns the negative of the quaternion.</I>
<DT>
<A HREF="#DOC.2.40.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>length</B>( void ) const
<DD><I>Length of the quaternion = sqrt( vec . vec )</I>
<DT>
<A HREF="#DOC.2.40.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>length2</B>( void ) const
<DD><I>Length of the quaternion = vec . vec</I>
<DT>
<A HREF="#DOC.2.40.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>conj</B>( void ) const
<DD><I>Conjugate </I>
<DT>
<A HREF="#DOC.2.40.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> <B>inverse</B>( void ) const
<DD><I>Multiplicative inverse method: q^(-1) = q^*/(q.q^*)</I>
<DT>
<A HREF="#DOC.2.40.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeRot</B>( const float angle, const float x, const float y, const float z )
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeRot</B>( const float angle, const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec )
<DD><I></I>
<DT>
<A HREF="#DOC.2.40.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>makeRot</B>( const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec1, const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec2 )
<DD><I>Make a rotation Quat which will rotate vec1 to vec2.</I>
<DT>
<A HREF="#DOC.2.40.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>getRot</B>( float&amp; angle, float&amp; x, float&amp; y, float&amp; z ) const
<DD><I>Return the angle and vector components represented by the quaternion</I>
<DT>
<A HREF="#DOC.2.40.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>getRot</B>( float&amp; angle, <!1><A HREF="Vec3.html">Vec3</A>&amp; vec ) const
<DD><I>Return the angle and vector represented by the quaternion</I>
<DT>
<A HREF="#DOC.2.40.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>slerp</B>( const float t, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; from, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; to)
<DD><I>Spherical Linear Interpolation.</I>
<DT>
<A HREF="#DOC.2.40.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>set</B>( const <!1><A HREF="Matrix.html">osg::Matrix</A>&amp; m )
<DD><I>Set quaternion to be equivalent to specified matrix</I>
<DT>
<A HREF="#DOC.2.40.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>get</B>( <!1><A HREF="Matrix.html">osg::Matrix</A>&amp; m ) const
<DD><I>Get the equivalent matrix for this quaternion</I>
<DT>
<A HREF="#DOC.2.40.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>inline friend ostream&amp; <B>operator << </B>(ostream&amp; output, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; vec)
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>A quaternion class. It can be used to represent an orientation in 3D space.</BLOCKQUOTE>
<DL>
<A NAME="_fv">
<A NAME="DOC.2.40.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec4.html">Vec4</A> _fv</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Quat">
<A NAME="DOC.2.40.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Quat( void )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Quat">
<A NAME="DOC.2.40.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Quat( float x, float y, float z, float w )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Quat">
<A NAME="DOC.2.40.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Quat( const <!1><A HREF="Vec4.html">Vec4</A>&amp; vec )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="asVec4">
<A NAME="DOC.2.40.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Vec4.html">Vec4</A> asVec4( void ) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="asVec3">
<A NAME="DOC.2.40.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Vec3.html">Vec3</A> asVec3( void ) const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator * ">
<A NAME="DOC.2.40.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator * (const float&amp; rhs) const </B></TT>
<DD>Multiply by scalar
<DL><DT><DD></DL><P>
<A NAME="operator *= ">
<A NAME="DOC.2.40.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator *= (const float&amp; rhs)</B></TT>
<DD>Unary multiply by scalar
<DL><DT><DD></DL><P>
<A NAME="operator*">
<A NAME="DOC.2.40.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator*(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const </B></TT>
<DD>Binary multiply
<DL><DT><DD></DL><P>
<A NAME="operator*=">
<A NAME="DOC.2.40.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator*=(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)</B></TT>
<DD>Unary multiply
<DL><DT><DD></DL><P>
<A NAME="operator / ">
<A NAME="DOC.2.40.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator / (const float&amp; rhs) const </B></TT>
<DD>Divide by scalar
<DL><DT><DD></DL><P>
<A NAME="operator /= ">
<A NAME="DOC.2.40.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator /= (const float&amp; rhs)</B></TT>
<DD>Unary divide by scalar
<DL><DT><DD></DL><P>
<A NAME="operator/">
<A NAME="DOC.2.40.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator/(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; denom) const </B></TT>
<DD>Binary divide
<DL><DT><DD></DL><P>
<A NAME="operator/=">
<A NAME="DOC.2.40.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator/=(const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; denom)</B></TT>
<DD>Unary divide
<DL><DT><DD></DL><P>
<A NAME="operator + ">
<A NAME="DOC.2.40.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator + (const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const </B></TT>
<DD>Binary addition
<DL><DT><DD></DL><P>
<A NAME="operator += ">
<A NAME="DOC.2.40.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator += (const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)</B></TT>
<DD>Unary addition
<DL><DT><DD></DL><P>
<A NAME="operator - ">
<A NAME="DOC.2.40.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator - (const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs) const </B></TT>
<DD>Binary subtraction
<DL><DT><DD></DL><P>
<A NAME="operator -= ">
<A NAME="DOC.2.40.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; operator -= (const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; rhs)</B></TT>
<DD>Unary subtraction
<DL><DT><DD></DL><P>
<A NAME="operator - ">
<A NAME="DOC.2.40.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> operator - () const </B></TT>
<DD>Negation operator - returns the negative of the quaternion.
Basically just calls operator - () on the Vec4
<DL><DT><DD></DL><P>
<A NAME="length">
<A NAME="DOC.2.40.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float length( void ) const </B></TT>
<DD>Length of the quaternion = sqrt( vec . vec )
<DL><DT><DD></DL><P>
<A NAME="length2">
<A NAME="DOC.2.40.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float length2( void ) const </B></TT>
<DD>Length of the quaternion = vec . vec
<DL><DT><DD></DL><P>
<A NAME="conj">
<A NAME="DOC.2.40.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> conj( void ) const </B></TT>
<DD>Conjugate
<DL><DT><DD></DL><P>
<A NAME="inverse">
<A NAME="DOC.2.40.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A> inverse( void ) const </B></TT>
<DD>Multiplicative inverse method: q^(-1) = q^*/(q.q^*)
<DL><DT><DD></DL><P>
<A NAME="makeRot">
<A NAME="DOC.2.40.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeRot( const float angle, const float x, const float y, const float z )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeRot">
<A NAME="DOC.2.40.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeRot( const float angle, const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="makeRot">
<A NAME="DOC.2.40.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void makeRot( const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec1, const <!1><A HREF="Vec3.html">Vec3</A>&amp; vec2 )</B></TT>
<DD>Make a rotation Quat which will rotate vec1 to vec2.
Generally take adot product to get the angle between these
and then use a cross product to get the rotation axis
Watch out for the two special cases of when the vectors
are co-incident or opposite in direction.
<DL><DT><DD></DL><P>
<A NAME="getRot">
<A NAME="DOC.2.40.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void getRot( float&amp; angle, float&amp; x, float&amp; y, float&amp; z ) const </B></TT>
<DD>Return the angle and vector components represented by the quaternion
<DL><DT><DD></DL><P>
<A NAME="getRot">
<A NAME="DOC.2.40.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void getRot( float&amp; angle, <!1><A HREF="Vec3.html">Vec3</A>&amp; vec ) const </B></TT>
<DD>Return the angle and vector represented by the quaternion
<DL><DT><DD></DL><P>
<A NAME="slerp">
<A NAME="DOC.2.40.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void slerp( const float t, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; from, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; to)</B></TT>
<DD>Spherical Linear Interpolation.
As t goes from 0 to 1, the Quat object goes from "from" to "to".
<DL><DT><DD></DL><P>
<A NAME="set">
<A NAME="DOC.2.40.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void set( const <!1><A HREF="Matrix.html">osg::Matrix</A>&amp; m )</B></TT>
<DD>Set quaternion to be equivalent to specified matrix
<DL><DT><DD></DL><P>
<A NAME="get">
<A NAME="DOC.2.40.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void get( <!1><A HREF="Matrix.html">osg::Matrix</A>&amp; m ) const </B></TT>
<DD>Get the equivalent matrix for this quaternion
<DL><DT><DD></DL><P>
<A NAME="operator << ">
<A NAME="DOC.2.40.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>inline friend ostream&amp; operator << (ostream&amp; output, const <!1><A HREF="Quat.html#DOC.2.40.9">Quat</A>&amp; vec)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

86
doc/osg/RP.html Normal file
View File

@ -0,0 +1,86 @@
<HTML>
<HEAD>
<TITLE>template<class T> class osg::RP</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>template&lt;class T&gt; class <A HREF="#DOC.DOCU">osg::RP</A></H2>
<BLOCKQUOTE>Smart pointer for handling referenced counted objects</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.32.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>RP</B>(T* t=0)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>RP</B>(const <!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; rp)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~RP</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; <B>operator = </B>(const <!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; rp)
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>T&amp; <B>operator*</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>T* <B>operator-></B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>operator!</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.32.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>T* <B>get</B>() const
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Smart pointer for handling referenced counted objects</BLOCKQUOTE>
<DL>
<A NAME="RP">
<A NAME="DOC.2.32.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> RP(T* t=0)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="RP">
<A NAME="DOC.2.32.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> RP(const <!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; rp)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~RP">
<A NAME="DOC.2.32.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~RP()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.32.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; operator = (const <!1><A HREF="RP.html#DOC.2.32.1">RP</A>&amp; rp)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator*">
<A NAME="DOC.2.32.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>T&amp; operator*() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator->">
<A NAME="DOC.2.32.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>T* operator->() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator!">
<A NAME="DOC.2.32.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool operator!() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="get">
<A NAME="DOC.2.32.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>T* get() const </B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

122
doc/osg/ReaderWriter.html Normal file
View File

@ -0,0 +1,122 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::ReaderWriter</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::ReaderWriter</A>: public <!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A></H2>
<BLOCKQUOTE>pure virtual base class for reading and writing of non native formats.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CReferenced,MReferenced.html,CReaderWriter,MReaderWriter.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.44.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~ReaderWriter</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>acceptsExtension</B>(const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html">Object</A>* <B>readObject</B>(const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Image.html">Image</A>* <B>readImage</B>(const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Node.html">Node</A>* <B>readNode</B>(const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeObject</B>(<!1><A HREF="Object.html">Object</A>&amp; , const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeImage</B>(<!1><A HREF="Image.html">Image</A>&amp; , const std::string&amp; )
<DD><I></I>
<DT>
<A HREF="#DOC.2.44.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeNode</B>(<!1><A HREF="Node.html">Node</A>&amp; , const std::string&amp; )
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>pure virtual base class for reading and writing of non native formats. </BLOCKQUOTE>
<DL>
<A NAME="~ReaderWriter">
<A NAME="DOC.2.44.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~ReaderWriter()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.44.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="acceptsExtension">
<A NAME="DOC.2.44.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool acceptsExtension(const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readObject">
<A NAME="DOC.2.44.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html">Object</A>* readObject(const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readImage">
<A NAME="DOC.2.44.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Image.html">Image</A>* readImage(const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readNode">
<A NAME="DOC.2.44.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Node.html">Node</A>* readNode(const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeObject">
<A NAME="DOC.2.44.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeObject(<!1><A HREF="Object.html">Object</A>&amp; , const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeImage">
<A NAME="DOC.2.44.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeImage(<!1><A HREF="Image.html">Image</A>&amp; , const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeNode">
<A NAME="DOC.2.44.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeNode(<!1><A HREF="Node.html">Node</A>&amp; , const std::string&amp; )</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

117
doc/osg/Referenced.html Normal file
View File

@ -0,0 +1,117 @@
<HTML>
<HEAD>
<TITLE>class osg::Referenced</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class <A HREF="#DOC.DOCU">osg::Referenced</A></H2>
<BLOCKQUOTE>Base class from providing referencing counted objects</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=245>
<param name=classes value="CReferenced,MReferenced.html,CSeg,MSeg.html,CReaderWriter,MReaderWriter.html,CObject,MObject.html,CNodeVisitor,MNodeVisitor.html,CMemoryAdapter,MMemoryAdapter.html,CDynamicLibrary,MDynamicLibrary.html,CCamera,MCamera.html">
<param name=before value="M,M|_,MR_,MR_,MR_,MR_,MR_,Mr_">
<param name=after value="M,M,M,M,M,M,M,M">
<param name=indent value="0,0,0,0,0,0,0,0">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.43.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Referenced</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.43.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Referenced</B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.43.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.43.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>ref</B>()
<DD><I>increment the reference count by one, indicating that this object has another pointer which is referencing it</I>
<DT>
<A HREF="#DOC.2.43.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>unref</B>()
<DD><I>decrement the reference count by one, indicating that a pointer to this object is referencing it.</I>
<DT>
<A HREF="#DOC.2.43.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>referenceCount</B>()
<DD><I>return the number pointers currently referencing this object.</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.43.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>int <B>_refCount</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.43.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Referenced</B>()
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Base class from providing referencing counted objects</BLOCKQUOTE>
<DL>
<A NAME="Referenced">
<A NAME="DOC.2.43.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Referenced()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="Referenced">
<A NAME="DOC.2.43.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Referenced(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="operator = ">
<A NAME="DOC.2.43.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; operator = (<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ref">
<A NAME="DOC.2.43.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void ref()</B></TT>
<DD>increment the reference count by one, indicating that
this object has another pointer which is referencing it
<DL><DT><DD></DL><P>
<A NAME="unref">
<A NAME="DOC.2.43.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void unref()</B></TT>
<DD>decrement the reference count by one, indicating that
a pointer to this object is referencing it. If the
refence count goes to zero, it is assumed that this object
is nolonger referenced and is automatically deleted.
<DL><DT><DD></DL><P>
<A NAME="referenceCount">
<A NAME="DOC.2.43.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int referenceCount()</B></TT>
<DD>return the number pointers currently referencing this object.
<DL><DT><DD></DL><P>
<A NAME="~Referenced">
<A NAME="DOC.2.43.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Referenced()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_refCount">
<A NAME="DOC.2.43.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>int _refCount</B></TT>
<DL><DT><DD></DL><P></DL>
<HR>
<DL><DT><B>Direct child classes:
</B><DD><A HREF="Seg.html">Seg</A><BR>
<A HREF="ReaderWriter.html">ReaderWriter</A><BR>
<A HREF="Object.html">Object</A><BR>
<A HREF="NodeVisitor.html">NodeVisitor</A><BR>
<A HREF="MemoryAdapter.html">MemoryAdapter</A><BR>
<A HREF="DynamicLibrary.html">DynamicLibrary</A><BR>
<A HREF="Camera.html">Camera</A><BR>
</DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

55
doc/osg/RegisterObjectProxy.html Normal file
View File

@ -0,0 +1,55 @@
<HTML>
<HEAD>
<TITLE>template<class T> class osg::RegisterObjectProxy</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>template&lt;class T&gt; class <A HREF="#DOC.DOCU">osg::RegisterObjectProxy</A></H2>
<BLOCKQUOTE>Proxy class for automatic registration of reader/writers with the Registry</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.46.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>RegisterObjectProxy</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.46.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~RegisterObjectProxy</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.46.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>T* <B>_obj</B>
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Proxy class for automatic registration of reader/writers with the
Registry</BLOCKQUOTE>
<DL>
<A NAME="RegisterObjectProxy">
<A NAME="DOC.2.46.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> RegisterObjectProxy()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~RegisterObjectProxy">
<A NAME="DOC.2.46.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~RegisterObjectProxy()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_obj">
<A NAME="DOC.2.46.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>T* _obj</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

55
doc/osg/RegisterReaderWriterProxy.html Normal file
View File

@ -0,0 +1,55 @@
<HTML>
<HEAD>
<TITLE>template<class T> class osg::RegisterReaderWriterProxy</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>template&lt;class T&gt; class <A HREF="#DOC.DOCU">osg::RegisterReaderWriterProxy</A></H2>
<BLOCKQUOTE>Proxy class for automatic registration of reader/writers with the Registry</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.47.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>RegisterReaderWriterProxy</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.47.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~RegisterReaderWriterProxy</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.47.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>T* <B>_rw</B>
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Proxy class for automatic registration of reader/writers with the
Registry</BLOCKQUOTE>
<DL>
<A NAME="RegisterReaderWriterProxy">
<A NAME="DOC.2.47.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> RegisterReaderWriterProxy()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~RegisterReaderWriterProxy">
<A NAME="DOC.2.47.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~RegisterReaderWriterProxy()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_rw">
<A NAME="DOC.2.47.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>T* _rw</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

175
doc/osg/Registry.html Normal file
View File

@ -0,0 +1,175 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Registry</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Registry</A></H2>
<BLOCKQUOTE> Registry is a singleton factory which stores the Objects types available at runtime for loading, and any Object reader or writers which are linked in at runtime for reading non-native file formats.</BLOCKQUOTE>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.45.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>~Registry</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>static <!1><A HREF="Registry.html#DOC.2.45.5">Registry</A>* <B>instance</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>addPrototype</B>(<!1><A HREF="Object.html">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>removePrototype</B>(<!1><A HREF="Object.html">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>addReaderWriter</B>(<!1><A HREF="ReaderWriter.html">ReaderWriter</A>* rw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>removeReaderWriter</B>(<!1><A HREF="ReaderWriter.html">ReaderWriter</A>* rw)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string <B>createLibraryNameForFile</B>(const std::string&amp; fileName)
<DD><I>create the platform specific library name associated with file</I>
<DT>
<A HREF="#DOC.2.45.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>std::string <B>createLibraryNameForExt</B>(const std::string&amp; ext)
<DD><I>create the platform specific library name associated with file extension</I>
<DT>
<A HREF="#DOC.2.45.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>loadLibrary</B>(const std::string&amp; fileName)
<DD><I>find the library in the SG_LIBRARY_PATH and load it</I>
<DT>
<A HREF="#DOC.2.45.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>closeLibrary</B>(const std::string&amp; fileName)
<DD><I>close the attached library with specified name</I>
<DT>
<A HREF="#DOC.2.45.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Object.html">Object</A>* <B>readObject</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Object.html">Object</A>* <B>readObject</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>writeObject</B>(<!1><A HREF="Object.html">Object</A>&amp; obj, const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Image.html">Image</A>* <B>readImage</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Image.html">Image</A>* <B>readImage</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>writeImage</B>(<!1><A HREF="Image.html">Image</A>&amp; obj, const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html">Node</A>* <B>readNode</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Node.html">Node</A>* <B>readNode</B>(const std::string&amp; fileName)
<DD><I></I>
<DT>
<A HREF="#DOC.2.45.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>writeNode</B>(<!1><A HREF="Node.html">Node</A>&amp; node, const std::string&amp; fileName)
<DD><I></I>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
Registry is a singleton factory which stores
the Objects types available at runtime for loading,
and any Object reader or writers which are linked in
at runtime for reading non-native file formats.<P>The RegisterObjectProxy defined in Object.h can be
used to automatically register at runtime a Object
with the Registry.<P>The RegisterReaderWriterProxy defined in ReaderWriter.h can
be used to automatically register at runtime a reader/writer
with the Registry.</BLOCKQUOTE>
<DL>
<A NAME="~Registry">
<A NAME="DOC.2.45.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> ~Registry()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="instance">
<A NAME="DOC.2.45.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>static <!1><A HREF="Registry.html#DOC.2.45.5">Registry</A>* instance()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addPrototype">
<A NAME="DOC.2.45.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void addPrototype(<!1><A HREF="Object.html">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="removePrototype">
<A NAME="DOC.2.45.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void removePrototype(<!1><A HREF="Object.html">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="addReaderWriter">
<A NAME="DOC.2.45.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void addReaderWriter(<!1><A HREF="ReaderWriter.html">ReaderWriter</A>* rw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="removeReaderWriter">
<A NAME="DOC.2.45.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void removeReaderWriter(<!1><A HREF="ReaderWriter.html">ReaderWriter</A>* rw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="createLibraryNameForFile">
<A NAME="DOC.2.45.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string createLibraryNameForFile(const std::string&amp; fileName)</B></TT>
<DD>create the platform specific library name associated with file
<DL><DT><DD></DL><P>
<A NAME="createLibraryNameForExt">
<A NAME="DOC.2.45.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>std::string createLibraryNameForExt(const std::string&amp; ext)</B></TT>
<DD>create the platform specific library name associated with file extension
<DL><DT><DD></DL><P>
<A NAME="loadLibrary">
<A NAME="DOC.2.45.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool loadLibrary(const std::string&amp; fileName)</B></TT>
<DD>find the library in the SG_LIBRARY_PATH and load it
<DL><DT><DD></DL><P>
<A NAME="closeLibrary">
<A NAME="DOC.2.45.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool closeLibrary(const std::string&amp; fileName)</B></TT>
<DD>close the attached library with specified name
<DL><DT><DD></DL><P>
<A NAME="readObject">
<A NAME="DOC.2.45.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Object.html">Object</A>* readObject(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readObject">
<A NAME="DOC.2.45.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Object.html">Object</A>* readObject(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeObject">
<A NAME="DOC.2.45.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool writeObject(<!1><A HREF="Object.html">Object</A>&amp; obj, const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readImage">
<A NAME="DOC.2.45.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Image.html">Image</A>* readImage(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readImage">
<A NAME="DOC.2.45.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Image.html">Image</A>* readImage(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeImage">
<A NAME="DOC.2.45.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool writeImage(<!1><A HREF="Image.html">Image</A>&amp; obj, const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readNode">
<A NAME="DOC.2.45.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html">Node</A>* readNode(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readNode">
<A NAME="DOC.2.45.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Node.html">Node</A>* readNode(const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeNode">
<A NAME="DOC.2.45.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool writeNode(<!1><A HREF="Node.html">Node</A>&amp; node, const std::string&amp; fileName)</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

497
doc/osg/RenderVisitor.html Normal file
View File

@ -0,0 +1,497 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::RenderVisitor</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::RenderVisitor</A>: public <!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A></H2>
<BLOCKQUOTE>Basic visitor for rendering a scene.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=65>
<param name=classes value="CNodeVisitor,MNodeVisitor.html,CRenderVisitor,MRenderVisitor.html">
<param name=before value="M,M">
<param name=after value="Md_,M">
<param name=indent value="0,1">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<A HREF="#DOC.2.41.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>TransparencySortMode</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>enum <B>CullingType</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.41.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>RenderVisitor</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~RenderVisitor</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>reset</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Node.html">Node</A>&amp;)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Geode.html">Geode</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Group.html">Group</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="DCS.html">DCS</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Switch.html">Switch</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.12"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="LOD.html">LOD</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.13"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>apply</B>(<!1><A HREF="Scene.html">Scene</A>&amp; node)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.14"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setGlobalState</B>(<!1><A HREF="GeoState.html">GeoState</A>* global)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.15"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setPerspective</B>(float fovy, float aspect, float znear, float zfar)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.16"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setLookAt</B>(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye, const <!1><A HREF="Vec3.html">Vec3</A>&amp; center, const <!1><A HREF="Vec3.html">Vec3</A>&amp; upVector)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.17"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setLookAt</B>(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.18"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setLODBias</B>(float bias)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.19"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>getLODBias</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.20"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setTransparencySortMode</B>(<!1><A HREF="RenderVisitor.html#DOC.2.41.1">TransparencySortMode</A> tsm)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.21"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setCullingActive</B>(<!1><A HREF="RenderVisitor.html#DOC.2.41.2">CullingType</A> ct, bool active)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.22"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>getCullingActive</B>(<!1><A HREF="RenderVisitor.html#DOC.2.41.2">CullingType</A> ct)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.23"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>calcNearFar</B>(double&amp; near_plane, double&amp; far_plane)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.24"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>render</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.41.32"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_viewFrustumCullingActive</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.33"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>_smallFeatureCullingActive</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.38"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="RenderVisitor.html#DOC.2.41.37">ViewStateStack</A> <B>_viewStateStack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.39"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ViewState.html">ViewState</A>* <B>_tvs</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.40"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="ViewState.html">ViewState</A>* <B>_cvs</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.43"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="RenderVisitor.html#DOC.2.41.41">OpaqueList</A> <B>_opaqueGeoSets</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.44"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="RenderVisitor.html#DOC.2.41.42">TransparentList</A> <B>_transparentGeoSets</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.45"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html">GeoState</A>* <B>_globalState</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.46"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_LODBias</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.47"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_fovy</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.48"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_aspect</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.49"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_znear</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.50"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>float <B>_zfar</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.52"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_frustumTop</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.53"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_frustumBottom</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.54"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_frustumLeft</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.55"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Vec3.html">Vec3</A> <B>_frustumRight</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.56"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="RenderVisitor.html#DOC.2.41.1">TransparencySortMode</A> <B>_tsm</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.41.25"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>pushMatrix</B>(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matrix)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.26"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>popMatrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.27"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>getCurrentMatrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.28"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="Matrix.html">Matrix</A>* <B>getInverseCurrentMatrix</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.29"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getEyeLocal</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.30"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getCenterLocal</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.31"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>const <!1><A HREF="Vec3.html">Vec3</A>&amp; <B>getLookVectorLocal</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.34"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isCulled</B>(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; sp)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.35"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>bool <B>isCulled</B>(const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; bb)
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.51"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>calculateClippingPlanes</B>()
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected</H3><DD><DT>
<A HREF="#DOC.2.41.36"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::pair&lt;<!1><A HREF="Matrix.html">Matrix</A>*,<!1><A HREF="GeoSet.html">GeoSet</A>*&gt; <B>MatrixGeoSet</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.37"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::vector&lt;<!1><A HREF="ViewState.html">ViewState</A>*&gt; <B>ViewStateStack</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.41"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::multimap&lt;<!1><A HREF="GeoState.html">GeoState</A>*,<!1><A HREF="RenderVisitor.html#DOC.2.41.36">MatrixGeoSet</A>&gt; <B>OpaqueList</B>
<DD><I></I>
<DT>
<A HREF="#DOC.2.41.42"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>typedef std::multimap&lt;float,<!1><A HREF="RenderVisitor.html#DOC.2.41.36">MatrixGeoSet</A>&gt; <B>TransparentList</B>
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="NodeVisitor.html">NodeVisitor</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Classes</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>enum <B>TraversalMode</B>
</DL></P>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setTraverseMode</B>(<!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> mode)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> <B>getTraverseMode</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setTraverseVisitor</B>(<!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* nv)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* <B>getTraverseVisitor</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>traverse</B>(<!1><A HREF="Node.html">Node</A>&amp; node)
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.7">NodeVisitor</A>* <B>_traverseVisitor</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="NodeVisitor.html#DOC.2.28.1">TraversalMode</A> <B>_traverseMode</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>Basic visitor for rendering a scene.
The visitor traverses the scene graph, collecting transparent
and opaque osg::GeoSet's into a depth sorted transparent bin
and a state sorted opaque bin. The opaque bin is rendered first,
and then the transparent bin in rendered in order from the furthest
osg::GeoSet from the eye to the one nearest the eye.</BLOCKQUOTE>
<DL>
<A NAME="RenderVisitor">
<A NAME="DOC.2.41.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> RenderVisitor()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="~RenderVisitor">
<A NAME="DOC.2.41.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~RenderVisitor()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="reset">
<A NAME="DOC.2.41.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void reset()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Node.html">Node</A>&amp;)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Geode.html">Geode</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Billboard.html">Billboard</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Group.html">Group</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="DCS.html">DCS</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Switch.html">Switch</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.12">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="LOD.html">LOD</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="apply">
<A NAME="DOC.2.41.13">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void apply(<!1><A HREF="Scene.html">Scene</A>&amp; node)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setGlobalState">
<A NAME="DOC.2.41.14">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setGlobalState(<!1><A HREF="GeoState.html">GeoState</A>* global)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setPerspective">
<A NAME="DOC.2.41.15">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setPerspective(float fovy, float aspect, float znear, float zfar)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setLookAt">
<A NAME="DOC.2.41.16">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setLookAt(const <!1><A HREF="Vec3.html">Vec3</A>&amp; eye, const <!1><A HREF="Vec3.html">Vec3</A>&amp; center, const <!1><A HREF="Vec3.html">Vec3</A>&amp; upVector)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setLookAt">
<A NAME="DOC.2.41.17">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setLODBias">
<A NAME="DOC.2.41.18">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setLODBias(float bias)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getLODBias">
<A NAME="DOC.2.41.19">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float getLODBias()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TransparencySortMode">
<A NAME="DOC.2.41.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum TransparencySortMode</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="LOOK_VECTOR_DISTANCE">
<A NAME="DOC.2.41.1.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> LOOK_VECTOR_DISTANCE</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OBJECT_EYE_POINT_DISTANCE">
<A NAME="DOC.2.41.1.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> OBJECT_EYE_POINT_DISTANCE</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="setTransparencySortMode">
<A NAME="DOC.2.41.20">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setTransparencySortMode(<!1><A HREF="RenderVisitor.html#DOC.2.41.1">TransparencySortMode</A> tsm)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="CullingType">
<A NAME="DOC.2.41.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>enum CullingType</B></TT>
<DL><DT><DD></DL><P><DL>
<A NAME="VIEW_FRUSTUM_CULLING">
<A NAME="DOC.2.41.2.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> VIEW_FRUSTUM_CULLING</B></TT>
<DL><DT><DD></DL><P>
<A NAME="SMALL_FEATURE_CULLING">
<A NAME="DOC.2.41.2.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> SMALL_FEATURE_CULLING</B></TT>
<DL><DT><DD></DL><P></DL>
<A NAME="setCullingActive">
<A NAME="DOC.2.41.21">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setCullingActive(<!1><A HREF="RenderVisitor.html#DOC.2.41.2">CullingType</A> ct, bool active)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getCullingActive">
<A NAME="DOC.2.41.22">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool getCullingActive(<!1><A HREF="RenderVisitor.html#DOC.2.41.2">CullingType</A> ct)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="calcNearFar">
<A NAME="DOC.2.41.23">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool calcNearFar(double&amp; near_plane, double&amp; far_plane)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="render">
<A NAME="DOC.2.41.24">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void render()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="pushMatrix">
<A NAME="DOC.2.41.25">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void pushMatrix(const <!1><A HREF="Matrix.html">Matrix</A>&amp; matrix)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="popMatrix">
<A NAME="DOC.2.41.26">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void popMatrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getCurrentMatrix">
<A NAME="DOC.2.41.27">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* getCurrentMatrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getInverseCurrentMatrix">
<A NAME="DOC.2.41.28">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Matrix.html">Matrix</A>* getInverseCurrentMatrix()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getEyeLocal">
<A NAME="DOC.2.41.29">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getEyeLocal()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getCenterLocal">
<A NAME="DOC.2.41.30">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getCenterLocal()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="getLookVectorLocal">
<A NAME="DOC.2.41.31">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>const <!1><A HREF="Vec3.html">Vec3</A>&amp; getLookVectorLocal()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_viewFrustumCullingActive">
<A NAME="DOC.2.41.32">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _viewFrustumCullingActive</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_smallFeatureCullingActive">
<A NAME="DOC.2.41.33">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool _smallFeatureCullingActive</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isCulled">
<A NAME="DOC.2.41.34">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isCulled(const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; sp)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="isCulled">
<A NAME="DOC.2.41.35">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>bool isCulled(const <!1><A HREF="BoundingBox.html">BoundingBox</A>&amp; bb)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="MatrixGeoSet">
<A NAME="DOC.2.41.36">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::pair&lt;<!1><A HREF="Matrix.html">Matrix</A>*,<!1><A HREF="GeoSet.html">GeoSet</A>*&gt; MatrixGeoSet</B></TT>
<DL><DT><DD></DL><P>
<A NAME="ViewStateStack">
<A NAME="DOC.2.41.37">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::vector&lt;<!1><A HREF="ViewState.html">ViewState</A>*&gt; ViewStateStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_viewStateStack">
<A NAME="DOC.2.41.38">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="RenderVisitor.html#DOC.2.41.37">ViewStateStack</A> _viewStateStack</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_tvs">
<A NAME="DOC.2.41.39">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ViewState.html">ViewState</A>* _tvs</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_cvs">
<A NAME="DOC.2.41.40">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="ViewState.html">ViewState</A>* _cvs</B></TT>
<DL><DT><DD></DL><P>
<A NAME="OpaqueList">
<A NAME="DOC.2.41.41">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::multimap&lt;<!1><A HREF="GeoState.html">GeoState</A>*,<!1><A HREF="RenderVisitor.html#DOC.2.41.36">MatrixGeoSet</A>&gt; OpaqueList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="TransparentList">
<A NAME="DOC.2.41.42">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>typedef std::multimap&lt;float,<!1><A HREF="RenderVisitor.html#DOC.2.41.36">MatrixGeoSet</A>&gt; TransparentList</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_opaqueGeoSets">
<A NAME="DOC.2.41.43">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="RenderVisitor.html#DOC.2.41.41">OpaqueList</A> _opaqueGeoSets</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_transparentGeoSets">
<A NAME="DOC.2.41.44">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="RenderVisitor.html#DOC.2.41.42">TransparentList</A> _transparentGeoSets</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_globalState">
<A NAME="DOC.2.41.45">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html">GeoState</A>* _globalState</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_LODBias">
<A NAME="DOC.2.41.46">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _LODBias</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_fovy">
<A NAME="DOC.2.41.47">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _fovy</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_aspect">
<A NAME="DOC.2.41.48">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _aspect</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_znear">
<A NAME="DOC.2.41.49">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _znear</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_zfar">
<A NAME="DOC.2.41.50">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>float _zfar</B></TT>
<DL><DT><DD></DL><P>
<A NAME="calculateClippingPlanes">
<A NAME="DOC.2.41.51">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void calculateClippingPlanes()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_frustumTop">
<A NAME="DOC.2.41.52">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _frustumTop</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_frustumBottom">
<A NAME="DOC.2.41.53">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _frustumBottom</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_frustumLeft">
<A NAME="DOC.2.41.54">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _frustumLeft</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_frustumRight">
<A NAME="DOC.2.41.55">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="Vec3.html">Vec3</A> _frustumRight</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_tsm">
<A NAME="DOC.2.41.56">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="RenderVisitor.html#DOC.2.41.1">TransparencySortMode</A> _tsm</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

269
doc/osg/Scene.html Normal file
View File

@ -0,0 +1,269 @@
<HTML>
<HEAD>
<TITLE>class SG_EXPORT osg::Scene</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.3">
</HEAD>
<BODY BGCOLOR="#ffffff">
<H2>class SG_EXPORT <A HREF="#DOC.DOCU">osg::Scene</A>: public <!1><A HREF="Group.html#DOC.2.18.9">Group</A></H2>
<BLOCKQUOTE>The top level group node in a scene graph.</BLOCKQUOTE>
<HR>
<H2>Inheritance:</H2>
<APPLET CODE="ClassGraph.class" WIDTH=600 HEIGHT=155>
<param name=classes value="CReferenced,MReferenced.html,CObject,MObject.html,CNode,MNode.html,CGroup,MGroup.html,CScene,MScene.html">
<param name=before value="M,M,M,M,M">
<param name=after value="Md_SPSPSP,Md_SPSP,Md_SP,Md_,M">
<param name=indent value="0,1,2,3,4">
<param name=arrowdir value="down">
</APPLET>
<HR>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<A HREF="#DOC.2.48.3"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A> <B>Scene</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.4"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>clone</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.5"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>isSameKindAs</B>(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.6"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual const char* <B>className</B>() const
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.7"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual void <B>accept</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.1"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>void <B>setGState</B>(<!1><A HREF="GeoState.html">osg::GeoState</A>* gstate)
<DD><I>set the scene's GeoState</I>
<DT>
<A HREF="#DOC.2.48.2"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html">osg::GeoState</A>* <B>getGState</B>()
<DD><I>return the scene's GeoState</I>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<A HREF="#DOC.2.48.11"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A><!1><A HREF="GeoState.html">osg::GeoState</A>* <B>_gstate</B>
<DD><I></I>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<A HREF="#DOC.2.48.8"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual <B>~Scene</B>()
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.9"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>readLocalData</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DD><I></I>
<DT>
<A HREF="#DOC.2.48.10"><IMG ALT="[more]" BORDER=0 SRC=icon1.gif></A>virtual bool <B>writeLocalData</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
<DD><I></I>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Group.html">Group</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>traverse</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>addChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>removeChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *child )
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>replaceChild</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A> *origChild, <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* newChild )
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumChildren</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>getChild</B>( int i )
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>containsNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
<DT>
<IMG ALT="o" SRC=icon2.gif>ChildList::iterator <B>findNode</B>( <!1><A HREF="Node.html#DOC.2.30.1">Node</A>* node )
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="Node.html#DOC.2.30.1">Node</A>&gt; &gt; <B>ChildList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Group.html#DOC.2.18.8">ChildList</A> <B>_children</B>
</DL></P>
<P><DL>
<DT><H3>Protected Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>computeBound</B>( void )
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Node.html">Node</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.1">Node</A>* <B>cloneNode</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual void <B>ascend</B>(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const std::string&amp; name )
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setName</B>( const char* name )
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getName</B>( void )
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.12">ParentList</A>&amp; <B>getParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.39">Group</A>* <B>getParent</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumParents</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setUserData</B>(void* data, <!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* ma=0L)
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>getUserData</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>* <B>getMemoryAdapter</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>setNodeMask</B>(<!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> nm)
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>getNodeMask</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A>&amp; <B>getDescriptions</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>const std::string&amp; <B>getDescription</B>(int i) const
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string&amp; <B>getDescription</B>(int i)
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>getNumDescriptions</B>() const
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>addDescription</B>(const std::string&amp; desc)
<DT>
<IMG ALT="o" SRC=icon2.gif>const <!1><A HREF="BoundingSphere.html">BoundingSphere</A>&amp; <B>getBound</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>dirtyBound</B>()
</DL></P>
<P><DL>
<DT><H3>Public</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;<!1><A HREF="Node.html#DOC.2.30.39">Group</A>*&gt; <B>ParentList</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef unsigned int <B>NodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>typedef std::vector&lt;std::string&gt; <B>DescriptionList</B>
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="BoundingSphere.html">BoundingSphere</A> <B>_bsphere</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>bool <B>_bsphere_computed</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>std::string <B>_name</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.12">ParentList</A> <B>_parents</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>friend <B>Group</B>
<DT>
<IMG ALT="o" SRC=icon2.gif>void* <B>_userData</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="ref_ptr.html">ref_ptr</A>&lt;<!1><A HREF="MemoryAdapter.html">MemoryAdapter</A>&gt; <B>_memoryAdapter</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.34">NodeMask</A> <B>_nodeMask</B>
<DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Node.html#DOC.2.30.21">DescriptionList</A> <B>_descriptions</B>
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Object.html">Object</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* <B>readClone</B>(<!1><A HREF="Input.html">Input</A>&amp; fr)
<DT>
<IMG ALT="o" SRC=icon2.gif>virtual bool <B>write</B>(<!1><A HREF="Output.html">Output</A>&amp; fw)
</DL></P>
</DL>
<HR><H3>Inherited from <A HREF="Referenced.html">Referenced</A>:</H3>
<DL>
<P><DL>
<DT><H3>Public Methods</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif><!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp; <B>operator = </B>(<!1><A HREF="Referenced.html#DOC.2.43.4">Referenced</A>&amp;)
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>ref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>void <B>unref</B>()
<DT>
<IMG ALT="o" SRC=icon2.gif>int <B>referenceCount</B>()
</DL></P>
<P><DL>
<DT><H3>Protected Fields</H3><DD><DT>
<IMG ALT="o" SRC=icon2.gif>int <B>_refCount</B>
</DL></P>
</DL>
<A NAME="DOC.DOCU">
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>The top level group node in a scene graph. </BLOCKQUOTE>
<DL>
<A NAME="Scene">
<A NAME="DOC.2.48.3">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B> Scene()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="clone">
<A NAME="DOC.2.48.4">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual <!1><A HREF="Object.html#DOC.2.36.1">Object</A>* clone() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="isSameKindAs">
<A NAME="DOC.2.48.5">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool isSameKindAs(<!1><A HREF="Object.html#DOC.2.36.1">Object</A>* obj)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="className">
<A NAME="DOC.2.48.6">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual const char* className() const </B></TT>
<DL><DT><DD></DL><P>
<A NAME="accept">
<A NAME="DOC.2.48.7">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual void accept(<!1><A HREF="NodeVisitor.html">NodeVisitor</A>&amp; nv)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="setGState">
<A NAME="DOC.2.48.1">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>void setGState(<!1><A HREF="GeoState.html">osg::GeoState</A>* gstate)</B></TT>
<DD>set the scene's GeoState
<DL><DT><DD></DL><P>
<A NAME="getGState">
<A NAME="DOC.2.48.2">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html">osg::GeoState</A>* getGState()</B></TT>
<DD>return the scene's GeoState
<DL><DT><DD></DL><P>
<A NAME="~Scene">
<A NAME="DOC.2.48.8">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual ~Scene()</B></TT>
<DL><DT><DD></DL><P>
<A NAME="readLocalData">
<A NAME="DOC.2.48.9">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool readLocalData(<!1><A HREF="Input.html">Input</A>&amp; fr)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="writeLocalData">
<A NAME="DOC.2.48.10">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B>virtual bool writeLocalData(<!1><A HREF="Output.html">Output</A>&amp; fw)</B></TT>
<DL><DT><DD></DL><P>
<A NAME="_gstate">
<A NAME="DOC.2.48.11">
<DT><IMG ALT="o" BORDER=0 SRC=icon2.gif><TT><B><!1><A HREF="GeoState.html">osg::GeoState</A>* _gstate</B></TT>
<DL><DT><DD></DL><P></DL>
<HR><DL><DT><B>This class has no child classes.</B></DL>
<DL><DT><DD></DL><P><I><A HREF="index.html">Alphabetic index</A></I> <I><A HREF="HIER.html">HTML hierarchy of classes</A> or <A HREF="HIERjava.html">Java</A></I><P><HR>
<BR>
This page was generated with the help of <A HREF="http://www.linuxsupportline.com/~doc++">DOC++</A>.
</BODY>

Some files were not shown because too many files have changed in this diff Show More