package com.jellekcompany.startrip.startrip;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLUtils;

import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import javax.microedition.khronos.opengles.GL10;

/**
 * Created by JeLLQ_Bajceps on 2016-12-12.
 */

public class STBackground {
    /*
        Wszystkie obrazki tekstur musza być pochodną 256x256
     */
    //współżędne potrzebne do interakcji ze środowiskiem OpenGL - współrzędne wierzchołków oraz krawędzi pomiędzy wierzchołkami
    private int[] textures = new int[1];

    //Bufory w których będą przechowywane zdefiniowane niżej tablice
    private FloatBuffer vertexBuffer;
    private FloatBuffer textureBuffer;
    private ByteBuffer indexBuffer;

    private float vertices[] = {
            /*
                3          2


                0          1
                każda z linijek reprezętuje kolejne wierzchołki kwadratu w pozycji x, y, z, w tym wypadku pokryje on całe tło
             */
            0.0f, 0.0f, 0.0f,
            1.0f, 0,0f, 0.0f,
            1.0f, 1.0f, 0,0f,
            0.0f, 1.0f, 0,0f,
    };

    private float texture[] = {
            //narożniki tekstury pokrywające się z narożnikami namalowanego kwadratu, wczytywany jest tylko jeden obrazek tła więc zczytuję wierzchołki na "sztywno"
            0.0f, 0.0f,
            1.0f, 0.0f,
            1.0f, 1.0f,
            0.0f, 1.0f,
    };

    private byte indices[] = {
            /*
               3        2
                 ______
                |    / |
                |  /   |
                |/_____|
               0        1

               Przechowuę tutaj numery ścian tworzące trójkąty z kwadratu odwrotnie do wskazuwek zegara
             */
            0, 1, 2,
            0, 2, 3,
    };

    //konstruktor klasy
    public STBackground(){
        //odpowiednie bufory wypełniamy odpowiednimi teksturami
        //byteBuff jest mnożony razy 4 bo float przechowuje 4 bajty, indices tylko 1
        ByteBuffer byteBuf = ByteBuffer.allocateDirect(vertices.length*4);
        byteBuf.order(ByteOrder.nativeOrder());
        vertexBuffer = byteBuf.asFloatBuffer();
        vertexBuffer.put(vertices);
        vertexBuffer.position(0);

        byteBuf = ByteBuffer.allocateDirect(texture.length*4);
        byteBuf.order(ByteOrder.nativeOrder());
        textureBuffer = byteBuf.asFloatBuffer();
        textureBuffer.put(texture);
        textureBuffer.position(0);

        indexBuffer = ByteBuffer.allocateDirect(indices.length);
        indexBuffer.put(indices);
        indexBuffer.position(0);
    }

    //Wczytywanie tekstur
    public void loadTexture(GL10 gl, int texture, Context context){
        //Na podstawie wskaźnika wczytywanie tekstury a potem zamykanie strumienai bitmapy
        InputStream imagestream = context.getResources().openRawResource(texture);
        Bitmap bitmap = null;
        try{
            bitmap = BitmapFactory.decodeStream(imagestream);
        }catch (Exception e){
        }finally {
            //zawsze zamykaj
            try {
                imagestream.close();
                imagestream = null;
            }catch (IOException e) {
            }
        }

        //wskaźnik na teksturę, mający strukturę słownikową (liczba nazw tekstur do wygenerowania, tablica liczb całkowitych by przechowywać liczbę dla każdej tekstury, przesunięcie wskaźnika tablicy)
        gl.glGenTextures(1, textures, 0);
        //wiązanie tekstury ze środowiskiem OpenGL. Gdyby były wczytywane dwie tekstury należałobu tą metodę powturzyć dwa razy dla każdej z testur
        gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
        //sposób mapowania na wierzchołkach, szybki, ale wyostrzony
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
        //płynne powtarzanie obrazka w nieskończoność, tekstura będzie przemieszczana na wierzchołkach
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_REPEAT);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_REPEAT);
        //skojarzenie bitmapowego strumienia wejściowego z pierwszą teksturą i poddanie go recyklingowi
        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
        bitmap.recycle();
    }

    //Nanoszenie tekstury na wierzchołki
    //będzie ona wykorzystywana za każdym razem gdy będzie wyświetlane tło, w przeciwieństwie do ładowania tekstury które nastąpi tylko raz
    public void draw(GL10 gl){
        //Wczytywanie tekstury, dzięki temu będzie gotowa do użycia (wiązanie tekstury z celem)
        gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
        //usuwanie niewidocznych powierzchni (Wszystkich, które nie znajdują się w zasięg wzroku)
        gl.glFrontFace(GL10.GL_CCW);
        gl.glEnable(GL10.GL_CULL_FACE);
        gl.glCullFace(GL10.GL_BACK);
        //odblokowanie stanu wierzchołków i tekstur i wczytanie ich buforu
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
        gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);
        //Nakładanie tekstury na wierzchołki i blokowanie wszystkich odblokowanych stanów
        gl.glDrawElements(GL10.GL_TRIANGLES, indices.length, GL10.GL_UNSIGNED_BYTE, indexBuffer);
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
        gl.glDisable(GL10.GL_CULL_FACE);

    }
}