asp.net c# view pdf : Break apart a pdf file software application dll winforms windows asp.net web forms OpenSceneGraph.3.0.Beginners.Guide-32089-part896

Building Geometry Models
[
68 
]
Specifying drawing types
The next step a晴er se瑴ng vertex a瑴ribute arrays is to tell the 
o
s
g
:
:
G
e
o
m
e
t
r
y
object 
how to render them. The virtual base class 
o
s
g
:
:
P
r
i
m
i
t
i
v
e
S
e
t
is used to manage a 
geometry primi瑩ve set which records the rendering order informa瑩on of ver瑩ces. The 
o
s
g
:
:
G
e
o
m
e
t
r
y
provides a few public methods to operate on one or more primi瑩ve sets:
1. The 
a
d
d
P
r
i
m
i
t
i
v
e
S
e
t
(
)
method takes an 
o
s
g
:
:
P
r
i
m
i
t
i
v
e
S
e
t
pointer 
as the parameter and a瑴aches a primi瑩ve set to the 
o
s
g
:
:
G
e
o
m
e
t
r
y
object.
2. The 
r
e
m
o
v
e
P
r
i
m
i
t
i
v
e
S
e
t
(
)
requires a zero-based index parameter and 
the number of primi瑩ve sets to remove. It will remove one or more a瑴ached 
primi瑩ve sets.
3. The 
g
e
t
P
r
i
m
i
t
i
v
e
S
e
t
(
)
returns the 
o
s
g
:
:
P
r
i
m
i
t
i
v
e
S
e
t
pointer at the 
specified index.
4. The 
returns the total number of primi瑩ve sets.
The 
o
s
g
:
:
P
r
i
m
i
t
i
v
e
S
e
t
class is unable to be instan瑩ated directly, but it brings 
out a few subclasses that are used to encapsulate OpenGL's 
g
l
D
r
a
w
A
r
r
a
y
s
(
)
and 
g
l
D
r
a
w
E
l
e
m
e
n
t
s
(
)
entries, for example 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
and 
.
The 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
class uses a number of sequen瑩al elements from vertex arrays 
to construct a sequence of geometry primi瑩ves. It can be created and a瑴ached to an 
o
s
g
:
:
G
e
o
m
e
t
r
y
object 
g
e
o
m
via the following declara瑩on:
The first parameter 
m
o
d
e
specifies what kind of primi瑩ves to render. Like the OpenGL 
g
l
D
r
a
w
A
r
r
a
y
s
(
)
entry, 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
usually accepts ten kinds of primi瑩ves: 
G
L
_
P
O
I
N
T
S
G
L
_
L
I
N
E
_
S
T
R
I
P
G
L
_
L
I
N
E
_
L
O
O
P
G
L
_
L
I
N
E
S
G
L
_
T
R
I
A
N
G
L
E
_
S
T
R
I
P
G
L
_
T
R
I
A
N
G
L
E
_
F
A
N
G
L
_
T
R
I
A
N
G
L
E
S
G
L
_
Q
U
A
D
_
S
T
R
I
P
G
L
_
Q
U
A
D
S
, and 
G
L
_
P
O
L
Y
G
O
N
.
The second and third parameters indicate that the primi瑩ve set begins at index first and 
has count elements altogether. Developers should make sure that there are at least first + 
count elements in the vertex array. OSG won't audit if the total number of ver瑩ces meets 
the requirement of the primi瑩ve set, which could cause crashes.
Time for action – drawing a colored quad
Let's work on a common shape in order to see the steps to complete a renderable geometry 
model. We will create a quadrangle with only four ver瑩ces as the four corners, and use 
G
L
_
Q
U
A
D
S
mode to draw these ver瑩ces. The 
G
L
_
Q
U
A
D
S
mode tells OpenGL to combine 
the first four coordinates in the vertex array as one quad, the second four as the second 
quad, and so on.
Break apart a pdf file - 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 separate pages; split pdf files
Break apart a pdf file - 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
how to split pdf file by pages; split pdf by bookmark
Chapter 4
[
69 
]
1.
Include the necessary headers:
2.
Create the vertex array and push the four corner points to the back of the array 
by using 
s
t
d
:
:
v
e
c
t
o
r
like opera瑩ons:
3.
We have to indicate the normal of each vertex; otherwise OpenGL will use a default 
(0, 0, 1) normal vector and the ligh瑩ng equa瑩on calcula瑩on may be incorrect. The 
four ver瑩ces actually face the same direc瑩on, so a single normal vector is enough. 
We will also set the 
s
e
t
N
o
r
m
a
l
B
i
n
d
i
n
g
(
)
method to 
B
I
N
D
_
O
V
E
R
A
L
L
later.
4.
We will indicate a unique color value to each vertex and make them colored. By 
default, OpenGL will use smooth coloring and blend colors at each vertex together:
5.
Next, we create the 
o
s
g
:
:
G
e
o
m
e
t
r
y
object and set the prepared vertex, normal, 
and color arrays to it. We also indicate that the single normal should be bound 
to the en瑩re geometry and that the colors should be bound per vertex:
C# PDF Page Insert Library: insert pages into PDF file in C#.net
Offer PDF page break inserting function. Apart from the ability to inserting a new PDF page into existing PDF document file, RasterEdge C# .NET PDF document
pdf split; pdf rotate single page
Building Geometry Models
[
70 
]
6.
The last step required to finish a geometry and add it to the scene graph 
is to specify the primi瑩ve set. A newly allocated 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
instance with the drawing mode set to 
G
L
_
Q
U
A
D
S
is used here, in order to 
render the four ver瑩ces as quad corners in a counter-clockwise order:
7.
Add the geometry to an 
o
s
g
:
:
G
e
o
d
e
object and render it in the scene viewer:
r
e
t
u
r
n
v
i
e
w
e
r
.
r
u
n
(
)
;
8.
Our program finally results in a nice colored quad, as shown in the 
following screenshot:
Chapter 4
[
71 
]
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
We assume that you are familiar with the following OpenGL code snippets:
The array variable 
v
e
r
t
i
c
e
s
is used to define the coordinates to be rendered. The OpenGL 
func瑩on 
g
l
D
r
a
w
A
r
r
a
y
s
(
)
will draw the geometry primi瑩ve of the mode 
G
L
_
Q
U
A
D
S
with 
four sequen瑩al elements in the array, that is, a quadrangle in the 3D space.
The 
o
s
g
:
:
G
e
o
m
e
t
r
y
class encapsulates the en瑩re process men瑩oned above, mainly 
by using the 
s
e
t
V
e
r
t
e
x
A
r
r
a
y
(
)
and 
a
d
d
P
r
i
m
i
t
i
v
e
S
e
t
(
)
methods. Actually, these 
vertex data and primi瑩ve sets se瑴ngs are not performed as soon as a user applica瑩on calls 
these methods, but will be applied when the geometry is reached during the next drawing 
traversal of the scene graph. This makes it possible to use most 
o
s
g
:
:
G
e
o
m
e
t
r
y
methods 
like proper瑩es, which can be read and modified without forcing the scene to render back 
and forth.
Pop quiz – results of different primitive types
In the previous example, we defined the modestart, and count parameters of the primi瑩ve 
and generated a quad as the result. It is important for you to understand how geometry 
ver瑩ces are interpreted by one or more primi瑩ve sets. Can you list the ten mode symbols 
(
G
L
_
T
R
I
A
N
G
L
E
S
G
L
_
Q
U
A
D
S
, and so on) and their major behaviors in a table? For example, 
do you know how each mode treats ver瑩ces and indices, and what shape is going to be 
drawn in the final stage?
Building Geometry Models
[
72 
]
Indexing primitives
The 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
works fine when reading vertex data straight through the arrays, 
without any skipping and hopping. However, it tends to be a li瑴le inefficient if there are lots 
of shared ver瑩ces. For example, in order to make 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
draw a cube with eight 
ver瑩ces in the 
G
L
_
T
R
I
A
N
G
L
E
S
mode, the vertex array should repeat each vertex a couple of 
瑩mes and should increase the array size to 36 (12 triangle faces) at last:
The 
class, as well as 
and 
classes, are used as index arrays in order to solve the 
above problem. They all derive from 
o
s
g
:
:
P
r
i
m
i
t
i
v
e
S
e
t
and encapsulate OpenGL's 
g
l
D
r
a
w
E
l
e
m
e
n
t
s
(
)
func瑩on, with different data types. The index array saves indices of 
vertex array elements. In this case, the cube's vertex array is able to be resized to eight, with 
an associated indexing primi瑩ve set.
The 
o
s
g
:
:
D
r
a
w
E
l
e
m
e
n
t
s
*
classes are designed to work just like 
s
t
d
:
:
v
e
c
t
o
r
, so any 
vector-related methods are compa瑩ble for use. For instance, to add indices to a newly 
allocated 
object, we could code like following:
This will specify the front face of our cube shown in the last image.
Chapter 4
[
73 
]
Time for action – drawing an octahedron
An octahedron is a polyhedron having eight triangle faces. It is really a nice example to show 
why primi瑩ve indexing is important. We will first sketch the octahedron structure, as shown 
in the following image:
The octahedron has six ver瑩ces, each shared by four triangles. We would have to create 
a vertex array with 24 elements to render all eight faces when using 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
However, with the help of an index array and the 
class, we 
can allocate a vertex array with only six elements and thus improve the efficiency of drawing 
the geometry.
1.
Include the necessary headers:
2.
As we have discussed before, the 
o
s
g
:
:
V
e
c
3
A
r
r
a
y
class inherits 
the characteris瑩cs of 
s
t
d
:
:
v
e
c
t
o
r
and can construct using a 
predetermined size parameter and work with 
o
p
e
r
a
t
o
r
[
]
directly.
Building Geometry Models
[
74 
]
3.
The 
accepts a size parameter besides 
the drawing mode parameter, too. A晴er that, we will specify the 
indices of ver瑩ces to describe all eight triangle faces.
4.
In order to create a geometry with a default white color, we will only set 
the vertex array and the 
primi瑩ve set. The 
normal array is also required but is not easy to compute manually. We will 
use a smoothed normal calculator to automa瑩cally obtain it. This calculator 
will be described in the next sec瑩on, Using polygonal techniques.
5.
Add the geometry to an 
o
s
g
:
:
G
e
o
d
e
object and make it the scene root:
r
e
t
u
r
n
v
i
e
w
e
r
.
r
u
n
(
)
;
6.
The generated octahedron is illustrated as shown in the following screenshot:
Chapter 4
[
75 
]
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
The vertex array mechanism reduces the number of OpenGL func瑩on calls. It stores vertex 
data in the applica瑩on memory, which is called the client side. The OpenGL pipeline on the 
server side gets access to different vertex arrays.
As can be seen from the following image, OpenGL obtains data from the vertex buffer on  
the client side and assembles primi瑩ve data in an orderly manner.
Building Geometry Models
[
76 
]
The vertex buffer here is used to manage data specified by 
s
e
t
*
A
r
r
a
y
(
)
methods of the 
o
s
g
:
:
G
e
o
m
e
t
r
y
class. 
o
s
g
:
:
D
r
a
w
A
r
r
a
y
s
marches straight through these arrays and 
draw them.
However, 
o
s
g
:
:
D
r
a
w
E
l
e
m
e
n
t
s
*
classes also provide an index array in order to reduce 
the number of ver瑩ces to transfer. The index array then allows a new vertex cache on the 
server side for temporary storage. OpenGL will fetch ver瑩ces from the cache directly, rather 
than read from the vertex buffer, which is on the client side. This will largely increase the 
performance.
Pop quiz – optimizing indexed geometries
The octahedron that we just drew is made up of only six ver瑩ces. Can you figure out how 
many ver瑩ces will be actually used if we are not going to index the geometry any more?
In many situa瑩ons, you will find that triangle strips can provide be瑴er performance in 
rendering con瑩nuous pieces of mesh faces. Assuming that we choose 
G
L
_
T
R
I
A
N
G
L
E
_
S
T
R
I
P
S
instead of 
G
L
_
T
R
I
A
N
G
L
E
S
in the previous example, how could we construct 
the index array this 瑩me?
Have a go hero – challenges with cubes and pyramids
Now it is your turn to draw some other polyhedrons, for example, a cube or a pyramid. 
The structure of a cube is discussed at the beginning of the sec瑩on Indexing primi瑩ves
It contains six ver瑩ces and 12 triangle faces, which is a good demonstra瑩on of indexing 
ver瑩ces.
A pyramid usually has one polygon base and several triangle faces mee瑩ng at an "apex". 
Take the square pyramid as an example: it contains five ver瑩ces and six triangle faces (the 
square base consists of two triangles). Each vertex is shared by three or four triangles:
Chapter 4
[
77 
]
Create a new 
o
s
g
:
:
G
e
o
m
e
t
r
y
object and add ver瑩ces and normals as arrays. The 
will also calculate smoothed normals. Specify an 
primi瑩ve set with the 
G
L
_
T
R
I
A
N
G
L
E
S
drawing mode. 
For advanced study, you may even add mul瑩ple primi瑩ve sets with different drawing  
modes, for instance, rendering the pyramid base with 
G
L
_
Q
U
A
D
S
, and triangle faces 
with 
G
L
_
T
R
I
A
N
G
L
E
_
F
A
N
.
Using polygonal techniques
OSG supports various polygonal techniques for manipula瑩ng the geometry objects. These 
pre-processing methods, such as polygon reduc瑩on and tessella瑩on, are o晴en used to  
create and improve polygonal models for rendering at a later 瑩me. They are designed to 
have a simple interface and be easy to use, but may perform complex calcula瑩ons backstage. 
They are not suggested to be used on-the-fly because of possibly massive computa瑩ons.
A few polygonal technique implementa瑩ons in OSG are listed as follows:
1. 
o
s
g
U
t
i
l
:
:
S
i
m
p
l
i
f
i
e
r
: This reduces the number of triangles in geometries. 
The public method 
s
i
m
p
l
i
f
y
(
)
can be used to simply enter a geometry object.
2. 
: This calculates normals for any geometries 
containing primi瑩ves, for instance, the octahedron that we have just seen. The 
public sta瑩c method 
s
m
o
o
t
h
(
)
can be used to generate smoothed normals of a 
geometry, instead of realloca瑩ng and se瑴ng the normal array yourselves.
3. 
: This generates arrays containing the 
tangent-space basis vectors for geometry ver瑩ces. It passes the geometry 
object as a parameter to the 
g
e
n
e
r
a
t
e
(
)
method and saves the results in 
g
e
t
T
a
n
g
e
n
t
A
r
r
a
y
(
)
g
e
t
N
o
r
m
a
l
A
r
r
a
y
(
)
, and 
g
e
t
B
i
n
o
r
m
a
l
A
r
r
a
y
(
)
The results can be used as varying vertex a瑴ributes in GLSL.
4. 
: This uses the OpenGL U瑩lity (glu) tessella瑩on 
rou瑩nes to break complex primi瑩ves into simple ones. It provides a 
method to change the primi瑩ve sets of the input 
geometry to tessellated ones.
5. 
: This converts geometry surface primi瑩ves into 
triangle strips, which allows faster rendering and more efficient memory usage.  
The public method 
s
t
r
i
p
i
f
y
(
)
is used to convert primi瑩ves in the input 
geometry into 
G
L
_
T
R
I
A
N
G
L
E
_
S
T
R
I
P
types.
Documents you may be interested
Documents you may be interested