it.alcacoop.fourinaline.actors.BoardImage.java Source code

Java tutorial

Introduction

Here is the source code for it.alcacoop.fourinaline.actors.BoardImage.java

Source

/**
 ##################################################################
 #                     FOUR IN A LINE MOBILE                      #
 ##################################################################
 #                                                                #
 #  Authors: Domenico Martella - Francesco Valente                #
 #  E-mail: info@alcacoop.it                                      #
 #  Date:   18/10/2013                                            #
 #                                                                #
 ##################################################################
 #                                                                #
 #  Copyright (C) 2013   Alca Societa' Cooperativa                #
 #                                                                #
 #  This file is part of FOUR IN A LINE MOBILE.                   #
 #  FOUR IN A LINE MOBILE is free software: you can redistribute  # 
 #  it and/or modify it under the terms of the GNU General        #
 #  Public License as published by the Free Software Foundation,  #
 #  either version 3 of the License, or (at your option)          #
 #  any later version.                                            #
 #                                                                #
 #  FOUR IN A LINE MOBILE is distributed in the hope that it      #
 #  will be useful, but WITHOUT ANY WARRANTY; without even the    #
 #  implied warranty of MERCHANTABILITY or FITNESS FOR A          #
 #  PARTICULAR PURPOSE.  See the GNU General Public License       #
 #  for more details.                                             #
 #                                                                #
 #  You should have received a copy of the GNU General            #
 #  Public License v3 along with this program.                    #
 #  If not, see <http://http://www.gnu.org/licenses/>             #
 #                                                                #
 ##################################################################
**/

