c# .net pdf reader : Add page pdf reader software application dll windows azure winforms web forms Pro_Silverlight_5_in_CSharp_4th_edition48-part113

CHAPTER 13  SILVERLIGHT 3D 
474 
 Note  A vertex is a data object that represents a single point in 3D space. For example, most 3D drawing 
systems work by constructing complex surfaces and objects out of thousands of tiny triangles. Each triangle is 
defined by its three corner points, and each of these corner points is a vertex. 
Obviously, most of the 3D objects you want won’t look like simple, flat triangles. Instead, you’ll need 
to combine triangles—sometimes just a few, but often hundreds or thousands that line up with one 
another at varying angles. For example, Figure 13-2 shows how a sphere can be constructed out of 
triangles. As you add more triangles, the surface becomes smoother. (In the rightmost figure, the sphere 
is actually built out of rectangles, but each of these rectangles is constructed from two triangles, which 
aren’t shown here.) 
Figure 13-2. Building 3D objects with triangles 
 NoteD objects. There are no spheres, 
cubes, or meshes in the library, although third-party toolkits can (and will) build on Silverlight’s 3D support to 
provide all these ingredients and more. 
So, the simplest possible shape you can render in 3D is a single triangle. To draw this triangle, you 
need to define a point at each corner, or vertex. A vertex buffer is the object that holds the combination of 
vertices for all the triangles in your shape. 
For example, imagine you want to draw the triangle shown in Figure 13-3. 
www.it-ebooks.info
Add page pdf reader - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add document to pdf pages; adding pages to a pdf document
Add page pdf reader - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add a page to pdf file; adding page numbers to a pdf document
CHAPTER 13  SILVERLIGHT 3D 
475 
Figure 13-3. A single triangle in 3D world space 
Before writing any code, you should import the following namespaces: 
using Microsoft.Xna.Framework.Graphics; 
using Microsoft.Xna.Framework; 
using System.Windows.Graphics; 
To draw your triangle, you’ll first need to define the three vertices of that triangle in a VertexBuffer. 
To optimize drawing performance, vertex buffers, object models, and so on, are always defined outside 
of the DrawingSurface.Draw event handler that actually draws them. So, it makes to define your 
VertexBuffer as a class-level variable inside your user control. At the same time, you’ll also want to create 
an instance of the BasicEffect class, which will manage other aspects of the drawing process, as you’ll 
learn later: 
// Stores the corners of all your triangles. 
private VertexBuffer vertexBuffer; 
// Stores various drawing details. 
private BasicEffect effect; 
Now, when the page loads you can get to work. The best design is to put your code in a dedicated 
method, like the PrepareDrawing() method shown here: 
private void PrepareDrawing() 
... 
You can then call this method from the constructor of your user control: 
public SingleTriangleExample() 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
add and remove pages from a pdf; add page number to pdf print
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
VB.NET Page: Insert PDF pages; VB.NET Page: Delete PDF Add Image to PDF; VB.NET Protect: Add Password to VB.NET Annotate: PDF Markup & Drawing. XDoc.Word for C#;
add page to existing pdf file; add and delete pages in pdf
CHAPTER 13  SILVERLIGHT 3D 
476 
InitializeComponent(); 
PrepareDrawing(); 
 Note  Don’t make the mistake of executing your initialization logic in an event handler for the Loaded event. 
