xref: /aosp_15_r20/external/replicaisland/src/com/replica/replicaisland/TiledVertexGrid.java (revision 5eae8ebb3c5756e41e77a1f7201fcf94b0eade1f)

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * 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 com.replica.replicaisland;

import javax.microedition.khronos.opengles.GL10;

public class TiledVertexGrid extends BaseObject {
	private static final float GL_MAGIC_OFFSET = 0.375f;
    private Grid mTileMap;
    private TiledWorld mWorld;
    private int mTileWidth;
    private int mTileHeight;

    private int mWidth;
    private int mHeight;
    private Texture mTexture;

    private float mWorldPixelWidth;
    private float mWorldPixelHeight;

    private int mTilesPerRow;
    private int mTilesPerColumn;

    private Boolean mGenerated;

    public TiledVertexGrid(Texture texture, int width, int height, int tileWidth, int tileHeight) {
        super();
        mTileWidth = tileWidth;
        mTileHeight = tileHeight;
        mWidth = width;
        mHeight = height;
        mTexture = texture;
        mGenerated = false;
    }

    @Override
    public void reset() {
    }

    public void setWorld(TiledWorld world) {
        mWorld = world;

    }

    private Grid generateGrid(int width, int height, int startTileX, int startTileY) {
        final int tileWidth = mTileWidth;
        final int tileHeight = mTileHeight;
        final int tilesAcross = width / tileWidth;
        final int tilesDown = height / tileHeight;
        final Texture texture = mTexture;
        final float texelWidth = 1.0f / texture.width;
        final float texelHeight = 1.0f / texture.height;
        final int textureTilesAcross = texture.width / tileWidth;
        final int textureTilesDown = texture.height / tileHeight;
        final int tilesPerWorldColumn = mWorld.getHeight();
        final int totalTextureTiles = textureTilesAcross * textureTilesDown;
        // Check to see if this entire grid is empty tiles.  If so, we don't need to do anything.
        boolean entirelyEmpty = true;
        for (int tileY = 0; tileY < tilesDown && entirelyEmpty; tileY++) {
            for (int tileX = 0; tileX < tilesAcross && entirelyEmpty; tileX++) {
                int tileIndex = mWorld.getTile(startTileX + tileX,
                        (tilesPerWorldColumn - 1 - (startTileY + tileY)));
                if (tileIndex >= 0) {
                    entirelyEmpty = false;
                    break;
                }
            }
        }

        Grid grid = null;
        if (!entirelyEmpty) {
            grid = new Grid(tilesAcross, tilesDown, false);
            for (int tileY = 0; tileY < tilesDown; tileY++) {
                for (int tileX = 0; tileX < tilesAcross; tileX++) {
                    final float offsetX = tileX * tileWidth;
                    final float offsetY = tileY * tileHeight;
                    int tileIndex = mWorld.getTile(startTileX + tileX,
                            (tilesPerWorldColumn - 1 - (startTileY + tileY)));
                    if (tileIndex < 0) {
                        tileIndex = totalTextureTiles - 1; // Assume that the last tile is empty.
                    }
                    int textureOffsetX = (tileIndex % textureTilesAcross) * tileWidth;
                    int textureOffsetY = (tileIndex / textureTilesAcross) * tileHeight;
                    if (textureOffsetX < 0 ||
                            textureOffsetX > texture.width - tileWidth ||
                            textureOffsetY < 0 ||
                            textureOffsetY > texture.height - tileHeight) {
                        textureOffsetX = 0;
                        textureOffsetY = 0;
                    }
                    final float u = (textureOffsetX + GL_MAGIC_OFFSET) * texelWidth;
                    final float v = (textureOffsetY + GL_MAGIC_OFFSET) * texelHeight;
                    final float u2 = ((textureOffsetX + tileWidth - GL_MAGIC_OFFSET) * texelWidth);
                    final float v2 = ((textureOffsetY + tileHeight - GL_MAGIC_OFFSET) * texelHeight);

                    final float[] p0 = { offsetX, offsetY, 0.0f };
                    final float[] p1 = { offsetX + tileWidth, offsetY, 0.0f };
                    final float[] p2 = { offsetX, offsetY + tileHeight, 0.0f };
                    final float[] p3 = { offsetX + tileWidth, offsetY + tileHeight, 0.0f };
                    final float[] uv0 = { u, v2 };
                    final float[] uv1 = { u2, v2 };
                    final float[] uv2 = { u, v };
                    final float[] uv3 = { u2, v };

                    final float[][] positions = { p0, p1, p2, p3 };
                    final float[][] uvs = { uv0, uv1, uv2, uv3 };

                    grid.set(tileX, tileY, positions, uvs);

                }
            }
        }
        return grid;
    }