/*******************************************************************************
 * Copyright 2011 See AUTHORS file.
 * 
 * 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
 * 
 *   http://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 it.alcacoop.fourinaline.actors;

import it.alcacoop.fourinaline.FourInALine;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Pixmap.Format;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.glutils.FrameBuffer;
import com.badlogic.gdx.graphics.glutils.ShaderProgram;
import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.ui.Widget;
import com.badlogic.gdx.scenes.scene2d.utils.Align;
import com.badlogic.gdx.scenes.scene2d.utils.Drawable;
import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable;
import com.badlogic.gdx.utils.Scaling;

public class BoardImage extends Widget {
    private Scaling scaling;
    private int align = Align.center;
    private float imageX, imageY, imageWidth, imageHeight;
    private Drawable drawable;
    private int nx, ny;
    private int xdim;
    private int ydim;
    private TextureRegion tile, mask;
    private Texture wood;
    private ShaderProgram shader;
    private FrameBuffer fbo1, fbo2;

    public BoardImage(final float imageWidth, final float imageHeight, final int nx, final int ny) {
        setDrawable(new TextureRegionDrawable(FourInALine.Instance.atlas.findRegion("hole")));
        this.scaling = Scaling.stretch;
        this.align = Align.center;
        this.nx = nx;
        this.ny = ny;
        xdim = (int) imageWidth / nx;
        ydim = (int) imageHeight / ny;
        setWidth((int) imageWidth);
        setHeight((int) imageHeight);
        tile = FourInALine.Instance.atlas.findRegion("hole");

        wood = FourInALine.Instance.wood;
        mask = new TextureRegion(FourInALine.Instance.mask);

        shader = new ShaderProgram(Gdx.files.internal("shaders/vertex.s"),
                Gdx.files.internal("shaders/fragment.s"));
        System.out.println(shader.isCompiled());
        System.out.println(shader.getLog());
    }

    public void layout() {
        if (drawable == null)
            return;

        float regionWidth = drawable.getMinWidth();
        float regionHeight = drawable.getMinHeight();
        float width = getWidth();
        float height = getHeight();

        Vector2 size = scaling.apply(regionWidth, regionHeight, width, height);
        imageWidth = size.x;
        imageHeight = size.y;

        if ((align & Align.left) != 0)
            imageX = 0;
        else if ((align & Align.right) != 0)
            imageX = (int) (width - imageWidth);
        else
            imageX = (int) (width / 2 - imageWidth / 2);

        if ((align & Align.top) != 0)
            imageY = (int) (height - imageHeight);
        else if ((align & Align.bottom) != 0)
            imageY = 0;
        else
            imageY = (int) (height / 2 - imageHeight / 2);

        if (fbo1 == null) {
            fbo1 = new FrameBuffer(Format.RGBA8888, (int) getWidth(), (int) getHeight(), false);
            fbo2 = new FrameBuffer(Format.RGBA8888, (int) getWidth(), (int) getHeight(), false);
        }

        SpriteBatch sb = new SpriteBatch();
        Matrix4 matrix = new Matrix4();
        matrix.setToOrtho2D(0, 0, getWidth(), getHeight()); // here is the actual size you want
        sb.setProjectionMatrix(matrix);

        fbo1.begin();
        sb.begin();
        Gdx.gl.glClearColor(1, 1, 1, 0);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
        if (drawable != null) {
            for (int x = 0; x < nx; x++)
                for (int y = 0; y < ny; y++) {
                    sb.draw(mask, x * xdim, y * ydim, 0, 0, xdim, ydim, 1, 1, 0);
                }
        }
        sb.end();
        fbo1.end();

        fbo2.begin();
        sb.setShader(shader);
        sb.begin();
        Gdx.gl.glClearColor(1, 1, 1, 0);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

        Gdx.gl20.glActiveTexture(GL20.GL_TEXTURE1);
        wood.bind();
        shader.setUniformi("u_wood", 1);

        Gdx.gl20.glActiveTexture(GL20.GL_TEXTURE0);
        sb.draw(fbo1.getColorBufferTexture(), 0, 0, getWidth(), getHeight());
        sb.end();
        shader.end();
        sb.setShader(null);
        fbo2.end();
    }

    public void draw(SpriteBatch batch, float parentAlpha) {
        validate();
        Color color = getColor();
        batch.setColor(color.r, color.g, color.b, color.a * parentAlpha);

        // BG
        if (drawable != null) {
            for (int x = 0; x < nx; x++)
                for (int y = 0; y < ny; y++) {
                    batch.draw(tile, x * xdim + getX(), y * ydim + getY(), 0, 0, xdim, ydim, 1, 1, 0);
                }
        }
        batch.setColor(1, 1, 1, 1);
        batch.draw(fbo2.getColorBufferTexture(), getX(), getY());
        batch.setColor(1, 1, 1, 1);
    }

    @Override
    public void setPosition(float x, float y) {
        setX(x);
        setY(y);
    }

    public void setDrawable(Drawable drawable) {
        if (drawable != null) {
            if (this.drawable == drawable)
                return;
            if (getPrefWidth() != drawable.getMinWidth() || getPrefHeight() != drawable.getMinHeight())
                invalidateHierarchy();
        } else {
            if (getPrefWidth() != 0 || getPrefHeight() != 0)
                invalidateHierarchy();
        }
        this.drawable = drawable;
    }

    public Drawable getDrawable() {
        return drawable;
    }

    public void setScaling(Scaling scaling) {
        if (scaling == null)
            throw new IllegalArgumentException("scaling cannot be null.");
        this.scaling = scaling;
    }

    public void setAlign(int align) {
        this.align = align;
    }

    public float getMinWidth() {
        return 0;
    }

    public float getMinHeight() {
        return 0;
    }

    public float getPrefWidth() {
        if (drawable != null)
            return drawable.getMinWidth();
        return 0;
    }

    public float getPrefHeight() {
        if (drawable != null)
            return drawable.getMinHeight();
        return 0;
    }

    public float getImageX() {
        return imageX;
    }

    public float getImageY() {
        return imageY;
    }

    public float getImageWidth() {
        return imageWidth;
    }

    public float getImageHeight() {
        return imageHeight;
    }
}