public void onDrawFrame(GL10 gl) {
    // Redraw background color
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    Log.i("MyGLRenderer", "MyGLRenderer : onDrawFrame() - Starting to set camera position");

    float[] mViewMatrix = new float[16];
    // Set the camera position (View matrix)
    Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

    float[] mMVPMatrix = new float[16];
    // Calculate the projection and view transformation
    Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

    Log.i("MyGLRenderer", "MyGLRenderer : onDrawFrame() - Drawing ClientSide");

    float[] scratch = new float[16];

    // Create a rotation transformation for the triangle
    long time = SystemClock.uptimeMillis() % 4000L;
    float angle = 0.090f * ((int) time);
    Matrix.setRotateM(mRotationMatrix, 0, angle, 0, 0, -1.0f);

    // Combine the rotation matrix with the projection and camera view
    // Note that the mMVPMatrix factor *must be first* in order
    // for the matrix multiplication product to be correct.
    Matrix.multiplyMM(scratch, 0, mMVPMatrix, 0, mRotationMatrix, 0);

    // Draw triangle
    mTriangle.draw_ClientSide(scratch);
  }
  public void onSurfaceChanged(GL10 unused, int width, int height) {
    GLES20.glViewport(0, 0, width, height);

    ratio = (float) width / height;

    // this projection matrix is applied to object coodinates
    // in the onDrawFrame() method
    Matrix.orthoM(mProjMatrix, 0, -ratio, ratio, -1, 1, 3, 7);

    muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
    Matrix.setLookAtM(mVMatrix, 0, 0, 0, 3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

    engine.initGL();

    GLES20.glUseProgram(mProgram);

    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

    GLES20.glUniform1i(mSampleHandle, 0);
    GLES20.glUniform1f(mOpacityHandle, 1f);

    GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 12, quadCoordsBuf);
    GLES20.glEnableVertexAttribArray(maPositionHandle);
    GLES20.glVertexAttribPointer(maTexCoordsHandle, 2, GLES20.GL_FLOAT, false, 8, quadTexCoordsBuf);
    GLES20.glEnableVertexAttribArray(maTexCoordsHandle);

    initTextures();
  }
  @Override
  public void onSurfaceChanged(GL10 glUnused, int width, int height) {
    GLES20.glViewport(0, 0, width, height);
    ratio = (float) width / height;

    Matrix.perspectiveM(
        mProjectionMatrix,
        0,
        FOV / (float) Math.PI * 180.0f,
        ratio,
        len / LEN_RANGE,
        len * LEN_RANGE);
    Matrix.setLookAtM(
        mViewMatrix,
        0,
        matCam[0] * len,
        matCam[1] * len,
        matCam[2] * len,
        0.0f,
        0.0f,
        0.0f,
        0.0f,
        0.0f,
        1.0f);

    float[] lightPos = {len, len, 0};
    GLES20.glUniform3fv(mLightPosHandle, 1, lightPos, 0);
  }
  @Override
  public void onDrawFrame(GL10 unused) {

    // Draw background color
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    // Set the camera position (View matrix)
    Matrix.setLookAtM(mVMatrix, 0, 0, 0, -5, 0f, 0f, 0f, 0f, 5.0f, 0.0f);

    // Calculate the projection and view transformation
    Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mVMatrix, 0);

    // Draw square
    // mSquare.draw(mMVPMatrix);

    // Create a rotation for the triangle
    //        long time = SystemClock.uptimeMillis() % 4000L;
    //        float angle = 0.090f * ((int) time);
    // Matrix.setRotateM(mRotationMatrix, 0, mAngle, 1, 0, -1.0f);
    Matrix.setRotateM(xRotationMatrix, 0, -mAngle2, 1, 0, 0f);
    Matrix.setRotateM(yRotationMatrix, 0, -mAngle, 0, 1, 0f);
    Matrix.multiplyMM(mRotationMatrix, 0, xRotationMatrix, 0, yRotationMatrix, 0);

    // Combine the rotation matrix with the projection and camera view
    Matrix.multiplyMM(mMVPMatrix, 0, mRotationMatrix, 0, mMVPMatrix, 0);

    // Draw triangle
    // mTriangle.draw(mMVPMatrix);
    if (mMesh != null) {
      mMesh.draw(mMVPMatrix);
    }
  }
 @Override
 public void onSurfaceChanged(GL10 unused, int width, int height) {
   float aspect = (float) width / height;
   Matrix.perspectiveM(mMatrixProjection, 0, 60f, aspect, .1f, 10f);
   Matrix.setLookAtM(mMatrixView, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0);
   Matrix.multiplyMM(mMatrixModelViewProjection, 0, mMatrixProjection, 0, mMatrixView, 0);
   mLastRenderTime = -1;
 }