d event is complete. Because the 
Draw event fires on a different thread (known as the render thread), your drawing code may start before the vertex 
buffer is ready, which will cause an exception. 
The rest of this section examines the code that you’ll put in the PrepareDrawing() method. 
First, you need to create the vertices for your shape. Each vertex is represented by an instance of the 
Vector3 class. Here’s the code that creates the three vertices needed for the triangle in Figure 13-3: 
// Define the triangle's vertices. 
Vector3 topCenter = new Vector3(0, 1, 0); 
Vector3 bottomLeft = new Vector3(-1, 0, 0); 
Vector3 bottomRight = new Vector3(1, 0, 0); 
Less obviously, each vertex also requires a color. When the pixel shader paints the triangle, it colors 
each pixel separately, by interpolating the colors of the three surrounding vertices. If the vertices use the 
same color, the entire triangle gets a solid fill. But if the vertices uses different colors (as in this example), 
you get a blended, gradient effect. 
To create colors, you use the Color class: 
// When creating a color, you supply the red, greed, blue, and 
// (optionally) alpha values. 
// This is white: 
Color color1 = new Color(255, 255, 255); 
// and red: 
Color color2 = new Color(255, 0, 0); 
// and green: 
Color color3 = new Color(0, 255, 0); 
To avoid a namespace conflict, make sure you don’t import the System.Windows.Media namespace, 
which has its own, conflicting version of the Color structure. 
Now, you’re ready to combine the position and color data to create an array of VertexPositionColor 
objects, which is the key ingredient in the vertex buffer you’re about to build: 
// Combine the color and vertex information. 
VertexPositionColor[] vertices = new VertexPositionColor[3]; 
vertices[0] = new VertexPositionColor(bottomLeft, color1); 
vertices[1] = new VertexPositionColor(topCenter, color3); 
vertices[2] = new VertexPositionColor(bottomRight, color2); 
The next step is to create a VertexBuffer object. To do this, you first need to get a reference to 
current GraphicsDevice, which is supplied by GraphicsDeviceManager: 
www.it-ebooks.info
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET PDF - Add Image to PDF Page in VB.NET. Have a try with this sample VB.NET code to add an image to the first page of PDF file. ' Open a document.
add page pdf reader; adding page numbers to a pdf in preview
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Open password protected PDF. Add password to PDF.
add page numbers to a pdf in preview; add page numbers to pdf using preview
CHAPTER 13  SILVERLIGHT 3D 
477 
GraphicsDevice device = GraphicsDeviceManager.Current.GraphicsDevice; 
Then you can create and fill a vertex buffer: 
vertexBuffer = new VertexBuffer(device, typeof(VertexPositionColor), 
vertices.Length, BufferUsage.WriteOnly); 
vertexBuffer.SetData(0, vertices, 0, vertices.Length, 0); 
If this code seems needlessly complex, that’s because the structure of the vertex buffer can vary. In 
this example, the vertex buffer is filled with VertexPositionColor objects (as specified by the second 
argument that’s passed to the VertexBuffer constructor). However, you could also have a vertex buffer 
that doesn’t contain color information or uses texture data. In fact, the vertex buffer acts almost like a 
low level array of bytes, and so you need to explicitly copy a range of data into it using the 
VertexBuffer.SetData() method. 
You’ve now completed all the code you need to fill the vertex buffer with a single triangle of 
information. However, before you can write the drawing logic, you need to create the camera that looks 
out onto your 3D scene. 
Positioning the Camera 
Before a 3D scene can be rendered, you need to place a camera at the correct position and orient it in the 
correct direction. 
Positioning the camera is easy enough, but it requires you to specify three details. The first detail is 
the point in 3D space where the camera will be placed. The second detail is the point that the camera is 
looking at. Taken together, these two details determine how far away the camera is from your content 
(and thus, how big the scene will appear in the DrawingSurface control) and whether the camera can see 
your content at all (if it’s pointed the wrong way, it won’t). Figure 13-4 shows how these details work 
together. 
Figure 13-4. Positioning the camera 
www.it-ebooks.info
C# PDF Password Library: add, remove, edit PDF file password in C#
your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via Add necessary references
adding pages to a pdf document in preview; add page number to pdf online
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
DLLs for Deleting Page from PDF Document in VB.NET Class. In order to run the sample code, the following steps would be necessary. Add necessary references:
adding page to pdf in preview; add blank page to pdf preview
CHAPTER 13  SILVERLIGHT 3D 
478 
However, these details aren’t quite enough. You also need to tell the camera which way is “up,” so it 
can orient itself. After all, even with a given position and look direction, there’s nothing to stop the 
camera from rotating itself around to see the scene sideways or upside-down. In Figure 13-4, the up 
direction points directly, geometrically up, toward the point (0,1,0). This is a natural setup, but the titled 
camera shown in Figure 13-5 is equally possible. 
Figure 13-5. Positioning the camera 
To position a camera, you must create a matrix that sets all three of these details. Actually 
understanding the matrix math that makes sense of 3D scenes is complex and far beyond the scope of 
this chapter. However, Silverlight includes just enough functionality for you to create the matrices you 
need and work with them, without chewing through the tough matrix math. 
For example, when placing a camera you use the handy Matrix.CreateLookAt() method. It takes the 
camera position, the camera look-at direction, and the up direction. Each of these ingredients is 
represented by a separate Vector3 object. Here’s how you would use the CreateLookAt() method to place 
the camera on the z-axis line, looking at the triangle head-on: 
Matrix view = Matrix.CreateLookAt(new Vector3(0, 0, 1), Vector3.Zero, Vector3.Up); 
By comparison, here’s how you’d move the camera to the point shown in Figure 13-4: 
Matrix view = Matrix.CreateLookAt(new Vector3(-2, 2, 3), Vector3.Zero, Vector3.Up); 
And here’s how to place the tilted camera in Figure 13-5: 
Matrix view = Matrix.CreateLookAt(new Vector3(-2, 2, 3), Vector3.Zero, 
new Vector3(-1, 2, 0)); 
Now the camera is tilted around the z-axis. As a result, your 3D content will appear to be tilted a bit 
in the other direction. It’s just as if you’d cocked your head to one side while surveying the scene. 
www.it-ebooks.info
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
C#.NET Project DLLs for Deleting PDF Document Page. In order to run the sample code, the following steps would be necessary. Add necessary references:
add page number to pdf hyperlink; add pdf pages to word document
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
C#.NET Tutorial for How to Add a Sticky Note Annotation to PDF Page with Visual enable users to annotate PDF without adobe PDF reader control installed.
add page numbers to pdf; add or remove pages from pdf
CHAPTER 13  SILVERLIGHT 3D 
479 
These camera details are called the view (or, sometimes, the view space). This view determines the 
position, size, and geometry that the 3D scene will have when it’s rendered. However, in Silverlight 3D 
there’s another key camera detail to think about, called the projection. While the view sets where the 
camera is, the projection sets the portion of the view that the camera can see (and, thus, the portion that 
the video card will draw). This visible portion of the scene is called the viewing frustrum, as shown in 
Figure 13-6. 
Figure 13-6. The view projection 
The view projection trims out parts of the scene that are too far away (which may be obscured by 
other objects anyway) and parts that are too close. Because the video card doesn’t need to render parts 
of the scene that won’t be shown, this technique ensures optimum performance. 
Once again, the Matrix class simplifies life with a dedicated method. The 
CreatePerspectiveFieldOfView() method takes four floating-point numbers and uses them to calculate a 
projection, which it returns as a matrix. Table 13-1 explains these four parameters. 
Table 13-1. Parameters for the CreatePerspectiveFieldOfView() Method 
Parameter 
Description 
fieldOfView 
The angle that the camera can see (from side to side), in radians. This is usually 
45 degrees, or π/4. The MathHelper provides this value through the static field 
MathHelpfer.PiOver4. 
aspectRatio 
The aspect ratio of the camera, which determines how the horizontal and 
vertical dimensions are sized relative to one another. Usually, you’ll set this to 
match the width of the DrawingSurface control (if it’s fixed) or the width of the 
container or page (if the DrawingSurface is allowed to expand to fit the available 
space). 
nearPlaneDistance 
If an object is closer to the camera than this distance, it cannot be seen and will 
not be rendered. 
farPlaneDistance 
If an object is farther from the camera than this distance, it cannot be seen and 
will not be rendered. 
www.it-ebooks.info
CHAPTER 13  SILVERLIGHT 3D 
480 
The following code creates the projection for the single-triangle example. It renders everything 
that’s between 1 and 10 units from the camera. The aspect ratio of 1.33 is calculated by dividing the 
DrawingSurface width (400) by the height (300). 
Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 
1.33f, 1, 10); 
Somewhat confusingly, the CreatePerspectiveFieldOf() method actually returns a perspective 
projection, which isn’t the final view projection you need for your 3D scene. To calculate the view 
projection, you need one extra step. Once the projection matrix is returned from the 
Matrix.CreatePerspectiveFieldOfView() method, you must multiply it by the view matrix, like so: 
Matrix viewProjection = view * projection; 
Now that you have the view and projection matrices, you’re ready to create and configure a 
BasicEffect object, which is the final initialization step that takes place in the PrepareDrawing() method. 
PERSPECTIVE AND ORTHOGRAPHIC CAMERAS 
The camera view and projection determine how a 3D scene is projected onto the 2D surface of the 
DrawingSurface control.  
When you call CreatePerspectiveFieldOfView(), you create a matrix for a perspective camera. A perspective 
camera renders the scene so that objects that are farther away appear smaller. This is the behavior that 
most people expect in a 3D scene. 
You can also create an orthographic camera by calling either the CreateOrthographic() or 
CreateOrthographicOffCenter() method of the Matrix class. An orthographic camera flattens 3D objects so 
ks a bit odd, but it’s 
useful for some types of visualization tools. For example, technical drawing applications often rely on this 
type of view. Finally, for even more specialized camera effects, you can create your own projection matrix 
by hand. Figure 13-7 shows the difference between a perspective camera and an orthographic camera. 
Figure 13-7. Perspective in different types of cameras 
www.it-ebooks.info
CHAPTER 13  SILVERLIGHT 3D 
481 
Configuring the BasicEffect 
To understand the BasicEffect object, you need to know a bit more about the Silverlight 3D model. 
Technically, Silverlight 3D does all its rendering work using shaders—tiny bits of code that run directly 
on the video card’s GPU. There are two types of shader: 
A vertex shader: This is a piece of code that examines each vertex in your vertex 
buffer and converts its position from a coordinate in virtual 3D space to a 
physical display position in the 2D drawing surface. 
A pixel shader: This is a piece of code that examines each pixel that’s about to 
be drawn (as part of a line or triangle) and assigns the appropriate color.  
You can write your own shaders and compile them with the fxc.exe utility from the DirectX SDK 
(available at http://msdn.microsoft.com/en-us/directx/aa937781). The syntax of a shader is HLSL (High 
Level Shader Language), which is similar to C#. However, writing low-level pixel-processing algorithms 
in any language is tedious and complex. 
Fortunately, Silverlight inherits Microsoft’s XNA higher-level effects model. The idea is that your 
application uses an effect object, which has its own built-in vertex and pixel shaders. Many effect objects 
introduce more sophisticated rendering, with support for textures, lighting, materials, fog, and skinning. 
All effect classes derive from the base Effect class in the Microsoft.Xna.Framework.Graphics 
namespace. Silverlight includes one nearly indispensable effect class called BasicEffect. Despite its 
name, BasicEffect is practical and surprisingly full featured—with the built-in ability to perform basic 
shading, texture mapping, and complex lighting. In this chapter, you’ll spend a great deal of time with 
BasicEffect, and learn how to use all these valuable features. 
To prepare the BasicEffect object in the current example, you need to set the view and the 
projection, using the matrices you created in the previous section: 
effect = new BasicEffect(device);  
effect.View = view; 
effect.Projection = viewProjection; 
You also need to set the world matrix, which allows you to move your object to a new position: 
effect.World = Matrix.Identity; 
The world matrix is handy when positioning multiple objects in a scene, each with a different 
BasicEffect object. The world matrix allows you to move each object from the initial place where you’ve 
defined it—typically, around the origin at (0,0,0)—to another position, relative to the rest of the scene. 
Conceptually, this step moves your content from its original object space to the world space of the 
complete scene. Technically, this move is performed by multiplying the original position by the world 
matrix you supply. 
In this example there is only one object, and there’s no need to move it to anywhere else in world 
space. So, the code uses the identity matrix. (The identity matrix is a matrix that, when used in a matrix 
multiplication operation, changes nothing. Thus, the object remains in its current location.) Later in this 
chapter, you’ll see how you can use the world matrix to move and rotate a 3D object. 
The final property you need to set in the BasicEffect object is VertexColorEnabled. By settings it to 
true, you switch on the built-in pixel shader that will color your triangle: 
effect.VertexColorEnabled = true
If you don’t take this step and you don’t supply any other pixel shader, the BasicEffect won’t draw 
your object. 
www.it-ebooks.info
CHAPTER 13  SILVERLIGHT 3D 
482 
This completes the initialization code in the PrepareDrawing() method. You’re now ready to move 
ahead to the actual drawing logic that uses all the ingredients you’ve seen to render your 3D content. 
Drawing the Scene 
As you learned earlier, the DrawingSurface control fires a Draw event when it’s time for your code to 
render the scene. The first order of business is to get a reference to the current GraphicsDevice object 
and clear any preexisting content with the Clear() method, like this: 
private void drawingSurface_Draw(object sender, DrawEventArgs e) 
GraphicsDevice device = GraphicsDeviceManager.Current.GraphicsDevice; 
device.Clear(new Color(0, 0, 0)); 
... 
 Note  Every drawing operation should begin with a call to the Clear() method. If you forget to clear your surface 
