asp.net c# view pdf : Break pdf into separate pages Library control component asp.net azure web page mvc OpenSceneGraph.3.0.Beginners.Guide-32088-part895

Crea瑩ng Your First OSG Program
[
58 
]
Time for action – saving the log file
We will make use of the 
s
t
d
:
:
o
f
s
t
r
e
a
m
class to redirect the OSG internal no瑩fy messages 
to an external log file. The virtual func瑩on 
n
o
t
i
f
y
(
)
of the 
o
s
g
:
:
N
o
t
i
f
y
H
a
n
d
l
e
r
derived 
class should be overridden to apply standard file stream opera瑩ons, and a global func瑩on 
is called before everything starts as well.
1.
Include the necessary headers:
#
i
n
c
l
u
d
e
<
f
s
t
r
e
a
m
>
2.
Implement the derived class 
L
o
g
F
i
l
e
H
a
n
d
l
e
r
, which will redirect no瑩fy messages 
to the file stream:
{
p
u
b
l
i
c
:
 protected:
}
;
3.
Now set a new no瑩fy handler to the en瑩re OSG system, and work under the INFO 
level to see more verbose messages. The func瑩on 
o
s
g
D
B
:
:
r
e
a
d
N
o
d
e
F
i
l
e
s
here 
directly reads all usable filenames from the command line and merges them into 
the root node. We also add an 
O
S
G
_
F
A
T
A
L
macro to check if there is no scene graph 
data loaded:
{
i
f
(
!
r
o
o
t
)
Break pdf into separate pages - Split, seperate PDF into multiple files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Explain How to Split PDF Document in Visual C#.NET Application
pdf split pages; pdf print error no pages selected
Break pdf into separate pages - VB.NET PDF File Split Library: Split, seperate PDF into multiple files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Splitter Control to Disassemble PDF Document
pdf link to specific page; break pdf password online
Chapter 3
[
59 
]
{
r
e
t
u
r
n
-
1
;
 }   
}
4.
Build and start the example. All informa瑩on will be saved in the log file 
o
u
t
p
u
t
.
t
x
t
, which is also indicated in the example. Try the command line 
with the newly-generated executable 
M
y
P
r
o
j
e
c
t
.
e
x
e
this 瑩me:
5.
Press the Esc key to quit, and then open the resul瑩ng log file in the working 
directory with notepad (on Windows) or any text editor:
6.
Don't be discouraged if you can't read and understand all of the informa瑩on listed 
here. It only shows how OSG is star瑩ng and ge瑴ng every part to work properly. It 
will be of great help in future development.
Crea瑩ng Your First OSG Program
[
60 
]
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
By default, OSG will send messages to the standard output stream 
s
t
d
:
:
c
o
u
t
and error 
stream 
s
t
d
:
:
c
e
r
r
. However, these messages can be easily redirected to other streams and 
even the GUI text windows. A log file here is friendly to end users and helps them a lot, while  
sending feedbacks.
Besides, se瑴ng the 
o
s
g
:
:
s
e
t
N
o
t
i
f
y
L
e
v
e
l
(
)
func瑩on will make the no瑩fy level reset to 
the specified level or a higher level. The no瑩fier system then ignores statements from lower 
levels and prints nothing to the output stream. For instance, assuming that you have the 
following lines in your applica瑩on:
The message with the no瑩fier level lower than 
F
A
T
A
L
will not be printed any more.
The environment variable 
O
S
G
_
N
O
T
I
F
Y
_
L
E
V
E
L
, which was men瑩oned in the previous 
chapter, can be used to control the displayed message level, too, for any OSG-based 
applica瑩ons.
Summary
This chapter provided a simple guide to crea瑩ng your own simple OSG program with the 
CMake tool, and introduced some prac瑩cal u瑩li瑩es. OSG uses smart pointers heavily for 
efficient manipula瑩on of opera瑩ng system resources allocated for each scene graph node 
at run 瑩me, which is crucial to the performance of these safety-cri瑩cal programs. To help 
understand the working principle of smart pointers, we spent much of the chapter explaining 
the use of 
o
s
g
:
:
r
e
f
_
p
t
r
<
>
and how to calculate the referenced count, and discussing 
various situa瑩ons that may occur when managing OSG scene elements.
In this chapter, we specifically covered:
‹
How to write a simple CMake script file and make it work with your own source  
code and OSG dependencies
‹
The principle of smart pointers and the garbage collec瑩on mechanism of OSG
‹
Advantages and notes on using the na瑩ve smart pointers with scene graph objects
‹
Some other useful classes and func瑩ons for parsing command-line arguments, and 
tracing and debugging your source code
4
Building Geometry Models
The basic opera瑩on of OpenGL's graphical pipeline is to accept vertex data 
(points, lines, triangles, and polygons) and pixel data (graphical image 
data), convert them into fragments and store them in the frame buffer. 
The frame buffer serves as a major interface between developers and the 
computer display, which maps each frame of graphic contents into memory 
space for read-write opera瑩on. OSG encapsulates the whole OpenGL vertex 
transforma瑩on and primi瑩ve assembly opera瑩ons in order to manage and 
send vertex data to the OpenGL pipeline, as well as some data transmission 
op瑩miza瑩ons and addi瑩onal polygonal techniques for improving rendering 
performance.
In this chapter, we just focus on how to draw and render geometry models through a fast 
path, and will cover the following topics:
‹
How to quickly draw basic objects with a few necessary parameters
‹
How to set ver瑩ces and vertex a瑴ribute arrays to construct a geometry object
‹
The reason and methods of indexing vertex data with primi瑩ves
‹
How to make use of different polygon techniques to op瑩mize rendering
‹
How to get access to geometry a瑴ributes and primi瑩ves
‹
Integrate OpenGL drawing calls into your OSG-based applica瑩ons
Building Geometry Models
[
62 
]
How OpenGL draws objects
OpenGL uses geometry primi瑩ves to draw different objects in the 3D world. A geometry 
primi瑩ve, which may be a set of points, lines, triangles, or polygonal faces, determines how 
OpenGL sorts and renders its associated vertex data. The easiest way to render a primi瑩ve 
is to specify a list of ver瑩ces between the 
g
l
B
e
g
i
n
(
)
and 
g
l
E
n
d
(
)
pair, which is called 
immediate mode, but it is inefficient in most cases.
The vertex data, including vertex coordinates, normals, colors, and texture coordinates, can 
also be stored in various arrays. Primi瑩ves will be formed by dereferencing and indexing the 
array elements. This method, named vertex array, reduces redundant shared ver瑩ces and 
thus performs be瑴er than immediate mode.
Display lists also significantly improve applica瑩on performance, because all vertex and pixel 
data are compiled and copied into the graphics memory. The prepared primi瑩ves can be 
reused repeatedly, without transmi瑴ng data over and over again. It helps a lot in drawing 
sta瑩c geometries.
The vertex buffer object (VBO) mechanism allows vertex array data to be stored in 
high-performance memory. This provides a more efficient solu瑩on for transferring  
dynamic data.
By default, OSG uses vertex arrays and display lists to manage and render geometries. 
However, this may change depending on different data types and rendering strategies.
We would like to also call a瑴en瑩on to the removal of immediate mode and display lists 
in OpenGL ES and OpenGL 3.x, for the purpose of producing a more lightweight interface. 
Of course OpenGL 3.x and further versions will keep these deprecated APIs for backward 
compa瑩bility. However, they are not recommended to be used in new code.
Geode and Drawable classes
The 
o
s
g
:
:
G
e
o
d
e
class corresponds to the leaf node of a scene graph. It has no child 
nodes, but always contains geometry informa瑩on for rendering. Its name 
G
e
o
d
e
is short 
for geometry node.
The geometry data to be drawn are stored in a set of 
o
s
g
:
:
D
r
a
w
a
b
l
e
objects managed 
by 
o
s
g
:
:
G
e
o
d
e
. The non-instan瑩atable 
o
s
g
:
:
D
r
a
w
a
b
l
e
class is defined as a pure virtual 
class. It has several subclasses for rendering models, images, and texts to the OpenGL 
pipeline. These renderable elements are collec瑩vely called drawables.
Chapter 4
[
63 
]
The 
o
s
g
:
:
G
e
o
d
e
class provides a few methods to a瑴ach and detach drawables, as well as 
collect informa瑩on about them:
1. The public method 
a
d
d
D
r
a
w
a
b
l
e
(
)
takes an 
o
s
g
:
:
D
r
a
w
a
b
l
e
pointer as its 
parameter and a瑴aches a drawable to the 
o
s
g
:
:
G
e
o
d
e
instance. All drawables 
added are internally managed by the 
o
s
g
:
:
r
e
f
_
p
t
r
<
>
smart pointer.
2. The public methods 
r
e
m
o
v
e
D
r
a
w
a
b
l
e
(
)
and 
r
e
m
o
v
e
D
r
a
w
a
b
l
e
s
(
)
will detach 
one or more drawables from the current 
o
s
g
:
:
G
e
o
d
e
object, and decrease their 
referenced coun瑩ng number as well. The 
r
e
m
o
v
e
D
r
a
w
a
b
l
e
(
)
method uses an 
o
s
g
:
:
D
r
a
w
a
b
l
e
pointer as the only parameter, and 
r
e
m
o
v
e
D
r
a
w
a
b
l
e
s
(
)
accepts 
two parameters: the zero-based index of the start element, and number of elements 
to be removed.
3. The 
g
e
t
D
r
a
w
a
b
l
e
(
)
method returns the 
o
s
g
:
:
D
r
a
w
a
b
l
e
object stored at the 
specified zero-based index.
4. The 
g
e
t
N
u
m
D
r
a
w
a
b
l
e
s
(
)
method returns the total number of a瑴ached 
drawables. Developers are then able to traverse each drawable in a cycle with 
the 
g
e
t
D
r
a
w
a
b
l
e
(
)
method, or remove all drawables at once by using the 
following code:
Rendering basic shapes
OSG provides an 
o
s
g
:
:
S
h
a
p
e
D
r
a
w
a
b
l
e
class, which inherits from the 
o
s
g
:
:
D
r
a
w
a
b
l
e
base class, to render basic geometry shapes quickly with plain parameters. An 
o
s
g
:
:
S
h
a
p
e
D
r
a
w
a
b
l
e
instance always includes an 
o
s
g
:
:
S
h
a
p
e
object to indicate the 
specified geometry's type and proper瑩es.
The 
s
e
t
S
h
a
p
e
(
)
method is usually used to allocate and set a shape. For example:
It will assign a box with a center point at (1.0, 0.0, 0.0) in its local coordinate space, width 
and height of 
1
0
, and depth of 
5
. Here, the class 
o
s
g
:
:
V
e
c
3
represents a three-element 
vector in OSG. Other predefined classes such as 
o
s
g
:
:
V
e
c
2
and 
o
s
g
:
:
V
e
c
4
will also help 
when defining ver瑩ces, colors, normals, and texture coordinates.
Note that 
o
s
g
:
:
V
e
c
3
means a float type vector, and 
o
s
g
:
:
V
e
c
3
d
means a double type 
one, as do 
o
s
g
:
:
V
e
c
2
and 
o
s
g
:
:
V
e
c
2
d
o
s
g
:
:
V
e
c
4
and 
o
s
g
:
:
V
e
c
4
d
, and so on.
The most frequently used basic shapes defined in OSG are: 
o
s
g
:
:
B
o
x
o
s
g
:
:
C
a
p
s
u
l
e
o
s
g
:
:
C
o
n
e
o
s
g
:
:
C
y
l
i
n
d
e
r
, and 
o
s
g
:
:
S
p
h
e
r
e
. Their appearances can be well defined 
by passing parameters directly to constructors.
Building Geometry Models
[
64 
]
Time for action – quickly creating simple objects
It is easy to create simple objects by using an 
o
s
g
:
:
S
h
a
p
e
subclass. We will take three 
typical shapes as examples: a box with different width, height, and depth values, a sphere 
with a radius value, and a cone with a radius and a height.
1.
Include necessary headers:
2.
Add three 
o
s
g
:
:
S
h
a
p
e
D
r
a
w
a
b
l
e
objects successively, each with a type of basic 
shape. We set these shapes to different posi瑩ons to make them visible to viewers  
at the same 瑩me, and for the reason of dis瑩nguishing them from each other, we  
color the la瑴er two shapes green and respec瑩vely, blue by using the 
s
e
t
C
o
l
o
r
(
)
method of 
o
s
g
:
:
S
h
a
p
e
D
r
a
w
a
b
l
e
:
3.
An 
o
s
g
:
:
G
e
o
d
e
object is created, and all the drawables are added to it. 
Note that the drawables and the geometry node are all managed by the 
o
s
g
:
:
r
e
f
_
p
t
r
<
>
smart pointer here. The 
o
s
g
:
:
G
e
o
d
e
object is finally 
used as the scene root of the viewer:
r
e
t
u
r
n
v
i
e
w
e
r
.
r
u
n
(
)
;
Chapter 4
[
65 
]
4.
Now it's 瑩me to see if these shapes are rendered properly. We don't have to 
care about the actual drawing work of vertex posi瑩ons, normals, and colors 
here, which brings convenience for debugging and quick shape viewing:
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
The 
o
s
g
:
:
S
h
a
p
e
D
r
a
w
a
b
l
e
class is useful for quick display, but it is not an efficient 
way of drawing geometry primi瑩ves. It should only be used for quick prototyping and 
debugging when you develop 3D applica瑩ons. To create geometries with high performance 
computa瑩on and visualiza瑩on requirements, the 
o
s
g
:
:
G
e
o
m
e
t
r
y
class, which is going to be 
introduced, is always a be瑴er choice.
OSG has an internal 
class that is used to perform basic shape 
drawing opera瑩ons. This class enables the use of vertex arrays in the style of a 
g
l
B
e
g
i
n
(
)
and 
g
l
E
n
d
(
)
pair, which makes the implementa瑩on of basic shapes easy to understand 
and extend.
To get and use an ini瑩alized 
object, you should 
define a class derived from the 
o
s
g
:
:
D
r
a
w
a
b
l
e
base class and re-implement its 
method, and start programming as if you are wri瑩ng the classic 
OpenGL 1.0 drawing calls:
{
g
l
.
B
e
g
i
n
(
)
;
g
l
.
E
n
d
(
)
;
}
More informa瑩on about re-implemen瑩ng the 
o
s
g
:
:
D
r
a
w
a
b
l
e
class can be found in the 
Implemen瑩ng your own drawables sec瑩on of this chapter.
Building Geometry Models
[
66 
]
Storing array data
As already men瑩oned in earlier chapters, OSG supports vertex arrays and VBO to speed 
up the rendering process. To manage the vertex data used in these two mechanisms, OSG 
defines a basic 
o
s
g
:
:
A
r
r
a
y
class and a few derived classes for commonly used array and 
index array types.
The 
o
s
g
:
:
A
r
r
a
y
class can't be instan瑩ated, but it declares interfaces to exchange 
with OpenGL calls and buffer data modifiers. Its subclasses (
o
s
g
:
:
V
e
c
2
A
r
r
a
y
o
s
g
:
:
V
e
c
3
A
r
r
a
y
o
s
g
:
:
U
I
n
t
A
r
r
a
y
, etc.) inherit the characteris瑩cs of the Standard 
Template Library vector class, and can thus make use of all of the 
s
t
d
:
:
v
e
c
t
o
r
members, 
including 
p
u
s
h
_
b
a
c
k
(
)
p
o
p
_
b
a
c
k
(
)
s
i
z
e
(
)
, and STL algorithms and iterators.
The following code will add a three-element vector to an exis瑩ng 
o
s
g
:
:
V
e
c
3
A
r
r
a
y
object 
named ver瑩ces:
The OSG built-in array classes should be allocated from heap and managed by smart 
pointers. However, it is not necessary for the array elements such as 
o
s
g
:
:
V
e
c
2
and 
o
s
g
:
:
V
e
c
3
to follow this rule, as they are very basic data types.
The 
o
s
g
:
:
G
e
o
m
e
t
r
y
class acts as the high-level wrapper of the OpenGL vertex array 
func瑩onality. It records different types of arrays and manages a geometry primi瑩ve set to 
render these vertex data in an orderly manner. It is derived from 
o
s
g
:
:
D
r
a
w
a
b
l
e
class and 
can be added to an 
o
s
g
:
:
G
e
o
d
e
object at any 瑩me. This class accepts arrays as basic data 
carriers and uses them to produce simple or complex geometry models.
Vertices and vertex attributes
The Vertex is the atomic element of geometry primi瑩ves. It uses several numeric a瑴ributes 
to describe a point in 2D or 3D spaces, including vertex posi瑩on, color, normal and texture 
coordinates, fog coordinate, and so on. The posi瑩on value is always required, and other 
a瑴ributes will help to define the nature of the point. OpenGL accepts up to 16 generic 
a瑴ributes to be specified per vertex, and can create different arrays in which to store 
each of them. All a瑴ribute arrays are supported by the 
o
s
g
:
:
G
e
o
m
e
t
r
y
class with the 
corresponding 
s
e
t
*
A
r
r
a
y
(
)
methods.
Chapter 4
[
67 
]
A table of built-in vertex a瑴ributes in OpenGL is listed below:
A瑴ribute
Suggested 
data type
osg::Geometry method
Equivalent OpenGL call
Posi瑩on
3D vectors
s
e
t
V
e
r
t
e
x
A
r
r
a
y
(
)
g
l
V
e
r
t
e
x
P
o
i
n
t
e
r
(
)
Normal
3D vectors 
normalized 
to the range 
[0, 1]
s
e
t
N
o
r
m
a
l
A
r
r
a
y
(
)
g
l
N
o
r
m
a
l
P
o
i
n
t
e
r
(
)
Color
4D vectors 
normalized 
to the range 
[0, 1]
s
e
t
C
o
l
o
r
A
r
r
a
y
(
)
g
l
C
o
l
o
r
P
o
i
n
t
e
r
(
)
Secondary 
color
4D vectors 
normalized 
to the range 
[0, 1]
g
l
S
e
c
o
n
d
a
r
y
C
o
l
o
r
P
o
i
n
t
e
r
E
X
T
(
)
Fog 
coordinate
Float values
s
e
t
F
o
g
C
o
o
r
d
A
r
r
a
y
(
)
Texture 
coordinates
2D or 3D 
vectors
s
e
t
T
e
x
C
o
o
r
d
A
r
r
a
y
(
)
g
l
T
e
x
C
o
o
r
d
P
o
i
n
t
e
r
(
)
Other 
general 
a瑴ributes
User-defined 
values
g
l
V
e
r
t
e
x
A
t
t
r
i
b
P
o
i
n
t
e
r
A
R
B
(
)
A vertex usually contains eight texture coordinates and three general a瑴ributes in current 
OpenGL graphics systems. In principle, each vertex should set all of its a瑴ributes to certain 
values, and form a set of arrays with exactly the same size; otherwise the undefined ones 
may cause unexpected problems. OSG provides binding methods to make the work more 
convenient. For instance, developers may call the public method 
s
e
t
C
o
l
o
r
B
i
n
d
i
n
g
(
)
of 
an 
o
s
g
:
:
G
e
o
m
e
t
r
y
object 
g
e
o
m
, and take an enumerate as the parameter:
This indicates that the color and the vertex are put into a one-to-one rela瑩onship. However, 
see the following code:
It will apply a single color value to the en瑩re geometry. There are 
s
e
t
N
o
r
m
a
l
B
i
n
d
i
n
g
(
)
, and 
, which do the similar work for other a瑴ribute types.
Documents you may be interested
Documents you may be interested