protected void setGLBackgroundTransparent(boolean transparent) {
   if (transparent) {
     mSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
     mSurfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
     mSurfaceView.setZOrderOnTop(true);
   } else {
     mSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
     mSurfaceView.getHolder().setFormat(PixelFormat.RGBA_8888);
     mSurfaceView.setZOrderOnTop(false);
   }
 }
Esempio n. 2
0
  private View createGLSurfaceView(
      Activity activity, boolean useGL2, final ResolutionStrategy resolutionStrategy) {
    EGLConfigChooser configChooser = getEglConfigChooser();
    if (useGL2 && checkGL20()) {
      //			GLSurfaceView20 view = new GLSurfaceView20(activity, resolutionStrategy);
      GLSurfaceView20 view = new GLSurfaceView20(activity, true, 16, 0, resolutionStrategy);
      Log.v("launcher", "create gl");
      //			view.setZOrderOnTop(true);
      if (configChooser != null) view.setEGLConfigChooser(configChooser);
      else
        view.setEGLConfigChooser(
            config.r, config.g, config.b, config.a, config.depth, config.stencil);
      // view.pauseEglHelper = config.pauseEglHelper;
      view.setRenderer(this);
      return view;
    } else {
      config.useGL20 = false;
      configChooser = getEglConfigChooser();
      int sdkVersion = Integer.parseInt(android.os.Build.VERSION.SDK);
      if (sdkVersion >= 11) {
        GLSurfaceView view =
            new GLSurfaceView(activity) {

              @Override
              protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                ResolutionStrategy.MeasuredDimension measures =
                    resolutionStrategy.calcMeasures(widthMeasureSpec, heightMeasureSpec);
                setMeasuredDimension(measures.width, measures.height);
              }
            };
        if (configChooser != null) view.setEGLConfigChooser(configChooser);
        else
          view.setEGLConfigChooser(
              config.r, config.g, config.b, config.a, config.depth, config.stencil);
        // view.pauseEglHelper = config.pauseEglHelper;
        view.setRenderer(this);
        return view;
      } else {
        GLSurfaceViewCupcake view = new GLSurfaceViewCupcake(activity, resolutionStrategy);
        if (configChooser != null) view.setEGLConfigChooser(configChooser);
        else
          view.setEGLConfigChooser(
              config.r, config.g, config.b, config.a, config.depth, config.stencil);
        view.setRenderer(this);
        return view;
      }
    }
  }
Esempio n. 3
0
  @Override
  public void onCreate(Bundle savedInstanceState) {

    Logger.log("onCreate");
    if (master != null) {
      copy(master);
    }
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow()
        .setFlags(
            WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    mGLView = new GLSurfaceView(getApplication());
    mGLView.setEGLConfigChooser(
        new GLSurfaceView.EGLConfigChooser() {
          public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
            // Ensure that we get a 16bit framebuffer. Otherwise, we'll fall
            // back to Pixelflinger on some device (read: Samsung I7500)
            int[] attributes = new int[] {EGL10.EGL_DEPTH_SIZE, 16, EGL10.EGL_NONE};
            EGLConfig[] configs = new EGLConfig[1];
            int[] result = new int[1];
            egl.eglChooseConfig(display, attributes, configs, 1, result);
            return configs[0];
          }
        });
    mGLView.setLayoutParams(
        new FrameLayout.LayoutParams(
            FrameLayout.LayoutParams.FILL_PARENT, FrameLayout.LayoutParams.FILL_PARENT));
    mGLView.setRenderer(new BRenderer());

    this.setContentView(mGLView);
    wakeLock = getWakeLock(this, TAG);
  }
  @Override
  public void onSetScript() {
    mSurfaceView = new GLSurfaceView(mActivity);

    mSurfaceView.setPreserveEGLContextOnPause(true);
    mSurfaceView.setEGLContextClientVersion(3);
    mSurfaceView.setEGLContextFactory(mContextFactory);
    mSurfaceView.setEGLConfigChooser(mConfigChooser);
    mSurfaceView.setEGLWindowSurfaceFactory(mWindowSurfaceFactory);
    mSurfaceView.setRenderer(mRenderer);
    mSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

    mActivity.setContentView(mSurfaceView);

    final DisplayMetrics metrics = new DisplayMetrics();
    mActivity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
    final VrAppSettings appSettings = mActivity.getAppSettings();
    final int screenWidthPixels = Math.max(metrics.widthPixels, metrics.heightPixels);
    final int screenHeightPixels = Math.min(metrics.widthPixels, metrics.heightPixels);
    final int frameBufferWidth = appSettings.getFramebufferPixelsWide();
    final int frameBufferHeight = appSettings.getFramebufferPixelsHigh();
    final SurfaceHolder holder = mSurfaceView.getHolder();
    holder.setFormat(PixelFormat.TRANSLUCENT);

    if ((-1 != frameBufferHeight) && (-1 != frameBufferWidth)) {
      if ((screenWidthPixels != frameBufferWidth) && (screenHeightPixels != frameBufferHeight)) {
        Log.v(TAG, "--- window configuration ---");
        Log.v(TAG, "--- width: %d", frameBufferWidth);
        Log.v(TAG, "--- height: %d", frameBufferHeight);
        // a different resolution of the native window requested
        holder.setFixedSize((int) frameBufferWidth, (int) frameBufferHeight);
        Log.v(TAG, "----------------------------");
      }
    }
  }
 private void initGLSurfaceView() {
   if (glView != null) {
     glView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
     glView.setRenderer(renderer);
     glView.setOnTouchListener(this);
   }
 }
 private void init(Context context, AttributeSet attrs) {
   mGLSurfaceView = new GPUImageGLSurfaceView(context, attrs);
   mGLSurfaceView.setZOrderOnTop(true);
   mGLSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
   mGLSurfaceView.getHolder().setFormat(PixelFormat.TRANSPARENT);
   addView(mGLSurfaceView);
   mGPUImage = new GPUImage(getContext());
   mGPUImage.setGLSurfaceView(mGLSurfaceView);
 }
Esempio n. 7
0
 /**
  * Sets the GLSurfaceView which will display the preview.
  *
  * @param view the GLSurfaceView
  */
 public void setGLSurfaceView(final GLSurfaceView view) {
   mGlSurfaceView = view;
   // 设置OpenGl版本号为2
   mGlSurfaceView.setEGLContextClientVersion(2);
   // 设置颜色缓存为RGBA,位数都为8,深度缓存位数为16,蒙版缓存位数为0
   mGlSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
   mGlSurfaceView.getHolder().setFormat(PixelFormat.RGBA_8888);
   mGlSurfaceView.setRenderer(mRenderer);
   // 脏模式,需要重绘时手动调用requestRender()
   mGlSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
   mGlSurfaceView.requestRender();
 }
 public void resetSurfaceView() {
   removeViewInLayout(surfaceView);
   surfaceView = null;
   surfaceView = new GLSurfaceView(getContext());
   // surfaceView.setBackgroundColor(Color.WHITE);
   surfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
   surfaceView.setZOrderOnTop(true);
   surfaceView.setRenderer(renderer);
   surfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
   surfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
   addViewInLayout(
       surfaceView,
       -1,
       new AbsListView.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT),
       false);
 }
  // --------------------------------------------------------------------------------------------------------------------
  // Internals
  private void setupSurfaceView(Context context) {
    surfaceView = new GLSurfaceView(getContext());

    cards = new FlipCards(this, flipOrientation == VERTICAL);
    renderer = new FlipRenderer(this, cards);

    surfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
    surfaceView.setZOrderOnTop(true);
    surfaceView.setRenderer(renderer);
    surfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
    surfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

    addViewInLayout(
        surfaceView,
        -1,
        new AbsListView.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT),
        false);
  }
  protected void createMultisampleConfig() {
    final int EGL_COVERAGE_BUFFERS_NV = 0x30E0;
    final int EGL_COVERAGE_SAMPLES_NV = 0x30E1;

    mSurfaceView.setEGLConfigChooser(
        new GLSurfaceView.EGLConfigChooser() {
          public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
            int[] configSpec =
                new int[] {
                  EGL10.EGL_RED_SIZE, 5,
                  EGL10.EGL_GREEN_SIZE, 6,
                  EGL10.EGL_BLUE_SIZE, 5,
                  EGL10.EGL_DEPTH_SIZE, 16,
                  EGL10.EGL_RENDERABLE_TYPE, 4,
                  EGL10.EGL_SAMPLE_BUFFERS, 1,
                  EGL10.EGL_SAMPLES, 2,
                  EGL10.EGL_NONE
                };

            int[] result = new int[1];
            if (!egl.eglChooseConfig(display, configSpec, null, 0, result)) {
              RajLog.e("Multisampling configuration 1 failed.");
            }

            if (result[0] <= 0) {
              // no multisampling, check for coverage multisampling
              configSpec =
                  new int[] {
                    EGL10.EGL_RED_SIZE,
                    5,
                    EGL10.EGL_GREEN_SIZE,
                    6,
                    EGL10.EGL_BLUE_SIZE,
                    5,
                    EGL10.EGL_DEPTH_SIZE,
                    16,
                    EGL10.EGL_RENDERABLE_TYPE,
                    4,
                    EGL_COVERAGE_BUFFERS_NV,
                    1,
                    EGL_COVERAGE_SAMPLES_NV,
                    2,
                    EGL10.EGL_NONE
                  };

              if (!egl.eglChooseConfig(display, configSpec, null, 0, result)) {
                RajLog.e(
                    "Multisampling configuration 2 failed. Multisampling is not possible on your device.");
              }

              if (result[0] <= 0) {
                configSpec =
                    new int[] {
                      EGL10.EGL_RED_SIZE, 5,
                      EGL10.EGL_GREEN_SIZE, 6,
                      EGL10.EGL_BLUE_SIZE, 5,
                      EGL10.EGL_DEPTH_SIZE, 16,
                      EGL10.EGL_RENDERABLE_TYPE, 4,
                      EGL10.EGL_NONE
                    };

                if (!egl.eglChooseConfig(display, configSpec, null, 0, result)) {
                  RajLog.e(
                      "Multisampling configuration 3 failed. Multisampling is not possible on your device.");
                }

                if (result[0] <= 0) {
                  throw new RuntimeException("Couldn't create OpenGL config.");
                }
              } else {
                mUsesCoverageAa = true;
              }
            }
            EGLConfig[] configs = new EGLConfig[result[0]];
            if (!egl.eglChooseConfig(display, configSpec, configs, result[0], result)) {
              throw new RuntimeException("Couldn't create OpenGL config.");
            }

            int index = -1;
            int[] value = new int[1];
            for (int i = 0; i < configs.length; ++i) {
              egl.eglGetConfigAttrib(display, configs[i], EGL10.EGL_RED_SIZE, value);
              if (value[0] == 5) {
                index = i;
                break;
              }
            }

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

            return config;
          }
        });
  }
  // Grabbed from original AndroidGraphics class, with modifications:
  //	+ overrided getHolder in created GLSurfaceView instances
  // + Activity changed to Context (as it should be in AndroidGraphics I think;p)
  private View createGLSurfaceView(
      Context context, boolean useGL2, final ResolutionStrategy resolutionStrategy) {
    EGLConfigChooser configChooser = getEglConfigChooser();

    if (useGL2 && checkGL20()) {
      GLSurfaceView20 view =
          new GLSurfaceView20(context, resolutionStrategy) {
            // -> specific for live wallpapers
            @Override
            public SurfaceHolder getHolder() {
              return getSurfaceHolder();
            }

            public void onDestroy() {
              onDetachedFromWindow(); // calls GLSurfaceView.mGLThread.requestExitAndWait();
            }
            // <- specific for live wallpapers
          };

      if (configChooser != null) view.setEGLConfigChooser(configChooser);
      else
        view.setEGLConfigChooser(
            config.r, config.g, config.b, config.a, config.depth, config.stencil);
      view.setRenderer(this);
      return view;
    } else {
      config.useGL20 = false;
      configChooser = getEglConfigChooser();
      int sdkVersion = android.os.Build.VERSION.SDK_INT;

      if (sdkVersion >= 11) {
        GLSurfaceView view =
            new GLSurfaceView(context) {
              @Override
              protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                ResolutionStrategy.MeasuredDimension measures =
                    resolutionStrategy.calcMeasures(widthMeasureSpec, heightMeasureSpec);
                setMeasuredDimension(measures.width, measures.height);
              }
              // -> specific for live wallpapers
              @Override
              public SurfaceHolder getHolder() {
                return getSurfaceHolder();
              }

              public void onDestroy() {
                onDetachedFromWindow(); // calls GLSurfaceView.mGLThread.requestExitAndWait();
              }
              // <- specific for live wallpapers
            };
        if (configChooser != null) view.setEGLConfigChooser(configChooser);
        else
          view.setEGLConfigChooser(
              config.r, config.g, config.b, config.a, config.depth, config.stencil);
        view.setRenderer(this);
        return view;
      } else {
        if (config.useGLSurfaceViewAPI18) {
          GLSurfaceViewAPI18 view =
              new GLSurfaceViewAPI18(context, resolutionStrategy) {
                // -> specific for live wallpapers
                @Override
                public SurfaceHolder getHolder() {
                  return getSurfaceHolder();
                }
                // <- specific for live wallpapers
              };
          if (configChooser != null) view.setEGLConfigChooser(configChooser);
          else
            view.setEGLConfigChooser(
                config.r, config.g, config.b, config.a, config.depth, config.stencil);
          view.setRenderer(this);
          return view;
        } else {
          GLSurfaceViewCupcake view =
              new GLSurfaceViewCupcake(context, resolutionStrategy) {
                // -> specific for live wallpapers
                @Override
                public SurfaceHolder getHolder() {
                  return getSurfaceHolder();
                }
                // <- specific for live wallpapers
              };
          if (configChooser != null) view.setEGLConfigChooser(configChooser);
          else
            view.setEGLConfigChooser(
                config.r, config.g, config.b, config.a, config.depth, config.stencil);
          view.setRenderer(this);
          return view;
        }
      }
    }
  }