I've been trying for some time to successfully get some bump mapping going on a cubemapped sphere.

I have a procedurally generated height-cubemap. With this I colourize to create a diffuse map.

Now, I'm creating a normalmap based on the code from "Mathematics for 3D Game Programming and Computer Graphics, Third Edition", which appears to work really well.

The problem I've had to date is Tangent-space normal map. I just cannot find a way to generate the normal-map and generate the tangent and binormal on my vertices without any graphical artifacts.

http://gamedev.stackexchange.com/que...ping-a-cubemap

http://stackoverflow.com/questions/3...ts-my-tangents

If anyone has a solution for that I'd love to know it.

I've basically given up on this for now though. What I'm trying to do now is generate a object-space normal map for my cubemapped sphere. This seems like it would be easier to generate and fool-proof to use. But so far I'm having trouble.

My normal map looks like this:

So I think there's clearly something wrong in it's generation. Here's the code that generates it.

Code :float scale = 15.0; std::deque<glm::vec4> normalMap(textureSize*textureSize); for(int x = 0; x < textureSize; ++x) { for(int y = 0; y < textureSize; ++y) { // center point int i11 = utils::math::get_1d_array_index_from_2d(x,y,textureSize); float v11 = cubeFacesHeight[i][i11].r; // to the left int i01 = utils::math::get_1d_array_index_from_2d(std::max(x-1,0),y,textureSize); float v01 = cubeFacesHeight[i][i01].r; // to the right int i21 = utils::math::get_1d_array_index_from_2d(std::min(x+1,textureSize-1),y,textureSize); float v21 = cubeFacesHeight[i][i21].r; // to the top int i10 = utils::math::get_1d_array_index_from_2d(x,std::max(y-1,0),textureSize); float v10 = cubeFacesHeight[i][i10].r; // and now the bottom int i12 = utils::math::get_1d_array_index_from_2d(x,std::min(y+1,textureSize-1),textureSize); float v12 = cubeFacesHeight[i][i12].r; glm::vec3 S = glm::vec3(1, 0, scale * v21 - scale * v01); glm::vec3 T = glm::vec3(0, 1, scale * v12 - scale * v10); glm::vec3 N = (glm::vec3(-S.z,-T.z,1) / std::sqrt(S.z*S.z + T.z*T.z + 1)); glm::vec3 originalDirection; if(i == POSITIVE_X) originalDirection = glm::vec3(textureSize,-y,-x); else if(i == NEGATIVE_X) originalDirection = glm::vec3(-textureSize,-x,-y); else if(i == POSITIVE_Y) originalDirection = glm::vec3(-x,-textureSize,-y); else if(i == NEGATIVE_Y) originalDirection = glm::vec3(-y,textureSize,-x); else if(i == POSITIVE_Z) originalDirection = glm::vec3(-y,-x,textureSize); else if(i == NEGATIVE_Z) originalDirection = glm::vec3(-y,-x,-textureSize); glm::vec3 o = originalDirection; glm::vec3 a = N; glm::vec3 ax = glm::normalize(o) * (glm::dot(a,glm::normalize(o))); N = ax; N.x = (N.x+1.0)/2.0; N.y = (N.y+1.0)/2.0; N.z = (N.z+1.0)/2.0; normalMap[utils::math::get_1d_array_index_from_2d(x,y,textureSize)] = glm::vec4(N.x,N.y,N.z,v11); } } for(int x = 0; x < textureSize; ++x) { for(int y = 0; y < textureSize; ++y) { cubeFacesHeight[i][utils::math::get_1d_array_index_from_2d(x,y,textureSize)] = normalMap[utils::math::get_1d_array_index_from_2d(x,y,textureSize)]; } }

cubeFacesHeight is 6 faces of height values.

What I'm attempting to do is use the value originally given to N, as this is the normal map as though it was the surface of a plane. Then, I'm attempting to apply this to the original direction vector of each point (which is also the normal vector). I think it's that application, where ax is set that it the problem.

I then implement it in my Fragment shader like so:

Code :#version 400 layout (location = 0) out vec4 color; struct Material { bool useMaps; samplerCube diffuse; samplerCube specular; samplerCube normal; float shininess; vec4 color1; vec4 color2; }; struct PointLight { bool active; vec3 position; vec3 ambient; vec3 diffuse; vec3 specular; float constant; float linear; float quadratic; }; uniform Material uMaterial; uniform mat4 model; uniform mat4 view; uniform mat4 projection; in vec3 ex_normal; in vec3 ex_positionCameraSpace; in vec3 ex_originalPosition; in vec3 ex_positionWorldSpace; in vec4 ex_positionLightSpace; in PointLight ex_light; /* ********************* Calculates the color when using a point light. Uses shadow map ********************* */ vec3 CalcPointLight(PointLight light, Material mat, vec3 n, vec3 fragPos, vec3 originalPos, vec3 viewDir) { /* just lighting stuff that doesn't matter */ vec3 lightDir = normalize(fragPos - light.position); vec3 reflectDir = normalize(reflect(lightDir, n)); float specularFactor = pow(dot(viewDir,reflectDir), mat.shininess); if(specularFactor > 0 && diffuseFactor > 0) specularColor = light.specular * specularFactor * specularMat; /*more lighting stuff*/ } vec3 get_normal(vec3 SRT) { vec3 map = texture(uMaterial.normal,SRT).rgb * 2.0 - 1.0; return mat3(transpose(inverse(view * model))) * map; } void main(void) { vec3 viewDir = normalize(-ex_positionCameraSpace); vec3 n = get_normal(glm::normalize(ex_originalPosition)); vec3 result = CalcPointLight(ex_light,uMaterial,n,ex_positionCameraSpace, ex_positionWorldSpace,viewDir); color = vec4(result,1.0); }

Considering that my Fragment shader works fine without sampling the normal map, and instead using "ex_originalPosition", I don't think it's the problem. I could just use some help in generating the object space normal map.