Java 类com.badlogic.gdx.graphics.GL30 实例源码

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{
    //Debug
    //stage.setDebugAll(true);

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

     //Draw stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

    /*------------------QUIT GAME------------------*/
    if (Gdx.input.isKeyPressed(Input.Keys.ESCAPE))
    {
        game.setScreen(new MenuScreen(game, client, server));
    }
}

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{        
    //Debug
    //stage.setDebugAll(true);

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    //Set background image
    rootTable.background(new TextureRegionDrawable(new TextureRegion(TextureManager.menuBackground)));

    //Draw stage
    stage.act(Gdx.graphics.getDeltaTime());
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

}

/**------------------------RENDER------------------------**/
    @Override
    public void render(float f) 
    {        
        //Debug
//        stage.setDebugAll(true);

        //Clear Screen
        Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
        Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

        //Draw stage
        stage.act(Constants.DELTATIME);
        stage.draw();

        /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
        super.changeToFullScreenOnF12();

        /*------------------QUIT GAME------------------*/
        if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE))
        {

            game.setScreen(new HostScreen(game, client, server));
        }
    }

public void init() {
    final int numVertices = this.vertexResolution * this.vertexResolution;
    final int numIndices = (this.vertexResolution-1) * (this.vertexResolution-1) * 6;

    mesh = new Mesh(true, numVertices, numIndices, attribs);
    this.vertices = new float[numVertices * stride];
    mesh.setIndices(buildIndices());
    buildVertices();
    mesh.setVertices(vertices);

    MeshPart meshPart = new MeshPart(null, mesh, 0, numIndices, GL30.GL_TRIANGLES);
    meshPart.update();
    ModelBuilder mb = new ModelBuilder();
    mb.begin();
    mb.part(meshPart, material);
    model = mb.end();
    modelInstance = new ModelInstance(model);
    modelInstance.transform = transform;
}

public void constructCells() {
    builder.begin();

    int vertAttrs = Position | Normal | TextureCoordinates;


    for(int x = 0; x < cells.length; x++) {
        for (int z = 0; z < cells[x].length; z++) {
            MeshPartBuilder partBuilder = builder.part("cell"+x+","+z, GL30.GL_TRIANGLES, vertAttrs, Reference.Defaults.Models.material());
            partBuilder.rect(getPoint("D", x, z), getPoint("C", x, z), getPoint("B", x, z), getPoint("A", x, z), Vector3.Y);
            cells[x][z].setCellPart(partBuilder.getMeshPart());
            cells[x][z].init();
        }
    }
    model = builder.end();
    instance = new ModelInstance(model);
}

public void draw(GameMap map, Batch batch) {
    if (map == null) {
        return;
    }

    if (additive)
        batch.setBlendFunction(GL30.GL_SRC_ALPHA, GL30.GL_ONE);

    Particle[] particles = this.particles;
    boolean[] active = this.active;
    Vector2 tempVector = MathUtil.getVector2();

    for (int i = 0, n = maxParticleCount; i < n; i++)
        if (active[i]) {
            tempVector.set(particles[i].getX() + particles[i].getOriginX(),
                    particles[i].getY() + particles[i].getOriginY());
            map.projectToTiles(tempVector);
            if (map.shouldRenderTile((int) tempVector.x, (int) tempVector.y)) {
                particles[i].draw(batch);
            }

        }
    MathUtil.freeVector2(tempVector);
    if (additive)
        batch.setBlendFunction(GL30.GL_SRC_ALPHA, GL30.GL_ONE_MINUS_SRC_ALPHA);
}

@Override
public void render(float delta) {
    // get any missing assets
    Assets.getAssetManager().update();

    // update phase
    gameState.update(delta, camera);
    UIManager.updateUI(delta);
    cameraController.updateCamera(delta);       
    camera.update();

    // render phase
    Gdx.gl.glClearColor(0f, 0f, 0f, 1f);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);
    renderer.render(delta, camera);
    UIManager.drawUI();
}

