myrenderer

package com.example.lab5

import android.content.Context
import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager
import android.opengl.GLSurfaceView
import android.opengl.GLU
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.FloatBuffer
import javax.microedition.khronos.egl.EGLConfig
import javax.microedition.khronos.opengles.GL10
import kotlin.math.cos
import kotlin.math.sin


/* Implementacja renderera - malarza na płótnie */

class MyRenderer : /*dziedziczenie*/GLSurfaceView.Renderer, SensorEventListener {
    private var shift=0f; //kąt do obracania figury na płótnie
    private var screenHeight = 0f;
    private var screenWidth = 0f;
    private var direction = false;
    private var speed = 0.01f

    constructor(context: Context) {
        val sensorService = context?.getSystemService(Context.SENSOR_SERVICE) as SensorManager
        val sensorList = sensorService.getSensorList(Sensor.TYPE_ACCELEROMETER)
        val thermometer = sensorList[0]
        sensorService.registerListener(this, thermometer, SensorManager.SENSOR_DELAY_NORMAL)
    }
    //funkcja wywoływana przy tworzeniu płótna
    override fun onSurfaceCreated(gl: GL10?, p1: EGLConfig?) {

    }

    //funkcja wywoływana przy zmianie i tworzeniu płótna
    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        /* OpenGL jest silnikiem z implementacją nieobiektową, dlatego jego funkcje dostępne są
        w wraperach w obiekcie gl
         */
        //konfiguracja rzutni
        screenWidth = width.toFloat()
        screenHeight = height.toFloat()
        gl?.glViewport(0, 0, width, height)
        //załadowanie jednostkowej macierzy jako macierzy projekcji
        gl?.glMatrixMode(GL10.GL_PROJECTION)
        gl?.glLoadIdentity()
        //konfiguracja perspektywy, korzystamy z GLU czyli narzędzi OpenGL
        GLU.gluPerspective(gl, 45.0f, width.toFloat() / height.toFloat(), -1.0f, -10.0f)
        //ustawienie domyslnego koloru w modelu barw RGBA
        gl?.glClearColor(0.0f, 1.0f, 0.0f, 1.0f)
    }
    override fun onDrawFrame(gl: GL10?) {

        //wierchołki trójkąta w 3D
        var vertices = floatArrayOf(
            0.0f, 0.0f, 0.0f
        )

        //currentYMove = 0f
        val screenRatio: Float = (screenWidth/screenHeight)
        var numberOfVertices: Int = 1
        var angle: Float = 0.0f

        val radius: Float = 0.0001f * screenHeight
        while (angle <= 2*Math.PI + 0.05f){

            //dodanie współrzędnej X
            vertices += radius * sin(angle)

            //dodanie współrzędnej Y
            vertices += radius * cos(angle) * screenRatio

            //dodanie współrzędnej Z
            vertices += 0.0f

            numberOfVertices++

            angle += 0.15f
        }


        //wierchołki trzeba przekazać poza JVM więc trzeba zaalokować bufor
        //numberOfVertices - wierzchołki, 3 - wymiary 4 - bajty na float

        val buffer: ByteBuffer = ByteBuffer.allocateDirect(numberOfVertices * 3 * 4)
        //natywny dla sprzętu układ bajtów w słowie maszynowym
        buffer.order(ByteOrder.nativeOrder())
        //do tego bufora chcemy się odwoływać jak do bufora floatów
        val verticesBuffer: FloatBuffer = buffer.asFloatBuffer()
        //wrzucamy wierzchołki do bufora poza JVM
        verticesBuffer.put(vertices)
        //ustawiamy pozycję w buforze
        verticesBuffer.position(0)
        //konfiguracja bufora kolorów i bufora głębi
        gl?.glClear(GL10.GL_COLOR_BUFFER_BIT or GL10.GL_DEPTH_BUFFER_BIT)
        //ustawienie koloru malowania i wypełniania
        gl?.glColor4f(0.0f, 0.0f, 1.0f, 1.0f)
        //załadowanie macierzy jednostkowej do macierzy transformacji
        gl?.glLoadIdentity()
        //obrót figury tj. wymnożenie macierzy transformacji
        //gl?.glRotatef(angle++ /*kąt obrotu*/, 0.0f, 0.0f, 1.0f /*oś obrotu*/)

        if(shift+radius/2f<=0.995f && shift-radius/2f >= -0.995f) {
            shift -= speed
        }
        if(shift>=0.995f-radius/2f) {
            shift = 0.995f - radius/2f
        }
        if(shift<=-0.995f+radius/2f) {
            shift = -0.995f + radius/2f
        }

        gl?.glTranslatef(0.0f, shift, 0.0f)
        //przechodzimy do stanu przekazania wierzchołków silnikowi OpenGL
        gl?.glEnableClientState(GL10.GL_VERTEX_ARRAY)
        //przekazujemy do silnika informację o wierzchołkach
        gl?.glVertexPointer(3, GL10.GL_FLOAT, 0, verticesBuffer)
        //zlecamy namalowanie trójkąta
        gl?.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0 /*początek*/, numberOfVertices/*liczba wierz.*/)

        //opuszczamy ten stan
        gl?.glDisableClientState(GL10.GL_VERTEX_ARRAY)
    }

    override fun onSensorChanged(event: SensorEvent?) {
        val value = event?.values?.get(1)

        if(value != null) {
            this.speed = value * 0.0025f
        }
    }

    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
    }
}