Example #6
0
 @Override
 public void onSurfaceChanged(GL10 gl, int width, int height) {
   glViewport(0, 0, width, height);
   // perspectiveM(projectionMatrix,0 , 45, (float) width / (float) height,1f, 10f);
   float aspectRatio = (float) width / (float) height;
   frustumM(projectionMatrix, 0, -aspectRatio, aspectRatio, -1, 1, 3, 7);
   setLookAtM(viewMatrix, 0, 0f, 0f, -3f, 0f, 0f, 0f, 0f, 1f, 0f);
 }
  @Override
  public void onDrawFrame(GL10 unused) {
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
    float[] parScratch = new float[16];
    float[] bogieScratch = new float[16];
    float[] birdieScratch = new float[16];
    float[] shadowScratch1 = new float[16];
    float[] shadowScratch2 = new float[16];

    // Set the camera position (View matrix)
    Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

    // Calculate the projection and view transformation
    Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

    float parAngle = -1 * (360 * parPercent);
    float birdieAngle = -1 * (360 * birdiePercent);
    float startingAngle = -90;

    // System.out.println("par angle = " + Float.toString(parAngle));
    // System.out.println("birdie angle = " + Float.toString(birdieAngle));
    // System.out.println("bogie angle = " + Float.toString(-1 * (360 * bogiePercent)));

    // Create a rotation transformation;
    if (angle > -450) {
      // rotates birdie sector to starting angle from angle 0
      if (angle > startingAngle) {
        Matrix.setRotateM(mRotationMatrixBirdie, 0, angle, 0, 0, -1.0f);
      }
      if (angle > startingAngle + birdieAngle) {
        Matrix.setRotateM(mRotationMatrixPar, 0, angle, 0, 0, -1.0f);
      }
      if (angle > startingAngle + birdieAngle + parAngle) {
        Matrix.setRotateM(mRotationMatrixBogie, 0, angle, 0, 0, -1.0f);
      }
      angle -= 2;
    }

    // Combine the rotation matrix with the projection and camera view
    // Note that the mMVPMatrix factor *must be first* in order
    // for the matrix multiplication product to be correct.
    Matrix.multiplyMM(shadowScratch1, 0, mMVPMatrix, 0, mRotationMatrixShadow, 0);
    Matrix.multiplyMM(bogieScratch, 0, mMVPMatrix, 0, mRotationMatrixBogie, 0);
    Matrix.multiplyMM(parScratch, 0, mMVPMatrix, 0, mRotationMatrixPar, 0);
    Matrix.multiplyMM(birdieScratch, 0, mMVPMatrix, 0, mRotationMatrixBirdie, 0);

    shadowPieWheel.draw(mMVPMatrix);
    wheelBG.draw(mMVPMatrix);
    bogiePieWheel.draw(bogieScratch);
    parPieWheel.draw(parScratch);
    birdiePieWheel.draw(birdieScratch);
    wheelHole.draw(mMVPMatrix);
  }
  @Override
  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {

    // Set the background clear color to sky blue
    GLES20.glClearColor(135.0f / 255.0f, 206.0f / 255.0f, 255.0f / 255f, 1.0f);
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);
    // GLES20.glEnable(GLES20.GL_CULL_FACE);
    GLES20.glEnable(GLES20.GL_TEXTURE_2D);

    // Position the eye behind the origin
    this.mCamera.eye = new Vector3d(0.0f, 0.0f, 0.0f);

    // We are looking toward the distance
    this.mCamera.look = new Vector3d(0f, 0f, 0f);

    // Set our up vector. This is where our head would be pointing were we holding the camera
    this.mCamera.up = new Vector3d(0.0f, 0.0f, 1.0f);

    // Set the view matrix. This matrix can be said to represent the camera position.
    // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
    // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
    Matrix.setLookAtM(
        this.mViewMatrix,
        0,
        this.mCamera.eye.x,
        this.mCamera.eye.y,
        this.mCamera.eye.z,
        this.mCamera.look.x,
        this.mCamera.look.y,
        this.mCamera.look.z,
        this.mCamera.up.x,
        this.mCamera.up.y,
        this.mCamera.up.z);

    Matrix.setIdentityM(mModelMatrix, 0);
    final String vertexShader = getVertexShader();
    final String fragmentShader = getFragmentShader();

    final int vertexShaderHandle = compileShader(GLES20.GL_VERTEX_SHADER, vertexShader);
    final int fragmentShaderHandle = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);

    mPerVertexProgramHandle =
        createAndLinkProgram(
            vertexShaderHandle,
            fragmentShaderHandle,
            new String[] {"a_Position", "a_Color", "a_Normal", "a_TexCoordinate"});

    addTexture(R.drawable.grass_texture_1);
    addTexture(R.drawable.azure_waters);
    addTexture(R.drawable.wood_texture_1);
    addTexture(R.drawable.sky_texture_1);
  }