public Pixmap getFrameBufferPixmap(Viewport viewport) {
    int w = viewport.getScreenWidth();
    int h = viewport.getScreenHeight();
    int x = viewport.getScreenX();
    int y = viewport.getScreenY();
    final ByteBuffer pixelBuffer = BufferUtils.newByteBuffer(w * h * 4);

    Gdx.gl.glBindFramebuffer(GL20.GL_FRAMEBUFFER, fbo.getFramebufferHandle());
    Gdx.gl.glReadPixels(x, y, w, h, GL30.GL_RGBA, GL30.GL_UNSIGNED_BYTE, pixelBuffer);
    Gdx.gl.glBindFramebuffer(GL20.GL_FRAMEBUFFER, 0);

    final int numBytes = w * h * 4;
    byte[] imgLines = new byte[numBytes];
    final int numBytesPerLine = w * 4;
    for (int i = 0; i < h; i++) {
        pixelBuffer.position((h - i - 1) * numBytesPerLine);
        pixelBuffer.get(imgLines, i * numBytesPerLine, numBytesPerLine);
    }

    Pixmap pixmap = new Pixmap(w, h, Pixmap.Format.RGBA8888);
    BufferUtils.copy(imgLines, 0, pixmap.getPixels(), imgLines.length);

    return pixmap;
}

@Override
public void beforeRender(Renderable renderable) {
  context.setDepthMask(true);
  context.setDepthTest(GL30.GL_LESS);
  if (env.depthShaderMode == LevelEnv.DepthShaderMode.Normal) {
    shader.setUniformf(UNIFORM_TRANSPARENT_DEPTH, 1.0f);
    if (BaseRenderable.haveTransparency(renderable.material)) {
      context.setCullFace(GL30.GL_NONE);
    } else {
      context.setCullFace(GL20.GL_FRONT);
    }
  } else {
    shader.setUniformf(UNIFORM_TRANSPARENT_DEPTH, 1.0f);
    context.setCullFace(GL20.GL_BACK);
  }

}

private VoxelChunkRenderableFactory buildFactoryFor(Chunk chunk, VoxelsAssembler assembler, Material material) {
  if (assembler.isEmpty()) {
    return null;
  } else {
    VoxelChunkRenderableFactory voxelChunkRenderableFactory = new VoxelChunkRenderableFactory();
    voxelChunkRenderableFactory.material                    = material;
    voxelChunkRenderableFactory.primitiveType               = GL30.GL_TRIANGLES;

    if (ForgE.config.getBool(Config.Key.GenerateWireframe))
      voxelChunkRenderableFactory.wireframe           = assembler.wireframe();
    voxelChunkRenderableFactory.triangleCount         = assembler.getTriangleCount();
    voxelChunkRenderableFactory.attributes            = MeshVertexInfo.voxelTypes();
    voxelChunkRenderableFactory.meshFactory           = assembler.meshFactory(voxelChunkRenderableFactory.attributes);
    return voxelChunkRenderableFactory;
  }
}

private VoxelChunkRenderable buildFaceForChunkWithAssembler(Chunk chunk, VoxelsAssembler assembler, boolean haveTransparency) {
  if (!assembler.isEmpty()) {
    VoxelChunkRenderable renderable   = new VoxelChunkRenderable();
    renderable.primitiveType          = GL30.GL_TRIANGLES;

    if (ForgE.config.getBool(Config.Key.GenerateWireframe))
      renderable.wireframe           = assembler.wireframe();
    renderable.triangleCount         = assembler.getTriangleCount();
    renderable.meshFactory           = assembler.meshFactory(MeshVertexInfo.voxelTypes());

    renderable.worldTransform.idt();
    renderable.material = new Material(new SolidTerrainAttribute());
    if (haveTransparency) {
      renderable.material.set(new BlendingAttribute(true,1f));
    }

    chunk.addFace(renderable);
    return renderable;
  } else {
    return null;
  }
}

@Override
public void render() {
  Gdx.gl.glClearColor(0, 0, 0, 1);
  Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

  //TODO background

  localTSR.draw(game.cRenderer);
  visitorTSR.draw(game.cRenderer);

  ShapeRenderer shapeRenderer = game.cRenderer.shape;
  shapeRenderer.begin(ShapeRenderer.ShapeType.Filled);
  shapeRenderer.setColor(new Color(0, 0, 1, 1));
  shapeRenderer.rect(button.x, button.y, button.width, button.height);
  shapeRenderer.end();
}

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{        
    //Debug
    //stage.setDebugAll(true);

    if(Gdx.graphics.isFullscreen())
    {
        checkBoxFullscreen.setChecked(true);
    }else
    {
        checkBoxFullscreen.setChecked(false);
    }

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    //Draw stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

    /*------------------QUIT GAME------------------*/
    if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE))
    {
        game.setScreen(new MenuScreen(game, client, server));
    }
}