the first time, the DrawingSurface will use a dark purplish background to indicate your oversight. 
The next step is to take the vertex buffer you created earlier, which contains the content you want to 
draw, and apply it to the GraphicsDevice. You do this by calling the SetVertexBuffer() method: 
... 
device.SetVertexBuffer(vertexBuffer); 
... 
And the final step is to perform the actual drawing. When using an effect object, you may need to 
repeat your drawing multiple times, depending on the sort of effect that it’s creating. Fortunately, you 
don’t need to worry about the number of passes. You simply need to step through all the EffectPass 
objects in the Effect.CurrentTechniques.Passes collection. For each one you find, call EffectPass.Apply(), 
and then draw your content with the GraphicsDevice.DrawPrimitives() method: 
...     
// Perform all the passes. 
foreach (EffectPass pass in effect.CurrentTechnique.Passes) 
pass.Apply(); 
device.DrawPrimitives(PrimitiveType.TriangleList,  
0, vertexBuffer.VertexCount / 3); 
Figure 13-8 shows the long-awaited and somewhat underwhelming result. Here, the camera is 
looking straight at a single, from a modest distance. The triangle uses three different colors (one at each 
vertex) to create a gradient fill, with the help of the BasicEffect object’s built-in pixel shader. 
www.it-ebooks.info
CHAPTER 13  SILVERLIGHT 3D 
483 
Figure 13-8. One of the simplest possible 3D scenes 
 Note  When you first show a page with a DrawingSurface control, the Draw event fires immediately. However, it 
won’t fire again, unless you call the DrawEventArgs.InvalidateSurface() method at the end of your drawing logic or 
call the DrawingSurface.Invalidate() method elsewhere in your code. You’ll learn more about this technique later in 
this chapter, when you begin animating your 3D objects. 
The DrawPrimitives() method is the heart of the drawing logic in this example. Here, the 
DrawPrimitives() method is used to draw a series of one or more triangles (a TriangleList), starting at the 
beginning of the vertex buffer (at position 0) and looking for just one triangle (the result of 
vertexBuffer.VertexCount / 3). 
This is fairly typical code. By adding more vertices to the end of the vertex buffer (in sets of three), 
you can add more triangles to the triangle list. Then, the DrawPrimitives() method will draw all the 
triangles in one step. 
However, it’s worth pointing out that there are a few other sorts of primitives you can draw, as listed 
in Table 13-2. Of course, if you draw a different type of primitive, you need to adjust your vertex buffer 
accordingly so it has the appropriate number of vertices. 
Table 13-2. 3D Primitives 
Primitive Type 
Description 
TriangleList 
The vertex buffer represents a series of distinct triangles. Each triangle is described 
by three vertices. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested