- Normal textures
- Tangent and Bitangent
- Preparing our VBO
- Computing the tangents and bitangents
- Indexing

- The shader
- Vertex shader
- Fragment shader

- Results
- Going further
- Orthogonalization
- Handedness
- Specular texture
- Debugging with the immediate mode
- Debugging with colors
- Debugging with variable names
- How to create a normal map

- Exercises
- References

Welcome for our 13th tutorial ! Today we will talk about normal mapping.

Since Tutorial 8 : Basic shading, you know how to get decent shading using triangle normals. One caveat is that until now, we only had one normal per vertex : inside each triangle, they vary smoothly, on the opposite to the colour, which samples a texture. The basic idea of normal mapping is to give normals similar variations.

A “normal texture” looks like this :

In each RGB texel is encoded a XYZ vector : each colour component is between 0 and 1, and each vector component is between -1 and 1, so this simple mapping goes from the texel to the normal :

`normal = (2*color)-1 // on each component`

The texture has a general blue tone because overall, the normal is towards the “outside of the surface”. As usual, X is right in the plane of the texture, Y is up (again in the plane of the texture), thus given the right hand rule Z point to the “outside” of the plane of the texture.

This texture is mapped just like the diffuse one; the big problem is how to convert our normal, which is expressed in the space each individual triangle (tangent space, also called image space), in model space (since this is what is used in our shading equation).

You are now so familiar with matrices that you know that in order to define a space (in our case, the tangent space), we need 3 vectors. We already have our UP vector : it’s the normal, given by Blender or computed from the triangle by a simple cross product. It’s represented in blue, just like the overall color of the normal map :

Next we need a tangent, T : a vector parallel to the surface. But there are many such vectors :

Which one should we choose ? In theory, any, but we have to be consistent with the neighbors to avoid introducing ugly edges. The standard method is to orient the tangent in the same direction that our texture coordinates :

Since we need 3 vectors to define a basis, we must also compute the bitangent B (which is any other tangent vector, but if everything is perpendicular, math is simpler) :

Here is the algorithm : if we note deltaPos1 and deltaPos2 two edges of our triangle, and deltaUV1 and deltaUV2 the corresponding differences in UVs, we can express our problem with the following equation :

`deltaPos1 = deltaUV1.x * T + deltaUV1.y * BdeltaPos2 = deltaUV2.x * T + deltaUV2.y * B`

Just solve this system for T and B, and you have your vectors ! (See code below)

Once we have our T, B, N vectors, we also have this nice matrix which enables us to go from Tangent Space to Model Space :

With this TBN matrix, we can transform normals (extracted from the texture) into model space. However, it’s usually done the other way around : transform everything from Model Space to Tangent Space, and keep the extracted normal as-is. All computations are done in Tangent Space, which doesn’t changes anything.

Do have this inverse transformation, we simply have to take the matrix inverse, which in this case (an orthogonal matrix, i.e each vector is perpendicular to the others. See “going further” below) is also its transpose, much cheaper to compute :

`invTBN = transpose(TBN)`

, i.e. :

## Computing the tangents and bitangents

Since we need our tangents and bitangents on top of our normals, we have to compute them for the whole mesh. We’ll do this in a separate function :

`void computeTangentBasis( // inputs std::vector<glm::vec3> & vertices, std::vector<glm::vec2> & uvs, std::vector<glm::vec3> & normals, // outputs std::vector<glm::vec3> & tangents, std::vector<glm::vec3> & bitangents){`

For each triangle, we compute the edge (deltaPos) and the deltaUV

` for ( int i=0; i<vertices.size(); i+=3){ // Shortcuts for vertices glm::vec3 & v0 = vertices[i+0]; glm::vec3 & v1 = vertices[i+1]; glm::vec3 & v2 = vertices[i+2]; // Shortcuts for UVs glm::vec2 & uv0 = uvs[i+0]; glm::vec2 & uv1 = uvs[i+1]; glm::vec2 & uv2 = uvs[i+2]; // Edges of the triangle : position delta glm::vec3 deltaPos1 = v1-v0; glm::vec3 deltaPos2 = v2-v0; // UV delta glm::vec2 deltaUV1 = uv1-uv0; glm::vec2 deltaUV2 = uv2-uv0;`

We can now use our formula to compute the tangent and the bitangent :

` float r = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV1.y * deltaUV2.x); glm::vec3 tangent = (deltaPos1 * deltaUV2.y - deltaPos2 * deltaUV1.y)*r; glm::vec3 bitangent = (deltaPos2 * deltaUV1.x - deltaPos1 * deltaUV2.x)*r;`

Finally, we fill the *tangents *and *bitangents *buffers. Remember, these buffers are not indexed yet, so each vertex has its own copy.

` // Set the same tangent for all three vertices of the triangle. // They will be merged later, in vboindexer.cpp tangents.push_back(tangent); tangents.push_back(tangent); tangents.push_back(tangent); // Same thing for bitangents bitangents.push_back(bitangent); bitangents.push_back(bitangent); bitangents.push_back(bitangent); }`

## Indexing

Indexing our VBO is very similar to what we used to do, but there is a subtle difference.

If we find a similar vertex (same position, same normal, same texture coordinates), we don’t want to use its tangent and bitangent too ; on the contrary, we want to average them. So let’s modify our old code a bit :

` // Try to find a similar vertex in out_XXXX unsigned int index; bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i], out_vertices, out_uvs, out_normals, index); if ( found ){ // A similar vertex is already in the VBO, use it instead ! out_indices.push_back( index ); // Average the tangents and the bitangents out_tangents[index] += in_tangents[i]; out_bitangents[index] += in_bitangents[i]; }else{ // If not, it needs to be added in the output data. // Do as usual [...] }`

Note that we don’t normalize anything here. This is actually handy, because this way, small triangles, which have smaller tangent and bitangent vectors, will have a weaker effect on the final vectors than big triangles (which contribute more to the final shape).

## Additional buffers & uniforms

We need two new buffers : one for the tangents, and one for the bitangents :

` GLuint tangentbuffer; glGenBuffers(1, &tangentbuffer); glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer); glBufferData(GL_ARRAY_BUFFER, indexed_tangents.size() * sizeof(glm::vec3), &indexed_tangents[0], GL_STATIC_DRAW); GLuint bitangentbuffer; glGenBuffers(1, &bitangentbuffer); glBindBuffer(GL_ARRAY_BUFFER, bitangentbuffer); glBufferData(GL_ARRAY_BUFFER, indexed_bitangents.size() * sizeof(glm::vec3), &indexed_bitangents[0], GL_STATIC_DRAW);`

We also need a new uniform for our new normal texture :

` [...] GLuint NormalTexture = loadTGA_glfw("normal.tga"); [...] GLuint NormalTextureID = glGetUniformLocation(programID, "NormalTextureSampler");`

And one for the 3x3 ModelView matrix. This is strictly speaking not necessary, but it’s easier ; more about this later. We just need the 3x3 upper-left part because we will multiply directions, so we can drop the translation part.

` GLuint ModelView3x3MatrixID = glGetUniformLocation(programID, "MV3x3");`

So the full drawing code becomes :

` // Clear the screen glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use our shader glUseProgram(programID); // Compute the MVP matrix from keyboard and mouse input computeMatricesFromInputs(); glm::mat4 ProjectionMatrix = getProjectionMatrix(); glm::mat4 ViewMatrix = getViewMatrix(); glm::mat4 ModelMatrix = glm::mat4(1.0); glm::mat4 ModelViewMatrix = ViewMatrix * ModelMatrix; glm::mat3 ModelView3x3Matrix = glm::mat3(ModelViewMatrix); // Take the upper-left part of ModelViewMatrix glm::mat4 MVP = ProjectionMatrix * ViewMatrix * ModelMatrix; // Send our transformation to the currently bound shader, // in the "MVP" uniform glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]); glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &ModelMatrix[0][0]); glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]); glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]); glUniformMatrix3fv(ModelView3x3MatrixID, 1, GL_FALSE, &ModelView3x3Matrix[0][0]); glm::vec3 lightPos = glm::vec3(0,0,4); glUniform3f(LightID, lightPos.x, lightPos.y, lightPos.z); // Bind our diffuse texture in Texture Unit 0 glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, DiffuseTexture); // Set our "DiffuseTextureSampler" sampler to user Texture Unit 0 glUniform1i(DiffuseTextureID, 0); // Bind our normal texture in Texture Unit 1 glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, NormalTexture); // Set our "Normal TextureSampler" sampler to user Texture Unit 0 glUniform1i(NormalTextureID, 1); // 1rst attribute buffer : vertices glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); glVertexAttribPointer( 0, // attribute 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); // 2nd attribute buffer : UVs glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER, uvbuffer); glVertexAttribPointer( 1, // attribute 2, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); // 3rd attribute buffer : normals glEnableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, normalbuffer); glVertexAttribPointer( 2, // attribute 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); // 4th attribute buffer : tangents glEnableVertexAttribArray(3); glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer); glVertexAttribPointer( 3, // attribute 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); // 5th attribute buffer : bitangents glEnableVertexAttribArray(4); glBindBuffer(GL_ARRAY_BUFFER, bitangentbuffer); glVertexAttribPointer( 4, // attribute 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); // Index buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer); // Draw the triangles ! glDrawElements( GL_TRIANGLES, // mode indices.size(), // count GL_UNSIGNED_INT, // type (void*)0 // element array buffer offset ); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); glDisableVertexAttribArray(4); // Swap buffers glfwSwapBuffers();`

## Vertex shader

As said before, we’ll do everything in camera space, because it’s simpler to get the fragment’s position in this space. This is why we multiply our T,B,N vectors with the ModelView matrix.

` vertexNormal_cameraspace = MV3x3 * normalize(vertexNormal_modelspace); vertexTangent_cameraspace = MV3x3 * normalize(vertexTangent_modelspace); vertexBitangent_cameraspace = MV3x3 * normalize(vertexBitangent_modelspace);`

These three vector define the TBN matrix, which is constructed this way :

` mat3 TBN = transpose(mat3( vertexTangent_cameraspace, vertexBitangent_cameraspace, vertexNormal_cameraspace )); // You can use dot products instead of building this matrix and transposing it. See References for details.`

This matrix goes from camera space to tangent space (The same matrix, but with XXX_modelspace instead, would go from model space to tangent space). We can use it to compute the light direction and the eye direction, in tangent space :

` LightDirection_tangentspace = TBN * LightDirection_cameraspace; EyeDirection_tangentspace = TBN * EyeDirection_cameraspace;`

## Fragment shader

Our normal, in tangent space, is really straightforward to get : it’s our texture :

` // Local normal, in tangent space vec3 TextureNormal_tangentspace = normalize(texture( NormalTextureSampler, UV ).rgb*2.0 - 1.0);`

So we’ve got everything we need now. Diffuse lighting uses *clamp( dot( n,l ), 0,1 )*, with n and l expressed in tangent space (it doesn’t matter in which space you make your dot and cross products; the important thing is that n and l are both expressed in the same space). Specular lighting uses *clamp( dot( E,R ), 0,1 )*, again with E and R expressed in tangent space. Yay !

Here is our result so far. You can notice that :

- The bricks look bumpy because we have lots of variations in the normals
- Cement looks flat because the normal texture is uniformly blue

## Orthogonalization

In our vertex shader we took the transpose instead of the inverse because it’s faster. But it only works if the space that the matrix represents is orthogonal, which is not yet the case. Luckily, this is very easy to fix : we just have to make the tangent perpendicular to the normal at he end of computeTangentBasis() :

`t = glm::normalize(t - n * glm::dot(n, t));`

This formula may be hard to grasp, so a little schema might help :

n and t are almost perpendicular, so we “push” t in the direction of -n by a factor of dot(n,t)

Here’s a little applet that explains it too (Use only 2 vectors).

## Handedness

You usually don’t have to worry about that, but in some cases, when you use symmetric models, UVs are oriented in the wrong way, and your T has the wrong orientation.

To check whether it must be inverted or not, the check is simple : TBN must form a right-handed coordinate system, i.e. cross(n,t) must have the same orientation than b.

In mathematics, “Vector A has the same orientation as Vector B” translates as dot(A,B)>0, so we need to check if dot( cross(n,t) , b ) > 0.

If it’s false, just invert t :

`if (glm::dot(glm::cross(n, t), b) < 0.0f){ t = t * -1.0f; }`

This is also done for each vertex at the end of computeTangentBasis().

## Specular texture

Just for fun, I added a specular texture to the code. It looks like this :

and is used instead of the simple “vec3(0.3,0.3,0.3)” grey that we used as specular color.

Notice that now, cement is always black : the texture says that it has no specular component.

The real aim of this website is that you DON’T use immediate mode, which is deprecated, slow, and problematic in many aspects.

However, it also happens to be really handy for debugging :

Here we visualize our tangent space with lines drawn in immediate mode.

For this, you need to abandon the 3.3 core profile :

`glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);`

then give our matrices to OpenGL’s old-school pipeline (you can write another shader too, but it’s simpler this way, and you’re hacking anyway) :

`glMatrixMode(GL_PROJECTION);glLoadMatrixf((const GLfloat*)&ProjectionMatrix[0]);glMatrixMode(GL_MODELVIEW);glm::mat4 MV = ViewMatrix * ModelMatrix;glLoadMatrixf((const GLfloat*)&MV[0]);`

Disable shaders :

`glUseProgram(0);`

And draw your lines (in this case, normals, normalized and multiplied by 0.1, and applied at the correct vertex) :

`glColor3f(0,0,1);glBegin(GL_LINES);for (int i=0; i<indices.size(); i++){ glm::vec3 p = indexed_vertices[indices[i]]; glVertex3fv(&p.x); glm::vec3 o = glm::normalize(indexed_normals[indices[i]]); p+=o*0.1f; glVertex3fv(&p.x);}glEnd();`

Remember : don’t use immediate mode in real world ! Only for debugging ! And don’t forget to re-enable the core profile afterwards, it will make sure that you don’t do such things.

## Debugging with colors

When debugging, it can be useful to visualize the value of a vector. The easiest way to do this is to write it on the framebuffer instead of the actual colour. For instance, let’s visualize LightDirection_tangentspace :

`color.xyz = LightDirection_tangentspace;`

This means :

- On the right part of the cylinder, the light (represented by the small white line) is UP (in tangent space). In other words, the light is in the direction of the normal of the triangles.
- On the middle part of the cylinder, the light is in the direction of the tangent (towards +X)

A few tips :

- Depending on what you’re trying to visualize, you may want to normalize it.
- If you can’t make sense of what you’re seeing, visualize all components separately by forcing for instance green and blue to 0.
- Avoid messing with alpha, it’s too complicated :)
- If you want to visualize negative value, you can use the same trick that our normal textures use : visualize (v+1.0)/2.0 instead, so that black means -1 and full color means +1. It’s hard to understand what you see, though.

## Debugging with variable names

As already stated before, it’s crucial to exactly know in which space your vectors are. Don’t take the dot product of a vector in camera space and a vector in model space.

Appending the space of each vector in their names (“…_modelspace”) helps fixing math bugs tremendously.

## How to create a normal map

Created by James O’Hare. Click to enlarge.

- Normalize the vectors in indexVBO_TBN before the addition and see what it does.
- Visualize other vectors (for instance, EyeDirection_tangentspace) in color mode, and try to make sense of what you see

- Crazybump , a great tool to make normal maps. Not free.
- Nvidia’s photoshop plugin. Free, but photoshop isn’t…
- Make your own normal maps out of several photos
- Make your own normal maps out of one photo
- Some more info on matrix transpose

## FAQs

### What is the formula for normal mapping? ›

Normal Map Compression

After the coordinate expansion from 0..1 to the -1..1 range, the z component can be computed in the shader with this formula: **z = sqrt(1 - x*x + y*y)** . This makes it possible to use two-channel textures (2 bytes per texel) to store normal maps.

**Why is my normal map blue? ›**

A normal map is an RGB texture, where each pixel represents the difference in direction the surface should appear to be facing, relative to its un-modified surface normal. These textures tend to have a bluey-purple tinge, **because of the way the vector is stored in the RGB values**.

**What is the range of normal mapping? ›**

A normal is a vector in 3D space. The values of each component of the vector can range from **-1 to 1**. When looking at a normal map, up is +Y, down is -Y, left is -X and right is +X.

**How do you calculate normal? ›**

The normal to the plane is given by the cross product **n=(r−b)×(s−b)**.

**How do you calculate mapping function? ›**

Mapping or Functions:

If every element of set A is associated with unique element of set B. The function 'f' from A to B is denoted by f : A → B. **If f is a function from A to B and x ∈ A, then f(x) ∈ B where f(x) is called the image of x under f and x is called the pre image of f(x) under 'f'**.

**Why is my normal map black? ›**

**Any surface not facing the light** in that case will be black. The same is true for any normal mapped surface where the normal map is altering the surface direction to face away from the light. If you don't want it to go black, you might want to have a less extreme normal map.

**What is the RGB value for normal map? ›**

So, for a level surface, the normal vector would be (0, 0, 1.0) and the corresponding color is RGB**(128, 128, 255) or #8080FF**. This is the blue color predominant in many normal maps.

**What do normal map colors mean? ›**

A normal map is an RGB texture, where **each pixel represents the difference in direction the surface should appear to be facing, relative to its un-modified surface normal**. These textures tend to have a bluey-purple tinge, because of the way the vector is stored in the RGB values.

**When should I use normal maps? ›**

A normal map is a good way to make a 3D object appear to have more detail. Normal mapping is best used **to add smaller details like wrinkles, bolts, and other details that need lots of triangles to model**. The usage of normal mapping can depend on the type and art direction of a game.

**What is the purpose of a normal map? ›**

In 3D computer graphics, normal mapping, or Dot3 bump mapping, is a texture mapping technique used for **faking the lighting of bumps and dents** – an implementation of bump mapping. It is used to add details without using more polygons.

### What is a normal map nursing? ›

What is a normal MAP? In general, most people need a MAP of at least 60 mm Hg (millimeters of mercury) or greater to ensure enough blood flow to vital organs, such as the heart, brain, and kidneys. Doctors usually consider anything **between 70 and 100 mm Hg** to be normal.

**What is Z in normal distribution? ›**

For the standard normal distribution, the number of standard deviations above or below the mean is the Z score. The total area under the standard normal distribution curve is 1.

**What is a 1 normal solution? ›**

A 1N solution contains **1 gram-equivalent weight of solute per liter of solution**. Expressing gram-equivalent weight includes the consideration of the solute's valence. The valence is a reflection of the combining power of an element often as measured by the number of hydrogen atoms it can displace or combine with.

**What is normality example? ›**

Let's take an example of how to calculate normality: **If 13 g of N2O4 is present in 500 ml of solution**. Find normality. We are given a mass of N2O4 = 0.65 g, and volume = 500 ml = 0.5 l. We know that normality, N = no of gram equivalent/volume of solution in liters.

**What is map calculator? ›**

This MAP calculator (Mean Arterial Pressure calculator) **finds the average arterial blood pressure during a single cardiac cycle**. Its value is derived from a patient's systolic and diastolic blood pressures.

**What is mapping method in math? ›**

mapping, **any prescribed way of assigning to each object in one set a particular object in another (or the same) set**. Mapping applies to any set: a collection of objects, such as all whole numbers, all the points on a line, or all those inside a circle.

**Why is my normal map purple? ›**

A normal map is an RGB texture, where each pixel represents the difference in direction the surface should appear to be facing, relative to its un-modified surface normal. These textures tend to have a bluey-purple tinge, **because of the way the vector is stored in the RGB values**.

**What does dark green mean on a map? ›**

Dark green usually represents **low-lying land**, with lighter shades of green used for higher elevations. In the next higher elevations, physical maps often use a palette of light brown to dark brown.

**Why are my normal maps green? ›**

The green normal map means that **those pixels are perturbed to be facing downwards**, despite the faces not being downward facing, that's now normal maps work. This is your bevel. Those green pixela are facing straight down.

**What makes a successful map? ›**

A good map is a map that **clearly communicates its message to the reader**. It should be easy to interpret map elements based on the symbology and graphics used, get oriented, and determine things such as distances and directions.

### How do I fix map accuracy? ›

...

**Turn on high accuracy mode**

- On your Android phone or tablet, open the Settings app .
- Tap Location.
- At the top, switch location on.
- Tap Mode. High accuracy.

**How do you improve map performance? ›**

**Procedure**

- Scale dependency on layers and labels.
- Remove unnecessary layers or data frames.
- Use annotation instead of labels.
- Avoid complex symbology and label effects.
- Use the ESRI_Optimized style set for defining simple line and fill symbols. ...
- Use a map cache to improve rendering performance.

**Is normal map sRGB or raw? ›**

Normal map appears with seams or with incorrect lighting

This is, **by default, sRGB**. You can set the Color Space to Raw for each normal map in its respective File Attribute Editor. See Specify the color space for textures and other image inputs.

**WHY IS 255 in RGB? ›**

RGB - Three Numbers

one each for red, green, and blue. In RGB, a color is defined as a mixture of pure red, green, and blue lights of various strengths. Each of the red, green and blue light levels is encoded as a number in the range 0.. 255, with 0 meaning zero light and 255 meaning **maximum light**.

**What color value is a normal map flat? ›**

The result of reading a flat texel from a normal map should be a z value of 1 and the x and y values as 0. Converting these values (0, 0, 1) into the colorspace of a normal map results in the color (**0.5, 0.5, 1**). This is why most normal maps appear bluish.

**Why is my normal map pink? ›**

**The BC5 compression method removes the blue channel of your normal map and leaves only the red and green ones which would make the normal map look pink**.

**Is normal map pink or blue? ›**

**Only tangent space normal maps are primarily blue**. This is because the colour blue represents a normal of (0,0,1) which would be an unchanged normal when the triangle lies in the plane x and y, i.e. perpendicular to the surface.

**What are the six colors on a map? ›**

**Page 1**

- U.S. Geological Survey (USGS) topo- graphic maps are printed using up to six colors (black, blue, green, red, brown, and purple). ...
- It is possible to order a separate, full- scale film negative or positive that shows in black and white all the features printed in a given color on a particular map.

**When making a map What is the first thing you should consider? ›**

Before making a map, cartographers decide what area they want to display and what type of information they want to present. They consider **the needs of their audience and the purpose of the map**. These decisions determine what kind of projection and scale they need, and what sorts of details will be included.

**What is the best type of map to use? ›**

#1.

The Mercator projection was created in 1569 by Gerardus Mercator for navigational purposes and became popular because it shows relative sizes accurately and is useful for navigation. The idea behind it is that straight lines drawn on this map are equivalent to great circles of longitude on Earth.

### What is the most accurate type of map to use? ›

