problème de base avec une texture éclairée par un projecteur

Question

Quelqu'un peut me aider à un problème simple? J'ai mis un carré construit à partir de nombreux triangles comme des triangles 20 * 20, j'ai ajouté à ce carré une texture, j'ai aussi mis la normale à ce carré et puisque son position est dans le plan de coordonnées Z zéro la normale est très facile à trouver (0,0,1). Le problème est que je ne peux pas voir mon carré texturé éclairé par un endroit du tout. J'ai aussi essayé d'enlever la lumière ambiante et de la réduire mais pas de chance. Aussi j'ai augmenté le nombre de petits triangles du carré pour une meilleure résolution mais pas de chance. J'ai l'exemple de base de recherche mais pas de chance. Quelqu'un a-t-il aussi trouvé une solution à un point sur une texture, ou quelqu'un peut-il m'en donner un petit exemple? Alors :

1. En surfacecreated j'ai mis:

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,GL10.GL_FASTEST); 
    gl.glClearColor(.5f, .5f, .5f, 1); 
    gl.glShadeModel(GL10.GL_SMOOTH); 
    gl.glEnable(GL10.GL_DEPTH_TEST); 
    gl.glEnable(GL10.GL_TEXTURE_2D); 

    float lightAmbient[] = new float[] { 0.3f, 0.3f, 0.3f, 1 }; 
    float lightDiffuse[] = new float[] { 0.7f, 0.7f, 0.7f, 1 }; 
    float lightSpecular[] = new float[] { 0.7f, 0.7f, 0.7f, 1 }; 
    lightDirection = new float[] {0.0f, 0.0f, -1.0f}; 
    lightPos = new float[] { 0, 0, 10f, 1 }; 

    gl.glEnable(GL10.GL_LIGHTING); 
    gl.glEnable(GL10.GL_LIGHT0); 


    gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0);  
    gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse, 0);  
    gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, lightSpecular, 0); 
    gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, lightPos, 0); 
    gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPOT_DIRECTION, lightDirection, 0); 
    gl.glLightf(GL10.GL_LIGHT0, GL10.GL_SPOT_CUTOFF, 3f); 
    gl.glLightf(GL10.GL_LIGHT0, GL10.GL_SPOT_EXPONENT, 100f); 
    gl.glEnable(GL10.GL_DEPTH_TEST); 
    gl.glDepthFunc(GL10.GL_LESS); 
    gl.glDisable(GL10.GL_DITHER); 
    gl.glTexEnvx(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE); 

    int[] textures = new int[1]; 
    gl.glGenTextures(1, textures, 0); 
    mTextureID = textures[0]; 
    gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID); 

    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, 
      GL10.GL_NEAREST); 
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, 
      GL10.GL_LINEAR); 

    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, 
      GL10.GL_CLAMP_TO_EDGE); 
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, 
      GL10.GL_CLAMP_TO_EDGE); 

    gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, 
      GL10.GL_REPLACE); 

    InputStream is = mContext.getResources() 
      .openRawResource(R.raw.wood); 
    Bitmap bitmap; 
    try { 
     bitmap = BitmapFactory.decodeStream(is); 
    } finally { 
     try { 
      is.close(); 
     } catch(IOException e) { 
      // Ignore. 
     } 
    } 

    GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0); 
    bitmap.recycle(); 

1. En onDrawFrame j'ai ajouté: gl.glClear (GL10.GL_COLOR_BUFFER_BIT | GL10. GL_DEPTH_BUFFER_BIT);

   gl.glMatrixMode(GL10.GL_MODELVIEW); 
   gl.glLoadIdentity(); 
   
   GLU.gluLookAt(gl, 0, 0, 10, 0f, 0f, 0f, 0f, 1.0f, 0.0f); 
   
   gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 
   gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY); 
   gl.glEnableClientState(GL10.GL_NORMAL_ARRAY); 
   
   gl.glActiveTexture(GL10.GL_TEXTURE0); 
   gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID); 
   gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, 
        GL10.GL_REPEAT); 
   gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, 
        GL10.GL_REPEAT); 
   
   mSquare.draw(gl); 
   

2. La classe Square est assez simple:

classe place {int points = 1;

int x1 = -2; 
int x2 = 2; 
int y1 = -2; 
int y2 = 2; 
int W = x2 - x1; 
int H = y2 - y1; 
int dx = 30; 
int dy = 30; 


private float vertices2[] = new float[3*4*dx * dy]; 
private float normals[] = new float[3*4*dx * dy]; 

float one = 1.0f; 
float texCoords[] = new float[3*4*dx * dy]; 

private FloatBuffer vertexbuffer1 = null; 
private FloatBuffer mTextureBuffer = null; 
private FloatBuffer mNormalBuffer = null; 

private void initVertexes() { 
    float incW = W/(float)dx; 
    float incH = H/(float)dy; 
    int i = 0; 
    int j = 0; 
    int k = 0; 

    for(float y = y2; y >= (y1 + incH) ; y -= incH) 
     for(float x = x1; x<= (x2 - incW); x += incW) { 

      vertices2[i++] = x ; 
      vertices2[i++] = y - incH; 
      vertices2[i++] = -point; 

      texCoords[j++] = (x2 + x)/(4f*W); 
      texCoords[j++] = (y2 + y -incH)/(4f*H); 

      normals[k++] = 0; 
      normals[k++] = 0; 
      normals[k++] = 1; 

      vertices2[i++] = x ; 
      vertices2[i++] = y ; 
      vertices2[i++] = -point; 

      texCoords[j++] = (x2 + x)/(4f*W); 
      texCoords[j++] = (y2 + y)/(4f*H); 

      normals[k++] = 0; 
      normals[k++] = 0; 
      normals[k++] = 1; 

      vertices2[i++] = x + incW; 
      vertices2[i++] = y - incH ; 
      vertices2[i++] = -point; 

      texCoords[j++] = (x2 + x + incW)/(4f*W); 
      texCoords[j++] = (y2 + y - incH)/(4f*H); 

      normals[k++] = 0; 
      normals[k++] = 0; 
      normals[k++] = 1; 

      vertices2[i++] = x + incW; 
      vertices2[i++] = y ; 
      vertices2[i++] = -point; 

      texCoords[j++] = (x2 + x + incW)/(4f*W); 
      texCoords[j++] = (y2 + y)/(4f*H); 

      normals[k++] = 0; 
      normals[k++] = 0; 
      normals[k++] = 1; 
     } 

} 


public Square() { 

    initVertexes(); 

    ByteBuffer vbb1 = ByteBuffer.allocateDirect(vertices2.length * 4); 
    vbb1.order(ByteOrder.nativeOrder()); 
    vertexbuffer1 = vbb1.asFloatBuffer(); 
    vertexbuffer1.put(vertices2); 
    vertexbuffer1.position(0); 

    ByteBuffer txtb1 = ByteBuffer.allocateDirect(texCoords.length * 4); 
    txtb1.order(ByteOrder.nativeOrder()); 
    mTextureBuffer = txtb1.asFloatBuffer(); 
    mTextureBuffer.put(texCoords); 
    mTextureBuffer.position(0); 

    ByteBuffer nor = ByteBuffer.allocateDirect(normals.length * 4); 
    nor.order(ByteOrder.nativeOrder()); 
    mNormalBuffer = nor.asFloatBuffer(); 
    mNormalBuffer.put(normals); 
    mNormalBuffer.position(0); 

}

public void draw(GL10 gl) { 

    gl.glEnable(GL10.GL_TEXTURE_2D); 
    gl.glNormalPointer(3, 0, mNormalBuffer); 
    gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTextureBuffer); 
    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexbuffer1); 
    gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 2*2*dx*dy); 

} 

}

Answer 1

Avez-vous vérifié que votre lumière illumine la place lorsque vous ne définissez pas GL_SPOT_CUTOFF et GL_SPOT_EXPONENT?

De la façon dont vous avez positionné votre lumière et la caméra, je pense que vous essayez de mettre en lumière de la position du spectateur. Une chose que vous devez surveiller est que les paramètres d'éclairage de position/orientation (ie GL_POSITION et GL_SPOT_DIRECTION) sont stockés dans l'espace des yeux, ce qui signifie qu'ils sont transformés par la valeur de la matrice modelview au moment où vous appelez glLightfv, et que La valeur transformée est stockée, pas celle que vous avez spécifiée. Il semble que vous n'ayez pas mis en place la matrice modelview tant que vous n'avez pas dessiné, donc la lumière n'est peut-être pas là où vous pensez que c'est. Pourtant, si vous essayez de mettre en valeur un projecteur, vous feriez mieux d'essayer d'appliquer la forme du projecteur en utilisant une autre texture, plutôt qu'en utilisant des calculs d'éclairage à fonction fixe, qui reposent sur la tessellation de votre géométrie et ne vous donnez pas autant de flexibilité pour définir la forme de votre surbrillance. Le cutoff que vous avez choisi est assez petit, ce qui peut faire que les projecteurs manquent complètement vos vertices.