/**------------------------RENDER------------------------**/
    @Override
    public void render(float f) 
    {        
        //Debug
//        stage.setDebugAll(true);

        //Clear Screen
        Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
        Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

        //Draw stage
        stage.act(Constants.DELTATIME);
        stage.draw();

        /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
        super.changeToFullScreenOnF12();

        /*------------------QUIT GAME------------------*/
        if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE))
        {
            if(oldMaxPlayerValue != maxPlayers)
            {
                server.resetServer();
            }

            game.setScreen(new HostScreen(game, client, server));
        }
    }

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{
    //Debug
    //stage.setDebugAll(true);

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    //Set background image
    rootTable.background(new TextureRegionDrawable(new TextureRegion(TextureManager.menuBackground)));

    //Render stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

    /*------------------QUIT GAME------------------*/
    if (Gdx.input.isKeyPressed(Input.Keys.ESCAPE))
    {
        game.setScreen(new MenuScreen(game, client, server));
    }

    /*------------------JOIN GAME WITH ENTER------------------*/
    if(Gdx.input.isKeyJustPressed(Input.Keys.ENTER))
    {
        ChangeEvent event1 = new ChangeEvent();
        joinButton.fire(event1);
    }
}

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{
    //Debug
    //stage.setDebugAll(true);

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    //Draw stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

    /*------------------QUIT GAME------------------*/
    if (Gdx.input.isKeyPressed(Input.Keys.ESCAPE))
    {
        if(isWinner)
        {
            AudioManager.getCurrentMusic().stop();
        }else
        {
            AudioManager.getCurrentMusic().stop();
        }

        server.stopServer();
        game.setScreen(new MenuScreen(game, client, server));
    }
}

@Override
public void getRenderables(Array<Renderable> renderables, Pool<Renderable> pool) {
    if (Gdx.input.isKeyJustPressed(Input.Keys.N)) {
        heightData[MathUtils.random(0, heightData.length-1)] = MathUtils.random(0, 1024);
        update();
    }
    modelInstance.nodes.forEach(n -> n.parts.forEach(p -> p.meshPart.primitiveType = GL30.GL_LINES));
    modelInstance.getRenderables(renderables, pool);
}

public static WorldObjectCharacter createDefaultPlayerCharacter(GameWorld.Generic world) {
    modelBuilder.begin();
    MeshPartBuilder builder = modelBuilder.part("player_body", GL30.GL_TRIANGLES, VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal | VertexAttributes.Usage.TextureCoordinates, Reference.Defaults.Models.material());
    CapsuleShapeBuilder.build(builder, 75, 500, 64);
    WorldObject obj = new WorldObject(world, new ModelInstance(modelBuilder.end()));
    if(world instanceof GameWorld.Physics) {
        world.addInstance(new BulletEntity<>(world, obj.transform(), obj));
    }else{
        world.addInstance(obj);
    }
    return new WorldObjectCharacter(obj);
}

/**
 * старый но! рабочий код) создания текстуры для буфера глубины. оставлен для истории
 */
@Deprecated
public void createDepthTextre(Texture.TextureFilter filter, Texture.TextureWrap wrap)
{
    // сначала биндим наш буфер
    gl.glBindFramebuffer(GL20.GL_FRAMEBUFFER, getFramebufferHandle());

    // создаем текстуру
    _depthTexture = gl.glGenTexture();
    // биндим ее
    gl.glBindTexture(GL11.GL_TEXTURE_2D, _depthTexture);
    gl.glTexImage2D(
            GL11.GL_TEXTURE_2D, 0,
            GL14.GL_DEPTH_COMPONENT16, width, height,
            0, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, null);
    // сделаем сглаживание
    gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, filter.getGLEnum());
    gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, filter.getGLEnum());
    gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL20.GL_TEXTURE_WRAP_S, wrap.getGLEnum());
    gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL20.GL_TEXTURE_WRAP_T, wrap.getGLEnum());
    // связываем нашу текстуру с буфером
    gl.glFramebufferTexture2D(GL20.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT,
                              GL20.GL_TEXTURE_2D,
                              _depthTexture, 0);

    // а вот тут может случится ата-та. т.к. надо знать ид буфера экрана. см код libgdx
    gl.glBindFramebuffer(GL20.GL_FRAMEBUFFER, 0);
}

