Esempio n. 1
0
  // @Override
  public void orbit(float horizAmount, float vertAmount) {
    xRotation += horizAmount;
    yRotation += vertAmount;

    Log.d("XROT", "X rotation: " + xRotation);
    Log.d("YROT", "Y rotation: " + yRotation);

    float[] newPos = Utilities.subtractVectors(position, target);
    float[] rotMatrix = new float[16];
    float[] rotatedPos = new float[4];

    if (newPos.length >= 4) newPos[3] = 1.0f;

    Matrix.setRotateM(rotMatrix, 0, horizAmount, 0.0f, 1.0f, 0.0f);
    Matrix.multiplyMV(rotatedPos, 0, rotMatrix, 0, newPos, 0);
    Matrix.multiplyMV(crossProd, 0, rotMatrix, 0, crossProd, 0);
    Matrix.multiplyMM(rotationMatrix, 0, rotMatrix, 0, rotationMatrix, 0);

    Matrix.setRotateM(rotMatrix, 0, vertAmount, crossProd[0], crossProd[1], crossProd[2]);
    Matrix.multiplyMV(rotatedPos, 0, rotMatrix, 0, rotatedPos, 0);
    Matrix.multiplyMM(rotationMatrix, 0, rotMatrix, 0, rotationMatrix, 0);

    position = Utilities.addVectors(rotatedPos, target);
    direction = Utilities.subtractVectors(target, position);
  }
  @Override
  public void onDrawEye(Eye eye) {
    if (resetCameraFlag) {
      float[] invertedEye = new float[16];
      Matrix.invertM(invertedEye, 0, eye.getEyeView(), 0);
      setUpCamera();
      Matrix.multiplyMM(mCameraMatrix, 0, invertedEye, 0, mCameraMatrix, 0);
      resetCameraFlag = false;
    }
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

    if (lockCameraFlag) {
      mViewMatrix = mCameraMatrix.clone();
    } else {
      Matrix.multiplyMM(mViewMatrix, 0, eye.getEyeView(), 0, mCameraMatrix, 0);
    }

    Matrix.multiplyMV(mLightPosInWorldSpace, 0, mLightModelMatrix, 0, mLightPosInModelSpace, 0);
    Matrix.multiplyMV(mLightPosInEyeSpace, 0, mViewMatrix, 0, mLightPosInWorldSpace, 0);

    mProjectionMatrix = eye.getPerspective(Z_NEAR, Z_FAR);

    GLES20.glUseProgram(mProgramHandle);
    currentContent.draw(eye);

    if (drawRedPoint) {
      drawTargetingPoint();
    }
    Util.checkGLError("Error Draw Eye");
  }
  @Override
  public void onDrawFrame(GL10 gl) {
    super.onDrawFrame(gl);
    // GL Draw code onwards
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

    // Do a complete rotation every 10 seconds.
    long time = SystemClock.uptimeMillis() % 10000L;
    float angleInDegrees = (360.0f / 10000.0f) * ((int) time);

    // Set our per-vertex lighting program.
    GLES20.glUseProgram(mProgramHandle);

    // Set program handles for cube drawing.
    mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_MVPMatrix");
    mMVMatrixHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_MVMatrix");
    mLightPosHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_LightPos");
    mTextureUniformHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_Texture");
    mPositionHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_Position");
    mColorHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_Color");
    mNormalHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_Normal");
    mTextureCoordinateHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_TexCoordinate");

    GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, getGLSurfaceTexture());
    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
    GLES20.glUniform1i(mTextureUniformHandle, 0);

    //        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);
    //        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, glSurfaceTex);
    //        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

    //        // Set the active texture unit to texture unit 0.
    //        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
    //
    //        // Bind the texture to this unit.
    //        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, glSurfaceTex);

    // Tell the texture uniform sampler to use this texture in the shader by binding to texture unit
    // 0.
    //        GLES20.glUniform1i(mTextureUniformHandle, 0);

    // Calculate position of the light. Rotate and then push into the distance.
    Matrix.setIdentityM(mLightModelMatrix, 0);
    Matrix.translateM(mLightModelMatrix, 0, 0.0f, 0.0f, -4.0f);
    Matrix.rotateM(mLightModelMatrix, 0, angleInDegrees, 0.0f, 1.0f, 0.0f);
    Matrix.translateM(mLightModelMatrix, 0, 0.0f, 0.0f, 2.0f);

    Matrix.multiplyMV(mLightPosInWorldSpace, 0, mLightModelMatrix, 0, mLightPosInModelSpace, 0);
    Matrix.multiplyMV(mLightPosInEyeSpace, 0, mViewMatrix, 0, mLightPosInWorldSpace, 0);

    Matrix.setIdentityM(mModelMatrix, 0);
    Matrix.translateM(mModelMatrix, 0, 0.0f, 0.0f, -3.3f);
    Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 1.0f, 1.0f, 0.0f);
    drawCube();

    // Draw a point to indicate the light.
    GLES20.glUseProgram(mPointProgramHandle);
    drawLight();
  }
