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;
}