BumMapping extensions & MacOS

Bonjour,
J'ai mis en place le bumpMapping dot product issu du tutorial
Gestion Dynamique de la lumière.
Mon système ne supporte pas les extensions :
GL_EXT_texture3D, GL_ARB_texture_env_dot3 et GL_ARB_texture_cube_map.

Apres verification les 2 dernières sont tout de meme présentes.
Malgré l'absence de la première j'ai le rendu suivant :
http://imageshack.us/a/img825/7438/c...0121012142.png

Pouvez m'expliquez si ce rendu est du à l'absence de GL_EXT_texture3D ?
Existe t il une solution pour contourner cette absence et ainsi mettre en place cette technique ?
Pourquoi les 2 extensions ne sont pas trouvées par JOGL ?

D'avance merci :)

Bonjour,

L'extension GL_EXT_texture3D doit servir pour faire du shadow mapping (je ne vois pas à quoi il servirai pour le bump mapping).

Sinon, l'implémentation des extensions dépend des constructeurs de cartes graphiques. Ils peuvent ou peuvent ne pas mettre les extensions. Du coup, il arrive que certaine machine n'ont pas les extensions nécessaires. La mise à jour des pilotes peut aider, quelque fois.

Ok ok pour l'extension GL_EXT_texture3D, j'ai suivi le tutoriel
http://mdeverdelhan.developpez.com/t.../dynamiclight/

Autrement comment expliquer pour les 2 autres extensions non détectées mais bien présentes ? Je ne comprend pas pourquoi j'obtiens le rendu en screenShot

Je post le code JOGL

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441

