text:
View Cart
Help | Contact
Successfully serving the music industry since 1967, Pender's Music Company is your complete source for sheet music and more. Our wide range of in-stock products includes music for band, choir, elementary classroom, solo voice, brass, woodwind and percussion instruments, piano and organ, strings, orchestra, guitar, and folk instruments in all genres. Styles of music include Christian, country, classical, pop, musical theater, jazz and folk. We also carry music accessories like strings, metronomes, stands, tuners, mutes and much more, helping all musicians – from educators to students, beginners to professionals – fulfill their musical needs.
Subscribe to E-News
Visit Our Staff Notes Blog
Our mobile website


text:
The Baby Bling Metamorphosis Jogging Stroller System is no ordinary stroller! Baby Bling gives you the ability to change the look and style of the stroller with five different designs (each design sold separately). This ability can extend the life of your stroller allowing you to use for either a girl or a boy. Or, just change the design for a new fresh look without buying and entire new stroller.
The Baby Bling Metamorphosis Stroller Comes Complete With:
Health & Fitness Tips |
Returns |
Contact US |
Store Policies
Non Mobile Site
888-337-4684 | email@example.com
© 2000-2019 healthchecksystems.com All rights reserved

subset: commoncrawl


text:
pitbullmamaliz wrote:Britney, when you see him give him lovin's from me, too!!!
Mickle wrote:I had to wait so I could get the money for the surgery..It sucks I said February and they said the 20th. If I had the money I think they would have preferred sooner.
Users browsing this forum: No registered users


text:
Last edited: 1 May 2013
The Alliance 3000 Parabolic Cooker has been designed by the NGO Alliance 3000 to be fabricated in the west African country of Burkina Faso. It uses fairly simple panel shapes to create the reflector, and sits on base that is easily rotated with a long handle.
External links
Alliance 3000
Le Deffend 04410 Puimoisson
Tel: 04 92 74 54 63


text:
Here's something to go with your morning Cheerios…
During a trip to Zoo Atlanta, a group of Georgia Tech scientists measured the duration of urination from a number of animals whose bladders ranged in size from less than 4 ounces to more than 25 gallons.
Despite the large difference in size, the duration of urination for the animals of different species remained nearly constant, at 21 seconds.
Why is this? In their research article, the scientists explain:
This feat is made possible by the increasing urethra length of large animals which amplifies gravitational force and flow rate. We also demonstrate the challenges faced by the urinary system for rodents and other small mammals for which urine flow is limited to single drops. Our findings reveal the urethra evolved as a flow-enhancing device, enabling the urinary system to be scaled up without compromising its function. This study may help in the diagnosis of urinary problems in animals and in inspiring the design of scalable hydrodynamic systems based on those in nature.
If nothing else this gives me something else to look for the next time I visit the Houston Zoo. And, dare I ask whether readers conform to the law of urination?
Found via Seriously Science?


text:
National Guard
Soldiers of the Massachusetts Army National Guard are entitled to a multitude of of outstanding federal and state benefits. The state of Massachusetts provides National Guard soldiers with an exclusive waiver which allows them to attend any of the 29 state colleges and universities 100% tuition and academic fee FREE!
''GI Bill® is a registered trademark of the U.S. Department of Veterans Affairs (VA). More information about education benefits offered by VA is available at the official U.S. government website athttp://www.benefits.va.gov/gibill."
The Massachusetts National Guard is a locally-based organization which takes great pride in bettering our people and communities. As Bay Staters ourselves, ensuring the best possible futures for our families, friends, and neighbors is always our number one goal. Our representatives live in the communities in which they serve and are at all times available to assist educators in improving the lives of their students. Our programs include STEM Robotics, Physical Fitness, Anti-Bullying Training, and much more. These Enhanced School Programs are offered to schools and community organizations at no cost. Below is a link to our full catalog of educational programs.