Example #9
0
  protected BaseRenderer(Context context) {
    this.context = context;

    /* *** set default ViewProjection Matrix*** */
    Matrix.setIdentityM(modelMatrix, 0);
    Matrix.translateM(modelMatrix, 0, xP, yP, zP);
    float[] viewMatrix = new float[16];
    float[] projectionMatrix = new float[16];
    MatrixHelper.perspectiveM(projectionMatrix, 45, 1f, 1f, 10f);
    Matrix.setLookAtM(viewMatrix, 0, 0, 0, 3.0f, 0.0f, 0.0f, 0.0f, 0, 1.0f, 0);
    Matrix.multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
    setModelViewProjectionMatrix();
  }
Example #10
0
 // @Override
 public void updateMatrix() {
   Matrix.setLookAtM(
       viewMatrix,
       0,
       position[0],
       position[1],
       position[2],
       position[0],
       position[1],
       position[2],
       0,
       1,
       0);
 }
Example #11
0
 private void updateLookAt() {
   Matrix.setLookAtM(
       this.mViewMatrix,
       0,
       this.mCamera.eye.x,
       this.mCamera.eye.y,
       this.mCamera.eye.z,
       this.mCamera.look.x,
       this.mCamera.look.y,
       this.mCamera.look.z,
       this.mCamera.up.x,
       this.mCamera.up.y,
       this.mCamera.up.z);
 }
