asp.net c# view pdf : Break a pdf into smaller files software SDK dll windows .net winforms web forms OpenSceneGraph.3.0.Beginners.Guide-320832-part882

Developing Visual Components
[
298 
]
4. 
The text is created by a separate global func瑩on, too. It defines a font object 
describing every character's glyph, as well as the size and posi瑩on parameters  
in the world space, and the content of the text. In the HUD text implementa瑩on,  
texts should always align with the XOY plane:
{
}
5. 
In the main entry, we create a new 
o
s
g
:
:
G
e
o
d
e
node and add mul瑩ple text 
objects to it. These introduce the leading features of a Cessna. Of course, you  
can add your own explana瑩ons about this type of monoplane by using addi瑩onal 
o
s
g
T
e
x
t
:
:
T
e
x
t
drawables:
2
0
.
0
f
)
)
;
1
5
.
0
f
)
)
;
6. 
The node including all texts should be added to the HUD camera. To ensure that 
the texts won't be affected by OpenGL normals and lights (they are textured 
geometries, a晴er all), we have to disable ligh瑩ng for the camera node:
Break a pdf into smaller files - 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
break pdf file into multiple files; break pdf file into parts
Break a pdf into smaller files - 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
acrobat split pdf into multiple files; pdf separate pages
Chapter 11
[
299 
]
7. 
The last step is to add the Cessna model and the camera to the scene graph, and 
start the viewer as usual:
r
e
t
u
r
n
v
i
e
w
e
r
.
r
u
n
(
)
;
8. 
In the rendering window, you will see two lines of text over the Cessna model. 
No ma瑴er how you translate, rotate, or scale on the view matrix, the HUD 
texts will never be covered. Thus, users can always read the most important 
informa瑩on directly, without looking away from their usual perspec瑩ves:
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
To build the example code with CMake or other na瑩ve compilers, you should add the osgText 
library as dependence, and include the osgPar瑩cleosgShadow, and osgFX libraries.
Here we specify the font from the 
a
r
i
a
l
.
t
t
f
file. This is a default font in most Windows 
and UNIX systems, and can also be found in OSG data paths. As you can see, this kind of font 
offers developers highly-precise displayed characters, regardless of font size se瑴ngs. This is 
because the outlines of 
T
r
u
e
T
y
p
e
fonts are made of mathema瑩cal line segments and Bezier 
curves, which means they are not vector fonts. Bitmap (raster) fonts don't have such features 
and may some瑩mes look ugly when resized. Disable 
s
e
t
F
o
n
t
(
)
here, to force 
o
s
g
T
e
x
t
to 
use a default 12x12 bitmap font. Can you figure out the difference between these two fonts?
Developing Visual Components
[
300 
]
Pop quiz – text positions and the projection matrix
We define our text objects with the following code:
There are two ques瑩ons for you to think about:
1. Firstly, why must the flat text be placed in the XOY plane? What will happen if we 
don't do that? Should we use an HUD camera or not?
2. Secondly, what is the reference frame of these text posi瑩ons? That is, when se瑴ng 
a text object's posi瑩on, how can we locate it in the rendering window? Is it related 
with the orthographic projec瑩on matrix? Could you move the two lines of our 
example to the right-bo瑴om corner?
Have a go hero – using wide characters to support more languages
The 
s
e
t
T
e
x
t
(
)
method of 
o
s
g
T
e
x
t
:
:
T
e
x
t
accepts 
s
t
d
:
:
s
t
r
i
n
g
variables directly. 
Meanwhile, it also accepts wide characters as the input argument. For example:
w
c
h
a
r
_
t
*
w
s
t
r
=
;
This makes it possible to support mul瑩-languages, for instance, Chinese and Japanese 
characters. Now, try obtaining a sequence of wide characters either by defining them directly 
or conver瑩ng from mul瑩-byte characters, and apply them to the 
o
s
g
T
e
x
t
:
:
T
e
x
t
object, 
to see if the language that you are interested in can be rendered. Please note that the font 
should also be changed to support the corresponding language.
Creating 3D texts
Believe it or not, OSG also provides support for 3D texts in the scene graph. Each character 
will be extruded with a depth parameter and finally rendered with OpenGL's vertex 
array mechanism. The implementer class, 
o
s
g
T
e
x
t
:
:
T
e
x
t
3
D
, is also derived form 
o
s
g
T
e
x
t
:
:
T
e
x
t
b
a
s
e
and thus has nearly the same methods as 
o
s
g
T
e
x
t
:
:
T
e
x
t
. It 
requires an 
o
s
g
T
e
x
t
:
:
F
o
n
t
3
D
instance as the font parameter, which can be obtained by 
the 
func瑩on.
Chapter 11
[
301 
]
Time for action – creating texts in the world space
A simple 3D text object will be created in this example. Like the 2D text class 
o
s
g
T
e
x
t
:
:
T
e
x
t
, the 
o
s
g
T
e
x
t
:
:
T
e
x
t
3
D
class also inherits a list of methods to set basic 
text parameters, including posi瑩on, size, alignment, font object, and the content. 3D texts 
are most likely to be used as a special effect of games and applica瑩ons.
1.
Include the necessary headers:
2.
Read an appropriate font file with the 
func瑩on, 
which is similar to 
. Using the 
o
s
g
d
b
_
f
r
e
e
t
y
p
e
plugin, 
T
r
u
e
T
y
p
e
fonts can be parsed into finely-detailed 3D character glyphs:
3.
So we are going to imitate the 
c
r
e
a
t
e
T
e
x
t
(
)
func瑩on in the last example. 
The only difference is that we have to set an extra depth parameter for the text  
character to make it stand out in the 3D world. The 
s
e
t
A
x
i
s
A
l
i
g
n
m
e
n
t
(
)
method 
here indicates that the text object is placed on the XOZ plane, with its front faces  
facing the nega瑩ve Y axis:
{
}
Developing Visual Components
[
302 
]
4.
Create a 3D text object with short words. Note that because 3D texts are actually 
made up of ver瑩ces and geometry primi瑩ves, abuse of them may cause high  
resource consump瑩on:
5.
This 瑩me we add an 
o
s
g
:
:
M
a
t
r
i
x
T
r
a
n
s
f
o
r
m
as the parent of 
t
e
x
t
G
e
o
d
e
It will apply an addi瑩onal transforma瑩on matrix to the model-view matrix 
when rendering all text drawables, and thus change their displayed posi瑩ons and  
a瑴tudes in the world coordinates:
o
s
g
:
:
M
a
t
r
i
x
T
r
a
n
s
f
o
r
m
;
6.
Add our Cessna to the scene graph again, and start the viewer:
r
e
t
u
r
n
v
i
e
w
e
r
.
r
u
n
(
)
;
7.
You will see some big le瑴ers above the model, but in fact the ini瑩al posi瑩on of 
the 3D text object should be at (0, 0, 0), which is also the origin of the Cessna. 
The 
o
s
g
:
:
M
a
t
r
i
x
T
r
a
n
s
f
o
r
m
node here prevents the model and the text from 
overlapping each other, by transla瑩ng 
t
e
x
t
G
e
o
d
e
to a new posi瑩on (0, 0, 10):
Chapter 11
[
303 
]
W
h
a
t
j
u
s
t
h
a
p
p
e
n
e
d
?
Both 2D and 3D texts can be transformed by their parent nodes. This is always helpful when 
we have to compose a paragraph or move a model followed by a text label. Similar to OSG's 
transforma瑩on nodes, the 
s
e
t
P
o
s
i
t
i
o
n
(
)
method of 
o
s
g
T
e
x
t
:
:
T
e
x
t
B
a
s
e
only sets 
the loca瑩on under the rela瑩ve reference frame of the text object's parent. The same thing 
happens to the 
s
e
t
R
o
t
a
t
i
o
n
(
)
method, which determines the rota瑩on of the text, and 
s
e
t
A
x
i
s
A
l
i
g
n
m
e
n
t
(
)
, which aligns the text with a specified plane.
The only excep瑩on is the 
S
C
R
E
E
N
alignment mode:
This mimics the billboard technique of scene objects, and makes the text (either 
o
s
g
:
:
T
e
x
t
or 
o
s
g
:
:
T
e
x
t
3
D
) always face the viewer. In 3D Geographic Informa瑩on Systems  (3DGIS), 
placing landmarks on earth or ci瑩es as billboards is a very common opera瑩on, and can be 
implemented with the 
S
C
R
E
E
N
mode. In this case, rota瑩on and parent transforma瑩ons are 
not available and should not be used, as they may cause confusion and poten瑩al problems.
Creating particle animations
Par瑩cles are used in various 3D applica瑩ons for special effects such as smoke, dust, 
explosions, fluid, fire, and rain. It is much more difficult to build and manage a complete 
par瑩cle system rather than construct other simple scene objects. In fact, OSG provides a 
large number of classes in the osgPar瑩cle library to enable customiza瑩on of complex par瑩cle 
systems, most of which may be extended and overridden using inheritance, if user-defined 
algorithms are needed.
The par瑩cle class, 
, represents the atomic par瑩cle unit. It is o晴en 
used as a design template before the simula瑩on loop starts, and copied and regenerated by 
the par瑩cle system in run-瑩me to render massive par瑩cles.
The par瑩cle system class, 
, manages the crea瑩on, 
upda瑩ng, rendering, and destruc瑩on of all par瑩cles. It is derived from 
o
s
g
:
:
D
r
a
w
a
b
l
e
so it can accept different rendering a瑴ributes and modes, just like normal drawables. It 
should be added to an 
o
s
g
:
:
G
e
o
d
e
nod, as the last class.
Developing Visual Components
[
304 
]
The emi瑴er abstract class (
o
s
g
P
a
r
t
i
c
l
e
:
:
E
m
i
t
t
e
r
) defines the number and 
basic proper瑩es of newly-generated par瑩cles every frame. Its descendant class, 
o
s
g
P
a
r
t
i
c
l
e
:
:
M
o
d
u
l
a
r
E
m
i
t
t
e
r
, works like a standard emi瑴er, which provides the 
mechanism for controlling par瑩cles to be created. It always holds three kinds of sub-controllers:
‹
The placer (
o
s
g
P
a
r
t
i
c
l
e
:
:
P
l
a
c
e
r
) sets the ini瑩al posi瑩on of every par瑩cle
‹
The shooter (
o
s
g
P
a
r
t
i
c
l
e
:
:
S
h
o
o
t
e
r
) sets the ini瑩al veloci瑩es of par瑩cles
‹
The counter (
o
s
g
P
a
r
t
i
c
l
e
:
:
C
o
u
n
t
e
r
) determines how many par瑩cles should 
be created
The program's abstract class (
o
s
g
P
a
r
t
i
c
l
e
:
:
P
r
o
g
r
a
m
) manipulates the posi瑩on, velocity, 
and other proper瑩es of each individual par瑩cle during its life瑩me. Its descendant class, 
, is composed of a list of 
subclasses to perform opera瑩ons on exis瑩ng par瑩cles.
Both the emi瑴er and program classes are indirectly derived from 
o
s
g
:
:
N
o
d
e
, which means 
that they can be treated as nodes in the scene graph. During the update and cull traversals, 
they will be automa瑩cally traversed, and sub-controllers and operators will be executed. 
The par瑩cle system will then make use of their results to re-compute and draw its managed 
par瑩cles. The re-compu瑩ng process can be done with the 
t
e
m
U
p
d
a
t
e
r
, which is actually a node, too. The updater should be placed a晴er the emi瑴er 
and the program in the scene graph, in order to ensure that updates are carried out in the 
correct order. For example:
The following diagram shows the hierarchy of the above osgPar瑩cle classes:
Chapter 11
[
305 
]
Time for action – building a fountain in the scene
We will demonstrate how to implement a basic par瑩cle fountain. The simula瑩on of a 
fountain can be described as follows: firstly, the water emi瑴ed from a point rises with a 
certain ini瑩al speed; then the speed decreases due to gravity of the earth, un瑩l reaching 
the highest point; a晴er that, the water drops fall down onto the ground or into the pool. 
To achieve this, an 
node, along with an emi瑴er and a 
program processor, should be created and added to the scene graph.
1. 
Include the necessary headers:
Developing Visual Components
[
306 
]
2. 
The en瑩re process of crea瑩ng a par瑩cle system can be implemented in a separate 
user func瑩on:
{
}
3. 
Now we are inside the func瑩on. Every par瑩cle system has a template par瑩cle that 
determines the behaviors of all newly-generated par瑩cles. Here, we set the shape  
of each par瑩cle in this system to 
P
O
I
N
T
. With the help of OpenGL's point sprite 
extension, these points can be rendered as textured billboards, which is  
enough in most cases:
4. 
Set the rendering a瑴ributes and modes of the par瑩cle system. These will 
automa瑩cally affect every rendered par瑩cle. Here, we a瑴ach a texture image  
to par瑩cles, and define a blending func瑩on in order to make the background of  
the image transparent:
5. 
Another two important a瑴ributes are 
o
s
g
:
:
P
o
i
n
t
and 
o
s
g
:
:
P
o
i
n
t
S
p
r
i
t
e
. The 
first will set the point size (diameter of a rasterized point), and the la瑴er will enable 
point sprites, which can effec瑩vely replace a four-point quad with a single vertex, 
without requiring to specify the texture coordinates and rotate the front face to the 
viewer. Besides, we had be瑴er turn off the ligh瑩ng of par瑩cles, and we set a suitable 
rendering order to enable it to be drawn correctly in the whole scene graph:
Chapter 11
[
307 
]
6. 
The 
class generates a random number 
of par瑩cles every frame. It is derived from 
o
s
g
P
a
r
t
i
c
l
e
:
:
C
o
u
n
t
e
r
and has a 
s
e
t
R
a
t
e
R
a
n
g
e
(
)
method that is used to specify the minimum and maximum 
number of elements:
7. 
Add the random rate counter to the standard emi瑴er. Also, we have to a瑴ach the 
par瑩cle system to it as the opera瑩on des瑩na瑩on. By default, the modular emi瑴er  
already includes a point-shape placer at (0, 0, 0), and a radial shooter that  
chooses a direc瑩on and an ini瑩al speed randomly for each par瑩cle, so we don't  
need to specify new ones here:
8. 
The 
class applies a constant accelera瑩on to all 
par瑩cles, on the fly. To simulate gravity, we can either use 
s
e
t
A
c
c
e
l
e
r
a
t
i
o
n
(
)
to specify the accelera瑩on vector of gravity, or call the 
s
e
t
T
o
G
r
a
v
i
t
y
(
)
method directly:
9. 
Add the only operator to the standard program node, and a瑴ach the par瑩cle 
system, too:
Documents you may be interested
Documents you may be interested