    public void draw(float x, float y, float scrollOriginX, float scrollOriginY) {
        TiledWorld world = mWorld;
        GL10 gl = OpenGLSystem.getGL();
        if (!mGenerated && world != null && gl != null && mTexture != null) {
            final int tilesAcross = mWorld.getWidth();
            final int tilesDown = mWorld.getHeight();

            mWorldPixelWidth = mWorld.getWidth() * mTileWidth;
            mWorldPixelHeight = mWorld.getHeight() * mTileHeight;
            mTilesPerRow = tilesAcross;
            mTilesPerColumn = tilesDown;


            BufferLibrary bufferLibrary = sSystemRegistry.bufferLibrary;

            Grid grid = generateGrid((int)mWorldPixelWidth, (int)mWorldPixelHeight, 0, 0);
            mTileMap = grid;
            mGenerated = true;
            if (grid != null) {
                bufferLibrary.add(grid);
                if (sSystemRegistry.contextParameters.supportsVBOs) {
                	grid.generateHardwareBuffers(gl);
                }
            }

        }

        final Grid tileMap = mTileMap;
        if (tileMap != null) {
            final Texture texture = mTexture;
            if (gl != null && texture != null) {

                int originX = (int) (x - scrollOriginX);
                int originY = (int) (y - scrollOriginY);


                final float worldPixelWidth = mWorldPixelWidth;

                final float percentageScrollRight =
                    scrollOriginX != 0.0f ? scrollOriginX / worldPixelWidth : 0.0f;
                final float tileSpaceX = percentageScrollRight * mTilesPerRow;
                final int leftTile = (int)tileSpaceX;

                // calculate the top tile index
                final float worldPixelHeight = mWorldPixelHeight;

                final float percentageScrollUp =
                    scrollOriginY != 0.0f ? scrollOriginY / worldPixelHeight : 0.0f;
                final float tileSpaceY = percentageScrollUp * mTilesPerColumn;
                final int bottomTile = (int)tileSpaceY;

                // calculate any sub-tile slop that our scroll position may require.
                final int horizontalSlop = ((tileSpaceX - leftTile) * mTileWidth) > 0 ? 1 : 0;
                final int verticalSlop = ((tileSpaceY - bottomTile) * mTileHeight) > 0 ? 1 : 0;


                OpenGLSystem.bindTexture(GL10.GL_TEXTURE_2D, texture.name);
                tileMap.beginDrawingStrips(gl, true);

                final int horzTileCount = (int)Math.ceil((float)mWidth / mTileWidth);
                final int vertTileCount = (int)Math.ceil((float)mHeight / mTileHeight);
                // draw vertex strips
                final int startX = leftTile;
                final int startY = bottomTile;
                final int endX = startX + horizontalSlop + horzTileCount;
                final int endY = startY + verticalSlop +  vertTileCount;

                gl.glPushMatrix();
                gl.glLoadIdentity();
                gl.glTranslatef(
                        originX,
                        originY,
                        0.0f);


                final int indexesPerTile = 6;
                final int indexesPerRow = mTilesPerRow * indexesPerTile;
                final int startOffset = (startX * indexesPerTile);
                final int count = (endX - startX) * indexesPerTile;
                for (int tileY = startY; tileY < endY && tileY < mTilesPerColumn; tileY++) {
                	final int row = tileY * indexesPerRow;
                	tileMap.drawStrip(gl, true, row + startOffset, count);
                }

                gl.glPopMatrix();

                Grid.endDrawing(gl);

            }
        }
    }

}