Example #12
0
  @Override
  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    // Use culling to remove back faces.
    GLES20.glEnable(GLES20.GL_CULL_FACE);

    // Enable depth testing
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);

    // Position the eye in front of the origin.
    final float eyeX = 0.0f;
    final float eyeY = 8.0f;
    final float eyeZ = 3.5f;

    // We are looking toward the distance
    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = -15.0f;

    // Set our up vector. This is where our head would be pointing were we holding the camera.
    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    // Set the view matrix. This matrix can be said to represent the camera position.
    // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
    // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
    Matrix.setLookAtM(ViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

    String vertexShaderSource =
        TextResourceReader.readTextFileFromResource(context, R.raw.simple_vertex_shader);
    String fragmentShaderSource =
        TextResourceReader.readTextFileFromResource(context, R.raw.simple_fragment_shader);

    int vertexShader = ShaderHelper.compileVertexShader(vertexShaderSource);
    int fragmentShader = ShaderHelper.compileFragmentShader(fragmentShaderSource);

    program = ShaderHelper.linkProgram(vertexShader, fragmentShader);

    if (LoggerConfig.ON) {
      ShaderHelper.validateProgram(program);
    }

    glUseProgram(program);

    uMatrixLocation = glGetUniformLocation(program, U_MATRIX);
  }
  private void setUpCamera() {
    final float eyeX = 0.0f;
    final float eyeY = 0.0f;
    final float eyeZ = 7.0f;

    mCameraPosition[0] = eyeX;
    mCameraPosition[1] = eyeY;
    mCameraPosition[2] = eyeZ;

    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = -1.0f;

    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    Matrix.setLookAtM(mCameraMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
  }
Example #14
0
  @Override
  public void onNewFrame(HeadTransform headTransform) {

    Matrix.rotateM(mModelCube, 0, TIME_DELTA, 0.5f, 0.5f, 1.0f);

    // Build the camera matrix and apply it to the ModelView.
    Matrix.setLookAtM(mCamera, 0, 0.0f, 0.0f, CAMERA_Z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

    headTransform.getHeadView(headView, 0);

    checkGLError("onReadyToDraw");

    float[] mtx = new float[16];
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
    surface.updateTexImage();
    surface.getTransformMatrix(mtx);
    mHeadTransform = headTransform;
    headTransform.getHeadView(headView, 0);
  }
  public void onDrawFrame(GL10 gl) {
    // TODO Auto-generated method stub
    loopStart = System.currentTimeMillis();
    try {
      if (loopRunTime < ZxCEngine.GAME_THREAD_FPS_SLEEP) {
        Thread.sleep(ZxCEngine.GAME_THREAD_FPS_SLEEP - loopRunTime);
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
    // gl.glLoadIdentity();
    loopEnd = System.currentTimeMillis();
    loopRunTime = ((loopEnd - loopStart));
    // Draw background color

    // GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    // Set the camera position (View matrix)
    Matrix.setLookAtM(mVMatrix, 0, 0, 0, -10, 0f, 0f, 0f, 0f, 10.0f, 10.0f);

    // Calculate the projection and view transformation
    Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mVMatrix, 0);

    // Draw square
    mSquare.draw(mMVPMatrix);
    // personaje.draw(mMVPMatrix);
    // Create a rotation for the triangle
    //        long time = SystemClock.uptimeMillis() % 4000L;
    //        float angle = 0.090f * ((int) time);
    Matrix.setRotateM(mRotationMatrix, 0, mAngle, 0, 0, -1.0f);

    // Combine the rotation matrix with the projection and camera view
    Matrix.multiplyMM(mMVPMatrix, 0, mRotationMatrix, 0, mMVPMatrix, 0);

    // Draw triangle
    // mTriangle.draw(mMVPMatrix);
  }
  /**
   * Called when a surface is created.
   *
   * @param gl The unused context.
   * @param config Unused configuration options.
   */
  @Override
  public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    GLES20.glClearColor(0.0f, 0f, 0f, 0.0f);
    // GLES20.glEnable(GLES20.GL_CULL_FACE);
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);

    final float eyeX = 0.0f;
    final float eyeY = 0.0f;
    final float eyeZ = 1.5f;
    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = -5.0f;
    // Set our up vector.
    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    // Set the view matrix => camera position
    Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

    // Create shaders (voodoo!):
    createShaders();
  }
 public void camMove(float ay, float az) {
   float[] matCamTemp = new float[16];
   float[] matZ = new float[16];
   Matrix.setRotateM(matZ, 0, az, 0.0f, 0.0f, 1.0f);
   Matrix.multiplyMM(matCamTemp, 0, matZ, 0, matCam, 0);
   matCopy(matCamTemp, matCam);
   Matrix.rotateM(matCam, 0, ay, 0.0f, 1.0f, 0.0f);
   if (Math.abs(Math.atan2(matCam[2], matCam[10])) > ANGLE_Y_LIMIT) {
     matCopy(matCamTemp, matCam);
   }
   Matrix.setLookAtM(
       mViewMatrix,
       0,
       matCam[0] * len,
       matCam[1] * len,
       matCam[2] * len,
       0.0f,
       0.0f,
       0.0f,
       0.0f,
       0.0f,
       1.0f);
 }
Example #18
0
  public static void setCamera(
      float cx, // 摄像机位置x
      float cy, // 摄像机位置y
      float cz, // 摄像机位置z
      float tx, // 摄像机目标点x
      float ty, // 摄像机目标点y
      float tz, // 摄像机目标点z
      float upx, // 摄像机UP向量X分量
      float upy, // 摄像机UP向量Y分量
      float upz // 摄像机UP向量Z分量	
      ) {
    Matrix.setLookAtM(mVMatrix, 0, cx, cy, cz, tx, ty, tz, upx, upy, upz);

    cameraLocation[0] = cx;
    cameraLocation[1] = cy;
    cameraLocation[2] = cz;

    llbb.clear();
    llbb.order(ByteOrder.nativeOrder()); // 设置字节顺序
    cameraFB = llbb.asFloatBuffer();
    cameraFB.put(cameraLocation);
    cameraFB.position(0);
  }
Example #19
0
  public void onSurfaceCreated(GL10 unused, EGLConfig config) {
    mSurfaceCreated = false;
    GLES20.glEnable(GLES20.GL_BLEND);
    //        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
    GLES20.glBlendFuncSeparate(
        GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA, GLES20.GL_ONE, GLES20.GL_ONE);
    GLES20.glClearColor(0, 0, 0, 0);

    // Set the camera position (View matrix)
    Matrix.setLookAtM(mVMatrix, 0, 0, 0, 1, 0, 0, -1, 0, 1, 0);

    GLColorOverlay.initGl();
    GLPicture.initGl();

    mColorOverlay = new GLColorOverlay(0);

    mSurfaceCreated = true;
    if (mQueuedNextBitmapRegionLoader != null) {
      BitmapRegionLoader loader = mQueuedNextBitmapRegionLoader;
      mQueuedNextBitmapRegionLoader = null;
      setAndConsumeBitmapRegionLoader(loader);
    }
  }
  @Override
  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {
    Log.d(TAG, "onSurfaceCreated");
    GLUtils.init();
    GLUtils.printSysConfig();

    // set the background color
    GLES20.glClearColor(0.0f, 1.0f, 0.0f, 1.0f);

    // set up the "camera"
    Matrix.setLookAtM(
        mViewMatrix,
        0,
        0.0f,
        0.0f,
        1.0f, // eye x,y,z
        0.0f,
        0.0f,
        0.0f, // look x,y,z
        0.0f,
        1.0f,
        0.0f); // up x,y,z

    mExternalSurfaceTexture = new ExternalSurfaceTexture();
    mReadExternalTextureShaderProgram = new ReadExternalTextureShaderProgram();

    mDefaultShaderProgram = new TextureShaderProgram();

    mTextureToScreenShaderProgram = new TextureShaderProgram();

    if (mOnExternalSurfaceTextureCreatedListener != null) {
      mOnExternalSurfaceTextureCreatedListener.onExternalSurfaceTextureCreated(
          mExternalSurfaceTexture);
    }

    mFrameRateCalculator = new FrameRateCalculator(30);
  }
Example #21
0
  @Override
  public void onSurfaceCreated(GL10 unused, EGLConfig config) {
    ShaderManager.getSingletonObject().unloadAll();
    ShaderManager.getSingletonObject().cleanUp();

    TextureManager.getSingletonObject().unloadAll();
    TextureManager.getSingletonObject().cleanUp();

    loadResources();

    if (phenixLineProgram != null) {
      phenixLineProgram.load();
    }

    ShaderManager.getSingletonObject().unloadAllShaders();

    renderTextures = new RenderTexture[2];
    frameBuffers = new FrameBuffer[2];

    setupFrameBuffer(unused);

    Matrix.setLookAtM(V_matrix, 0, 0, 0, 1.0f, 0f, 0f, 0f, 0f, -1.0f, 0.0f);
    Matrix.orthoM(Q_matrix, 0, 0, 1, 0, 1, -1, 1);
  }
  @Override
  public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    super.onSurfaceCreated(gl, config);
    // Set the background clear color to black.
    GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    // Use culling to remove back faces.
    GLES20.glEnable(GLES20.GL_CULL_FACE);

    // Enable depth testing
    GLES20.glEnable(GLES20.GL_DEPTH_TEST);

    // The below glEnable() call is a holdover from OpenGL ES 1, and is not needed in OpenGL ES 2.
    // Enable texture mapping
    // GLES20.glEnable(GLES20.GL_TEXTURE_2D);

    // Position the eye in front of the origin.
    final float eyeX = 0.0f;
    final float eyeY = 0.0f;
    final float eyeZ = -0.5f;

    // We are looking toward the distance
    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = -5.0f;

    // Set our up vector. This is where our head would be pointing were we holding the camera.
    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    // Set the view matrix. This matrix can be said to represent the camera position.
    // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
    // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
    Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

    final String vertexShader = getVertexShader();
    final String fragmentShader = getFragmentShader();

    final int vertexShaderHandle =
        ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, vertexShader);
    final int fragmentShaderHandle =
        ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);

    mProgramHandle =
        ShaderHelper.createAndLinkProgram(
            vertexShaderHandle,
            fragmentShaderHandle,
            new String[] {"a_Position", "a_Color", "a_Normal", "a_TexCoordinate"});

    // Define a simple shader program for our point.
    final String pointVertexShader =
        RawResourceReader.readTextFileFromRawResource(mContext, R.raw.point_vertex_shader);
    final String pointFragmentShader =
        RawResourceReader.readTextFileFromRawResource(mContext, R.raw.point_fragment_shader);

    final int pointVertexShaderHandle =
        ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, pointVertexShader);
    final int pointFragmentShaderHandle =
        ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, pointFragmentShader);
    mPointProgramHandle =
        ShaderHelper.createAndLinkProgram(
            pointVertexShaderHandle, pointFragmentShaderHandle, new String[] {"a_Position"});
  }
  private void drawCar(int program, float[] startPos) {
    Matrix.setIdentityM(mMMatrix, 0);
    Matrix.setIdentityM(mTransMatrix, 0);

    // Képernyõ Y tengely
    if (Math.abs(mDY) < 2) mDY = 0;

    if (Math.abs(mDY) <= 250) {
      accelY = -1 * mDY * 2;
    } else {
      if (mDY < 0) mDY = -250f;
      if (mDY > 0) mDY = 250f;
    }
    distanceY += accelY;
    Log.d("mDY:", String.valueOf(mDY));

    // Képernyõ X tengely
    if (Math.abs(mDX) < 2) mDX = 0;
    float[] forward = {(float) Math.cos(mDX / 50), 0.0f, (float) Math.sin(mDX / 50)};

    // lookAt
    lookAt[0] = eyePos[0] + 25 * forward[0];
    lookAt[1] = eyePos[1] + 25 * forward[1];
    lookAt[2] = eyePos[2] + 25 * forward[2];

    // eyePos
    eyePos[0] = 0.0f + distanceY / 1000 * forward[0];
    eyePos[2] = 25.0f + distanceY / 1000 * forward[2];

    Matrix.setLookAtM(
        mVMatrix, 0, eyePos[0], eyePos[1], eyePos[2], lookAt[0], lookAt[1], lookAt[2], 0.0f, 1.0f,
        0.0f);

    // Kormányzás
    startPos[0] = eyePos[0] + 5 * forward[0];
    startPos[2] = eyePos[2] + 5 * forward[2];

    Matrix.translateM(mTransMatrix, 0, startPos[0], startPos[1], startPos[2]);

    Matrix.multiplyMM(mMMatrix, 0, mMMatrix, 0, mTransMatrix, 0); // Translate
    Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, mMMatrix, 0); // View
    Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0); // Proj

    // send to the shader
    GLES20.glUniformMatrix4fv(
        GLES20.glGetUniformLocation(program, "uMVPMatrix"), 1, false, mMVPMatrix, 0);

    // Create the normal modelview matrix
    // Invert + transpose of mvpmatrix
    Matrix.invertM(normalMatrix, 0, mMVPMatrix, 0);
    Matrix.transposeM(normalMatrix, 0, normalMatrix, 0);

    // send to the shader
    GLES20.glUniformMatrix4fv(
        GLES20.glGetUniformLocation(program, "normalMatrix"), 1, false, mMVPMatrix, 0);

    /** * DRAWING OBJECT * */
    // Get buffers from mesh
    Object3D ob = this._objects[this.CUBE];
    Mesh mesh = ob.getMesh();
    FloatBuffer _vb = mesh.get_vb();
    ShortBuffer _ib = mesh.get_ib();

    short[] _indices = mesh.get_indices();

    // Vertex buffer

    // the vertex coordinates
    _vb.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
    GLES20.glVertexAttribPointer(
        GLES20.glGetAttribLocation(program, "aPosition"),
        3,
        GLES20.GL_FLOAT,
        false,
        TRIANGLE_VERTICES_DATA_STRIDE_BYTES,
        _vb);
    GLES20.glEnableVertexAttribArray(GLES20.glGetAttribLocation(program, "aPosition"));

    // the normal info
    _vb.position(TRIANGLE_VERTICES_DATA_NOR_OFFSET);
    GLES20.glVertexAttribPointer(
        GLES20.glGetAttribLocation(program, "aNormal"),
        3,
        GLES20.GL_FLOAT,
        false,
        TRIANGLE_VERTICES_DATA_STRIDE_BYTES,
        _vb);
    GLES20.glEnableVertexAttribArray(GLES20.glGetAttribLocation(program, "aNormal"));

    // Texture info

    // bind textures
    if (ob.hasTexture()) { // && enableTexture) {
      // number of textures
      int[] texIDs = ob.get_texID();

      for (int i = 0; i < _texIDs.length; i++) {
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + i);
        // Log.d("TEXTURE BIND: ", i + " " + texIDs[i]);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texIDs[i]);
        GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "texture" + (i + 1)), i);
      }
    }

    // enable texturing? [fix - sending float is waste]
    GLES20.glUniform1f(
        GLES20.glGetUniformLocation(program, "hasTexture") /*shader.hasTextureHandle*/,
        ob.hasTexture() && enableTexture ? 2.0f : 0.0f);

    // texture coordinates
    _vb.position(TRIANGLE_VERTICES_DATA_TEX_OFFSET);
    GLES20.glVertexAttribPointer(
        GLES20.glGetAttribLocation(program, "textureCoord") /*shader.maTextureHandle*/,
        2,
        GLES20.GL_FLOAT,
        false,
        TRIANGLE_VERTICES_DATA_STRIDE_BYTES,
        _vb);
    GLES20.glEnableVertexAttribArray(
        GLES20.glGetAttribLocation(
            program, "textureCoord")); // GLES20.glEnableVertexAttribArray(shader.maTextureHandle);

    // Draw with indices
    GLES20.glDrawElements(GLES20.GL_TRIANGLES, _indices.length, GLES20.GL_UNSIGNED_SHORT, _ib);
    checkGlError("glDrawElements");

    /** END DRAWING OBJECT ** */
  }
 @Override
 public void onSurfaceChanged(GL10 unused, int width, int height) {
   float aspect = (float) width / height;
   Matrix.perspectiveM(mMatrixProjection, 0, 60f, aspect, .1f, 10f);
   Matrix.setLookAtM(mMatrixView, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0);
 }
