import QtQuick 2.0
import QtQuick.Scene3D 2.0
import Qt3D.Core 2.0
import Qt3D.Render 2.0
import Qt3D.Input 2.0
import Qt3D.Extras 2.0

Item {
    id: root

    width: 640
    height: 640

    Scene3D {
        id: scene

        anchors.fill: parent

        aspects: ["render", "input", "logic"]
        cameraAspectRatioMode: Scene3D.AutomaticAspectRatio
        multisample: true

        Entity {
            id: sceneRoot

            RenderSettings {
                id: renderSettings
                activeFrameGraph: ForwardRenderer {
                    clearColor: Qt.rgba(0.75, 0.75, 0.75, 0.1)
                    camera: camera
                }
            }

            InputSettings { id: inputSettings }

            Camera {
                id: camera
                projectionType: CameraLens.PerspectiveProjection
                fieldOfView: 45
                nearPlane : 0.1
                farPlane : 1000.0
                position: Qt.vector3d( 20.0, 20.0, 20.0 )
                upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
                viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
            }

            components: [renderSettings, inputSettings]

            Entity {
                id: torusEntity
                components: [ mesh, material ]

                property TorusMesh mesh: TorusMesh {
                    minorRadius: 1
                    radius: 4
                    rings: 100
                    slices: 20
                }

                property var material: phongMaterial // uncomment this line for "broken" shader compilation
                //property var material: simpleMaterial // uncomment this line for "working" shader compilation

                property PhongMaterial phongMaterial: PhongMaterial {
                    ambient: "red"
                }

                property Material simpleMaterial: Material {
                    id: customMaterial
                    property color maincolor: "red"

                    parameters: [
                        Parameter {
                            name: "maincolor"
                            value: Qt.vector3d(customMaterial.maincolor.r, customMaterial.maincolor.g, customMaterial.maincolor.b)
                        }
                    ]

                    effect: Effect {
                        FilterKey {
                            id: forward
                            name: "renderingStyle"
                            value: "forward"
                        }
                        ShaderProgram {
                            id: gl3Shader
                            vertexShaderCode: "
#version 150 core

in vec3 vertexPosition;
out vec3 worldPosition;
uniform mat4 modelMatrix;
uniform mat4 mvp;

void main()
{
    worldPosition = vec3(modelMatrix * vec4(vertexPosition, 1.0));
    gl_Position = mvp * vec4(worldPosition, 1.0);
}
"
                            fragmentShaderCode: "
#version 150 core

uniform vec3 maincolor;
out vec4 fragColor;

void main()
{
    fragColor = vec4(maincolor, 1.0);
}
"
                        }
                        ShaderProgram {
                            id: gles2Shader
                            vertexShaderCode: "
attribute highp vec3 vertexPosition;
varying highp vec3 worldPosition;
uniform highp mat4 modelMatrix;
uniform highp mat4 mvp;

void main()
{
    worldPosition = vec3(modelMatrix * vec4(vertexPosition, 1.0));
    gl_Position = mvp * vec4(worldPosition, 1.0);
}
"
                            fragmentShaderCode: "
uniform highp vec3 maincolor;

void main()
{
    gl_FragColor = vec4(maincolor, 1.0);
}
"
                        }
                        techniques: [
                            Technique {
                                filterKeys: [forward]
                                graphicsApiFilter {
                                    api: GraphicsApiFilter.OpenGL
                                    profile: GraphicsApiFilter.CoreProfile
                                    majorVersion: 3
                                    minorVersion: 1
                                }
                                renderPasses: RenderPass {
                                    shaderProgram: gl3Shader
                                }
                            },
                            Technique {
                                filterKeys: [forward]
                                graphicsApiFilter {
                                    api: GraphicsApiFilter.OpenGL
                                    profile: GraphicsApiFilter.NoProfile
                                    majorVersion: 2
                                    minorVersion: 0
                                }
                                renderPasses: RenderPass {
                                    shaderProgram: gles2Shader
                                }
                            },
                            Technique {
                                filterKeys: [forward]
                                graphicsApiFilter {
                                    api: GraphicsApiFilter.OpenGLES
                                    profile: GraphicsApiFilter.CoreProfile
                                    majorVersion: 2
                                    minorVersion: 0
                                }
                                renderPasses: RenderPass {
                                    shaderProgram: gles2Shader
                                }
                            }
                        ]
                    }
                }
            }
        }
    }
}