gt:         if (blending) {
context: /*
   * This file is part of Gaia Sky, which is released under the Mozilla Public License 2.0.
   * See the file LICENSE.md in the project root for full license details.
   */
  
  /*******************************************************************************
   * Copyright 2012 bmanuel
   *
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   *
   * https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   ******************************************************************************/
  
  package gaiasky.util.gdx.contrib.postprocess.effects;
  
  import com.badlogic.gdx.Gdx;
  import com.badlogic.gdx.graphics.Color;
  import com.badlogic.gdx.graphics.GL20;
  import com.badlogic.gdx.graphics.Texture;
  import com.badlogic.gdx.graphics.glutils.FrameBuffer;
  import com.badlogic.gdx.math.Vector2;
  import gaiasky.util.gdx.contrib.postprocess.PostProcessor;
  import gaiasky.util.gdx.contrib.postprocess.PostProcessorEffect;
  import gaiasky.util.gdx.contrib.postprocess.filters.Blur;
  import gaiasky.util.gdx.contrib.postprocess.filters.Blur.BlurType;
  import gaiasky.util.gdx.contrib.postprocess.filters.Combine;
  import gaiasky.util.gdx.contrib.postprocess.filters.CrtScreen;
  import gaiasky.util.gdx.contrib.postprocess.filters.CrtScreen.RgbMode;
  import gaiasky.util.gdx.contrib.postprocess.utils.PingPongBuffer;
  import gaiasky.util.gdx.contrib.utils.GaiaSkyFrameBuffer;
  
  public final class CrtMonitor extends PostProcessorEffect {
      private PingPongBuffer pingPongBuffer = null;
      private FrameBuffer buffer = null;
      private CrtScreen crt;
      private Blur blur;
      private Combine combine;
      private boolean doblur;
  
      private boolean blending = false;
      private int sfactor, dfactor;
  
      // the effect is designed to work on the whole screen area, no small/mid size tricks!
      public CrtMonitor(int fboWidth, int fboHeight, boolean barrelDistortion, boolean performBlur, RgbMode mode, int effectsSupport) {
          doblur = performBlur;
  
          if (doblur) {
              pingPongBuffer = PostProcessor.newPingPongBuffer(fboWidth, fboHeight, PostProcessor.getFramebufferFormat(), false);
              blur = new Blur(fboWidth, fboHeight);
              blur.setPasses(1);
              blur.setAmount(1f);
              // blur.setType( BlurType.Gaussian3x3b ); // high defocus
              blur.setType(BlurType.Gaussian3x3); // modern machines defocus
          } else {
              buffer = new FrameBuffer(PostProcessor.getFramebufferFormat(), fboWidth, fboHeight, false);
          }
  
          combine = new Combine();
          crt = new CrtScreen(barrelDistortion, mode, effectsSupport);
      }
  
      @Override
      public void dispose() {
          crt.dispose();
          combine.dispose();
          if (doblur) {
              blur.dispose();
          }
  
          if (buffer != null) {
              buffer.dispose();
          }
  
          if (pingPongBuffer != null) {
              pingPongBuffer.dispose();
          }
      }
  
      public void enableBlending(int sfactor, int dfactor) {
          this.blending = true;
          this.sfactor = sfactor;
          this.dfactor = dfactor;
      }
  
      public void disableBlending() {
          this.blending = false;
      }
  
      // setters
      public void setTime(float elapsedSecs) {
          crt.setTime(elapsedSecs);
      }
  
      public void setColorOffset(float offset) {
          crt.setColorOffset(offset);
      }
  
      public void setChromaticDispersion(float redCyan, float blueYellow) {
          crt.setChromaticDispersion(redCyan, blueYellow);
      }
  
      public void setChromaticDispersionRC(float redCyan) {
          crt.setChromaticDispersionRC(redCyan);
      }
  
      public void setChromaticDispersionBY(float blueYellow) {
          crt.setChromaticDispersionBY(blueYellow);
      }
  
      public void setTint(Color tint) {
          crt.setTint(tint);
      }
  
      public void setTint(float r, float g, float b) {
          crt.setTint(r, g, b);
      }
  
      public void setDistortion(float distortion) {
          crt.setDistortion(distortion);
      }
  
      public void setZoom(float zoom) {
          crt.setZoom(zoom);
      }
  
      public void setRgbMode(RgbMode mode) {
          crt.setRgbMode(mode);
      }
  
      // getters
      public Combine getCombinePass() {
          return combine;
      }
  
      public float getOffset() {
          return crt.getOffset();
      }
  
      public Vector2 getChromaticDispersion() {
          return crt.getChromaticDispersion();
      }
  
      public float getZoom() {
          return crt.getZoom();
      }
  
      public Color getTint() {
          return crt.getTint();
      }
  
      public RgbMode getRgbMode() {
          return crt.getRgbMode();
      }
  
      @Override
      public void rebind() {
          crt.rebind();
      }
  
      @Override
      public void render(FrameBuffer src, FrameBuffer dest, GaiaSkyFrameBuffer main) {
          // the original scene
          Texture in = src.getColorBufferTexture();
  
          boolean blendingWasEnabled = PostProcessor.isStateEnabled(GL20.GL_BLEND);
          Gdx.gl.glDisable(GL20.GL_BLEND);
  
          Texture out = null;
  
          if (doblur) {
  
              pingPongBuffer.begin();
              {
                  // crt pass
                  crt.setInput(in).setOutput(pingPongBuffer.getSourceBuffer()).render();
  
                  // blur pass
                  blur.render(pingPongBuffer);
              }
              pingPongBuffer.end();
  
              out = pingPongBuffer.getResultTexture();
          } else {
              // crt pass
              crt.setInput(in).setOutput(buffer).render();
  
              out = buffer.getColorBufferTexture();
          }
  
          if (blending || blendingWasEnabled) {
              Gdx.gl.glEnable(GL20.GL_BLEND);
          }
  
  