**AuthaGraph**. The AuthaGraphy projection was created by Japanese architect Hajime Narukawa in 1999. It is considered the most accurate projection in the mapping world for its way of showing relative areas of landmasses and oceans with very little distortion of shapes.

**What are the 4 importance of map? ›**

Maps represent the real world on a much smaller scale. They help you travel from one location to another. They help you organize information. They help you figure out where you are and how to get where you want to go.

**What is the mean arterial pressure of 120 80? ›**

In physiological blood pressure values (120/80 mmHg) the mean arterial pressure value is **93,3 mmHg**.

**How do you calculate a MAP quizlet? ›**

-Mean arterial pressure (MAP) is calculated by **dividing the pulse pressure by three and adding the result to the diastolic pressure**. The pulse pressure is the difference between the systolic and diastolic pressures.

**What is the normal value for mean arterial pressure? ›**

Mean arterial pressure

The reference range is **70-100 mm Hg**.

**Is data mapping hard? ›**

Nonetheless, data mapping is **complex and challenging**. Many companies start data mapping projects only to abandon them before completion.

**What are the 4 types of map data? ›**

There are many types in map visualization, such as **administrative maps, heatmaps, statistical maps, trajectory maps, bubble maps**, etc.

**What is the most common method of mapping? ›**

**The choropleth** is likely the most common type of thematic map because published statistical data (from government or other sources) is generally aggregated into well-known geographic units, such as countries, states, provinces, and counties, and thus they are relatively easy to create using GIS, spreadsheets, or other ...

**How do you smooth out a map? ›**

**The Ironing Method**

Being careful not to touch your hot iron directly to the paper iron over the slightly damp cloth. The steam from the moisture in the cloth combined with hot iron pushing the paper on to the boar will help smooth out the crease. Repeat this process over the entire map. That's it!

**How do you map a texture? ›**

To get texture mapping working you need to do three things: load a texture into OpenGL, supply texture coordinates with the vertices (to map the texture to them) and perform a sampling operation from the texture using the texture coordinates in order to get the pixel color.

### How do you calculate map reading? ›

**To calculate distance on a map you must do the following:**

- Measure distance between two points on a map in cm or mm.
- Multiply this by the scale of the map and divide by 100 000 if you used centimetres or by 1000 000 if you used millimetres to get kilometres.

**How does normal mapping work? ›**

A normal map **uses RGB information that corresponds directly with the X, Y and Z axis in 3D space**. This RGB information tells the 3D application the exact direction of the surface normals are oriented in for each and every polygon.

**What is a normal map and what is it used for? ›**

Normal maps are a type of Bump Map. They are **a special kind of texture that allow you to add surface detail such as bumps, grooves, and scratches to a model which catch the light as if they are represented by real geometry**.

**How can I improve my map reading score? ›**

**Here are some strategies designed to improve your child's confidence in the MAP skills that will be tested on the exam.**

- Take the NWEA Practice Test.
- Consider Online Tutoring.
- Make math relevant and fun for your child.

**What are the 3 types of scales on a map? ›**

There are three types of scales commonly used on maps: **written or verbal scale, a graphic scale, or a fractional scale**. A written or verbal scale uses words to describe the relationship between the map and the landscape it depicts such as one inch represents one mile.

**Why is it called normal map? ›**

A normal map is **an image that stores a direction at each pixel**. These directions are called normals. The red, green, and blue channels of the image are used to control the direction of each pixel's normal. A normal map is commonly used to fake high-resolution details on a low-resolution model.

**What is the base color to normal map? ›**

The base color of a normal map — where all normals are “normal” (orthogonal to the face) — is **(0.5, 0.5, 1)** . This is an attractive color but was not chosen arbitrarily. RGB colors have values between 0 and 1, whereas a model's normal values are between -1 and 1.

**How do you make an accurate map scale? ›**

**Creating a Scale Map**

- Find a map of an area you want to use.
- Find both the actual and measured distances of two points on your map.
- Divide the actual distance by the measured distance on the map for your scale.
- Place your scale numbers on the map.