Esempio n. 4
0
 /**
  * Example. An object at position 5,5,5 is rotated by an rotation matrix (set via {@link
  * MeshComponent#setRotationMatrix(float[])} and we want to know there the point 0,0,1 (which
  * normaly without rotation would be at 5,5,6 ) is now. then we can use this method and pass 0,0,1
  * and we will get the correct world coordinates
  *
  * @param modelSpaceCoords
  * @return the coordinates in the world system
  */
 public Vec getWorldCoordsFromModelSpacePosition(Vec modelSpaceCoords) {
   float[] resultVec = new float[3];
   float[] modelSpaceCoordsVec = {modelSpaceCoords.x, modelSpaceCoords.y, modelSpaceCoords.z};
   Matrix.multiplyMV(resultVec, 0, markerRotationMatrix, 0, modelSpaceCoordsVec, 0);
   return new Vec(
       resultVec[0] + myPosition.x, resultVec[1] + myPosition.y, resultVec[2] + myPosition.z);
 }
 public Vector3 getDirection() {
   Matrix.setIdentityM(matrix, 0);
   Matrix.rotateM(matrix, 0, yaw, 0, 1, 0);
   Matrix.rotateM(matrix, 0, pitch, 1, 0, 0);
   Matrix.multiplyMV(outVex, 0, matrix, 0, inVex, 0);
   direction.set(outVex[0], outVex[1], outVex[2]);
   return direction;
 }
 public void updateEyeSpacePosition() {
   Matrix.multiplyMV(
       eyeSpacePosition,
       0,
       GameState.getInstance().getCamera("MainCam").getViewMatrix(),
       0,
       pos,
       0);
 }
Esempio n. 7
0
  @Override
  public void onDrawEye(Eye eyeTransform) {
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

    checkGLError("colorParam");

    GLES20.glUseProgram(mProgram);
    GLES20.glDrawElements(
        GLES20.GL_TRIANGLES, drawOrder.length, GLES20.GL_UNSIGNED_SHORT, drawListBuffer);

    checkGLError("befor activeTex");
    GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
    checkGLError("after activeTex");
    GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
    checkGLError("bind Text");

    checkGLError("mPostionHandle");
    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
    GLES20.glEnableVertexAttribArray(mPositionHandle);
    GLES20.glVertexAttribPointer(
        mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, vertexBuffer);

    checkGLError("mTexture Handle");
    mTextureCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
    GLES20.glEnableVertexAttribArray(mTextureCoordHandle);
    GLES20.glVertexAttribPointer(
        mTextureCoordHandle,
        COORDS_PER_VERTEX,
        GLES20.GL_FLOAT,
        false,
        vertexStride,
        textureVerticesBuffer);
    checkGLError("after mTexture Handle");

    mColorHandle = GLES20.glGetAttribLocation(mProgram, "s_texture");
    checkGLError("mColor Handel");

    GLES20.glDrawElements(
        GLES20.GL_TRIANGLES, drawOrder.length, GLES20.GL_UNSIGNED_SHORT, drawListBuffer);

    checkGLError("Disable");
    GLES20.glDisableVertexAttribArray(mPositionHandle);
    GLES20.glDisableVertexAttribArray(mTextureCoordHandle);

    checkGLError("before Cube 2");
    Matrix.multiplyMM(mView, 0, eyeTransform.getEyeView(), 0, mCamera, 0);
    Matrix.multiplyMV(lightPosInEyeSpace, 0, mView, 0, LIGHT_POS_IN_WORLD_SPACE, 0);

    checkGLError("before Cube");
    float[] perspective = eyeTransform.getPerspective(Z_NEAR, Z_FAR);
    Matrix.multiplyMM(modelView, 0, mView, 0, mModelCube, 0);
    Matrix.multiplyMM(modelViewProjection, 0, perspective, 0, modelView, 0);
    drawCube();
  }
Esempio n. 8
0
  // XXX Find out whether or not using Matrix operations is better than a home-grown solution.
  // Perhaps run a test to see how long matrix ops really take.
  // TODO: Try to multiply multiple points in one M x V operation in Primitive.
  // This function belongs in Element, not Point.
  // XXX This rotates about the origin.
  public Float3 rotate(float a, float x, float y, float z) {

    float[] v = new float[] {this.x, this.y, this.z, 1};

    float[] m = new float[16];
    Matrix.setIdentityM(m, 0);
    Matrix.rotateM(m, 0, a, x, y, z);
    Matrix.multiplyMV(v, 0, m, 0, v, 0);

    return new Float3(v[0], v[1], v[2]);
  }