text:
|Programming Guide > Chapter 5
Chapter 5
Parameter Name
Default Value
(0.0, 0.0, 0.0, 1.0)
ambient RGBA intensity of light
(1.0, 1.0, 1.0, 1.0)
diffuse RGBA intensity of light
(1.0, 1.0, 1.0, 1.0)
specular RGBA intensity of light
(0.0, 0.0, 1.0, 0.0)
(x, y, z, w) position of light
(0.0, 0.0, -1.0)
(x, y, z) direction of spotlight
spotlight exponent
spotlight cutoff angle
constant attenuation factor
linear attenuation factor
quadratic attenuation factor
Note: The default values listed for GL_DIFFUSE and GL_SPECULAR in Table 5-1 apply only to GL_LIGHT0. For other lights, the default value is (0.0, 0.0, 0.0, 1.0) for both GL_DIFFUSE and GL_SPECULAR.
Example 5-2 shows how to use glLight*():
Example 5-2 : Defining Colors and Position for a Light Source
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 }; GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position);
As you can see, arrays are defined for the parameter values, and glLightfv() is called repeatedly to set the various parameters. In this example, the first three calls to glLightfv() are superfluous, since they're being used to specify the default values for the GL_AMBIENT, GL_DIFFUSE, and GL_SPECULAR parameters.
Note: Remember to turn on each light with glEnable(). (See "Enabling Lighting" for more information about how to do this.)
All the parameters for glLight*() and their possible values are explained in the following sections. These parameters interact with those that define the overall lighting model for a particular scene and an object's material properties. (See "Selecting a Lighting Model" and "Defining Material Properties" for more information about these two topics. "The Mathematics of Lighting" explains how all these parameters interact mathematically.)
OpenGL allows you to associate three different color-related parameters - GL_AMBIENT, GL_DIFFUSE, and GL_SPECULAR - with any particular light. The GL_AMBIENT parameter refers to the RGBA intensity of the ambient light that a particular light source adds to the scene. As you can see in Table 5-1, by default there is no ambient light since GL_AMBIENT is (0.0, 0.0, 0.0, 1.0). This value was used in Example 5-1. If this program had specified blue ambient light as
GLfloat light_ambient[] = { 0.0, 0.0, 1.0, 1.0}; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
the result would have been as shown in the left side of "Plate 13" in Appendix I.
The GL_DIFFUSE parameter probably most closely correlates with what you naturally think of as "the color of a light." It defines the RGBA color of the diffuse light that a particular light source adds to a scene. By default, GL_DIFFUSE is (1.0, 1.0, 1.0, 1.0) for GL_LIGHT0, which produces a bright, white light as shown in the left side of "Plate 13" in Appendix I. The default value for any other light (GL_LIGHT1, ... , GL_LIGHT7) is (0.0, 0.0, 0.0, 0.0).
The GL_SPECULAR parameter affects the color of the specular highlight on an object. Typically, a real-world object such as a glass bottle has a specular highlight that's the color of the light shining on it (which is often white). Therefore, if you want to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE parameter. By default, GL_SPECULAR is (1.0, 1.0, 1.0, 1.0) for GL_LIGHT0 and (0.0, 0.0, 0.0, 0.0) for any other light.
Note: The alpha component of these colors is not used until blending is enabled. (See Chapter 6.) Until then, the alpha value can be safely ignored.
As previously mentioned, you can choose whether to have a light source that's treated as though it's located infinitely far away from the scene or one that's nearer to the scene. The first type is referred to as a directional light source; the effect of an infinite location is that the rays of light can be considered parallel by the time they reach an object. An example of a real-world directional light source is the sun. The second type is called a positional light source, since its exact position within the scene determines the effect it has on a scene and, specifically, the direction from which the light rays come. A desk lamp is an example of a positional light source. You can see the difference between directional and positional lights in "Plate 12" in Appendix I. The light used in Example 5-1 is a directional one:
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_POSITION, light_position);
As shown, you supply a vector of four values (x, y, z, w) for the GL_POSITION parameter. If the last value, w, is zero, the corresponding light source is a directional one, and the (x, y, z) values describe its direction. This direction is transformed by the modelview matrix. By default, GL_POSITION is (0, 0, 1, 0), which defines a directional light that points along the negative z-axis. (Note that nothing prevents you from creating a directional light with the direction of (0, 0, 0), but such a light won't help you much.)
If the w value is nonzero, the light is positional, and the (x, y, z) values specify the location of the light in homogeneous object coordinates. (See Appendix F.) This location is transformed by the modelview matrix and stored in eye coordinates. (See "Controlling a Light's Position and Direction" for more information about how to control the transformation of the light's location.) Also, by default, a positional light radiates in all directions, but you can restrict it to producing a cone of illumination by defining the light as a spotlight. (See "Spotlights" for an explanation of how to define a light as a spotlight.)
Note: Remember that the colors across the face of a smooth-shaded polygon are determined by the colors calculated for the vertices. Because of this, you probably want to avoid using large polygons with local lights. If you locate the light near the middle of the polygon, the vertices might be too far away to receive much light, and the whole polygon will look darker than you intended. To avoid this problem, break up the large polygon into smaller ones.
For real-world lights, the intensity of light decreases as distance from the light increases. Since a directional light is infinitely far away, it doesn't make sense to attenuate its intensity over distance, so attenuation is disabled for a directional light. However, you might want to attenuate the light from a positional light. OpenGL attenuates a light source by multiplying the contribution of that source by an attenuation factor:
d= distance between the light's position and the vertex
kc = GL_CONSTANT_ATTENUATION
kl = GL_LINEAR_ATTENUATION
kq = GL_QUADRATIC_ATTENUATION
By default, kc is 1.0 and both kl and kq are zero, but you can give these parameters different values:
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 2.0); glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0); glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.5);
Note that the ambient, diffuse, and specular contributions are all attenuated. Only the emission and global ambient values aren't attenuated. Also note that since attenuation requires an additional division (and possibly more math) for each calculated color, using attenuated lights may slow down application performance.
As previously mentioned, you can have a positional light source act as a spotlight - that is, by restricting the shape of the light it emits to a cone. To create a spotlight, you need to determine the spread of the cone of light you desire. (Remember that since spotlights are positional lights, you also have to locate them where you want them. Again, note that nothing prevents you from creating a directional spotlight, but it won't give you the result you want.) To specify the angle between the axis of the cone and a ray along the edge of the cone, use the GL_SPOT_CUTOFF parameter. The angle of the cone at the apex is then twice this value, as shown in Figure 5-2.
Figure 5-2 : GL_SPOT_CUTOFF Parameter
Note that no light is emitted beyond the edges of the cone. By default, the spotlight feature is disabled because the GL_SPOT_CUTOFF parameter is 180.0. This value means that light is emitted in all directions (the angle at the cone's apex is 360 degrees, so it isn't a cone at all). The value for GL_SPOT_CUTOFF is restricted to being within the range [0.0,90.0] (unless it has the special value 180.0). The following line sets the cutoff parameter to 45 degrees:
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0);
You also need to specify a spotlight's direction, which determines the axis of the cone of light:
GLfloat spot_direction[] = { -1.0, -1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
The direction is specified in object coordinates. By default, the direction is (0.0, 0.0, -1.0), so if you don't explicitly set the value of GL_SPOT_DIRECTION, the light points down the negative z-axis. Also, keep in mind that a spotlight's direction is transformed by the modelview matrix just as though it were a normal vector, and the result is stored in eye coordinates. (See "Controlling a Light's Position and Direction" for more information about such transformations.)
In addition to the spotlight's cutoff angle and direction, there are two ways you can control the intensity distribution of the light within the cone. First, you can set the attenuation factor described earlier, which is multiplied by the light's intensity. You can also set the GL_SPOT_EXPONENT parameter, which by default is zero, to control how concentrated the light is. The light's intensity is highest in the center of the cone. It's attenuated toward the edges of the cone by the cosine of the angle between the direction of the light and the direction from the light to the vertex being lit, raised to the power of the spot exponent. Thus, higher spot exponents result in a more focused light source. (See "The Mathematics of Lighting" for more details on the equations used to calculate light intensity.)
As mentioned, you can have at least eight lights in your scene (possibly more, depending on your OpenGL implementation). Since OpenGL needs to perform calculations to determine how much light each vertex receives from each light source, increasing the number of lights adversely affects performance. The constants used to refer to the eight lights are GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, GL_LIGHT3, and so on. In the preceding discussions, parameters related to GL_LIGHT0 were set. If you want an additional light, you need to specify its parameters; also, remember that the default values are different for these other lights than they are for GL_LIGHT0, as explained in Table 5-1. Example 5-3 defines a white attenuated spotlight.
Example 5-3 : Second Light Source
GLfloat light1_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; GLfloat light1_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_position[] = { -2.0, 2.0, 1.0, 1.0 }; GLfloat spot_direction[] = { -1.0, -1.0, 0.0 }; glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular); glLightfv(GL_LIGHT1, GL_POSITION, light1_position); glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5); glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5); glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2); glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0); glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction); glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0); glEnable(GL_LIGHT1);
If these lines were added to Example 5-1, the sphere would be lit with two lights, one directional and one spotlight.
Try This
Modify Example 5-1 in the following manner:
OpenGL treats the position and direction of a light source just as it treats the position of a geometric primitive. In other words, a light source is subject to the same matrix transformations as a primitive. More specifically, when glLight*() is called to specify the position or the direction of a light source, the position or direction is transformed by the current modelview matrix and stored in eye coordinates. This means you can manipulate a light source's position or direction by changing the contents of the modelview matrix. (The projection matrix has no effect on a light's position or direction.) This section explains how to achieve the following three different effects by changing the point in the program at which the light position is set, relative to modeling or viewing transformations:
In the simplest example, as in Example 5-1, the light position remains fixed. To achieve this effect, you need to set the light position after whatever viewing and/or modeling transformation you use. In Example 5-4, the relevant code from the init() and reshape() routines might look like this.
Example 5-4 : Stationary Light Source
glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity(); if (w <= h) glOrtho (-1.5, 1.5, -1.5*h/w, 1.5*h/w, -10.0, 10.0); else glOrtho (-1.5*w/h, 1.5*w/h, -1.5, 1.5, -10.0, 10.0); glMatrixMode (GL_MODELVIEW); glLoadIdentity(); /* later in init() */ GLfloat light_position[] = { 1.0, 1.0, 1.0, 1.0 }; glLightfv(GL_LIGHT0, GL_POSITION, position);
As you can see, the viewport and projection matrices are established first. Then, the identity matrix is loaded as the modelview matrix, after which the light position is set. Since the identity matrix is used, the originally specified light position (1.0, 1.0, 1.0) isn't changed by being multiplied by the modelview matrix. Then, since neither the light position nor the modelview matrix is modified after this point, the direction of the light remains (1.0, 1.0, 1.0).
Now suppose you want to rotate or translate the light position so that the light moves relative to a stationary object. One way to do this is to set the light position after the modeling transformation, which is itself changed specifically to modify the light position. You can begin with the same series of calls in init() early in the program. Then you need to perform the desired modeling transformation (on the modelview stack) and reset the light position, probably in display(). Example 5-5 shows what display() might be.
Example 5-5 : Independently Moving Light Source
static GLdouble spin; void display(void) { GLfloat light_position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glPushMatrix(); glRotated(spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glPopMatrix(); glutSolidTorus (0.275, 0.85, 8, 15); glPopMatrix(); glFlush(); }
spinis a global variable and is probably controlled by an input device. display() causes the scene to be redrawn with the light rotated spin degrees around a stationary torus. Note the two pairs of glPushMatrix() and glPopMatrix() calls, which are used to isolate the viewing and modeling transformations, all of which occur on the modelview stack. Since in Example 5-5 the viewpoint remains constant, the current matrix is pushed down the stack and then the desired viewing transformation is loaded with gluLookAt(). The matrix stack is pushed again before the modeling transformation glRotated() is specified. Then the light position is set in the new, rotated coordinate system so that the light itself appears to be rotated from its previous position. (Remember that the light position is stored in eye coordinates, which are obtained after transformation by the modelview matrix.) After the rotated matrix is popped off the stack, the torus is drawn.
Example 5-6 is a program that rotates a light source around an object. When the left mouse button is pressed, the light position rotates an additional 30 degrees. A small, unlit, wireframe cube is drawn to represent the position of the light in the scene.
Example 5-6 : Moving a Light with Modeling Transformations: movelight.c
#include <GL/gl.h> #include <GL/glu.h> #include "glut.h" static int spin = 0; void init(void) { glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); } /* Here is where the light position is reset after the modeling * transformation (glRotated) is called. This places the * light at a new position in world coordinates. The cube * represents the position of the light. */ void display(void) { GLfloat position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); glTranslatef (0.0, 0.0, -5.0); glPushMatrix (); glRotated ((GLdouble) spin, 1.0, 0.0, 0.0); glLightfv (GL_LIGHT0, GL_POSITION, position); glTranslated (0.0, 0.0, 1.5); glDisable (GL_LIGHTING); glColor3f (0.0, 1.0, 1.0); glutWireCube (0.1); glEnable (GL_LIGHTING); glPopMatrix (); glutSolidTorus (0.275, 0.85, 8, 15); glPopMatrix (); glFlush (); } void reshape (int w, int h) { glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity(); gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } void mouse(int button, int state, int x, int y) { switch (button) { case GLUT_LEFT_BUTTON: if (state == GLUT_DOWN) { spin = (spin + 30) % 360; glutPostRedisplay(); } break; default: break; } } int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize (500, 500); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMainLoop(); return 0; }
To create a light that moves along with the viewpoint, you need to set the light position before the viewing transformation. Then the viewing transformation affects both the light and the viewpoint in the same way. Remember that the light position is stored in eye coordinates, and this is one of the few times when eye coordinates are critical. In Example 5-7, the light position is defined in init(), which stores the light position at (0, 0, 0) in eye coordinates. In other words, the light is shining from the lens of the camera.
Example 5-7 : Light Source That Moves with the Viewpoint
GLfloat light_position() = { 0.0, 0.0, 0.0, 1.0 }; glViewport(0, 0, (GLint) w, (GLint) h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 100.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glLightfv(GL_LIGHT0, GL_POSITION, light_position);
If the viewpoint is now moved, the light will move along with it, maintaining (0, 0, 0) distance, relative to the eye. In the continuation of Example 5-7, which follows next, the global variables (ex, ey, ez) and (upx, upy, upz) control the position of the viewpoint and up vector. The display() routine that's called from the event loop to redraw the scene might be this:
static GLdouble ex, ey, ez, upx, upy, upz; void display(void) { glClear(GL_COLOR_BUFFER_MASK | GL_DEPTH_BUFFER_MASK); glPushMatrix(); gluLookAt (ex, ey, ez, 0.0, 0.0, 0.0, upx, upy, upz); glutSolidTorus (0.275, 0.85, 8, 15); glPopMatrix(); glFlush(); }
When the lit torus is redrawn, both the light position and the viewpoint are moved to the same location. As the values passed to gluLookAt() change and the eye moves, the object will never appear dark, because it is always being illuminated from the eye position. Even though you haven't respecified the light position, the light moves because the eye coordinate system has changed.
This method of moving the light can be very useful for simulating the illumination from a miner's hat. Another example would be carrying a candle or lantern. The light position specified by the call to glLightfv(GL_LIGHTi, GL_POSITION, position) would be the x, y, and z distance from the eye position to the illumination source. Then as the eye position moves, the light will remain the same relative distance away.
Try This
Modify Example 5-6 in the following manner:
The OpenGL notion of a lighting model has three components:
This section explains how to specify a lighting model. It also discusses how to enable lighting - that is, how to tell OpenGL that you want lighting calculations performed.
The command used to specify all properties of the lighting model is glLightModel*(). glLightModel*() has two arguments: the lighting model property and the desired value for that property.
Parameter Name
Default Value
(0.2, 0.2, 0.2, 1.0)
ambient RGBA intensity of the entire scene
0.0 or GL_FALSE
how specular reflection angles are computed
0.0 or GL_FALSE
choose between one-sided or two-sided lighting
As discussed earlier, each light source can contribute ambient light to a scene. In addition, there can be other ambient light that's not from any particular source. To specify the RGBA intensity of such global ambient light, use the GL_LIGHT_MODEL_AMBIENT parameter as follows:
GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
In this example, the values used for lmodel_ambient are the default values for GL_LIGHT_MODEL_AMBIENT. Since these numbers yield a small amount of white ambient light, even if you don't add a specific light source to your scene, you can still see the objects in the scene. "Plate 14" in Appendix I shows the effect of different amounts of global ambient light.
The location of the viewpoint affects the calculations for highlights produced by specular reflectance. More specifically, the intensity of the highlight at a particular vertex depends on the normal at that vertex, the direction from the vertex to the light source, and the direction from the vertex to the viewpoint. Keep in mind that the viewpoint isn't actually being moved by calls to lighting commands (you need to change the projection transformation, as described in "Projection Transformations" in Chapter 3); instead, different assumptions are made for the lighting calculations as if the viewpoint were moved.
With an infinite viewpoint, the direction between it and any vertex in the scene remains constant. A local viewpoint tends to yield more realistic results, but since the direction has to be calculated for each vertex, overall performance is decreased with a local viewpoint. By default, an infinite viewpoint is assumed. Here's how to change to a local viewpoint:
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
This call places the viewpoint at (0, 0, 0) in eye coordinates. To switch back to an infinite viewpoint, pass in GL_FALSE as the argument.
Lighting calculations are performed for all polygons, whether they're front-facing or back-facing. Since you usually set up lighting conditions with the front-facing polygons in mind, however, the back-facing ones typically aren't correctly illuminated. In Example 5-1 where the object is a sphere, only the front faces are ever seen, since they're the ones on the outside of the sphere. So, in this case, it doesn't matter what the back-facing polygons look like. If the sphere is going to be cut away so that its inside surface will be visible, however, you might want to have the inside surface be fully lit according to the lighting conditions you've defined; you might also want to supply a different material description for the back faces. When you turn on two-sided lighting with
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
OpenGL reverses the surface normals for back-facing polygons; typically, this means that the surface normals of visible back- and front-facing polygons face the viewer, rather than pointing away. As a result, all polygons are illuminated correctly. However, these additional operations usually make two-sided lighting perform more slowly than the default one-sided lighting.
To turn two-sided lighting off, pass in GL_FALSE as the argument in the preceding call. (See "Defining Material Properties" for information about how to supply material properties for both faces.) You can also control which faces OpenGL considers to be front-facing with the command glFrontFace(). (See "Reversing and Culling Polygon Faces" in Chapter 2 for more information.)
With OpenGL, you need to explicitly enable (or disable) lighting. If lighting isn't enabled, the current color is simply mapped onto the current vertex, and no calculations concerning normals, light sources, the lighting model, and material properties are performed. Here's how to enable lighting:
To disable lighting, call glDisable() with GL_LIGHTING as the argument.
You also need to explicitly enable each light source that you define, after you've specified the parameters for that source. Example 5-1 uses only one light, GL_LIGHT0:
You've seen how to create light sources with certain characteristics and how to define the desired lighting model. This section describes how to define the material properties of the objects in the scene: the ambient, diffuse, and specular colors, the shininess, and the color of any emitted light. (See "The Mathematics of Lighting" for the equations used in the lighting and material-property calculations.) Most of the material properties are conceptually similar to ones you've already used to create light sources. The mechanism for setting them is similar, except that the command used is called glMaterial*().
Parameter Name
Default Value
(0.2, 0.2, 0.2, 1.0)
ambient color of material
(0.8, 0.8, 0.8, 1.0)
diffuse color of material
ambient and diffuse color of material
(0.0, 0.0, 0.0, 1.0)
specular color of material
specular exponent
(0.0, 0.0, 0.0, 1.0)
emissive color of material
ambient, diffuse, and specular color indices
As discussed in "Selecting a Lighting Model," you can choose to have lighting calculations performed differently for the front- and back-facing polygons of objects. If the back faces might indeed be seen, you can supply different material properties for the front and the back surfaces by using the face parameter of glMaterial*(). See "Plate 14" in Appendix I for an example of an object drawn with different inside and outside material properties.
To give you an idea of the possible effects you can achieve by manipulating material properties, see "Plate 16" in Appendix I. This figure shows the same object drawn with several different sets of material properties. The same light source and lighting model are used for the entire figure. The sections that follow discuss the specific properties used to draw each of these spheres.
Note that most of the material properties set with glMaterial*() are (R, G, B, A) colors. Regardless of what alpha values are supplied for other parameters, the alpha value at any particular vertex is the diffuse-material alpha value (that is, the alpha value given to GL_DIFFUSE with the glMaterial*() command, as described in the next section). (See "Blending" in Chapter 6 for a complete discussion of alpha values.) Also, none of the RGBA material properties apply in color-index mode. (See "Lighting in Color-Index Mode" for more information about what parameters are relevant in color-index mode.)
The GL_DIFFUSE and GL_AMBIENT parameters set with glMaterial*() affect the color of the diffuse and ambient light reflected by an object. Diffuse reflectance plays the most important role in determining what you perceive the color of an object to be. It's affected by the color of the incident diffuse light and the angle of the incident light relative to the normal direction. (It's most intense where the incident light falls perpendicular to the surface.) The position of the viewpoint doesn't affect diffuse reflectance at all.
Ambient reflectance affects the overall color of the object. Because diffuse reflectance is brightest where an object is directly illuminated, ambient reflectance is most noticeable where an object receives no direct illumination. An object's total ambient reflectance is affected by the global ambient light and ambient light from individual light sources. Like diffuse reflectance, ambient reflectance isn't affected by the position of the viewpoint.
For real-world objects, diffuse and ambient reflectance are normally the same color. For this reason, OpenGL provides you with a convenient way of assigning the same value to both simultaneously with glMaterial*():
GLfloat mat_amb_diff[] = { 0.1, 0.5, 0.8, 1.0 }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff);
In this example, the RGBA color (0.1, 0.5, 0.8, 1.0) - a deep blue color - represents the current ambient and diffuse reflectance for both the front- and back-facing polygons.
In "Plate 16" in Appendix I, the first row of spheres has no ambient reflectance (0.0, 0.0, 0.0, 0.0), and the second row has a significant amount of it (0.7, 0.7, 0.7, 1.0).
Specular reflection from an object produces highlights. Unlike ambient and diffuse reflection, the amount of specular reflection seen by a viewer does depend on the location of the viewpoint - it's brightest along the direct angle of reflection. To see this, imagine looking at a metallic ball outdoors in the sunlight. As you move your head, the highlight created by the sunlight moves with you to some extent. However, if you move your head too much, you lose the highlight entirely.
OpenGL allows you to set the effect that the material has on reflected light (with GL_SPECULAR) and control the size and brightness of the highlight (with GL_SHININESS). You can assign a number in the range of [0.0, 128.0] to GL_SHININESS - the higher the value, the smaller and brighter (more focused) the highlight. (See "The Mathematics of Lighting" for the details of how specular highlights are calculated.)
In "Plate 16" in Appendix I, the spheres in the first column have no specular reflection. In the second column, GL_SPECULAR and GL_SHININESS are assigned values as follows:
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat low_shininess[] = { 5.0 }; glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
In the third column, the GL_SHININESS parameter is increased to 100.0.
By specifying an RGBA color for GL_EMISSION, you can make an object appear to be giving off light of that color. Since most real-world objects (except lights) don't emit light, you'll probably use this feature mostly to simulate lamps and other light sources in a scene. In "Plate 16" in Appendix I, the spheres in the fourth column have a reddish, grey value for GL_EMISSION:
GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0}; glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
Notice that the spheres appear to be slightly glowing; however, they're not actually acting as light sources. You would need to create a light source and position it at the same location as the sphere to create that effect.
Example 5-1 uses the same material properties for all vertices of the only object in the scene (the sphere). In other situations, you might want to assign different material properties for different vertices on the same object. More likely, you have more than one object in the scene, and each object has different material properties. For example, the code that produced "Plate 16" in Appendix I has to draw twelve different objects (all spheres), each with different material properties. Example 5-8 shows a portion of the code in display().
Example 5-8 : Different Material Properties: material.c
GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 }; GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 }; GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 }; GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 }; GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat no_shininess[] = { 0.0 }; GLfloat low_shininess[] = { 5.0 }; GLfloat high_shininess[] = { 100.0 }; GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0}; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* draw sphere in first row, first column * diffuse reflection only; no ambient or specular */ glPushMatrix(); glTranslatef (-3.75, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, second column * diffuse and specular reflection; low shininess; no ambient */ glPushMatrix(); glTranslatef (-1.25, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, third column * diffuse and specular reflection; high shininess; no ambient */ glPushMatrix(); glTranslatef (1.25, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, fourth column * diffuse reflection; emission; no ambient or specular refl. */ glPushMatrix(); glTranslatef (3.75, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); glutSolidSphere(1.0, 16, 16); glPopMatrix();
As you can see, glMaterialfv() is called repeatedly to set the desired material property for each sphere. Note that it only needs to be called to change a property that needs to be respecified. The second, third, and fourth spheres use the same ambient and diffuse properties as the first sphere, so these properties do not need to be respecified. Since glMaterial*() has a performance cost associated with its use, Example 5-8 could be rewritten to minimize material-property changes.
Another technique for minimizing performance costs associated with changing material properties is to use glColorMaterial().
Note that glColorMaterial() specifies two independent values: the first specifies which face or faces are updated, and the second specifies which material property or properties of those faces are updated. OpenGL does not maintain separate mode variables for each face.
After calling glColorMaterial(), you need to call glEnable() with GL_COLOR_MATERIAL as the parameter. Then, you can change the current color using glColor*() (or other material properties, using glMaterial*()) as needed as you draw:
glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_DIFFUSE); /* now glColor* changes diffuse reflection */ glColor3f(0.2, 0.5, 0.8); /* draw some objects here */ glColorMaterial(GL_FRONT, GL_SPECULAR); /* glColor* no longer changes diffuse reflection */ /* now glColor* changes specular reflection */ glColor3f(0.9, 0.0, 0.2); /* draw other objects here */ glDisable(GL_COLOR_MATERIAL);
You should use glColorMaterial() whenever you need to change a single material parameter for most vertices in your scene. If you need to change more than one material parameter, as was the case for "Plate 16" in Appendix I, use glMaterial*(). When you don't need the capabilities of glColorMaterial() anymore, be sure to disable it so that you don't get undesired material properties and don't incur the performance cost associated with it. The performance value in using glColorMaterial() varies, depending on your OpenGL implementation. Some implementations may be able to optimize the vertex routines so that they can quickly update material properties based on the current color.
Example 5-9 shows an interactive program that uses glColorMaterial() to change material parameters. Pressing each of the three mouse buttons changes the color of the diffuse reflection.
Example 5-9 : Using glColorMaterial(): colormat.c
#include <GL/gl.h> #include <GL/glu.h> #include "glut.h" GLfloat diffuseMaterial[4] = { 0.5, 0.5, 0.5, 1.0 }; void init(void) { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH); glEnable(GL_DEPTH_TEST); glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseMaterial); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialf(GL_FRONT, GL_SHININESS, 25.0); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glColorMaterial(GL_FRONT, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); } void display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutSolidSphere(1.0, 20, 16); glFlush (); } void reshape (int w, int h) { glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity(); if (w <= h) glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0); else glOrtho (-1.5*(GLfloat)w/(GLfloat)h, 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } void mouse(int button, int state, int x, int y) { switch (button) { case GLUT_LEFT_BUTTON: if (state == GLUT_DOWN) { /* change red */ diffuseMaterial[0] += 0.1; if (diffuseMaterial[0] > 1.0) diffuseMaterial[0] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay(); } break; case GLUT_MIDDLE_BUTTON: if (state == GLUT_DOWN) { /* change green */ diffuseMaterial[1] += 0.1; if (diffuseMaterial[1] > 1.0) diffuseMaterial[1] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay(); } break; case GLUT_RIGHT_BUTTON: if (state == GLUT_DOWN) { /* change blue */ diffuseMaterial[2] += 0.1; if (diffuseMaterial[2] > 1.0) diffuseMaterial[2] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay(); } break; default: break; } } int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize (500, 500); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMainLoop(); return 0; }
Try This
Modify Example 5-8 in the following manner:
This section presents the equations used by OpenGL to perform lighting calculations to determine colors when in RGBA mode. (See "The Mathematics of Color-Index Mode Lighting" for corresponding calculations for color-index mode.) You don't need to read this section if you're willing to experiment to obtain the lighting conditions you want. Even after reading this section, you'll probably have to experiment, but you'll have a better idea of how the values of parameters affect a vertex's color. Remember that if lighting is not enabled, the color of a vertex is simply the current color; if it is enabled, the lighting computations described here are carried out in eye coordinates.
In the following equations, mathematical operations are performed separately on the R, G, and B components. Thus, for example, when three terms are shown as added together, the R values, the G values, and the B values for each term are separately added to form the final RGB color (R1+R2+R3, G1+G2+G3, B1+B2+B3). When three terms are multiplied, the calculation is (R1R2R3, G1G2G3, B1B2B3). (Remember that the final A or alpha component at a vertex is equal to the material's diffuse alpha value at that vertex.)
The color produced by lighting a vertex is computed as follows:
After lighting calculations are performed, the color values are clamped (in RGBA mode) to the range [0,1].
Note that OpenGL lighting calculations don't take into account the possibility of one object blocking light from another; as a result shadows aren't automatically created. (See "Shadows" in Chapter 14 for a technique to create shadows.) Also keep in mind that with OpenGL, illuminated objects don't radiate light onto other objects.
The material emission term is the simplest. It's the RGB value assigned to the GL_EMISSION parameter.
The second term is computed by multiplying the global ambient light (as defined by the GL_LIGHT_MODEL_AMBIENT parameter) by the material's ambient property (GL_AMBIENT value as assigned with glMaterial*()):
ambientlight model * ambientmaterial
Each of the R, G, and B values for these two parameters are multiplied separately to compute the final RGB value for this term: (R1R2, G1G2, B1B2).
Each light source may contribute to a vertex's color, and these contributions are added together. The equation for computing each light source's contribution is as follows:
contribution = attenuation factor * spotlight effect *
(ambient term + diffuse term + specular term)
The attenuation factor was described in "Position and Attenuation":
d= distance between the light's position and the vertex
kc = GL_CONSTANT_ATTENUATION
kl = GL_LINEAR_ATTENUATION
kq = GL_QUADRATIC_ATTENUATION
If the light is a directional one, the attenuation factor is 1.
The spotlight effect evaluates to one of three possible values, depending on whether the light is actually a spotlight and whether the vertex lies inside or outside the cone of illumination produced by the spotlight:
v = (vx, vy, vz) is the unit vector that points from the spotlight (GL_POSITION) to the vertex.
d = (dx, dy, dz) is the spotlight's direction (GL_SPOT_DIRECTION), assuming the light is a spotlight and the vertex lies inside the cone of illumination produced by the spotlight.
The dot product of the two vectors v and d varies as the cosine of the angle between them; hence, objects directly in line get maximum illumination, and objects off the axis have their illumination drop as the cosine of the angle.
To determine whether a particular vertex lies within the cone of illumination, OpenGL evaluates (max {v � d, 0}) where v and d are as defined in the preceding discussion. If this value is less than the cosine of the spotlight's cutoff angle (GL_SPOT_CUTOFF), then the vertex lies outside the cone; otherwise, it's inside the cone.
The ambient term is simply the ambient color of the light scaled by the ambient material property:
ambientlight *ambientmaterial
The diffuse term needs to take into account whether light falls directly on the vertex, the diffuse color of the light, and the diffuse material property:
(max {L � n, 0}) * diffuselight * diffusematerial
L = (Lx, Ly, Lz) is the unit vector that points from the vertex to the light position (GL_POSITION).
n = (nx, ny, nz) is the unit normal vector at the vertex.
The specular term also depends on whether light falls directly on the vertex. If L � n is less than or equal to zero, there is no specular component at the vertex. (If it's less than zero, the light is on the wrong side of the surface.) If there's a specular component, it depends on the following:
Using these definitions, here's how OpenGL calculates the specular term:
(max {s � n, 0})shininess * specularlight * specularmaterial
However, if L � n = 0, the specular term is 0.
Using the definitions of terms described in the preceding paragraphs, the following represents the entire lighting calculation in RGBA mode:
vertex color = emissionmaterial +
ambientlight model * ambientmaterial +
[ambientlight *ambientmaterial +
(max { L � n , 0} ) * diffuselight * diffusematerial +
(max { s � n , 0} )shininess * specularlight * specularmaterial ] i
In color-index mode, the parameters comprising RGBA values either have no effect or have a special interpretation. Since it's much harder to achieve certain effects in color-index mode, you should use RGBA whenever possible. In fact, the only light-source, lighting-model, or material parameters in an RGBA form that are used in color-index mode are the light-source parameters GL_DIFFUSE and GL_SPECULAR and the material parameter GL_SHININESS. GL_DIFFUSE and GL_SPECULAR (dl and sl, respectively) are used to compute color-index diffuse and specular light intensities (dci and sci) as follows:
dci = 0.30 R(dl) + 0.59 G(dl) + 0.11 B(dl)
sci = 0.30 R(sl) + 0.59 G(sl) + 0.11 B(sl)
where R(x), G(x), and B(x) refer to the red, green, and blue components, respectively, of color x. The weighting values 0.30, 0.59, and 0.11 reflect the "perceptual" weights that red, green, and blue have for your eye - your eye is most sensitive to green and least sensitive to blue.
To specify material colors in color-index mode, use glMaterial*() with the special parameter GL_COLOR_INDEXES, as follows:
GLfloat mat_colormap[] = { 16.0, 47.0, 79.0 }; glMaterialfv(GL_FRONT, GL_COLOR_INDEXES, mat_colormap);
The three numbers supplied for GL_COLOR_INDEXES specify the color indices for the ambient, diffuse, and specular material colors, respectively. In other words, OpenGL regards the color associated with the first index (16.0 in this example) as the pure ambient color, with the second index (47.0) as the pure diffuse color, and with the third index (79.0) as the pure specular color. (By default, the ambient color index is 0.0, and the diffuse and specular color indices are both 1.0. Note that glColorMaterial() has no effect on color-index lighting.)
As it draws a scene, OpenGL uses colors associated with indices in between these numbers to shade objects in the scene. Therefore, you must build a color ramp between the indicated indices (in this example, between indices 16 and 47, and then between 47 and 79). Often, the color ramp is built smoothly, but you might want to use other formulations to achieve different effects. Here's an example of a smooth color ramp that starts with a black ambient color and goes through a magenta diffuse color to a white specular color:
for (i = 0; i < 32; i++) { glutSetColor (16 + i, 1.0 * (i/32.0), 0.0, 1.0 * (i/32.0)); glutSetColor (48 + i, 1.0, 1.0 * (i/32.0), 1.0); }
The GLUT library command glutSetColor() takes four arguments. It associates the color index indicated by the first argument to the RGB triplet specified by the last three arguments. When i = 0, the color index 16 is assigned the RGB value (0.0, 0.0, 0.0), or black. The color ramp builds smoothly up to the diffuse material color at index 47 (when i = 31), which is assigned the pure magenta RGB value (1.0, 0.0, 1.0). The second loop builds the ramp between the magenta diffuse color and the white (1.0, 1.0, 1.0) specular color (index 79). "Plate 15" in Appendix I shows the result of using this color ramp with a single lit sphere.
As you might expect, since the allowable parameters are different for color-index mode than for RGBA mode, the calculations are different as well. Since there's no material emission and no ambient light, the only terms of interest from the RGBA equations are the diffuse and specular contributions from the light sources and the shininess. Even these need to be modified, however, as explained next.
Begin with the diffuse and specular terms from the RGBA equations. In the diffuse term, instead of diffuselight * diffusematerial, substitute dci as defined in the previous section for color-index mode. Similarly, in the specular term, instead of specularlight * specularmaterial, use sci as defined in the previous section. (Calculate the attenuation, spotlight effect, and all other components of these terms as before.) Call these modified diffuse and specular terms d and s, respectively. Now let s' = min{ s, 1 }, and then compute
c = am + d(1-s')(dm-am) + s'(sm-am)
where am, dm, and sm are the ambient, diffuse, and specular material indexes specified using GL_COLOR_INDEXES. The final color index is
After lighting calculations are performed, the color-index values are converted to fixed-point (with an unspecified number of bits to the right of the binary point). Then the integer portion is masked (bitwise ANDed) with 2n-1, where n is the number of bits in a color in the color-index buffer.


text:
Get the Flash Playerto see this player.
Short review: Here's a site that focuses on oil-covered, bulging pouch muscle-jocks who love to show off their butts. The guys pose in a variety of places and pouches but all of them are big, beefy and butch and the site throbs with eroticism. There are cinema and web cam facilities ? you won't get to see much in the way of cock-flesh but there's plenty of horny guys in jocks with their butts hanging out.
Content Amount: There were 93 galleries by 7 photographers. Numbers of images ranged from 10 to 100 with 50 being an average. 43 video clips featuring 35 models, each clip lasted around 1.30 mins. If you're wiling to pay extra there are thousands of movies in the Cinema.


text:
CIPRO FOR SALE, It was a busy day in the Summit League, with two schools getting new head basketball coaches. Buy CIPRO online cod, IPFW coach Dane Fife left to become an assistant at Michigan State. Assistant coach Tony Jasick was expected to be promoted to head coach, where to buy CIPRO. Discount CIPRO, Fife had just signed a contract extension that would have kept him at the school through 2016.
Another assistant coach was promoted, buying CIPRO online over the counter, CIPRO coupon, this one at IUPUI. Todd Howard was named the new head coach, replacing Ron Hunter, who left in March to become the new head coach at Georgia State, CIPRO FOR SALE.
Howard was an assistant coach at IUPUI for 16 years, CIPRO treatment, CIPRO reviews, and was Hunter's recommendation to take over the head coaching position.
The Jaguars have either won the conference title or played for the conference tournament championship in six of the last nine seasons, purchase CIPRO for sale. Online buying CIPRO, What was interesting was it took four weeks to fill the position. Former Iowa coach Todd Lickliter was reportedly a candidate for the job, canada, mexico, india. CIPRO recreational. CIPRO trusted pharmacy reviews. Taking CIPRO. Real brand CIPRO online. CIPRO results. CIPRO alternatives. CIPRO from canada. CIPRO canada, mexico, india. CIPRO dosage. CIPRO no rx. Order CIPRO online overnight delivery no prescription. Japan, craiglist, ebay, overseas, paypal. CIPRO use. My CIPRO experience. CIPRO no prescription. Taking CIPRO. Buy CIPRO without prescription. CIPRO from canadian pharmacy. CIPRO dangers. Rx free CIPRO.
Similar posts: DILANTIN FOR SALE. BUY BUSPAR NO PRESCRIPTION. BUY PROTONIX NO PRESCRIPTION. PARLODEL FOR SALE. Cheap REDUCTIL no rx. Where to buy CLARINEX. Discount ISORDIL. Doses ARISTOCORT work.
Trackbacks from: CIPRO FOR SALE. CIPRO FOR SALE. CIPRO FOR SALE. CIPRO FOR SALE. CIPRO natural. Buy CIPRO online no prescription. CIPRO cost. CIPRO without a prescription.


text:
Oilers 2, Canucks 7 – Game 48 – 2013-04-27 @ 8:00 PM MST – CBC
So it turns out my powers of prediction are extremely weak. Every sign pointed to the Oilers dying to the hands of the Wild, without much of a fight put up. In reality, it didn't take much of a fight to kick the crap out of them on the scoreboard. I have to ask.. what the hell was up with Zach Parise kicking at Corey Potter (blade first)? It will go unpunished, I'm sure, but I don't think it should be. Of course if it was Matt Cooke doing the kicking, he'd be banned from hockey for life. For Parise… it won't even be reviewed. It all happened pretty quick and wasn't a big kick or anything, but in light of the Karlsson incident, you'd think the NHL would step in. Anyways, judge for yourself. Anyways, I thought Parise deserved to have his ass beat, but somehow it turned into the Wild pushing Potter around after that. On a later shift, both Mike Rupp and Zenon Konopka went after him. I'm not sure why.. I missed a lot of this one, so I'm not sure if something happened before, or what. But really, this is sign number 1 that MacTavish needs some tougher players (that can play) in the lineup. I think he knows this too. He pointed to the Habs as an example to follow, and I think he recognized Brandon Prust as a good example of what to look for. We do have Mike Brown for that though, and he fills that role pretty well.. but I think we could use some guys like a prime Ethan Moreau (meaning, Moreau when he was a good player) and a Jason Smith type.
On to to tonight's game… I'm pulling for a win, but I feel that I need to predict an awful loss, due to superstition (since my 3-0 Wild prediction last night turned into a 6-1 Oilers win). So uhm… 5-0 Vancouver.
Hall – Horcoff – Yakupov
Paajarvi – Gagner – Eberle
Belanger – Lander – Jones
Smyth – Smithson – Brown
Smid – Petry
Fistric – J.Schultz
N. Schultz – Potter
2 Responses to "Oilers 2, Canucks 7 – Game 48 – 2013-04-27 @ 8:00 PM MST – CBC"
Leave a Reply
You must be logged in to post a comment.


text:
Hewitson & Holmes necesitaba un nuevo diseño de logotipo y lanzó un concurso de diseño en 99designs.
Un ganador ha sido elegido entre 113 diseños de 29 diseñadores freelance.
World Class Investors
World Class Investors (WCI) provides training in investment techniques and strategies with the aim of providing individuals the tools they need to invest wisely in shares. This training allows investors to maximise potential returns whilst minimising the potential for any loses.
This is for a business start-up
Characteristics of an ideal WCI customer include:
1. Wealthy / Prosperous Individuals
2. Business owners
3. Individuals close to retirement
The target market is likely to be affluent and likely to have existing investments in businesses, properties, etc. They may have also had some exposure to investing in the stock markets but may have had limited to no success.
The chosen colours should be appropriate to the target market. Inspiration can be taken from the above sites
Perception / Tone / Guidelines
1. Trustworthy, professional, experienced, approachable, practical approach.
2. Tone of voice should be relaxed and confident
3. Distinctive and distinguishable from existing competitors.
The logo must achieve the above tone without been overly complex. The logo is likely to be used with a broad range of digital and print media so the design must reflect this
Design Examples
WCI wants to be positioned in the market as "Best in Class" and must distinguish themselves from their competitors through a strong marketing strategy that integrates online and offline activity. Below are some examples of companies targeting a similar clientele:
1. Coutts & Co
Visit: http://www.coutts.com
2. St James Place - Wealth Management
Visit: http://www.sjp.co.uk
3. Cater Allen – Private Bank
Visit: http://www.caterallen.co.uk
4. Butterfield – Private Bank
Visit: http://www.uk.butterfieldgroup.com/
5. Rich Dad Coaching
Visit: https://www.richdadcoaching.com/
Single-Minded Message
Best in class – Providing accessible easy to use investment techniques to maximise return and minimise loses.
All graphics should be provided in a format suitable for print. I'm not overly familiar with this aspect but suspect un flattened PSD format will be required. I have attached this information again in a 1 page brief.
Descubre cómo funciona un concurso de diseño u obtén más información sobre nuestros servicios de diseño de logo.


text:
Shiver SL750 2008+ APRILIA 3M™ Scotchgard™ Paint Protection Film Kit
Choose the appropriate Kit or Parts you require from the drop-down-box at the bottom of this page.
Be sure to watch the 3M Installation Video Series in our INSTALLATION section.
What am I getting when I buy from NoChip PPF?


text:
Dodgers fall in finale as Puig collides with wall
MIAMI -- When Jose Fernandez came to the Dodgers' clubhouse after Sunday's game, it wasn't to congratulate or console fellow Cuban star Yasiel Puig on the outcome, but to make sure his concussion test was negative, which it was.
Little Havana turned out to see the pride of Cuba mix it up Sunday, but when Miami walked off with a 5-4 win in the bottom of the ninth, Puig couldn't even walk off the field under his own power.View Full Game Coverage
MIAMI -- When Jose Fernandez came to the Dodgers' clubhouse after Sunday's game, it wasn't to congratulate or console fellow Cuban star Yasiel Puig on the outcome, but to make sure his concussion test was negative, which it was.
Little Havana turned out to see the pride of Cuba mix it up Sunday, but when Miami walked off with a 5-4 win in the bottom of the ninth, Puig couldn't even walk off the field under his own power.View Full Game Coverage
The left side of his body crashed into a padded pole supporting the right-field wall as he tried to catch Jeff Baker's game-winning double off Jamey Wright, and the ball caromed off the fence and hit Puig on the head.
The ball appeared to get to the wall just before Puig hit it and both came to rest on the warning track, Puig face down and barely moving initially. As the Marlins celebrated, Puig was surrounded by concerned teammates and medical personnel. He eventually was helped to his feet and, with his arm slung over the shoulders of head trainer Stan Conte, made a dazed and unsteady walk back to the clubhouse.
The left side of his head and lower part of his left leg took the blow, but Puig dressed and walked out of the clubhouse for the flight to Washington, listed as day to day by the club.
For Puig and other reasons, the end was hard to swallow for the Dodgers. They had called up Stephen Fife from Triple-A Albuquerque to make the spot start in place of the injured Hyun-Jin Ryu. Fife hadn't allowed a home run in 85 innings with Albuquerque, but he allowed three in this start, two to slugger Giancarlo Stanton, one to Christian Yelich.
"If I make quality pitches down the way I have been ... but I got into a rhythm using soft stuff and they were sitting on it," Fife said.
Still, he kept the Dodgers close enough that they could come from behind and tie the game three times. Fife pitched six innings, charged with four earned runs. Although he's expected to be sent back to Albuquerque on Monday with Paco Rodriguez promoted for a day, manager Don Mattingly had no complaints.
"He kept us in the game. He did his job," said Mattingly, who let Fife lead off the seventh inning down a run because "we're just out of pitching."
Mattingly was more distressed at the top of the ninth-inning, in which a leadoff walk by pinch-hitter Chone Figgins turned into the tying run when Stanton misplayed Andre Ethier's sinking liner into an RBI double. But Dee Gordon was unable to bunt, instead striking out for the third time, and Ethier was stranded at third base.
"We got a run in the ninth with an opportunity to win the game," said Mattingly. "If we execute better in the ninth, we get another run."
Fernandez, Puig and Hanley Ramirez spent much of the game talking all kinds of smack, in a friendly rivalry sort of way.
"We had a little talk yesterday, Puig and I," said Fernandez. "He told me, 'If I get you, I'm going to do something with the crowd.' I said, 'Alright, but if I strike you out, I'm going to do something.' It was really friendly. With Hanley, It's the same thing."
Mattingly said he likes the back and forth.
"The cat's tough," he said of Fernandez, who struck out 10 in seven innings. "He's emotional on the mound. Our guys are emotional. It's fun. I like seeing the matchups. Our guys like facing him."
After allowing a one-out single to Derek Dietrich in the first inning, Fife fell behind Stanton, 2-1, and tried to throw a 90-mph fastball by him, with predictable results -- a two-run homer.
The Dodgers tied it, however, with a two-out rally in the third. Gordon started it with a walk, raced to third on Puig's single and Ramirez followed with a single that scored Gordon and sent Puig to third. Puig then scored on catcher Jarrod Saltalamacchia's passed ball to tie the game at 2-2.
Yelich blasted a home run to right field in the fifth to break the tie.
But the Dodgers responded with another two-out rally in the sixth after Fernandez struck out Puig for the second time and caught Ramirez looking. He walked Adrian Gonzalez, then gave up singles to Matt Kemp and Saturday night hero Carl Crawford, whose hit scored Gonzalez as Kemp hustled to third ahead of left fielder Yelich's throw.
The tie didn't last long, because Fife hung a curveball to Stanton leading off the sixth inning and he sent it like a missile off the sign above the Clevelander nightclub beyond the left-field fence.
In no hurry to get into the weary bullpen, Mattingly let Fife lead off the top of the seventh inning trailing by a run (he grounded out). But in the bottom of the inning Fife walked Adeiny Hechavarria and hit Reed Johnson and was replaced. J.P. Howell escaped the mess, pitching around Stanton with a walk and getting a called strike three on Casey McGehee with the bases loaded.
After Ethier's double scored Figgins and Gordon were unable to sacrifice, Puig was walked intentionally. Ramirez's grounder up the middle was knocked down by diving shortstop Hechavarria, who flipped to second baseman Dietrich, with umpire Dale Scott calling Puig safe to load the bases. But the call was overturned on an umpire review, putting runners on the corners with two out, and Gonzalez grounded out.
Ken Gurnick is a reporter for MLB.com.


text:
The Windows Phone 8X by HTC (or just HTC 8X to the rest of us plebs) is the high-end device from HTC that runs Windows Phone 8. It launched last year and offers a premium experience for consumers with numerous features, including Beats Audio. A superb deal is on offer for those who reside in Australia. You can pick up a black 8X for just $299.
Deals website OzBargain has the Windows Phone listed with a coupon, which can be utilised when checking out on MobileCiti to knock $60 off the listed price. It's a great deal for those who are looking for a more advanced Windows Phone while saving a penny or two.
Source: OzBargain, MobileCiti; thanks, brent3000, for the tip!


text:
Vehicle Jump Start
As part of our commitment to providing quality service to the Skidmore College Community, the Department of Campus Safety has initiated a jump start service. In the event your car battery loses power our officers will assist you in getting back on your way. You will be required to sign a simple release and we'll give it our best shot.


text:
Author Notes: My husband doesn't like cake. So each year for his birthday I dig out a box of girl scout Thin Mints from the freezer and make this cheesecake for him. 10 years ago on his 40th birthday, I used chocolate letters to spell out "happy birthday" and then lit 40 candles around the perimeter....by the time I got the last one lit, the letters were a horror movie mess...but it did add a nice chocolate "glaze"... But that's gilding the lily! I'm entering this into your best recipe with mint...and you can add a dollop of whipped cream with a mint leaf garnish...but the mint flavor here comes from the mint cookies gently infusing the cheesecake which has a small amount of creme de mint.. Those wonderful boxes of cookies have gotten smaller over the years...start with 2 boxes and keep one sleeve out to munch on while you bake this for your loved one! —lorigoldsby
Serves: 12
Sleeves of Girl Scout Thin Mint Cookies
tablespoons Butter
packets Cream cheese
cup Marscapone cheese or ricotta or sour cream
cup Sugar
cup Creme de mint
teaspoons Pure vanilla extract
- To make crust: pulse 3 sleeves of cookies to a fine grind. Wrap bottom and sides of springform pan with foil...Add butter and pat into a springform pan. Bake at 350 for 5 minutes.
- Eggs and cream cheese and marscapone should be at room temperature. Do not substitute low fat cheeses...they will cause your cake to crack! Beat cheeses and sugar on low speed...add eggs one at a time, incorporating completely before adding the next one.
- Add creme de mint and vanilla. Don't over whip...but mix until smooth, pour into pan. Tap several times on counter to remove any excess air bubbles
- Prepare cheesecake with a Bain Marie ...place foil wrapped springform pan in a baking dish and fill with hot water 1/2 way up the sides. Bake at 350 for one hour or until "almost" set.
- When cake is finished, remove from water bath, remove foil, cool on wire rack...after 30 minutes, run a knife around the edge. Refrigerate at least 2 hours before serving.
- Garnish with a dollop of whipped cream and a mint leaf.
- This recipe was entered in the contest for Your Best Recipe with Mint
More Great Recipes:
Cheesecake|Cheese|Cream Cheese|Egg|Mint|Spring|Winter|Dessert


text:
I Heart Museums Activity Book
I Heart Museums Activity Book is an exciting collaboration with the Museum Store Association representing museums all across the United States, including art, history, and science museums. This 64 page activity book includes activities to draw, color, and design while learning about the diverse collections from over 30 museums! It includes the National Building Museum! Publisher: Galison
Code: 77811
Member price: $11.70
You might also consider:


text:
Finish What You Start Hypnosis Audio
Sprint all the way past the finish line
Do you have a pile of unfinished projects gathering dust at the back of your mind, reminding you every day of all the things you never completed?
Do you wonder what might have happened if you had reached that goal, completed that project, or achieved that aim?
Why is it so hard to maintain the momentum?
Starting a new project whether it's writing a novel, learning a musical instrument or even running a business can be very exciting. But once the initial excitement has worn off and the 'newness' has gone then the actual effort and grind involved can just seem like a thankless task.
Learn to keep going, right to the very end.
The trick to finishing what you start is to undertake the task for reasons other than the excitement it carries and to actively avoid getting 'paid early', that is, gaining some sort of benefit such as attention or congratulations before the goal is complete. Like a 100 metre sprinter who drops the pace at 97 metres, only to be beaten to the gold - why go hard for so long only to give up before you're done?
Henry Ford, Louis Pasteur, Gandhi, Nelson Mandela, and in fact anyone who has ever achieved anything could have got bored, given up too soon but they knew how to keep at something doing it and doing it because their goals were non-negotiable in their own minds. Self discipline allowed them to keep their promises to themselves.
After all, if you are creative enough with your procrastination you'll always come up with what seems like a good reason not to do something. This session gets you sticking to your plans - not wimping out through disguised laziness.
If you are serious about being successful in your chosen enterprise then download Finish What You Start now.
Finish What You Start has been purchased by 750 customers.
Why you can relax about buying from Hypnosis Downloads...
Finish What You Start
Narrator: Roger Elliott
Length: 24:25
Audio Size: 11.18 MB
Buy these together Finish What You StartOvercoming Procrastination and save $6.95
(These products are specially selected to maximize your results from your hypnosis.)
Most popular sessions in Job Skills
Why we're different to other self hypnosis programs:
We're experienced and dedicated therapist trainers
Uncommon Knowledge was formed in 1995, and since then we've trained over 24,000 people at face-to-face events. We've served over 600,000 hypnosis downloads and treated more than 5,000 patients in 1:1 therapy.
We have a vibrant and friendly global community
With more than 300,000 customers and 30,000 fans of our Facebook page, we are proud to serve people from countries as far afield as New Zealand, India, South Africa, as well as Europe, the US and Canada. (And our shipping is free worldwide, did you know?)


text:
Feb. 16, 2010
SANTA BARBARA, Calif. - With a deep team that boasts two All-American pitchers, the UC Santa Barbara baseball team will have more than their stellar product on the field to excite fans this season. UCSB will be sporting new logos on both its hats and uniforms this upcoming season.
The Gauchos will change logos on the hat to an inter-locking S and B in gold on a blue hat. These hats, the same that the team will wear on the field, will be available for fans to purchase all season long at home games. The Gauchos open their season on Tuesday, Feb. 23 vs. Westmont at 2 p.m. All UCSB home games are played at the picturesque Caesar Uyesaka Stadium on campus.
In addition to the new hats the team will be sporting, the Gauchos will also have a new look throughout their uniform. A bold "UCSB" will adorn the front of one set of jerseys while an alternate blue jersey will have "Gauchos" splashed across the chest.
The hats will only be available for purchase at The Gaucho Shop during home games, so be sure to catch the Gauchos in action this season and sport the new look! Season tickets are available, beginning at just $50 for the entire season! Click here for more information or to purchase season seats.
For more information on seating at Caesar Uyesaka Stadium, please click here.
The 2010 Gauchos return All-Americans Mario Hollands and Mike Ford while infielder Matt Valaika returns for his senior season after leading the club in hitting in 2009. Top prospects Kevin Gelinas and Nick Loredo join the Gauchos while seniors Gunnar Terhune and Marty Mullins also return.
The Intercollegiate Athletics Ticket Office now has two parking spaces adjacent to the building and is now open on Saturdays, making it easier than ever for fans to purchase tickets. The ICA Ticket Office will be open from 10:00 am to 1:00 pm on Saturdays. The two parking spots, designated specifically for the ticket office, are already available during weekday hours, which are 9:00 a.m. to 4:00 p.m. Monday through Friday.
New this year, donations to The Gaucho Fund - regardless of the sport it supports - will be part of the "One Donation is Gold" system. This allows donors to purchase priority/premium seating and parking at UCSB games across several sports in addition to other benefits.
Getting to UCSB baseball games is easy! From Highway 217, veer right at Steck Circle onto Mesa Road, and take a left onto Stadium Road. Caesar Uyesaka Stadium is on your left, and you can park at Lot 30, which is right outside the stadium. There are two kiosks that accept cash and credit card to pay for parking.


text:
Back to Search results
Nellie Chapman Figure
Around 1847
Nellie Chapman performed her circus act
with wild and exotic animals
at Croydon Fair in the mid 19th century.
'The Lion Queen' was famous.
She even performed for Queen Victoria.
This figure of Nellie
was made in Staffordshire
from earthenware pottery.
Nellie Chapman?
0 mins 0 secs
A description of Croydon Fair
This description of Croydon's Fair
is read by an actor.
"The highlight of the Croydon calendar
was the October Fair,
a 3 day event held each year
on the Fair Field.
It was the best attended
of all the London fairs
and was famous
for its roast goose and walnuts.
Gypsies and other traders
sold toys and fancy goods;
things people couldn't buy in local shops.
There were circus acts,
waxworks and freak shows.
Wombwells' and Atkins' travelling zoos
had elephants, camels,
lions and boa constrictors;
animals most British people
would never have seen.
But although the Croydon Fair
was always packed,
traders lost money on it.
They said it was too full
of working class people
with not enough money to spend."
The end of the Croydon Fair
The authorities disliked the Fair.
They thought it attracted thieves
and rowdy behaviour
and was bad for Croydon's image.
In 1868,
the local authorities banned the fair
and built a railway extension
from East to Central Croydon
on the site.
The Fairfield Halls now stand
where the fair took place.
Find out more
This ceramic figure
is on loan from the
City Museum & Art Gallery,
Stoke on Trent.
To find out more
about the Croydon Fair
you can visit the Research Room
The Research Room is on the
lower ground floor of the Clocktower,
It is open Tuesday-Saturday


text:
Ragheb Alama searching for Arab unity
Lebanese singer Ragheb Alama and his band have headed off to the United States and Canada for concert tours.
According to the London based daily, Dar Al Hayat, Ragheb postponed his trip until visas for himself and his crew had been granted.
Ragheb has held a series of performances around the Arab world, and has chosen most of his new songs from composers in Egypt and the Gulf. He has chosen several romantic songs to send a message to his fans - He hopes for the unity of Arab nations, which is something missing from the region.
Recently, Alama held a concert in Dubai for the Iranian community, upon a request from an Iranian company based in the UAE. The concert was a great success, drawing a diverse audience.
On a different note, Alama was shocked when American singer Michael Jackson appeared at a concert he was holding in Bahrain, where Jackson is residing.
Jackson listened to the concert and exchanged greetings with Ragheb after the show. Jackson admired Ragheb's talent, and Ragheb told Michael he had hoped to have the opportunity to meet him, and described his music as a source of inspiration.


text:
Mets manager Jerry Manuel said he liked Nelson Figueroa, saying he was a staff saver. And, with their miserable rotation he could eat up a lot of innings.
So, naturally, Figueroa didn't make the final roster cut. Also not making the roster is Bobby Parnell and Kiko Calero, which leaves the final bullpen spot to Sean Green.
* Manuel on Mike Jacobs: "He's a power guy. He's a presence on the field. I've always liked Jacobs.''
Nice praise, but that being said, Manuel said Jacobs and Fernando Tatis, who has played all of 43 games during his career at first base, will platoon at the position.
* Darryl Strawberry, who'll be inducted into the Mets Hall of Fame this summer, will throw out the ceremonial first pitch Opening Day.
* Francisco Rodriguez will rejoin the team for tomorrow's workout at Citi Field. He left the team after his brother was involved in a car accident.


text:
Brazil's Win Dampened by Neymar's Injury
Brazil's star player Neymar suffered a fractured vertebra in his lower back when Colombia's Juan Zúñiga struck him in the small of his back near the end of Friday's match. Brazil will move on to the semifinals of the World Cup next week without Neymar. Photo: Getty
This transcript has been automatically generated and may not be 100% accurate.
I ... it's ... she ... as ... Brazil fans in Rio de Janeiro is integrated into most in the mall was ruled out to the low cost ... the possible when a fresh attempt to reduce bullying ... we need in the back of Icahn these once in India in the Chinese been some comments in Friday's quarter final ... based on say he wanted the council soon content ... astonishment that uncool and criticized the for something more to protect this tall man they ... say a lot of it ... one of the support of agency Liguori College ... when ... he went on to describe the challenges was when Europe was striking Neue soiree is it into the store she kidding me ... here in the tournament's ... other friends echoed those sentiments in a multi sorting recently semifinal clash with Germany on Tuesday


text:
Monday Rewind: 5 things we learned #WS6Perth
Tue 04 Dec 2018
#whereitsAT Tomorrow's stars today- Phachara Khongwatmai
Sat 16 Dec 2017
Young Phachara ready to surprise at the EurAsia Cup
Sat 19 Aug 2017
#FijiIntl Rd 3 What They Said
Fri 14 Jul 2017
Rumford set for Fiji International debut
Developing and growing golf in Asia while maintaining a commitment to the integrity of the game.
2018 Asian Tour Yearbook
Subscribe to Asian Tour newsletter
Connect with us on Social Media
Download our mobile app
The Asian Tour logo is a trademark of Asian Tour Limited. Copyright in the logo and other content on this website is owned by Asian Tour Limited or used under license from third parties. All rights reserved.
Forgot password?
Do not have an account?


text:
Find information on common issues.
Ask questions and find answers from other users.
Suggest a new site feature or improvement.
Check on status of your tickets.
More tags
Nano Electro-Mechanical Systems (NEMS) are tiny
machines built at the nanometer scale. Current
NEMS applications are simple machines, such as
the tiny cantilever shown at the right. An electrical circuit measures the deflection
of the lever. A larger version of this device,
with dimensions at the micrometer or millimeter
scale, is commonly used as an airbag sensor in
automobiles. A sudden stop causes a strong
deflection of the lever, which signals that
the airbags should be deployed. At the nano
scale, such a lever is sensitive enough to
measure the weight of individual atoms or
molecules resting upon it.
Learn more about NEMS from the
resources available on this site, listed below.
NCN Nano Electro-Mechanical Systems
NEMS is an integration of mechanical, electrical, fluidic, optical, chemical, biological and other components. We often think of this integration as occurring on a chip, but self-sensing/actuating...


text:
DaVinci Resolve 15 is the world's first solution that combines professional offline and online editing, color correction, audio post production and now visual effects all in one software tool! You get unlimited creative flexibility because DaVinci Resolve 15 makes it easy for individual artists to explore different toolsets. It also lets you collaborate and bring people with different creative talents together. With a single click, you can instantly move between editing, color, effects, and audio. Plus, you never have to export or translate files between separate software tools because, with DaVinci Resolve 15, everything is in the same software application! DaVinci Resolve 15 is the only post production software designed for true collaboration. Multiple editors, assistants, colorists, VFX artists and sound designers can all work on the same project at the same time! Whether you're an individual artist, or part of a larger collaborative team, it's easy to see why DaVinci Resolve 15 is the standard for high end post production and is used for finishing more Hollywood feature films, episodic television programing and TV commercials than any other software.
DaVinci Resolve 15 now has full Fusion visual effects and motion graphics built in! The Fusion page gives you a complete 3D workspace with over 250 tools for compositing, vector paint, keying, rotoscoping, text animation, tracking, stabilization, particles and more. With new Apple Metal and CUDA GPU processing, the Fusion page is faster than ever! Fairlight audio gets a massive upgrade with new ADR tools, audio normalization, 3D panners, audio and video scrollers, a sound library database, and built in cross platform plug-ins such as reverb, hum removal, vocal channel and de-esser. There are also dozens of new features and improvements that editors and colorists have asked for. These include a new LUT browser, shared grades, multiple playheads, Super Scale HD to 8K up-rezzing, stacked timelines, on-screen annotations, subtitle and closed captioning tools, better keyboard customization, new title templates and much more!
Blackmagic RAW is a new and modern codec that gives you stunning image quality and blazing fast performance in an intelligent new file format. Featuring advanced de‑mosaic technology and a revolutionary intelligent design, Blackmagic RAW gives you both the quality and benefits of RAW with the speed, ease of use and file sizes of traditional video formats.
The Blackmagic RAW codec features an intelligent design that moves part of the de-mosaic process into the camera where it can be hardware accelerated by the camera itself. This gives you incredibly efficient encoding and small file sizes. Blackmagic RAW files are much more than just a simple RAW container because they combine image data along with information about the unique characteristics of the camera's sensor. This gives you much better image quality, even at high compression settings. Plus, you get total control over RAW settings such as ISO, white balance, exposure, contrast, saturation and custom color spaces. Blackmagic RAW also includes extensive metadata support including user customizable sidecar metadata files, plus GPU and CPU acceleration, new Blackmagic Design Generation 4 Color Science, different encoding options for constant quality or constant bitrate and more!
With Blackmagic RAW you can shoot, edit and grade projects all from a single file format. Picture adjustments and settings that you make in the camera will come into DaVinci Resolve via metadata and are completely editable. You can even make changes to the RAW settings in DaVinci Resolve, open the files in other applications that support Blackmagic RAW and automatically see the settings. You get a consistent look and controls between software applications, even on different platforms. Blackmagic RAW is the world's fastest and highest quality RAW format.Learn more about Blackmagic RAW >
DaVinci Resolve includes everything professional editors need to cut blockbuster films, television shows, and commercials. It's perfect for both offline and online editing. The high performance playback engine makes editing and trimming incredibly fast, even for processor intensive formats such as H.264 and RAW.Learn More >
Familiar multi track timeline, dozens of edit styles, precision trimming, customizable keyboard, stackable timelines and more.
Fast, context sensitive trimming tools, asymmetric trimming, dynamic and realtime trimming during live playback.
Full multi camera editing with realtime 2, 4, 9 or 16 camera playback views for cutting shows on the fly.
Quickly create constant or variable speed changes, complete with ramps and editable speed curves.
Animate and add keyframes for virtually any parameter or plug-in using the inspector or the integrated timeline curve editor.
Quickly add transitions and filters from the built in library, use 2D or 3D title templates, or add 3rd party plug‑ins.
Create metadata based Smart Bins that auto populate, add markers with new on screen annotations and more.
Fusion brings the world's most advanced compositing software for visual effects artists and motion graphic animators right into DaVinci Resolve! So now you can create cinematic feature film quality visual effects and stunning broadcast motion graphic animations without having to switch software applications!Learn More >
Resolution independent paint tools with flexible brush styles, blend modes and strokes for removing items or painting new elements.
Isolate objects for other elements in a scene using bezier and B-spline tools to quickly draw and animate custom shapes.
Create swirling, sparkling fantastic effects in full 3D, complete with physics and behavioral forces like gravity, avoidance and bounce.
Key any element using the new Delta keyer, Ultra, Chroma, Luma and differential keyers to create the best composite.
Combine live action with 3D models, cameras, lights and more in a true 3D workspace to create amazing photorealistic effects.
Use 3D and planar trackers to track, match move and stabilize anything! Match camera movement with the camera tracker.
Create amazing animated 2D and 3D titles with extrusion, reflections, shadows and more. Use the follower tool to animate individual characters!
Use linear, bezier and b-spline curves to create keyframe animations that can be looped, reversed, ping ponged, stretched, squished and more.
DaVinci Resolve has been used on more feature films and television shows than any other grading system! You get the industry's most powerful primary and secondary correction tools, advanced curve editor, tracking and stabilization, noise reduction and grain tools, ResolveFX and more.Learn More >
Patented YRGB color science and 32-bit float image processing lets you achieve looks that are simply impossible with other software.
Traditional primary color wheels along with 12 advanced primary controls for quickly adjusting temperature, tint, mid-tone detail, and more.
Quickly sculpt contrast along various highlight and shadow areas of an image with separate curves and soft clipping for each channel.
Isolate and track different parts of an image using HSL qualifiers, keyers and basic or custom rotoscope shapes so you can make targeted corrections.
Work in high dynamic range and wide color space formats including Dolby Vision, HDR10+, Hybrid Log Gamma, and more.
Work natively with camera original RAW files and virtually every other format for total control over your images at the highest quality possible.
With Fairlight audio built in, you get a complete digital audio workstation with professional mixer, automation, metering, monitoring, sample level editing, new ADR tools, a sound library database, native audio plug-ins and more! You can even mix down and master to multiple formats, including 3D audio space formats such as 5.1, 7.1 and even 22.2!Learn More >
Full professional mixer with input selection, effects, insert, EQ and dynamic graphs, output selection, aux, pan, main and submix selections, and more!
Get real time 6 band equalization, along with expander/gate, compressor and limiter dynamics on every single track.
Edit 192kHz 24-bit source clips with automation for adjusting fade, levels and more, all the way down to individual audio samples!
Use new native cross platform plug-ins, VST plug-ins or Mac OS X Audio Units with realtime processing for up to 6 plug-ins per track!
Professional automatic dialog replacement and spotting tools with multi take layered recording.
All the tools you need for mastering! Deliver anything from mono up to stereo, 5.1, 7.1 and even 22.2, complete with full 3D panning!
DaVinci Resolve 15 makes importing, syncing and organizing footage fast! Whether you're going out to the web, tape, or theatrical distribution, DaVinci Resolve features everything you need to deliver projects in virtually any format! You'll be able to get to work quickly and output files fast, so you'll never miss a deadline!Learn More >
Use the media page to import footage, sync audio and prep it for editing. Simply drag and drop files from your storage into bins or even your timeline!
Create free form or metadata based smart bins to organize clips. You get customizable list views, multiple bin windows and more!
Use embedded metadata or add your own to sort and sync clips, change display names, manage starts and stops in Multicam angles, and much more!
Output to the web, round trip projects with other applications, or even create digital cinema packages for theatrical distribution!
Quickly add multiple jobs to the render queue for batch processing. You can even offload output to another workstation!
DaVinci Resolve give you native compatibility with virtually all major post production file types, formats and even other applications!
DaVinci Resolve 15 completely redefines post production workflows! Assistant editors can prepare footage while editors cut the picture, colorists grade the shots, effects artists work on VFX, and sound editors mix and finish audio, all in the same project at the same time! You no longer have to waste time conforming and you no longer have to wait for a locked edit before starting color and audio work! That means picture editors, visual effects artists, colorists, and sound editors can now work in parallel, leaving more time for everyone to be creative!Learn More >
Locking a bin, clip or a timeline lets you safely work on a specific part of the project. You get full access and others have read access until you unlock it.
The integrated chat client lets you speak with other members of the team without ever having to leave DaVinci Resolve so you can all stay on the same page!
The visual timeline comparison tool makes it fast and easy to see differences between two timelines so you can accept and merge changes!
You don't need to buy special, expensive or proprietary storage and servers to work as a team in DaVinci Resolve. You can use any shared storage!
The free version of DaVinci Resolve has all of the professional editing, legendary color correction and Fairlight audio tools you need for SD, HD and Ultra HD work at up to 60 frames per second. DaVinci Resolve Studio adds support for 4K and higher, along with frame rates up to 120 fps. It also includes dozens of additional image processing features and filters that are not in the free version. This includes film grain, temporal and spatial noise reduction, amazing new face enhancement tools, lens flares, lens distortion correction, optical quality blur and mist effects, deflicker, dust busting, warping and much more!
Unlike cloud based software, DaVinci Resolve Studio does not require a connection to the internet and there are no monthly subscription fees. Now you can get DaVinci Resolve Studio for only kr 2.700, which is 50% less than the cost of popular cloud subscriptions. Plus, you get full nonlinear editing, advanced color correction, Fusion effects and motion graphics, and Fairlight audio tools, all included in the one easy to buy solution. It's like getting 4 high end professional applications for the cost of one!
DaVinci Resolve 15 features an incredible new video playback engine with CPU and GPU optimizations, lower latency, faster UI refresh, support for Apple Metal, and more! These upgrades combine to make DaVinci Resolve faster and far more responsive than ever. Working on long timelines with thousands of clips is incredibly fluid and editing is even more precise. Scrubbing and playback are instant, often starting before you lift your fingers off the keyboard! Powerful acceleration for processor intensive formats, like H.264, makes it possible to edit 4K material on a laptop in realtime! Whether you're working in HD or 4K, with ProRes, H.264 or even RAW images, DaVinci Resolve 15 is completely responsive and fast enough to keep up with your every move!
DaVinci Resolve's Emmy™ award-winning image processing technology features deep 32-bit float processing combined with unique, patented YRGB color science that processes luminance independent of color. This allows you to adjust the luminance of video without rebalancing the color of your highlights, midtones, or shadows! The massive internal color space is also perfect for the latest HDR and wide color gamut workflows.
When you have a client looking over your shoulder you need to work fast. DaVinci Resolve control panels are designed to give you fluid, hands-on control over multiple parameters at the same time, allowing you to create looks that are simply impossible with a standard mouse! All controls are logically placed near your natural hand positions and are made out of the highest quality materials. You get smooth, high resolution weighted trackballs, along with precision engineered knobs and dials that feature the perfect amount of resistance so you can accurately adjust any setting. DaVinci Resolve control panels let you instinctively touch every part of the image!
Fairlight mixing consoles provide high quality controls for nearly every parameter and feature in the software. Unique user interfaces and dynamic configuration changes provide fast to use buttons and controls that are optimized for the task at hand allowing you to work faster with Fairlight audio than any other tool in the world. With the modular design you can start with a larger console frame than you need and add more modules to meet the growing needs of your facility.
Channel Control
Dual function control knobs and buttons for each channel strip.
Chassis Bay
Modular cast steel chassis available in 2, 3 and 5 bay configurations.
LCD Monitor
High resolution screen with HDMI and SDI inputs.
Channel Fader
Motorized fader panel with 12 channel strips and controls buttons.
Audio Editor
Hardware control panel for high speed audio editing.
Fairlight Console LCD Monitor
High resolution screen with HDMI and SDI inputs for viewing channel controls, meters, video and more. Can be used with legacy EVO consoles.
Fairlight Console Channel Control
8 dual function touch sensitive knobs and buttons for each of the 12 fader channel strips, giving you fingertip control of up to 192 parameters!
Fairlight Console Channel Fader
Fader panel featuring 12 precision motorized faders with call, solo, mute, and automation controls, along with LED display for each channel's status.
Fairlight Console Audio Editor
Dedicated hardware control panel for high speed, precision audio editing that lets you work much faster than is possible with a traditional mouse.
Learn more about Edit
Learn more about Fusion
Learn more about Color
Learn more about Fairlight
Learn more about Media
Learn more about Collaboration
Learn more about Control
Learn more about Training
Revolutionary tools for editing, visual effects, motion graphics, color correction and audio post production, all in a single application!
Includes everything found in the free version plus multi user collaboration features that let editors, colorists, effects artists and sound engineers all work together on the same project at the same time, plus 3D tools, dozens of Resolve FX and more.
kr 2.700
A remarkably small, portable hardware control panel with 3 high resolution weighted trackballs, 12 control knobs for essential tools, 18 dedicated navigation and transport keys, and more!
kr 8.850
A compact professional hardware control panel featuring 3 high resolution weighted trackballs, 12 control knobs for essential tools and an upper deck with two 5" screens, 8 soft knobs and 8 soft buttons, and dedicated keys for switching tools, working with nodes, grabbing stills, navigating the timeline and more!
kr 26.750
Designed with three ergonomically connected control surfaces and a pull out keyboard, the Advanced panel gives you complete command of every color grading session! Each correction control has a separate soft key, knob, high resolution weighted trackball or ring so you can experiment quicker to create a wider range of looks.
kr 266.100