public class LessonDynamicLight5 {   private static Logger logger = Logger.getLogger(LessonDynamicLight5.class .getName());   boolean[] keys = new boolean[256];   // private SolidForm form; Map<String, Mesh> meshs; private Renderer renderer;   // TextureLoader textureLoader; // IDs of the textures int textureId; int normalMapId; int lightmap; int normalCubeMapId;   // la couleur ambiante de l'affichage Color ambiant; Light redLight; Light blueLight; Light whiteLight;   float angleRotationY = 0; float cameraHeight = 8; float whiteAngle = 0; float whiteHeight = 3; float whiteDistance = 4; boolean useWhiteLight = false; boolean drawLocalSpace = false;   public void init() { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   gl.setSwapInterval(1); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // gl.glColor3f(1.0f, 0.0f, 0.0f); gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST); gl.glClearDepth(1.0); // gl.glLineWidth(2); gl.glEnable(gl.GL_DEPTH_TEST); gl.glDepthFunc(gl.GL_LEQUAL);   initExtensions(); initTextures(); // initCallback(); generateSphereMap(64);   // form = FormFactory.getSolidForm("scene.obj"); // form.init(); try { this.meshs = DataAssemblerFactory .getMeshOBJ("objets/obj/scene.obj"); for (Map.Entry<String, Mesh> entry : meshs.entrySet()) { Mesh mesh = entry.getValue(); mesh.init(); } } catch (FichierIntrouvableException e) { logger.error(e.getMessage(), e); System.exit(0); } catch (FileParserFormatNotSupportedException e) { logger.error(e.getMessage(), e); System.exit(0); } catch (Exception e) { logger.error(e.getMessage(), e); } renderer = new DirectRenderer(); // render.init(meshs);   ambiant = new Color(0.1f, 0.1f, 0.1f);   try { redLight = LightManager.getLightManager().getNewLight(); redLight.setPosition(5, 5, 0); redLight.setColorAmbient(Color.ROUGE); redLight.lightOn(); // redLight.setRadius(15);   blueLight = LightManager.getLightManager().getNewLight(); blueLight.setPosition(-5, 5, 0); blueLight.setColorAmbient(Color.BLEU); // blueLight.setRadius(20);   whiteLight = LightManager.getLightManager().getNewLight(); whiteLight.setPosition((float) Math.cos(whiteAngle * (3.141 / 180)) * whiteDistance, whiteHeight, (float) Math.sin(whiteAngle * (3.141 / 180)) * whiteDistance); whiteLight.setColorAmbient(Color.BLANC); // whiteLight.setRadius(10); } catch (MaxNumberOfLightException e) { // TODO Auto-generated catch block e.printStackTrace(); } }   public void render() { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl(); GLUgl2 glu = GLContextManager.getInstance().getOpenGLContext().getGlu();   gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT); gl.glLoadIdentity(); float posX = (float) (Math.cos(angleRotationY * (3.141 / 180)) * 8); float posZ = (float) (Math.sin(angleRotationY * (3.141 / 180)) * 8); glu.gluLookAt(posX, cameraHeight, posZ, 0, 0, 0, 0, 1, 0);   // on configure la premiere unité de texture : elle contient la texture // de la scene gl.glActiveTexture(gl.GL_TEXTURE0); gl.glEnable(gl.GL_TEXTURE_2D); gl.glBindTexture(gl.GL_TEXTURE_2D, textureId); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);   // on effectue le rendu de la lumiere ambiante gl.glColor3f(ambiant.getR(), ambiant.getG(), ambiant.getB()); // on dessine le model de base for (Map.Entry<String, Mesh> entry : meshs.entrySet()) { Mesh mesh = entry.getValue(); renderer.init(mesh); renderer.render(); }   if (drawLocalSpace) { gl.glDisable(gl.GL_TEXTURE_2D); for (Map.Entry<String, Mesh> entry : meshs.entrySet()) { Mesh mesh = entry.getValue(); mesh.drawLocalSpace(); // model->drawLocalSpace(); } }   // on doit reconfigurer les unité de textures // la premiere unité contient la cube map de normalisation gl.glActiveTexture(gl.GL_TEXTURE0); gl.glEnable(gl.GL_TEXTURE_CUBE_MAP); gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, normalCubeMapId); // on souhaite que la cube map remplace la couleur des vertex gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_REPLACE);   // la deuxieme unite de texture contient la normal map gl.glActiveTexture(gl.GL_TEXTURE1); gl.glEnable(gl.GL_TEXTURE_2D); gl.glBindTexture(gl.GL_TEXTURE_2D, normalMapId); // on configure la normal map pour qu'elle effectue la passe de DOT3 gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_COMBINE); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_RGB_SCALE, 1); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_COMBINE_RGB, gl.GL_DOT3_RGB); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_SOURCE0_RGB, gl.GL_PREVIOUS); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_SOURCE1_RGB, gl.GL_TEXTURE); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_OPERAND0_RGB, gl.GL_SRC_COLOR); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_OPERAND1_RGB, gl.GL_SRC_COLOR);   // la troisieme contient la texture d'attenuation gl.glActiveTexture(gl.GL_TEXTURE2); gl.glEnable(gl.GL_TEXTURE_3D); gl.glBindTexture(gl.GL_TEXTURE_3D, lightmap); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE); // la troisieme contient la texture de diffuse gl.glActiveTexture(gl.GL_TEXTURE3); gl.glEnable(gl.GL_TEXTURE_2D); gl.glBindTexture(gl.GL_TEXTURE_2D, textureId); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);   // on doit activer le blending additif pour pouvoir utiliser ce mode // d'eclairage gl.glEnable(gl.GL_BLEND); gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE); gl.glDepthMask(false);   // on ajoute nos lumieres // addLightCubeMap(redLight); // addLightCubeMap(blueLight); // if (useWhiteLight) { // addLightCubeMap(whiteLight); // } for (Map.Entry<String, Mesh> entry : meshs.entrySet()) { Mesh mesh = entry.getValue(); mesh.addLightCubeMap(redLight); mesh.addLightCubeMap(blueLight); if (useWhiteLight) { mesh.addLightCubeMap(whiteLight); } }   // on desactive la quatrieme unité de texture gl.glActiveTexture(gl.GL_TEXTURE3); gl.glDisable(gl.GL_TEXTURE_2D); // on desactive la troisieme unité de texture gl.glActiveTexture(gl.GL_TEXTURE2); gl.glDisable(gl.GL_TEXTURE_3D); // on desactive la seconde unité de texture gl.glActiveTexture(gl.GL_TEXTURE1); gl.glDisable(gl.GL_TEXTURE_2D); // on desactive la premiere unité de texture gl.glActiveTexture(gl.GL_TEXTURE0); gl.glDisable(gl.GL_TEXTURE_CUBE_MAP);   gl.glActiveTexture(gl.GL_TEXTURE0); gl.glEnable(gl.GL_TEXTURE_3D); gl.glBindTexture(gl.GL_TEXTURE_3D, lightmap); gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);   gl.glBlendFunc(gl.GL_DST_COLOR, gl.GL_ONE); // model->renderColor(redLight); // model->renderColor(blueLight); // if (useWhiteLight) { // model->renderColor(whiteLight); // } for (Map.Entry<String, Mesh> entry : meshs.entrySet()) { Mesh mesh = entry.getValue(); mesh.renderColor(redLight); mesh.renderColor(blueLight); if (useWhiteLight) { mesh.renderColor(whiteLight); } }   gl.glActiveTexture(gl.GL_TEXTURE0); gl.glDisable(gl.GL_TEXTURE_3D);   gl.glDepthMask(true); gl.glDisable(gl.GL_BLEND);   // on affiche les lumieres gl.glPointSize(5.0f); gl.glBegin(gl.GL_POINTS); gl.glColor3f(redLight.getColorAmbient().getR(), redLight .getColorAmbient().getG(), redLight.getColorAmbient().getB()); gl.glVertex3f(redLight.getPosition().getX(), redLight.getPosition() .getY(), redLight.getPosition().getZ()); gl.glColor3f(blueLight.getColorAmbient().getR(), blueLight .getColorAmbient().getG(), blueLight.getColorAmbient().getB()); gl.glVertex3f(blueLight.getPosition().getX(), blueLight.getPosition() .getY(), blueLight.getPosition().getZ()); gl.glColor3f(whiteLight.getColorAmbient().getR(), whiteLight .getColorAmbient().getG(), whiteLight.getColorAmbient().getB()); gl.glVertex3f(whiteLight.getPosition().getX(), whiteLight.getPosition() .getY(), whiteLight.getPosition().getZ()); gl.glEnd(); gl.glPointSize(1.0f);   // gl.glutSwapBuffers(); gl.glFlush(); }   public boolean[] getKeys() { return this.keys; }   public void setKeyValue(int key, boolean value) { this.keys[key] = value; }   private void initExtensions() { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   if (!gl.isExtensionAvailable("GL_ARB_multitexture")) { logger.error("votre carte ne suporte pas l'extension GL_ARB_multitexture"); System.exit(0); }   boolean functionsOK = gl.isFunctionAvailable("glMultiTexCoord2fARB") && gl.isFunctionAvailable("glMultiTexCoord3fARB") && gl.isFunctionAvailable("glMultiTexCoord4fARB") && gl.isFunctionAvailable("glActiveTextureARB") && gl.isFunctionAvailable("glClientActiveTextureARB");   if (!functionsOK) { logger.error("impossible d'initialiser l'entension GL_ARB_multitexture"); System.exit(0); }   if (!gl.isFunctionAvailable("GL_EXT_texture3D")) { logger.error("votre carte ne suporte pas l'extension GL_EXT_texture3D"); // System.exit(0); }   functionsOK = gl.isFunctionAvailable("glTexImage3DEXT") && gl.isFunctionAvailable("glTexSubImage3DEXT");   if (!functionsOK) { logger.error("impossible d'initialiser l'entension GL_EXT_texture3D"); // System.exit(0); }   if (!gl.isFunctionAvailable("GL_ARB_texture_env_dot3")) { logger.error("votre carte ne suporte pas l'extension GL_ARB_texture_env_dot3"); // System.exit(0); } if (!gl.isFunctionAvailable("GL_ARB_texture_cube_map")) { logger.error("votre carte ne suporte pas l'extension GL_ARB_texture_cube_map"); // System.exit(0); } }   private void initTextures() { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl(); GLUgl2 glu = GLContextManager.getInstance().getOpenGLContext().getGlu();   // textureLoader = new TextureLoader(); // textureLoader.init();   gl.glEnable(gl.GL_TEXTURE_2D);   Texture texture = null; try { texture = TextureManager.getInstance().getTexture("nehe/rock.tga", false); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } // textureLoader.getTexture(gl, "nehe/rock.tga");   // TGA image; if (texture == null) { logger.error("impossible de charger l'image rock.tga"); System.exit(0); } textureId = GLTextureManager.generateID(); // gl.glGenTextures (1, textureId); gl.glBindTexture(gl.GL_TEXTURE_2D, textureId); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT); if (texture.getBpp() == 24) { glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 3, texture.getWidth(), texture.getHeight(), gl.GL_RGB, gl.GL_UNSIGNED_BYTE, texture.getPixels()); } else { glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 4, texture.getWidth(), texture.getHeight(), gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, texture.getPixels()); }   try { texture = TextureManager.getInstance().getTexture( "nehe/normal.tga", false); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } if (texture == null) { logger.error("impossible de charger l'image normal.tga"); System.exit(0); }   normalMapId = GLTextureManager.generateID(); // gl.glGenTextures (1, &normalMapId); gl.glBindTexture(gl.GL_TEXTURE_2D, normalMapId); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT); gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT); if (texture.getBpp() == 24) { glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 3, texture.getWidth(), texture.getHeight(), gl.GL_RGB, gl.GL_UNSIGNED_BYTE, texture.getPixels()); } else { glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 4, texture.getWidth(), texture.getHeight(), gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, texture.getPixels()); }   gl.glDisable(gl.GL_TEXTURE_2D); }   private void generateSphereMap(int size) { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   gl.glEnable(GL2.GL_TEXTURE_3D); if (size < 1) { logger.error("la taille de la texture 3D doit etre superieur à 1\n"); return; }   float[] datas = new float[size * size * size * 3]; // on remplie avec la couleur noir for (int i = 0; i < size * size * size * 3; i++) { datas[i] = 0.0f; }   float length; // la demi largeur de la texture3d en texels float size2 = (float) size / 2.0f; for (float i = 0; i < size; i++) { for (float j = 0; j < size; j++) { for (float k = 0; k < size; k++) { // la demi-largeur moins la distance du centre au texel // courant de la texture. // size2-1 pour éviter l'élairage sur le bord de la texture // mais centre moins brillant length = (float) ((size2 - 1) - Math.sqrt((i - size2) * (i - size2) + (j - size2) * (j - size2) + (k - size2) * (k - size2))); // normalisation dans la plage[0,1] (intensité de la // lumière) length /= size2;   // on stocke la couleur avec son intensité dans le texel datas[(int) i * size * size * 3 + (int) j * size * 3 + (int) k * 3] = length; datas[(int) i * size * size * 3 + (int) j * size * 3 + (int) k * 3 + 1] = length; datas[(int) i * size * size * 3 + (int) j * size * 3 + (int) k * 3 + 2] = length; } } }   // glGenTextures(1,&lightmap); lightmap = GLTextureManager.generateID(); gl.glBindTexture(GL2.GL_TEXTURE_3D, lightmap); gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR); gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE); gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE); gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_R, gl.GL_CLAMP_TO_EDGE); gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);   FloatBuffer dataBuffer = FloatBuffer.wrap(datas); gl.glTexImage3D(gl.GL_TEXTURE_3D, 0, gl.GL_RGB, size, size, size, 0, gl.GL_RGB, gl.GL_FLOAT, dataBuffer);   gl.glDisable(gl.GL_TEXTURE_3D); // delete[] datas; datas = null; dataBuffer = null; } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313

public class Mesh {   private static Logger logger = Logger.getLogger(Mesh.class.getName());   private String name; private List<Face> faces; private Bounds bounds;   private Renderer renderer; private GLTexture texture; private GLTexture textureMap;   private GLBlending blending; private Material material;   // VBO id // private int VBOID;   public Mesh(String name) { this.name = name; this.faces = new ArrayList<Face>();   this.texture = new GLTexture(); this.material = new PlasticWhiteMaterial(); this.blending = new GLBlending(); }   public void init() { this.renderer = RendererFactory.getStructureRenderer(); this.renderer.init(this); }   public void update() {   }   public void render() { GL2 gl2 = GLContextManager.getInstance().getOpenGLContext().getGl();   material.render(gl2); blending.enable(); texture.enabled(gl2); renderer.render(); texture.disable(gl2); blending.disable(); }   public void addLightCubeMap(Light light) { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   Point lightPos = light.getPosition(); gl.glBegin(gl.GL_TRIANGLES); // for (int i = 0; i < nbFaces; i++) { for (Face face : faces) { for (int i = 0; i < 3; i++) { Point point = face.getPoint(i); // int vertexIndex = face.vertexIndex[i]; // on calcule le vecteur lumiere->vertex // on calcule le vecteur vertex->lumiere normalise // Point tempVect = vertex[vertexIndex] - lightPos; Point tempVect = VectorUtil.sub(point, lightPos);   Point t = face.getTangent(i); Point b = face.getBinormal(i); Point n = face.getNormal(i);   Point lightToVertex = new Point(); lightToVertex.setX(VectorUtil.mult(t, tempVect)); lightToVertex.setY(VectorUtil.mult(b, tempVect)); lightToVertex.setZ(VectorUtil.mult(n, tempVect)); // nous avons donc maintenant le vecteur de la lumiere vers le // vertex transformer dans l'espace local du vertex. // on l'envoie en temps que coordonnée de texture pour la cube // map gl.glMultiTexCoord3f(gl.GL_TEXTURE0, lightToVertex.getX(), lightToVertex.getY(), lightToVertex.getZ()); // maintenant, on envoie les coordonner de textures // la seconde unite de texture contient la normal map, ce sont // donc les même coordonnée de textures que // la scene // TexCoord tc = texCoords[face.texCoordIndex[i]]; TexCoord tc = face.getUv(i); gl.glMultiTexCoord2f(gl.GL_TEXTURE1, tc.getU(), tc.getV()); // la troisieme unite de texture contient la texture 3D // d'attenuation, on calcule donc l'eclairage // Point v = vertex[vertexIndex]; Point lightTexCoord = light.computeLighting(point); gl.glMultiTexCoord3f(gl.GL_TEXTURE2, lightTexCoord.getX(), lightTexCoord.getY(), lightTexCoord.getZ()); // la quatrieme unité de texture contient la texture de diffuse, // donc les coordonnée de texture de la scene gl.glMultiTexCoord2f(gl.GL_TEXTURE3, tc.getU(), tc.getV()); gl.glVertex3f(point.getX(), point.getY(), point.getZ()); } } gl.glEnd(); }   public void computeLocalSpace(Face face) { Point point0 = face.getPoint(0); Point point1 = face.getPoint(1); Point point2 = face.getPoint(2);   // on calcule 2 vecteur formant les bord du triangle // le vecteur side0 est celui allant du vertex 0 au vertex 1 // Point side0 = vertex[face.vertexIndex[1]] - // vertex[face.vertexIndex[0]]; Point side0 = VectorUtil.sub(point1, point0); // le vecteur side1 est celui allant du vertex 0 au vertex 2 // Point side1 = vertex[face.vertexIndex[2]] - // vertex[face.vertexIndex[0]]; Point side1 = VectorUtil.sub(point2, point0);   // ici on calcule la normale à la face // side0.cross(side1); Point normal = VectorUtil.cross(side0, side1); // normal.normalise(); VectorUtil.normalise(normal);   // maintenant on calcule les coefficient des tangentes // ces coefficient sont fonction des coordonnée de texture du polygone TexCoord textCoord0 = face.getUv(0); TexCoord textCoord1 = face.getUv(1); TexCoord textCoord2 = face.getUv(2);   // float deltaT0 = texCoords[face.texCoordIndex[1]].v // - texCoords[face.texCoordIndex[0]].v; float deltaT0 = textCoord1.getV() - textCoord0.getV(); // float deltaT1 = texCoords[face.texCoordIndex[2]].v // - texCoords[face.texCoordIndex[0]].v; float deltaT1 = textCoord2.getV() - textCoord0.getV(); // // on effectue la même chose pour la binormal // float deltaB0 = texCoords[face.texCoordIndex[1]].u // - texCoords[face.texCoordIndex[0]].u; float deltaB0 = textCoord1.getU() - textCoord0.getU(); // float deltaB1 = texCoords[face.texCoordIndex[2]].u // - texCoords[face.texCoordIndex[0]].u; float deltaB1 = textCoord2.getU() - textCoord0.getU();   float scale = 1 / ((deltaB0 * deltaT1) - (deltaB1 * deltaT0));   // on calcule la tangente temporaire // Point tmpTangente = ((side0 * deltaT1) - (side1 * deltaT0)) * scale; Point tmpTangente = VectorUtil.multPoint( VectorUtil.sub(VectorUtil.multPoint(side0, deltaT1), VectorUtil.multPoint(side1, deltaT0)), scale); // tmpTangente.normalise(); VectorUtil.normalise(tmpTangente);   // on calcule la binormal temporaire // Point tmpBinormal = ((side0 * (-deltaB1)) + (side1 * deltaB0)) * // scale; Point tmpBinormal = VectorUtil.multPoint(VectorUtil.add( VectorUtil.multPoint(side0, -deltaB1), VectorUtil.multPoint(side1, deltaB0)), scale); // tmpBinormal.normalise(); VectorUtil.normalise(tmpBinormal);   // nous avons donc maintenant les tangente, binormale et normale de la // face. on les additionne à celles deja presente // dans les tableau // tangents[face.vertexIndex[0]] += tmpTangente; // tangents[face.vertexIndex[1]] += tmpTangente; // tangents[face.vertexIndex[2]] += tmpTangente; Point tangent0 = face.getTangent(0); Point tangent1 = face.getTangent(1); Point tangent2 = face.getTangent(2); face.setTangent(0, VectorUtil.add(tangent0, tmpTangente)); face.setTangent(1, VectorUtil.add(tangent1, tmpTangente)); face.setTangent(2, VectorUtil.add(tangent2, tmpTangente));   // binormals[face.vertexIndex[0]] += tmpBinormal; // binormals[face.vertexIndex[1]] += tmpBinormal; // binormals[face.vertexIndex[2]] += tmpBinormal; Point binormal0 = face.getBinormal(0); Point binormal1 = face.getBinormal(1); Point binormal2 = face.getBinormal(2); face.setBinormal(0, VectorUtil.add(binormal0, tmpBinormal)); face.setBinormal(1, VectorUtil.add(binormal1, tmpBinormal)); face.setBinormal(2, VectorUtil.add(binormal2, tmpBinormal));   // normals[face.vertexIndex[0]] += normal; // normals[face.vertexIndex[1]] += normal; // normals[face.vertexIndex[2]] += normal; Point normal0 = face.getNormal(0); Point normal1 = face.getNormal(1); Point normal2 = face.getNormal(2); face.setNormal(0, VectorUtil.add(normal0, normal)); face.setNormal(1, VectorUtil.add(normal1, normal)); face.setNormal(2, VectorUtil.add(normal2, normal)); }   public void drawLocalSpace() { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   gl.glBegin(gl.GL_LINES); List<Face> faces = this.getFaces(); for (Face face : faces) { for (int i = 0; i < 3; i++) { Point p = face.getPoint(i); Point t = face.getTangent(i); Point b = face.getBinormal(i); Point n = face.getNormal(i);   // tangente en rouge Point tangent = VectorUtil.add(t, p); gl.glColor3f(1, 0, 0); gl.glVertex3f(p.getX(), p.getY(), p.getZ()); gl.glVertex3f(tangent.getX(), tangent.getY(), tangent.getZ()); // binormal en vert Point binormal = VectorUtil.add(b, p); gl.glColor3f(0, 1, 0); gl.glVertex3f(p.getX(), p.getY(), p.getZ()); gl.glVertex3f(binormal.getX(), binormal.getY(), binormal.getZ()); // normal en bleu Point normal = VectorUtil.add(n, p); gl.glColor3f(0, 0, 1); gl.glVertex3f(p.getX(), p.getY(), p.getZ()); gl.glVertex3f(normal.getX(), normal.getY(), normal.getZ()); } } gl.glEnd(); }   public void renderColor(Light light) { GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();   gl.glColor3f(light.getColorAmbient().getR(), light.getColorAmbient() .getG(), light.getColorAmbient().getB()); Point lightPos = light.getPosition(); gl.glBegin(gl.GL_TRIANGLES); // for (int i = 0; i < nbFaces; i++) { for (Face face : faces) { for (int i = 0; i < 3; i++) { Point v = face.getPoint(i); Point lightTexCoord = light.computeLighting(v); // la premiere unité de texture contient la texture // d'attenuation gl.glMultiTexCoord3f(gl.GL_TEXTURE0, lightTexCoord.getX(), lightTexCoord.getY(), lightTexCoord.getZ()); gl.glVertex3f(v.getX(), v.getY(), v.getZ()); } } gl.glEnd(); }   public String getName() { return name; }   public void setName(String name) { this.name = name; }   public List<Face> getFaces() { return faces; }   public void setFaces(List<Face> faces) { this.faces = faces; }   public void addFace(Face face) { this.faces.add(face); }   public Bounds getBounds() { return bounds; }   public void setBounds(Bounds bounds) { this.bounds = bounds; }   public GLBlending getBlending() { return blending; }   public void setBlending(GLBlending blending) { this.blending = blending; }   public Renderer getRenderer() { return renderer; }   public void setRenderer(Renderer renderer) { this.renderer = renderer; }   public GLTexture getTexture() { return texture; }   public void setTexture(GLTexture texture) { this.texture = texture; }   public Material getBasicMaterial() { return material; }   public void setBasicMaterial(Material basicMaterial) { this.material = basicMaterial; }   public GLTexture getTextureMap() { return textureMap; }   public void setTextureMap(GLTexture textureMap) { this.textureMap = textureMap; }

---

j'ai corrigé une erreur de calcul dans mon code au niveau de l'application des lumieres, j'obtiens un rendu cohérent. Il reste encore beaucoup trop lumineux à mon gout mais c'est deja un bon point.

Par contre je n'ai pas l'impression d'avoir cet effet 3D...
Je n'arrive toujours pas à comprendre pourquoi 2 extensions ne sont pas détectés via gl.isFunctionsAvailable("...") :
GL_ARB_texture_env_dot3
GL_ARB_texture_cube_map

J'ai vérifier elles ont bien implémentés sur macarte graphique intel hd graphics 30000

Citation:

---

Envoyé par gladek

J'ai vérifier elles ont bien implémentés sur macarte graphique intel hd graphics 30000

---

Je crois que c'est 3000 et pas 30000 :aie:

Sinon, il faut savoir que Intel ont des implémentations assez pauvres d'OpenGL (qui repose sur Mesa en plus ...). Plus précisément, ils ont du matos graphique limité et un pilote limité aussi, donc qu'une extension n'existe pas, il n'y a rien d'étonnant.


Je tiens à rappeler mon premier message :

Citation:

---

Sinon, l'implémentation des extensions dépend des constructeurs de cartes graphiques. Ils peuvent ou peuvent ne pas mettre les extensions. Du coup, il arrive que certaine machine n'ont pas les extensions nécessaires. La mise à jour des pilotes peut aider, quelque fois.

---

Il faut bien comprendre que les extensions sont facultatives. Dans le sens, un constructeur peut décider de l'intégrer ou non, si cela lui chante. S'il ne l'intègre pas, il sera toujours "OpenGL compliant" (conforme à la norme) car il a suivit la spécification (et les extensions ne rentrent pas dans la spécifications, car ce sont comme des expérimentations et si par la suite, tout le monde utilise ou l'on remarque que c'est une bonne chose, alors l'extension peut être normalisée et être intégrée dans la prochaine version de la spécification).

Donc, oui, il arrive que certains matos / pilotes n'ont pas toutes les extensions requises pour faire tout ce que l'on veut.

Finalement, je vous conseille de mettre le pilote à jour, ne sait-on jamais (surtout qu'une toute récente nouvelle version de Mesa vient de sortir).

je suis sous macos et j'utlise l'application OpenGL Extensions Viewer 4.0.
Ce dernier me liste bien les 2 extensions.
Je n'ai peut etre pas besoin de cette mise à jour ?

En affichant la liste des extensions retournée par gl les 2 extensions sont bien listées...

Dans ce cas, il y a un problème avec gl.isFunctionsAvailable("...").
Peut être parce que vous utilisez l'ARB, alors que cela a été mis en place dans la norme, ou alors que c'est appelé _EXT.
Sinon, peut être parce que le contexte que vous créez n'est pas le bon :koi: même si je crois que cela ne change pas grand chose.
Vous pouvez aussi essayez de voir avec glxinfo et puis de voir avec glGetString(GL_EXTENSIONS);

la fonction gl.isFunctionsAvailable("...") me retourne false
alors que glGetString(GL_EXTENSIONS); me liste les 2 extensions...

Voila le rendu
http://imageshack.us/a/img835/9923/c...0121018203.png

je n'ai pas l'impression que le BumpMap soit en place et l'image est beaucoup plus claire que celle sur le tutoriel...

En effet, il n' ya pas de bump mapping et donc (surement lié) l'image est plus claire (car il n'y a pas les ombrages liées au relief)

je vais tester ma carte graphique et le bump mapping Dot3 avec l'exemple
http://www.paulsprojects.net/tutoria...implebump.html

Je suis en train de convertir tout ça en java/jogl. J'ai juste une question au niveau d'une syntaxe :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

unsigned char * data=new unsigned char[32*32*3]; unsigned char * bytePtr; //positive x bytePtr=data;   for(int j=0; j<size; j++) { for(int i=0; i<size; i++) { tempVector.SetX(halfSize); tempVector.SetY(-(j+offset-halfSize)); tempVector.SetZ(-(i+offset-halfSize)); tempVector.Normalize(); tempVector.PackTo01(); bytePtr[0]=(unsigned char)(tempVector.GetX()*255); bytePtr[1]=(unsigned char)(tempVector.GetY()*255); bytePtr[2]=(unsigned char)(tempVector.GetZ()*255);   bytePtr+=3; } }

---

Je ne comprend pas l'opertaion "bytePtr+=3"
Est ce que quelqu'un peut m'eclairer ?

(J'ai transformer ce tableau en byte[] sous java)

Je vous conseille des article plus récent, qui utilise au minimum OpenGL 2 et les shaders.

Sinon, le bytePtr+=3 déplace le pointeur du tableau de 3 cases.
Au début, le bytePtr indique le début du tableau, puis on déplace, disons une tête de lecture, pour avancer dans le tableau.

Ici, on peut faire en sorte que bytePtr soit remplacer par un int, qui sera utilisé comme index et cela sera la même chose.

une solution pour tester, avez vous un lien vers une application ou demo bumpmap dot3 sur macosx ?

j'ai tester le code bumpmap dot3 C++ sous window7 et le rendu est correct...
je ne comprend plus rien...

j'ai reussi a obtenir le rendu souhaité :)
mon sol est enfin bien en "relief"

Il me reste un dernier soucis, mon sol est affiché correctement mais les colonnes sont transparentes...
http://imageshack.us/a/img853/8742/c...0121023161.png

Avez vous une idée pour corriger ce rendu ?

Résultat final :)
http://imageshack.us/a/img535/1149/c...0121024213.png