Esempio n. 9
0
  /**
   * Calculates a pick ray based on the given screen coordinates and the current projection matrix
   * and model view matrix.
   *
   * <p>The screen coordinates are expected to have (0,0) at the mLocalTranslationper left corner of
   * the screen and the y-axis is reversed compared to the OpenGL y-axis.
   *
   * @param pickX screen x coordinate
   * @param pickY screen y coordinate
   */
  public Ray calculatePickRay(float pickX, float pickY) {
    // coordinates centered on the screen
    // -1 <= x <= 1 and -1 <= y <= 1
    float unit_x = (pickX - mHalfWidth) / mHalfWidth;
    float unit_y = ((mHeight - pickY) - mHalfHeight) / mHalfHeight;

    float[] rayRawPos = {0.0f, 0.0f, 0.0f, 1.0f};
    float[] rayRawDir = {unit_x * mNearHeight * mAspect, unit_y * mNearHeight, -mZNear, 0.0f};
    float[] rayPos = new float[4];
    float[] rayDir = new float[4];

    // multiply the position and vector with the inverse model matrix
    // to get world coordinates
    synchronized (mViewMatrix) {
      Matrix.invertM(mInvModelMatrix, 0, mViewMatrix, 0);
    }
    Matrix.multiplyMV(rayPos, 0, mInvModelMatrix, 0, rayRawPos, 0);
    Matrix.multiplyMV(rayDir, 0, mInvModelMatrix, 0, rayRawDir, 0);

    return new Ray(rayPos[0], rayPos[1], rayPos[2], rayDir[0], rayDir[1], rayDir[2]);
  }
Esempio n. 10
0
  private NodeOrderUnit[] buildDrawOrder(float[] conversionMatrix) {
    NodeOrderUnit[] drawOrder = new NodeOrderUnit[nodes.length];
    float[] tempPos = new float[4];

    for (int i = 0; i < nodes.length; i++) {
      Matrix.multiplyMV(tempPos, 0, conversionMatrix, 0, nodes[i].getPos4f(), 0);
      drawOrder[i] = new NodeOrderUnit(i, tempPos[2]);
    }

    Arrays.sort(drawOrder);

    return drawOrder;
  }
Esempio n. 11
0
  // different version of glu.glunproject
  public static Vector3d unProject(
      float winx, float winy, float winz, float[] resultantMatrix, float width, float height) {
    winy = height - winy;
    float[] m = new float[16], in = new float[4], out = new float[4];
    Matrix.invertM(m, 0, resultantMatrix, 0);
    in[0] = (winx / width) * 2 - 1;
    in[1] = (winy / height) * 2 - 1;
    in[2] = 2 * winz - 1;
    in[3] = 1;
    Matrix.multiplyMV(out, 0, m, 0, in, 0);

    if (out[3] == 0) return null;

    out[3] = 1 / out[3];
    return new Vector3d(out[0] * out[3], out[1] * out[3], out[2] * out[3]);
  }
Esempio n. 12
0
  public void GetWorldCoords(float[] worldPos, float touchX, float touchY, float z) {
    // SCREEN height & width (ej: 320 x 480)
    float screenW = mViewPort[2];
    float screenH = mViewPort[3];

    // Invert y coordinate, as android uses
    // top-left, and ogl bottom-left.
    int oglTouchY = (int) (screenH - touchY);

    /*
     * Transform the screen point to clip space in ogl (-1,1)
     */
    normalizedInPoint[0] = (float) (touchX * 2.0f / screenW - 1.0);
    normalizedInPoint[1] = (float) (oglTouchY * 2.0f / screenH - 1.0);
    normalizedInPoint[2] = z;
    normalizedInPoint[3] = 1.0f;

    /*
     * Obtain the transform matrix and then the inverse.
     */
    // MatrixUtils.PrintMat("Proj", mProjection);
    // MatrixUtils.PrintMat("Model", mModelView);
    Matrix.multiplyMM(transformMatrix, 0, mProjection, 0, mModelView, 0);
    Matrix.invertM(invertedMatrix, 0, transformMatrix, 0);

    /*
     * Apply the inverse to the point in clip space
     */
    Matrix.multiplyMV(outPoint, 0, invertedMatrix, 0, normalizedInPoint, 0);

    if (outPoint[3] == 0.0) {
      // Avoid /0 error.
      Log.e("World coords", "ERROR!");
      return;
    }

    // Divide by the 3rd component to find
    // out the real position.
    worldPos[0] = outPoint[0] / outPoint[3];
    worldPos[1] = outPoint[1] / outPoint[3];
    worldPos[2] = outPoint[2] / outPoint[3];
  }
Esempio n. 13
0
 public void apply(float[] mCoordsIn, float[] mCoordsOut) {
   Matrix.multiplyMV(mCoordsOut, 0, mMatrix, mTop, mCoordsIn, 0);
 }
 /**
  * Calculates view position for light.
  *
  * @param viewM View matrix.
  */
 public void updateMatrices(float[] viewM) {
   Matrix.multiplyMV(mViewPos, 0, viewM, 0, mPosition, 0);
   for (int i = 0; i < 3; ++i) {
     mViewPos[i] /= mViewPos[3];
   }
 }
Esempio n. 15
0
  /* Modifications return new objects */
  public Float3 transform(float[] transformation) {

    float[] v = new float[] {this.x, this.y, this.z, 1};
    Matrix.multiplyMV(v, 0, transformation, 0, v, 0);
    return new Float3(v[0], v[1], v[2]);
  }