package electrosphere.renderer.meshgen;

/**
 * Utilities for generating and managing skyboxes
 */
public class SkyboxMeshgen {

    
    // public static Model createSkyboxModel(Material optionalMaterial){
    //     Model skyboxModel = new Model();
    //     skyboxModel.meshes = new ArrayList<Mesh>();
        
    //     skyboxModel.modelMatrix = new Matrix4d();
        
        
        
    //     // boolean apply_lighting = false;
    //     // boolean has_bones = false;
        
    //     Mesh skyboxmesh = new Mesh("skybox"){
    //         @Override
    //         public void complexDraw(RenderPipelineState renderPipelineState){
    //             if(renderPipelineState.getUseMeshShader()){
    //                 GL11.glDepthFunc(GL_LEQUAL);
    //                 glUseProgram(shader.getShaderId());
    //             }
                
    //             if(renderPipelineState.getUseMaterial()){
    //                 if(this.getMaterial() == null){
    //                     Globals.materialDefault.apply_material(0,1);
    //                     Iterator<Vector3f> colorIterator = Globals.skyboxColors.iterator();
    //                     int counter = 0;
    //                     float[] temp = new float[3];
    //                     while(colorIterator.hasNext()){
    //                         Vector3f colorCurrent = colorIterator.next();
    //                         temp[0] = colorCurrent.x / 255.0f;
    //                         temp[1] = colorCurrent.y / 255.0f;
    //                         temp[2] = colorCurrent.z / 255.0f;
    // //                        System.out.println("colors[" + counter + "] " + temp[0] + " " + temp[1] + " " + temp[2]);
    //                         glUniform3fv(glGetUniformLocation(shader.getShaderId(), "colors[" + counter + "]"), temp);
    //                         counter++;
    //                     }
    //                 }
    //             }
                
    //             glBindVertexArray(vertexArrayObject);
                
                
                
    //             if(renderPipelineState.getBufferStandardUniforms()){
    //                 //buffer model/view/proj matrices
    //                 glUniformMatrix4fv(shader.shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16]));
    //                 glUniformMatrix4fv(shader.shaderVertexViewLoc, false, new Matrix4f(Globals.viewMatrix).scale(100).get(new float[16]));
    //                 glUniformMatrix4fv(shader.shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16]));
    //                 glUniform3fv(shader.shaderVertexViewPosLoc, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
    //             }
                
    //             GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
    //             glBindVertexArray(0);
                
    //             if(renderPipelineState.getUseMeshShader()){
    //                 GL11.glDepthFunc(GL_LESS);
    //             }
    //         }
    //     };
        
        
        
    //     //
    //     //  VAO
    //     //
    //     skyboxmesh.generateVAO();
        
        
        
        
        
        
        
        
        
        
    //     float[] vertexcoords = {
    //          100.0f, 100.0f, 100.0f,
    //          100.0f, 100.0f,-100.0f,
    //          100.0f,-100.0f, 100.0f,
    //          100.0f,-100.0f,-100.0f,
    //         -100.0f, 100.0f, 100.0f,
    //         -100.0f, 100.0f,-100.0f,
    //         -100.0f,-100.0f, 100.0f,
    //         -100.0f,-100.0f,-100.0f,
            
    //     };
        
    //     //
    //     //Buffer data to GPU
    //     //
        
    //     try {
    //         skyboxmesh.vertexCount = vertexcoords.length / 3;
    //         FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount * 3);
    //         float[] temp = new float[3];
    //         for (int i = 0; i < skyboxmesh.vertexCount; i++) {
    //             temp[0] = vertexcoords[i * 3 + 0];
    //             temp[1] = vertexcoords[i * 3 + 1];
    //             temp[2] = vertexcoords[i * 3 + 2];
    //             VertexArrayBufferData.put(temp);
    //         }
    //         VertexArrayBufferData.flip();
    //         skyboxmesh.buffer_vertices(VertexArrayBufferData, 3);
    //     } catch (NullPointerException ex){
    //         ex.printStackTrace();
    //     }
        
    //     int[] facedata = {
    //         0,1,4,
    //         1,4,5,
    //         1,3,5,
    //         3,5,7,
    //         4,5,7,
    //         4,6,7,
            
