Java Code Examples for javax.microedition.khronos.egl.EGL10#EGL_NONE

public ComponentSizeChooserAntialiasNormal(int redSize, int greenSize, int blueSize,
        int alphaSize, int depthSize, int stencilSize) {
    super(
            new int[] {
            EGL10.EGL_RED_SIZE, redSize,
            EGL10.EGL_GREEN_SIZE, greenSize,
            EGL10.EGL_BLUE_SIZE, blueSize,
            EGL10.EGL_ALPHA_SIZE, alphaSize,
            EGL10.EGL_DEPTH_SIZE, depthSize,
            EGL10.EGL_STENCIL_SIZE, stencilSize,
            EGL10.EGL_RENDERABLE_TYPE, 4 /* EGL_OPENGL_ES2_BIT */,
            EGL10.EGL_SAMPLE_BUFFERS, 1 /* true */,
            EGL10.EGL_SAMPLES, 2,
            EGL10.EGL_NONE},
            redSize, greenSize, blueSize, 
            alphaSize, depthSize, stencilSize);
}
 

private void initGL() {

        int[] configAttribs = {
                EGL10.EGL_BUFFER_SIZE, 32,
                EGL10.EGL_ALPHA_SIZE, 8,
                EGL10.EGL_BLUE_SIZE, 8,
                EGL10.EGL_GREEN_SIZE, 8,
                EGL10.EGL_RED_SIZE, 8,
                EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,
                EGL10.EGL_NONE
        };

        mEgl = (EGL10) EGLContext.getEGL();
        mEGLDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
        mEgl.eglInitialize(mEGLDisplay, new int[2]);
        mEgl.eglChooseConfig(mEGLDisplay, configAttribs, mEglConfigs, 1, new int[1]);
    }
 

@Override
public void createPbufferSurface(int width, int height) {
  checkIsNotReleased();
  if (eglSurface != EGL10.EGL_NO_SURFACE) {
    throw new RuntimeException("Already has an EGLSurface");
  }
  int[] surfaceAttribs = {EGL10.EGL_WIDTH, width, EGL10.EGL_HEIGHT, height, EGL10.EGL_NONE};
  eglSurface = egl.eglCreatePbufferSurface(eglDisplay, eglConfig, surfaceAttribs);
  if (eglSurface == EGL10.EGL_NO_SURFACE) {
    throw new RuntimeException("Failed to create pixel buffer surface with size " + width + "x"
        + height + ": 0x" + Integer.toHexString(egl.eglGetError()));
  }
}
 

private int[] filterConfigSpec(int[] configSpec) {
  int len = configSpec.length;
  int[] newConfigSpec = new int[len + 2];
  System.arraycopy(configSpec, 0, newConfigSpec, 0, len - 1);
  newConfigSpec[len - 1] = EGL10.EGL_RENDERABLE_TYPE;
  newConfigSpec[len] = 4; /* EGL_OPENGL_ES2_BIT */
  newConfigSpec[len + 1] = EGL10.EGL_NONE;
  return newConfigSpec;
}
 

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
  int[] attrib_list = {
      EGL_CONTEXT_CLIENT_VERSION, eglContextClientVersion, EGL10.EGL_NONE
  };

  return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
      eglContextClientVersion != 0 ? attrib_list : null);
}
 

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
	Log.w(TAG, "creating OpenGL ES 2.0 context");
	checkEglError("Before eglCreateContext", egl);
	int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
	EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
	checkEglError("After eglCreateContext", egl);
	return context;
}
 

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
    int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion,
            EGL10.EGL_NONE };

    return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
            mEGLContextClientVersion != 0 ? attrib_list : null);
}
 

public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display)
{
    // This EGL config specification is used to specify 2.0
    // rendering. We use a minimum size of 4 bits for
    // red/green/blue, but will perform actual matching in
    // chooseConfig() below.
    final int EGL_OPENGL_ES2_BIT = 0x0004;
    final int[] s_configAttribs_gl20 = { EGL10.EGL_RED_SIZE, 4,
            EGL10.EGL_GREEN_SIZE, 4, EGL10.EGL_BLUE_SIZE, 4,
            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL10.EGL_NONE };
        
    return getMatchingConfig(egl, display, s_configAttribs_gl20);
}
 

@Override
public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config, Object nativeWindow) {
    int[] attribList = new int[]{
            EGL10.EGL_WIDTH, width,
            EGL10.EGL_HEIGHT, height,
            EGL10.EGL_NONE
    };
    return egl.eglCreatePbufferSurface(display, config, attribList);
}
 

public GLRender(int width, int height) {
	
	int[] version = new int[2];   
	EGLConfig[] configs = new EGLConfig[1];  
	int[] num_config = new int[1];  

	int[] configSpec ={  
			EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,   
			EGL10.EGL_RED_SIZE, 8,  
			EGL10.EGL_GREEN_SIZE, 8,  
			EGL10.EGL_BLUE_SIZE, 8,  
			EGL10.EGL_ALPHA_SIZE, 8,  
			EGL10.EGL_NONE   
	};  

	int attribListPbuffer[] = {  
			EGL10.EGL_WIDTH, width,  
			EGL10.EGL_HEIGHT, height,  
			EGL10.EGL_NONE  
	};
	
	mEgl = (EGL10)EGLContext.getEGL();
	mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

	mEgl.eglInitialize(mEglDisplay, version);

	mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, num_config);

	EGLConfig mEglConfig = configs[0];

	mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig, EGL10.EGL_NO_CONTEXT, null);
	if (mEglContext == EGL10.EGL_NO_CONTEXT) {
		Log.d(TAG, "EGL_NO_CONTEXT");
	}

	mEglPBSurface = mEgl.eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribListPbuffer);
	if (mEglPBSurface == EGL10.EGL_NO_SURFACE) {
		int errorcode = mEgl.eglGetError();
		switch(errorcode) {
		case EGL10.EGL_BAD_DISPLAY:
			Log.d(TAG, "EGL_BAD_DISPLAY");
			break;
		case EGL10.EGL_NOT_INITIALIZED:
			Log.d(TAG, "EGL_NOT_INITIALIZED");
			break;
		case EGL10.EGL_BAD_CONFIG:
			Log.d(TAG, "EGL_BAD_CONFIG");
			break;
		case EGL10.EGL_BAD_ATTRIBUTE:
			Log.d(TAG, "EGL_BAD_ATTRIBUTE");
			break;
		case EGL10.EGL_BAD_ALLOC:
			Log.d(TAG, "EGL_BAD_ALLOC");
			break;
		case EGL10.EGL_BAD_MATCH:
			Log.d(TAG, "EGL_BAD_MATCH");
			break;
		}				
	}


	if (!mEgl.eglMakeCurrent(mEglDisplay, mEglPBSurface, mEglPBSurface, mEglContext)) {
		Log.d(TAG, "bind failed code:" + mEgl.eglGetError());
	}

	mGL = (GL10) mEglContext.getGL();
	PixelBuffer = IntBuffer.allocate(width * height);
}
 

private void eglSetup(int width, int height) {
    mEGL = (EGL10) EGLContext.getEGL();
    mEGLDisplay = mEGL.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

    if (mEGLDisplay == EGL10.EGL_NO_DISPLAY) {
        throw new RuntimeException("unable to get EGL10 display");
    }

    if (!mEGL.eglInitialize(mEGLDisplay, null)) {
        mEGLDisplay = null;
        throw new RuntimeException("unable to initialize EGL10");
    }

    int[] attribList = {
            EGL10.EGL_RED_SIZE, 8,
            EGL10.EGL_GREEN_SIZE, 8,
            EGL10.EGL_BLUE_SIZE, 8,
            EGL10.EGL_ALPHA_SIZE, 8,
            EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,
            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL10.EGL_NONE
    };
    EGLConfig[] configs = new EGLConfig[1];
    int[] numConfigs = new int[1];
    if (!mEGL.eglChooseConfig(mEGLDisplay, attribList, configs, configs.length, numConfigs)) {
        throw new RuntimeException("unable to find RGB888+pbuffer EGL config");
    }
    int[] attrib_list = {
            EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL10.EGL_NONE
    };
    mEGLContext = mEGL.eglCreateContext(mEGLDisplay, configs[0], EGL10.EGL_NO_CONTEXT, attrib_list);
    checkEglError("eglCreateContext");
    if (mEGLContext == null) {
        throw new RuntimeException("null context");
    }
    int[] surfaceAttribs = {
            EGL10.EGL_WIDTH, width,
            EGL10.EGL_HEIGHT, height,
            EGL10.EGL_NONE
    };
    mEGLSurface = mEGL.eglCreatePbufferSurface(mEGLDisplay, configs[0], surfaceAttribs);
    checkEglError("eglCreatePbufferSurface");
    if (mEGLSurface == null) {
        throw new RuntimeException("surface was null");
    }
}
 

@Override public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
  // try to find a normal configuration first.
  int[] configSpec = {
      EGL10.EGL_RED_SIZE, r, EGL10.EGL_GREEN_SIZE, g, EGL10.EGL_BLUE_SIZE, b,
      EGL10.EGL_ALPHA_SIZE, a, EGL10.EGL_DEPTH_SIZE, depth, EGL10.EGL_STENCIL_SIZE, stencil,
      EGL10.EGL_RENDERABLE_TYPE, renderableType, EGL10.EGL_SAMPLE_BUFFERS, 1, EGL10.EGL_SAMPLES,
      multisample, EGL10.EGL_NONE
  };
  value = new int[1];
  if (!egl.eglChooseConfig(display, configSpec, null, 0, value)) {
    throw new IllegalArgumentException("eglChooseConfig failed");
  }
  int numConfigs = value[0];

  // No normal multisampling config was found. Try to create a
  // converage multisampling configuration, for the nVidia Tegra2.
  // See the EGL_NV_coverage_sample documentation.
  if (numConfigs <= 0 && multisample > 1) {
    final int EGL_COVERAGE_BUFFERS_NV = 0x30E0;
    final int EGL_COVERAGE_SAMPLES_NV = 0x30E1;

    configSpec = new int[] {
        EGL10.EGL_RED_SIZE, r, EGL10.EGL_GREEN_SIZE, g, EGL10.EGL_BLUE_SIZE, b,
        EGL10.EGL_ALPHA_SIZE, a, EGL10.EGL_DEPTH_SIZE, depth, EGL10.EGL_STENCIL_SIZE, stencil,
        EGL10.EGL_RENDERABLE_TYPE, renderableType, EGL_COVERAGE_BUFFERS_NV, 1,
        EGL_COVERAGE_SAMPLES_NV, multisample, EGL10.EGL_NONE
    };

    if (!egl.eglChooseConfig(display, configSpec, null, 0, value)) {
      throw new IllegalArgumentException("2nd eglChooseConfig failed");
    }
    numConfigs = value[0];

    // Give up, try without multisampling.
    if (numConfigs <= 0) {
      configSpec = new int[] {
          EGL10.EGL_RED_SIZE, r, EGL10.EGL_GREEN_SIZE, g, EGL10.EGL_BLUE_SIZE, b,
          EGL10.EGL_ALPHA_SIZE, a, EGL10.EGL_DEPTH_SIZE, depth, EGL10.EGL_STENCIL_SIZE, stencil,
          EGL10.EGL_RENDERABLE_TYPE, renderableType, EGL10.EGL_NONE
      };

      if (!egl.eglChooseConfig(display, configSpec, null, 0, value)) {
        throw new IllegalArgumentException("3rd eglChooseConfig failed");
      }
      numConfigs = value[0];

      if (numConfigs <= 0) {
        throw new IllegalArgumentException("No configs match configSpec");
      }
    } else {
      usesCoverageAa = true;
      Log.i(TAG, "usesCoverageAa");
    }
  }

  // Get all matching configurations.
  EGLConfig[] configs = new EGLConfig[numConfigs];
  if (!egl.eglChooseConfig(display, configSpec, configs, numConfigs, value)) {
    throw new IllegalArgumentException("data eglChooseConfig failed");
  }

  // CAUTION! eglChooseConfigs returns configs with higher bit depth
  // first: Even though we asked for rgb565 configurations, rgb888
  // configurations are considered to be "better" and returned first.
  // You need to explicitly filter the data returned by eglChooseConfig!
  int index = -1;
  for (int i = 0; i < configs.length; ++i) {
    if (findConfigAttrib(egl, display, configs[i], EGL10.EGL_RED_SIZE, 0) == r) {
      index = i;
      break;
    }
  }
  if (index == -1) {
    Log.i(TAG, "Did not find sane config, using first");
  }
  EGLConfig config = configs.length > 0 ? configs[index] : null;
  if (config == null) {
    throw new IllegalArgumentException("No config chosen");
  }
  return config;
}
 

EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
    int[] attribList = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
    return egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attribList);
}
 

@Override
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
    int[] val = new int[1];

    // Try to find a normal multisample configuration first.
    int[] configSpec = {
            EGL10.EGL_RED_SIZE, 5,
            EGL10.EGL_GREEN_SIZE, 6,
            EGL10.EGL_BLUE_SIZE, 5,
            EGL10.EGL_ALPHA_SIZE, 8,
            EGL10.EGL_DEPTH_SIZE, 16,
            // Requires that setEGLContextClientVersion(2) is called on the view.
            EGL10.EGL_RENDERABLE_TYPE, 4 /*EGL14.EGL_OPENGL_ES2_BIT*/ /*0x40 /*EGLExt.EGL_OPENGL_ES3_BIT_KHR*/,
            EGL10.EGL_STENCIL_SIZE, 8,
            EGL10.EGL_NONE};

    if (!egl.eglChooseConfig(display, configSpec, null, 0, val)) {
        throw new IllegalArgumentException("eglChooseConfig failed");
    }
    int numConfigs = val[0];

    if (numConfigs <= 0) {

        configSpec = new int[]{
                // EGL10.EGL_RENDERABLE_TYPE, 4, EGL10.EGL_NONE };
                EGL10.EGL_RED_SIZE, 8,
                EGL10.EGL_GREEN_SIZE, 8,
                EGL10.EGL_BLUE_SIZE, 8,
                EGL10.EGL_ALPHA_SIZE, 8,
                EGL10.EGL_DEPTH_SIZE, 16,
                EGL10.EGL_RENDERABLE_TYPE, 4 /*EGL14.EGL_OPENGL_ES2_BIT*/ /*0x40 /*EGLExt.EGL_OPENGL_ES3_BIT_KHR*/,
                EGL10.EGL_STENCIL_SIZE, 8,
                EGL10.EGL_NONE};

        if (!egl.eglChooseConfig(display, configSpec, null, 0, val)) {
            throw new IllegalArgumentException("eglChooseConfig failed");
        }
        numConfigs = val[0];

        if (numConfigs <= 0) {
            throw new IllegalArgumentException("No configs match configSpec");
        }
    }

    // Get all matching configurations.
    EGLConfig[] configs = new EGLConfig[numConfigs];
    if (!egl.eglChooseConfig(display, configSpec, configs, numConfigs, val)) {
        throw new IllegalArgumentException("data eglChooseConfig failed");
    }

    // CAUTION! eglChooseConfigs returns configs with higher bit depth
    // first: Even though we asked for rgb565 configurations, rgb888
    // configurations are considered to be "better" and returned first.
    // You need to explicitly filter the data returned by eglChooseConfig!

    EGLConfig config = configs.length > 0 ? configs[0] : null;
    if (config == null) {
        throw new IllegalArgumentException("No config chosen");
    }
    return config;
}
 

int[] build(){
    return new int[]{0x3098,version, EGL10.EGL_NONE};
}
 

EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
    int[] attribList = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
    return egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attribList);
}
 

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
  int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};

  return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, attrib_list);
}
 

