// 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_