Example #25
0
 public static void updateCameraPos(float[] viewMatrix) {
   if (focus == null) return;
   VPoint focusPoint = focus.getAnchor();
   setPos((float) focusPoint.position.x, (float) focusPoint.position.y, 0.0f);
   Matrix.setLookAtM(viewMatrix, 0, pos[0], pos[1], -3, pos[0], pos[1], 0f, 0f, 1.0f, 0.0f);
 }
  /* (non-Javadoc)
   * @see fr.kesk.gl.shader.GlShader#render(fr.kesk.gl.GlAssets.Node)
   */
  @Override
  public void render(Node nodeInstance) {
    // android.util.Log.d(TAG,"render("+nodeInstance.id+")");
    if (this.lightType == Light.DIRECTIONAL) {
      this.lightModel[4] = this.lightModel[5] = this.lightModel[6] = 0f;
      this.lightModel[7] = 1f;
      MatrixUtils.multiplyMV(this.lightModel, 4, nodeInstance.model, 0, this.lightModel, 4);
      this.lightModel[0] = this.lightModel[4] - this.lightModel[8];
      this.lightModel[1] = this.lightModel[5] - this.lightModel[9];
      this.lightModel[2] = this.lightModel[6] - this.lightModel[10];
      this.lightModel[3] = 1f;
      Matrix.setLookAtM(
          this.lightMvpCache,
          0,
          this.lightModel[0],
          this.lightModel[1],
          this.lightModel[2],
          this.lightModel[4],
          this.lightModel[5],
          this.lightModel[6],
          0f,
          1f,
          0f);
      MatrixUtils.multiplyMM(this.lightMvpCache, 32, this.lightMvpCache, 16, this.lightMvpCache, 0);
      MatrixUtils.multiplyMM(
          this.currentShadowMap.shadowMatrix,
          0,
          GlFastShadowMapShader.BIAS_MATRIX,
          0,
          this.lightMvpCache,
          32);
    } else if (this.lightType == Light.POINT) {
      this.lightModel[4] = this.lightModel[5] = this.lightModel[6] = 0f;
      this.lightModel[7] = 1f;
      MatrixUtils.multiplyMV(this.lightModel, 4, nodeInstance.model, 0, this.lightModel, 4);
      Matrix.setLookAtM(
          this.lightMvpCache,
          0,
          this.lightModel[0],
          this.lightModel[1],
          this.lightModel[2],
          this.lightModel[4],
          this.lightModel[5],
          this.lightModel[6],
          0f,
          1f,
          0f);
      MatrixUtils.multiplyMM(this.lightMvpCache, 32, this.lightMvpCache, 16, this.lightMvpCache, 0);
      MatrixUtils.multiplyMM(
          this.currentShadowMap.shadowMatrix,
          0,
          GlFastShadowMapShader.BIAS_MATRIX,
          0,
          this.lightMvpCache,
          32);
    }

    // Render the scene in the FBO
    this.fbo.bind();
    this.program.start();
    this.cullfaceMode = GlContext.glGetState(GLES20.GL_CULL_FACE_MODE);
    this.viewPort = GlContext.glGetState(GLES20.GL_VIEWPORT);
    GLES20.glCullFace(GLES20.GL_FRONT);
    GLES20.glViewport(0, 0, this.quality, this.quality);
    GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
    GLES20.glEnableVertexAttribArray(this.a_PositionVec4Handle);
    this.drawNode(nodeInstance);
    GLES20.glDisableVertexAttribArray(this.a_PositionVec4Handle);
    this.fbo.unbind();
    GLES20.glCullFace((int) this.cullfaceMode[0]);
    GLES20.glViewport(
        (int) this.viewPort[0],
        (int) this.viewPort[1],
        (int) this.viewPort[2],
        (int) this.viewPort[3]);
  }
