// Copyright (C) 2011-2012 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.

#pragma version(1)

#pragma rs java_package_name(com.android.scenegraph)

#ifndef _TRANSFORM_DEF_
#define _TRANSFORM_DEF_

#include "rs_graphics.rsh"

#define TRANSFORM_NONE      0
#define TRANSFORM_TRANSLATE 1
#define TRANSFORM_ROTATE    2
#define TRANSFORM_SCALE     3

#define CULL_FRUSTUM 0
#define CULL_ALWAYS  2

#define LIGHT_POINT       0
#define LIGHT_DIRECTIONAL 1

// Shader params that involve only data
#define SHADER_PARAM_DATA_ONLY                 10000
#define SHADER_PARAM_FLOAT4_DATA               10001
#define SHADER_PARAM_TRANSFORM_DATA            10002
#define SHADER_PARAM_TRANSFORM_MODEL           10003

// Shader params that involve camera
#define SHADER_PARAM_CAMERA                    1000
#define SHADER_PARAM_FLOAT4_CAMERA_POS         1001
#define SHADER_PARAM_FLOAT4_CAMERA_DIR         1002
#define SHADER_PARAM_TRANSFORM_VIEW            1003
#define SHADER_PARAM_TRANSFORM_PROJ            1004
#define SHADER_PARAM_TRANSFORM_VIEW_PROJ       1005
#define SHADER_PARAM_TRANSFORM_MODEL_VIEW      1006
#define SHADER_PARAM_TRANSFORM_MODEL_VIEW_PROJ 1007

// Shader Params that only involve lights
#define SHADER_PARAM_LIGHT                     100
#define SHADER_PARAM_FLOAT4_LIGHT_COLOR        103
#define SHADER_PARAM_FLOAT4_LIGHT_POS          104
#define SHADER_PARAM_FLOAT4_LIGHT_DIR          105

#define SHADER_PARAM_TEXTURE                   10

#define TEXTURE_NONE          0
#define TEXTURE_2D            1
#define TEXTURE_CUBE          2
#define TEXTURE_RENDER_TARGET 3

typedef struct TransformComponent_s {
    float4 value;
    int type;
    rs_allocation name;
} SgTransformComponent;

typedef struct __attribute__((packed, aligned(4))) SgTransform {
    rs_matrix4x4 globalMat;
    rs_matrix4x4 localMat;

    rs_allocation components;
    int isDirty;

    rs_allocation children;
    rs_allocation name;

    // Used to check whether transform params need to be updated
    uint32_t timestamp;
} SgTransform;

typedef struct VertexShader_s {
    rs_program_vertex program;
    // Buffer with vertex constant data
    rs_allocation shaderConst;
    // ShaderParam's that populate data
    rs_allocation shaderConstParams;
    // location of the per object constants on the buffer
    int objectConstIndex;
} SgVertexShader;

typedef struct FragmentShader_s {
    rs_program_fragment program;
    // Buffer with vertex constant data
    rs_allocation shaderConst;
    // ShaderParam's that populate data
    rs_allocation shaderConstParams;
    // ShaderParam's that set textures
    rs_allocation shaderTextureParams;
    // location of the per object constants on the buffer
    int objectConstIndex;
} SgFragmentShader;

typedef struct RenderState_s {
    rs_allocation pv; // VertexShader struct
    rs_allocation pf; // FragmentShader struct
    rs_program_store ps;
    rs_program_raster pr;
} SgRenderState;

typedef struct Renderable_s {
    rs_allocation render_state;
    // Buffer with vertex constant data
    rs_allocation pv_const;
    // ShaderParam's that populate data
    rs_allocation pv_constParams;
    // Buffer with fragment constant data
    rs_allocation pf_const;
    // ShaderParam's that populate data
    rs_allocation pf_constParams;
    rs_allocation pf_textures[8];
    int pf_num_textures;
    rs_mesh mesh;
    int meshIndex;
    rs_allocation transformMatrix;
    rs_allocation name;
    float4 boundingSphere;
    float4 worldBoundingSphere;
    int bVolInitialized;
    int cullType; // specifies whether to frustum cull
    int isVisible;
} SgRenderable;

typedef struct RenderPass_s {
    rs_allocation color_target;
    rs_allocation depth_target;
    rs_allocation camera;
    rs_allocation objects;

    float4 clear_color;
    float clear_depth;
    bool should_clear_color;
    bool should_clear_depth;
} SgRenderPass;

typedef struct Camera_s {
    rs_matrix4x4 proj;
    rs_matrix4x4 view;
    rs_matrix4x4 viewProj;
    float4 position;
    float near;
    float far;
    float horizontalFOV;
    float aspect;
    rs_allocation name;
    rs_allocation transformMatrix;
    float4 frustumPlanes[6];

    int isDirty;
    // Timestamp of the camera itself to signal params if anything changes
    uint32_t timestamp;
    // Timestamp of our transform
    uint32_t transformTimestamp;
} SgCamera;

typedef struct Light_s {
    float4 position;
    float4 color;
    float intensity;
    int type;
    rs_allocation name;
    rs_allocation transformMatrix;
} SgLight;