private boolean initGL() {
    egl10 = (EGL10) EGLContext.getEGL();

    eglDisplay = egl10.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
    if (eglDisplay == EGL10.EGL_NO_DISPLAY) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglGetDisplay failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    }

    int[] version = new int[2];
    if (!egl10.eglInitialize(eglDisplay, version)) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglInitialize failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    }

    int[] configsCount = new int[1];
    EGLConfig[] configs = new EGLConfig[1];
    int[] configSpec = new int[]{
            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL10.EGL_RED_SIZE, 8,
            EGL10.EGL_GREEN_SIZE, 8,
            EGL10.EGL_BLUE_SIZE, 8,
            EGL10.EGL_ALPHA_SIZE, 8,
            EGL10.EGL_DEPTH_SIZE, 0,
            EGL10.EGL_STENCIL_SIZE, 0,
            EGL10.EGL_NONE
    };
    EGLConfig eglConfig;
    if (!egl10.eglChooseConfig(eglDisplay, configSpec, configs, 1, configsCount)) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglChooseConfig failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    } else if (configsCount[0] > 0) {
        eglConfig = configs[0];
    } else {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglConfig not initialized");
        }
        finish();
        return false;
    }

    int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};
    eglContext = egl10.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
    if (eglContext == null) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglCreateContext failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    }

    if (surfaceTexture instanceof SurfaceTexture) {
        eglSurface = egl10.eglCreateWindowSurface(eglDisplay, eglConfig, surfaceTexture, null);
    } else {
        finish();
        return false;
    }

    if (eglSurface == null || eglSurface == EGL10.EGL_NO_SURFACE) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("createWindowSurface failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    }
    if (!egl10.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
        if (BuildVars.LOGS_ENABLED) {
            FileLog.e("eglMakeCurrent failed " + GLUtils.getEGLErrorString(egl10.eglGetError()));
        }
        finish();
        return false;
    }

    GLES20.glEnable(GLES20.GL_BLEND);
    GLES20.glDisable(GLES20.GL_DITHER);
    GLES20.glDisable(GLES20.GL_STENCIL_TEST);
    GLES20.glDisable(GLES20.GL_DEPTH_TEST);

    painting.setupShaders();
    checkBitmap();
    painting.setBitmap(bitmap);

    Utils.HasGLError();

    return true;
}
 

private void eglSetup(int width, int height) {
    mEGL = (EGL10) EGLContext.getEGL();
    mEGLDisplay = mEGL.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

    if (mEGLDisplay == EGL10.EGL_NO_DISPLAY) {
        throw new RuntimeException("unable to get EGL10 display");
    }

    if (!mEGL.eglInitialize(mEGLDisplay, null)) {
        mEGLDisplay = null;
        throw new RuntimeException("unable to initialize EGL10");
    }

    int[] attribList = {
            EGL10.EGL_RED_SIZE, 8,
            EGL10.EGL_GREEN_SIZE, 8,
            EGL10.EGL_BLUE_SIZE, 8,
            EGL10.EGL_ALPHA_SIZE, 8,
            EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,
            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL10.EGL_NONE
    };
    EGLConfig[] configs = new EGLConfig[1];
    int[] numConfigs = new int[1];
    if (!mEGL.eglChooseConfig(mEGLDisplay, attribList, configs, configs.length, numConfigs)) {
        throw new RuntimeException("unable to find RGB888+pbuffer EGL config");
    }
    int[] attrib_list = {
            EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL10.EGL_NONE
    };
    mEGLContext = mEGL.eglCreateContext(mEGLDisplay, configs[0], EGL10.EGL_NO_CONTEXT, attrib_list);
    checkEglError("eglCreateContext");
    if (mEGLContext == null) {
        throw new RuntimeException("null context");
    }
    int[] surfaceAttribs = {
            EGL10.EGL_WIDTH, width,
            EGL10.EGL_HEIGHT, height,
            EGL10.EGL_NONE
    };
    mEGLSurface = mEGL.eglCreatePbufferSurface(mEGLDisplay, configs[0], surfaceAttribs);
    checkEglError("eglCreatePbufferSurface");
    if (mEGLSurface == null) {
        throw new RuntimeException("surface was null");
    }
}
 

public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
    int[] attr_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };

    context = egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, attr_list);
    return context;
}