    //         0,2,4,
    //         2,4,6,
    //         0,1,2,
    //         1,2,3,
            
    //         2,3,6,
    //         3,6,7,
            
    //     };
        
    //     //
    //     //  FACES
    //     //
    //     skyboxmesh.faceCount = facedata.length / 3;
    //     skyboxmesh.elementCount = facedata.length;
    //     IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(skyboxmesh.elementCount);
    //     for(int i = 0; i < skyboxmesh.faceCount; i++){
    //         int[] temp = new int[3];
    //         temp[0] = facedata[i * 3 + 0];
    //         temp[1] = facedata[i * 3 + 1];
    //         temp[2] = facedata[i * 3 + 2];
    //         elementArrayBufferData.put(temp);
    //     }
    //     elementArrayBufferData.flip();
    //     skyboxmesh.buffer_faces(elementArrayBufferData);
        
        
        
        
    //     if(optionalMaterial != null){
    //         //
    //         //  NORMALS
    //         //
    //         try {
    //             skyboxmesh.normalCount = vertexcoords.length / 3;
    //             FloatBuffer NormalArrayBufferData;
    //             if(skyboxmesh.normalCount > 0){
    //                 NormalArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.normalCount * 3);
    //                 float[] temp = new float[3];
    //                 for (int i = 0; i < skyboxmesh.normalCount; i++) {
    //                     temp[0] = vertexcoords[i * 3 + 0];
    //                     temp[1] = vertexcoords[i * 3 + 1];
    //                     temp[2] = vertexcoords[i * 3 + 2];
    //                     NormalArrayBufferData.put(temp);
    //                 }
    //                 NormalArrayBufferData.flip();
    //                 skyboxmesh.buffer_normals(NormalArrayBufferData, 3);
    //             }
    //         } catch (NullPointerException ex){
    //             ex.printStackTrace();
    //         }
    //         //
    //         //  TEXTURE COORDINATES
    //         //
    //         /*try {
    //             skyboxmesh.textureCoordCount = mesh.mTextureCoords(0).capacity();
    //             FloatBuffer TextureArrayBufferData;
    //             if(skyboxmesh.textureCoordCount > 0){
    //                 TextureArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.textureCoordCount * 2);
    //                 float[] temp = new float[2];
    //                 for (int i = 0; i < skyboxmesh.textureCoordCount; i++) {
    //                     AIVector3D normal = texturecoords.get(i);
    //                     temp[0] = normal.x();
    //                     temp[1] = normal.y();
    // //                        temp[2] = normal.z();
    //                     TextureArrayBufferData.put(temp);
    //                 }
    //                 TextureArrayBufferData.flip();
    //                 skyboxmesh.buffer_texture_coords(TextureArrayBufferData);
    //             }
    //         } catch (NullPointerException ex){
    //             ex.printStackTrace();
    //         }

    //         skyboxmesh.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting);

    //         skybox_model.materials.add(optionalMaterial);
    //         */
    //     } else {
    //         skyboxmesh.shader = ShaderProgram.loadSpecificShader("/Shaders/skybox/VertexShaderNoTexture.vs", "/Shaders/skybox/FragmentShaderNoTexture.fs");
    //             try {
    //             FloatBuffer ColorArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount);
    //             for (int i = 0; i < skyboxmesh.vertexCount; i++) {
    //                 ColorArrayBufferData.put(i);
    //             }
    //             ColorArrayBufferData.flip();
    //             int idBuffer = glGenBuffers();
    //             glBindBuffer(GL_ARRAY_BUFFER, idBuffer);
    //             GL15.glBufferData(GL_ARRAY_BUFFER, ColorArrayBufferData, GL_STATIC_DRAW);
    //             glVertexAttribPointer(1, 1, GL11.GL_FLOAT, false, 0, 0);
    //             glEnableVertexAttribArray(1);
    //         } catch (NullPointerException ex){
    //             ex.printStackTrace();
    //         }
    //     }
        
        
        
    //     skyboxmesh.setHasBones(false);
        
        
        
        
    //     glBindVertexArray(0);
        
        
        
        
        
        
        
        
        
    //     skyboxmesh.setParent(skyboxModel);
        
        
    //     skyboxModel.meshes.add(skyboxmesh);
        
        
    //     return skyboxModel;
    // }
    
}