// This represents the shader parameter data needed to set a float or transform data
typedef struct ShaderParamData_s {
    int type;
    float4 float_value;
    uint32_t timestamp;
    rs_allocation paramName;
    rs_allocation camera;
    rs_allocation light;
    rs_allocation transform;
    rs_allocation texture;
} SgShaderParamData;

// This represents a shader parameter that knows how to update itself for a given
// renderable or shader and contains a timestamp for the last time this buffer was updated
typedef struct ShaderParam_s {
    // Used to check whether transform params need to be updated
    uint32_t transformTimestamp;
    // Used to check whether data params need to be updated
    // These are used when somebody set the matrix of float value directly in java
    uint32_t dataTimestamp;
    // Specifies where in the constant buffer data gets written to
    int bufferOffset;
    // An instance of SgShaderParamData that could be shared by multiple objects
    rs_allocation data;
    // How many components of the vector we need to write
    int float_vecSize;
} SgShaderParam;

// This represents a texture object
typedef struct Texture_s {
    uint32_t type;
    rs_allocation texture;
} SgTexture;

static void printName(rs_allocation name) {
    if (!rsIsObject(name)) {
        rsDebug("no name", 0);
        return;
    }

    rsDebug((const char*)rsGetElementAt(name, 0), 0);
}

static void printCameraInfo(const SgCamera *cam) {
    rsDebug("***** Camera information. ptr:", cam);
    printName(cam->name);
    const SgTransform *camTransform = (const SgTransform *)rsGetElementAt(cam->transformMatrix, 0);
    rsDebug("Transform name:", camTransform);
    printName(camTransform->name);

    rsDebug("Aspect: ", cam->aspect);
    rsDebug("Near: ", cam->near);
    rsDebug("Far: ", cam->far);
    rsDebug("Fov: ", cam->horizontalFOV);
    rsDebug("Position: ", cam->position);
    rsDebug("Proj: ", &cam->proj);
    rsDebug("View: ", &cam->view);
}

static void printLightInfo(const SgLight *light) {
    rsDebug("***** Light information. ptr:", light);
    printName(light->name);
    const SgTransform *lTransform = (const SgTransform *)rsGetElementAt(light->transformMatrix, 0);
    rsDebug("Transform name:", lTransform);
    printName(lTransform->name);

    rsDebug("Position: ", light->position);
    rsDebug("Color : ", light->color);
    rsDebug("Intensity: ", light->intensity);
    rsDebug("Type: ", light->type);
}

static void getCameraRay(const SgCamera *cam, int screenX, int screenY, float3 *pnt, float3 *vec) {
    rsDebug("=================================", screenX);
    rsDebug("Point X", screenX);
    rsDebug("Point Y", screenY);

    rs_matrix4x4 mvpInv;
    rsMatrixLoad(&mvpInv, &cam->viewProj);
    rsMatrixInverse(&mvpInv);

    float width = (float)rsgGetWidth();
    float height = (float)rsgGetHeight();

    float4 pos = {(float)screenX, height - (float)screenY, 0.0f, 1.0f};

    pos.x /= width;
    pos.y /= height;

    rsDebug("Pre Norm X", pos.x);
    rsDebug("Pre Norm Y", pos.y);

    pos.xy = pos.xy * 2.0f - 1.0f;

    rsDebug("Norm X", pos.x);
    rsDebug("Norm Y", pos.y);

    pos = rsMatrixMultiply(&mvpInv, pos);
    float oneOverW = 1.0f / pos.w;
    pos.xyz *= oneOverW;

    rsDebug("World X", pos.x);
    rsDebug("World Y", pos.y);
    rsDebug("World Z", pos.z);

    rsDebug("Cam X", cam->position.x);
    rsDebug("Cam Y", cam->position.y);
    rsDebug("Cam Z", cam->position.z);

    *vec = normalize(pos.xyz - cam->position.xyz);
    rsDebug("Vec X", vec->x);
    rsDebug("Vec Y", vec->y);
    rsDebug("Vec Z", vec->z);
    *pnt = cam->position.xyz;
}

static bool intersect(const SgRenderable *obj, float3 pnt, float3 vec) {
    // Solving for t^2 + Bt + C = 0
    float3 originMinusCenter = pnt - obj->worldBoundingSphere.xyz;
    float B = dot(originMinusCenter, vec) * 2.0f;
    float C = dot(originMinusCenter, originMinusCenter) -
              obj->worldBoundingSphere.w * obj->worldBoundingSphere.w;

    float discriminant = B * B - 4.0f * C;
    if (discriminant < 0.0f) {
        return false;
    }
    discriminant = sqrt(discriminant);

    float t0 = (-B - discriminant) * 0.5f;
    float t1 = (-B + discriminant) * 0.5f;

    if (t0 > t1) {
        float temp = t0;
        t0 = t1;
        t1 = temp;
    }

    // The sphere is behind us
    if (t1 < 0.0f) {
        return false;
    }
    return true;
}


#endif // _TRANSFORM_DEF_