/**
 * Initializes the screen for drawing on it. It also stops the spriteBatch for a transparent background.
 * 
 * @param spriteBatch
 *            The sprite batch to draw on.
 */
private static void init(SpriteBatch spriteBatch)
{
    spriteBatch.end();
    Gdx.gl.glEnable(GL30.GL_BLEND);
    Gdx.gl.glBlendFunc(GL30.GL_SRC_ALPHA, GL30.GL_ONE_MINUS_SRC_ALPHA);

    __shapeRenderer.setProjectionMatrix(METRO.__camera.combined);
    __shapeRenderer.begin(ShapeType.Filled);
    __shapeRenderer.setColor(__r, __g, __b, __a);
}

/**
 * Resets the screen and the spriteBatch to the default values so that METRO can use it normally. The drawing has finished at this point.
 * 
 * @param spriteBatch
 *            The sprite batch to draw on.
 */
private static void reset(SpriteBatch spriteBatch)
{
    __shapeRenderer.end();
    Gdx.gl.glDisable(GL30.GL_BLEND);
    spriteBatch.begin();
}

/**
 * Initializes the screen for drawing on it. It also stops the spriteBatch for a transparent background.
 */
private static void init()
{
    METRO.__spriteBatch.end();
    Gdx.gl.glEnable(GL30.GL_BLEND);
    Gdx.gl.glBlendFunc(GL30.GL_SRC_ALPHA, GL30.GL_ONE_MINUS_SRC_ALPHA);

    if (__shapeRenderer == null)
    {
        __shapeRenderer = new ShapeRenderer();
    }
    __shapeRenderer.setProjectionMatrix(METRO.__camera.combined);
    __shapeRenderer.begin(ShapeType.Line);
    __shapeRenderer.setColor(__r, __g, __b, __a);
}

/**
 * Resets the screen and the spriteBatch to the default values so that METRO can use it normally. The drawing has finished at this point.
 */
private static void reset()
{
    __shapeRenderer.end();
    Gdx.gl.glDisable(GL30.GL_BLEND);
    METRO.__spriteBatch.begin();
}

/**
 * Initializes the rendering by clearing the screen and updating the control list.
 */
private void renderInit()
{
    Gdx.gl.glClearColor(1, 1, 1, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

}

@Override
public void render() {
    update(Gdx.graphics.getRawDeltaTime());

    Gdx.gl30.glClearColor(1, 1, 1, 1);
    Gdx.gl30.glClear(GL30.GL_COLOR_BUFFER_BIT | GL30.GL_DEPTH_BUFFER_BIT
            | (Gdx.graphics.getBufferFormat().coverageSampling ? GL30.GL_COVERAGE_BUFFER_BIT_NV : 0));

    Gdx.graphics.setCursor(cursor);

    if (state == 1) {
        if (!menu.equals(null)) {
            menu.render(mX, mY);
        }
    } else if (state == 2) {
        if (!singleplayer.equals(null)) {
            singleplayer.render(mX, mY);
        }
    } else if (state == 3) {
        if (!help.equals(null)) {
            help.render(mX, mY);
        }
    } else if (state == 4) {
        if (!options.equals(null)) {
            options.render(mX, mY);
        }
    } else if (state == 5) {
        if (!credits.equals(null)) {
            credits.render(mX, mY);
        }
    }
}

@Override
public void beforeRender(VoxelChunkRenderable renderable) {
  if (BaseRenderable.haveTransparency(renderable.material)) {
    context.setBlending(true, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
    context.setCullFace(GL30.GL_NONE);
  } else {
    context.setBlending(false, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
    context.setCullFace(GL30.GL_BACK);
  }
}

@Override
public void afterBegin() {
  context.setCullFace(GL30.GL_BACK);
  context.setBlending(false, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
  context.setDepthMask(true);
  context.setDepthTest(GL30.GL_LEQUAL);
}

@Override
public void beforeRender(SpriteRenderable renderable) {
  shader.setUniformi(UNIFORM_SPRITE_TEXTURE, context.textureBinder.bind(renderable.texture));

  context.setBlending(true, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
  context.setCullFace(GL30.GL_BACK);
}

@Override
public void run(RenderContext renderContext, LevelEnv env) {
  renderContext.begin(); {
    ForgE.fb.begin(targetFboName); {
      ForgE.graphics.clearAll(Color.CLEAR);// TODO change it using json
      shader.begin(ForgE.fb.getScreenCamera(), renderContext, env); {
        shader.render(ForgE.fb.getScreenQuad(), GL30.GL_TRIANGLE_STRIP);
      } shader.end();
    } ForgE.fb. end();
  } renderContext.end();
}

private Renderable getRenderable() {
  if (renderable == null) {
    this.renderable           = new CubemapSkyboxRenderable();
    this.renderable.mesh      = buildMesh();

    renderable.primitiveType  = GL30.GL_TRIANGLE_STRIP;
    renderable.worldTransform.idt();
  }

  return renderable;
}

public void build(BaseSprite3D sprite) {
  this.mesh             = sprite.getMesh();
  this.primitiveType    = GL30.GL_TRIANGLES;
  this.triangleCount    = 2;
  //this.haveTransparency = sprite.haveTransparency();
  this.texture          = sprite.getTexture();
  sprite.applyToMatrix(this.worldTransform);
}

private TextureRegion createBgIcon(String atlas, String region) {
    TextureAtlas a = new TextureAtlas(
            Gdx.files.absolute(Ctx.project.getAssetPath() + Project.ATLASES_PATH + "/1/" + atlas + ".atlas"));
    AtlasRegion r = a.findRegion(region);

    if (r == null) {
        a.dispose();
        return null;
    }

    GLFrameBuffer.FrameBufferBuilder frameBufferBuilder = new GLFrameBuffer.FrameBufferBuilder(200,
            (int) (r.getRegionHeight() * 200f / r.getRegionWidth()));

    frameBufferBuilder.addColorTextureAttachment(GL30.GL_RGBA8, GL30.GL_RGBA, GL30.GL_UNSIGNED_BYTE);
    FrameBuffer fbo = frameBufferBuilder.build();

    SpriteBatch fboBatch = new SpriteBatch();
    fboBatch.setColor(Color.WHITE);
    OrthographicCamera camera = new OrthographicCamera();
    camera.setToOrtho(false, fbo.getWidth(), fbo.getHeight());
    fboBatch.setProjectionMatrix(camera.combined);

    Gdx.gl.glDisable(GL20.GL_SCISSOR_TEST);
    fbo.begin();
    fboBatch.begin();
    fboBatch.draw(r, 0, 0, fbo.getWidth(), fbo.getHeight());
    fboBatch.end();

    TextureRegion tex = ScreenUtils.getFrameBufferTexture(0, 0, fbo.getWidth(), fbo.getHeight());
    // tex.flip(false, true);

    fbo.end();
    Gdx.gl.glEnable(GL20.GL_SCISSOR_TEST);

    fbo.dispose();
    a.dispose();
    fboBatch.dispose();

    return tex;
}

@Override
  public void render(float delta) {
    float tpf = Math.min(0.25f, timer.tickSeconds());

    // TODO: need better way to set TPF
    context.getTransformMotionSystem().setTpf(tpf);
    context.getWorld().process();

    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    SpriteBatch batch = context.getBatch();
    Camera camera = context.getCurrentCamera();
    camera.update();

    batch.setProjectionMatrix(camera.combined);
    batch.begin();
    // render
    context.getRenderSystem().process();
    batch.end();

    if (debugMode) {
      grid.render();
      context.getPhysicsSystem().debugRender(camera.combined);
    }

    // physics world step
    context.getPhysicsSystem().setTPF(tpf);
    context.getPhysicsSystem().step();
    context.getPhysicsSystem().process();

//    fpsLogger.log();
  }

private void setProgram(int p1, int p2, int p3, int p4) {
    batch.setBlendFunction(-1, -1);
    Gdx.gl30.glBlendFuncSeparate(p1,p2, p3, p4);
    Gdx.gl30.glBlendEquationSeparate(GL30.GL_FUNC_ADD, GL30.GL_FUNC_ADD);
}

@Override
public GL30 getGL30 () {
   return gl30;
}

@Override
public void render(float f) 
{
    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    //Draw stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    if(flashingTimer >= endFlashingTimer)
    {
        if(pressAnyKey.isVisible())
        {
            pressAnyKey.setVisible(false);
        }else
        {
            pressAnyKey.setVisible(true);
        }
        flashingTimer = 0;
    }else
    {
        flashingTimer += Constants.DELTATIME;
    }

    if(inputHandler.isAnyKey() || hideTimer != 0)
    {
        pressAnyKey.setVisible(false);

        AudioManager.getCurrentMusic().dispose();

        if(hideTimer == 0)
        {
            //Add click sound
            Sound sound = AudioManager.getNormalExplosion();
            long id = sound.play();
            sound.setVolume(id, AudioManager.getSoundVolume() * Constants.NORMALBOMBEXPLOSIONMOD);
        }

        if(hideTimer >= endHideTimer)
        {
            game.setScreen(new MenuScreen(game, client, server));
        }else
        {
            hideTimer += Constants.DELTATIME;
        }
    }

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

}

/**------------------------RENDER------------------------**/
@Override
public void render(float f) 
{        
    //Debug
    //stage.setDebugAll(true);

    //Clear Screen
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    try 
    {
        ipTextField.setText(client.getCurrentIp().getHostAddress());
    } catch (SocketException ex) 
    {
        ipTextField.setText("ERROR");
        ex.printStackTrace();
    } catch (NullPointerException e)
    {
        ipTextField.setText("No network");
    }

    checkCurrentPlayerCompatibility();

    p1Field.setVisible(false);
    p2Field.setVisible(false);
    p3Field.setVisible(false);
    p4Field.setVisible(false);

    for(int i=0; i < Server.getClientConnectionArraySize(); i++)
    {
        ClientConnection clientconnection = Server.getClient(i);

        //Who joined
        switch(clientconnection.getPlayerId())
        {
            case 1:
                p1Field.setVisible(true);
                break;

            case 2:
                p2Field.setVisible(true);
                break;

            case 3:
                p3Field.setVisible(true);
                break;

            case 4:
                p4Field.setVisible(true);
                break;
        }
    }

    //Draw stage
    stage.act(Constants.DELTATIME);
    stage.draw();

    /*------------------SWITCH TO FULLSCREEN AND BACK------------------*/
    super.changeToFullScreenOnF12();

    /*------------------QUIT GAME------------------*/
    if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE))
    {
        server.stopServer();
        game.setScreen(new MenuScreen(game, client, server));
    }
}

@Override
public GL30 getGL30 () {
    return gl30;
}

@Override
public void applyToShader(ShaderProgram program) {
    final int texNum = GL30.GL_MAX_TEXTURE_UNITS-2;
}

/**
 * Updates and draws the particles. This is slightly more efficient than
 * calling {@link #update(float)} and {@link #draw(Batch)} separately.
 */
public void draw(GameMap map, Batch batch, float delta) {
    accumulator += delta * 1000;
    if (accumulator < 1) {
        draw(map, batch);
        return;
    }
    int deltaMillis = (int) accumulator;
    accumulator -= deltaMillis;

    if (additive)
        batch.setBlendFunction(GL30.GL_SRC_ALPHA, GL30.GL_ONE);

    Particle[] particles = this.particles;
    boolean[] active = this.active;
    int activeCount = this.activeCount;
    for (int i = 0, n = maxParticleCount; i < n; i++) {
        if (active[i]) {
            Particle particle = particles[i];
            if (updateParticle(particle, delta, deltaMillis)) {
                tempVector.set(particle.getX() + particle.getOriginX(), particle.getY() + particle.getOriginY());
                map.projectToTiles(tempVector);
                if (map.shouldRenderTile((int) tempVector.x, (int) tempVector.y)) {
                    particle.draw(batch);
                }
            } else {
                active[i] = false;
                activeCount--;
            }
        }
    }
    this.activeCount = activeCount;

    if (additive)
        batch.setBlendFunction(GL30.GL_SRC_ALPHA, GL30.GL_ONE_MINUS_SRC_ALPHA);

    if (delayTimer < delay) {
        delayTimer += deltaMillis;
        return;
    }

    if (firstUpdate) {
        firstUpdate = false;
        addParticle();
    }

    if (durationTimer < duration)
        durationTimer += deltaMillis;
    else {
        restart();
    }

    emissionDelta += deltaMillis;
    float emissionTime = emission + emissionDiff * emissionValue.getScale(durationTimer / (float) duration);
    if (emissionTime > 0) {
        emissionTime = 1000 / emissionTime;
        if (emissionDelta >= emissionTime) {
            int emitCount = (int) (emissionDelta / emissionTime);
            emitCount = Math.min(emitCount, maxParticleCount - activeCount);
            emissionDelta -= emitCount * emissionTime;
            emissionDelta %= emissionTime;
            addParticles(emitCount);
        }
    }
    if (activeCount < minParticleCount)
        addParticles(minParticleCount - activeCount);
}