Example #27
0
 public CameraGL() {
   viewMatrix = new float[16];
   projectionMatrix = new float[16];
   Matrix.setLookAtM(viewMatrix, 0, 0f, 0f, -100.0f, 0f, 0f, 1f, 0f, 1.0f, 0.0f);
 }
Example #28
0
  @Override
  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {

    SurfaceCreated(glUnused, config);
    // Set the background clear color to gray.
    GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);

    // Position the eye behind the origin.
    final float eyeX = 0.0f;
    final float eyeY = 0.0f;
    final float eyeZ = 1.5f;

    // We are looking toward the distance
    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = -5.0f;

    // Set our up vector. This is where our head would be pointing were we holding the camera.
    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    // Set the view matrix. This matrix can be said to represent the camera position.
    // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
    // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
    Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

    final String vertexShader =
        "uniform mat4 u_MVPMatrix;      \n" // A constant representing the combined
            // model/view/projection matrix.
            + "attribute vec4 a_Position;     \n" // Per-vertex position information we will pass
            // in.
            + "attribute vec4 a_Color;        \n" // Per-vertex color information we will pass in.
            + "varying vec4 v_Color;          \n" // This will be passed into the fragment shader.
            + "void main()                    \n" // The entry point for our vertex shader.
            + "{                              \n"
            + "   v_Color = a_Color;          \n" // Pass the color through to the fragment shader.
            // It will be interpolated across the triangle.
            + "   gl_Position = u_MVPMatrix   \n" // gl_Position is a special variable used to store
            // the final position.
            + "               * a_Position;   \n" // Multiply the vertex by the matrix to get the
            // final point in
            + "}                              \n"; // normalized screen coordinates.

    final String fragmentShader =
        "precision mediump float;       \n" // Set the default precision to medium. We don't need as
            // high of a
            // precision in the fragment shader.
            + "varying vec4 v_Color;          \n" // This is the color from the vertex shader
            // interpolated across the
            // triangle per fragment.
            + "void main()                    \n" // The entry point for our fragment shader.
            + "{                              \n"
            + "   gl_FragColor = v_Color;     \n" // Pass the color directly through the pipeline.
            + "}                              \n";

    // Load in the vertex shader.
    int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);

    if (vertexShaderHandle != 0) {
      // Pass in the shader source.
      GLES20.glShaderSource(vertexShaderHandle, vertexShader);

      // Compile the shader.
      GLES20.glCompileShader(vertexShaderHandle);

      // Get the compilation status.
      final int[] compileStatus = new int[1];
      GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

      // If the compilation failed, delete the shader.
      if (compileStatus[0] == 0) {
        GLES20.glDeleteShader(vertexShaderHandle);
        vertexShaderHandle = 0;
      }
    }

    if (vertexShaderHandle == 0) {
      throw new RuntimeException("Error creating vertex shader.");
    }

    // Load in the fragment shader shader.
    int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);

    if (fragmentShaderHandle != 0) {
      // Pass in the shader source.
      GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);

      // Compile the shader.
      GLES20.glCompileShader(fragmentShaderHandle);

      // Get the compilation status.
      final int[] compileStatus = new int[1];
      GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

      // If the compilation failed, delete the shader.
      if (compileStatus[0] == 0) {
        GLES20.glDeleteShader(fragmentShaderHandle);
        fragmentShaderHandle = 0;
      }
    }

    if (fragmentShaderHandle == 0) {
      throw new RuntimeException("Error creating fragment shader.");
    }

    // Create a program object and store the handle to it.
    int programHandle = GLES20.glCreateProgram();

    if (programHandle != 0) {
      // Bind the vertex shader to the program.
      GLES20.glAttachShader(programHandle, vertexShaderHandle);

      // Bind the fragment shader to the program.
      GLES20.glAttachShader(programHandle, fragmentShaderHandle);

      // Bind attributes
      GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
      GLES20.glBindAttribLocation(programHandle, 1, "a_Color");

      // Link the two shaders together into a program.
      GLES20.glLinkProgram(programHandle);

      // Get the link status.
      final int[] linkStatus = new int[1];
      GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);

      // If the link failed, delete the program.
      if (linkStatus[0] == 0) {
        GLES20.glDeleteProgram(programHandle);
        programHandle = 0;
      }
    }

    if (programHandle == 0) {
      throw new RuntimeException("Error creating program.");
    }

    // Set program handles. These will later be used to pass in values to the program.
    mMVPMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");
    mPositionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
    mColorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");

    // Tell OpenGL to use this program when rendering.
    GLES20.glUseProgram(programHandle);
  }
  /** Initialization function */
  public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {
    // initialize shaders
    try {
      _shaders[GOURAUD_SHADER] =
          new Shader(
              vShaders[GOURAUD_SHADER], fShaders[GOURAUD_SHADER], mContext, false, 0); // gouraud
      _shaders[PHONG_SHADER] =
          new Shader(vShaders[PHONG_SHADER], fShaders[PHONG_SHADER], mContext, false, 0); // phong
      _shaders[NORMALMAP_SHADER] =
          new Shader(
              vShaders[NORMALMAP_SHADER],
              fShaders[NORMALMAP_SHADER],
              mContext,
              false,
              0); // normal map
    } catch (Exception e) {
      Log.d("SHADER 0 SETUP", e.getLocalizedMessage());
    }

    GLES20.glEnable(GLES20.GL_DEPTH_TEST);
    GLES20.glClearDepthf(1.0f);
    GLES20.glDepthFunc(GLES20.GL_LEQUAL);
    GLES20.glDepthMask(true);

    // cull backface
    GLES20.glEnable(GLES20.GL_CULL_FACE);
    GLES20.glCullFace(GLES20.GL_BACK);

    // light variables
    float[] lightP = {30.0f, 0.0f, 10.0f, 1};
    this.lightPos = lightP;

    float[] lightC = {0.5f, 0.5f, 0.5f};
    this.lightColor = lightC;

    // material properties
    float[] mA = {0.45f, 0.45f, 0.45f, 1.0f};
    matAmbient = mA;

    float[] mD = {0.6f, 0.6f, 0.6f, 1.0f};
    matDiffuse = mD;

    float[] mS = {0.9f, 0.9f, 0.9f, 1.0f};
    matSpecular = mS;

    matShininess = 5.0f;

    // setup textures for all objects
    for (int i = 0; i < _objects.length; i++) setupTextures(_objects[i]);

    // set the view matrix

    Matrix.setLookAtM(
        mVMatrix, 0, eyePos[0], eyePos[1], eyePos[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    /*Matrix.setLookAtM(
    rm,
    rmOffset,
    eyeX, eyeY, eyeZ,
    centerX, centerY, centerZ,
    upX, upY, upZ)*/
  }
  public void camZoom(float exp) {
    len = LEN_DEFAULT * (float) Math.pow(LEN_RANGE, exp);

    Matrix.perspectiveM(
        mProjectionMatrix,
        0,
        FOV / (float) Math.PI * 180.0f,
        ratio,
        len / LEN_RANGE,
        len * LEN_RANGE);
    Matrix.setLookAtM(
        mViewMatrix,
        0,
        matCam[0] * len,
        matCam[1] * len,
        matCam[2] * len,
        0.0f,
        0.0f,
        0.0f,
        0.0f,
        0.0f,
        1.0f);

    float[] lightPos = {len, len, 0};
    GLES20.glUniform3fv(mLightPosHandle, 1, lightPos, 0);
  }