libs/hwui/AmbientShadow.cpp - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2013 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.
  */

 #define LOG_TAG "OpenGLRenderer"

 #include <math.h>
 #include <utils/Log.h>
 #include <utils/Vector.h>

 #include "AmbientShadow.h"
 #include "ShadowTessellator.h"
 #include "Vertex.h"

 namespace android {
 namespace uirenderer {

 /**
  * Calculate the shadows as a triangle strips while alpha value as the
  * shadow values.
  *
  * @param vertices The shadow caster's polygon, which is represented in a Vector3
  *                  array.
  * @param vertexCount The length of caster's polygon in terms of number of
  *                    vertices.
  * @param centroid3d The centroid of the shadow caster.
  * @param heightFactor The factor showing the higher the object, the lighter the
  *                     shadow.
  * @param geomFactor The factor scaling the geometry expansion along the normal.
  *
  * @param shadowVertexBuffer Return an floating point array of (x, y, a)
  *               triangle strips mode.
  */
 void AmbientShadow::createAmbientShadow(const Vector3* vertices, int vertexCount,
         const Vector3& centroid3d, float heightFactor, float geomFactor,
         VertexBuffer& shadowVertexBuffer) {
     const int rays = SHADOW_RAY_COUNT;
     const int layers = SHADOW_LAYER_COUNT;
     // Validate the inputs.
     if (vertexCount < 3 || heightFactor <= 0 || layers <= 0 || rays <= 0
         || geomFactor <= 0) {
 #if DEBUG_SHADOW
         ALOGE("Invalid input for createAmbientShadow(), early return!");
 #endif
         return;
     }

     Vector<Vector2> dir; // TODO: use C++11 unique_ptr
     dir.setCapacity(rays);
     float rayDist[rays];
     float rayHeight[rays];
     calculateRayDirections(rays, dir.editArray());

     // Calculate the length and height of the points along the edge.
     //
     // The math here is:
     // Intersect each ray (starting from the centroid) with the polygon.
     for (int i = 0; i < rays; i++) {
         int edgeIndex;
         float edgeFraction;
         float rayDistance;
         calculateIntersection(vertices, vertexCount, centroid3d, dir[i], edgeIndex,
                 edgeFraction, rayDistance);
         rayDist[i] = rayDistance;
         if (edgeIndex < 0 || edgeIndex >= vertexCount) {
 #if DEBUG_SHADOW
             ALOGE("Invalid edgeIndex!");
 #endif
             edgeIndex = 0;
         }
         float h1 = vertices[edgeIndex].z;
         float h2 = vertices[((edgeIndex + 1) % vertexCount)].z;
         rayHeight[i] = h1 + edgeFraction * (h2 - h1);
     }

     // The output buffer length basically is roughly rays * layers, but since we
     // need triangle strips, so we need to duplicate vertices to accomplish that.
     AlphaVertex* shadowVertices = shadowVertexBuffer.alloc<AlphaVertex>(SHADOW_VERTEX_COUNT);

     // Calculate the vertex of the shadows.
     //
     // The math here is:
     // Along the edges of the polygon, for each intersection point P (generated above),
     // calculate the normal N, which should be perpendicular to the edge of the
     // polygon (represented by the neighbor intersection points) .
     // Shadow's vertices will be generated as : P + N * scale.
     int currentVertexIndex = 0;
     for (int layerIndex = 0; layerIndex <= layers; layerIndex++) {
         for (int rayIndex = 0; rayIndex < rays; rayIndex++) {

             Vector2 normal(1.0f, 0.0f);
             calculateNormal(rays, rayIndex, dir.array(), rayDist, normal);

             float opacity = 1.0 / (1 + rayHeight[rayIndex] / heightFactor);

             // The vertex should be start from rayDist[i] then scale the
             // normalizeNormal!
             Vector2 intersection = dir[rayIndex] * rayDist[rayIndex] +
                     Vector2(centroid3d.x, centroid3d.y);

             float layerRatio = layerIndex / (float)(layers);
             // The higher the intersection is, the further the ambient shadow expanded.
             float expansionDist = rayHeight[rayIndex] / heightFactor *
                     geomFactor * (1 - layerRatio);
             AlphaVertex::set(&shadowVertices[currentVertexIndex++],
                     intersection.x + normal.x * expansionDist,
                     intersection.y + normal.y * expansionDist,
                     layerRatio * opacity);
         }

     }
     float centroidAlpha = 1.0 / (1 + centroid3d.z / heightFactor);
     AlphaVertex::set(&shadowVertices[currentVertexIndex++],
             centroid3d.x, centroid3d.y, centroidAlpha);

 #if DEBUG_SHADOW
     if (currentVertexIndex != SHADOW_VERTEX_COUNT) {
         ALOGE("number of vertex generated for ambient shadow is wrong! "
               "current: %d , expected: %d", currentVertexIndex, SHADOW_VERTEX_COUNT);
     }
     for (int i = 0; i < SHADOW_VERTEX_COUNT; i++) {
         ALOGD("ambient shadow value: i %d, (x:%f, y:%f, a:%f)", i, shadowVertices[i].x,
                 shadowVertices[i].y, shadowVertices[i].alpha);
     }
 #endif
 }

 /**
  * Generate an array of rays' direction vectors.
  *
  * @param rays The number of rays shooting out from the centroid.
  * @param dir Return the array of ray vectors.
  */
 void AmbientShadow::calculateRayDirections(int rays, Vector2* dir) {
     float deltaAngle = 2 * M_PI / rays;

     for (int i = 0; i < rays; i++) {
         dir[i].x = sinf(deltaAngle * i);
         dir[i].y = cosf(deltaAngle * i);
     }
 }

 /**
  * Calculate the intersection of a ray hitting the polygon.
  *
  * @param vertices The shadow caster's polygon, which is represented in a
  *                 Vector3 array.
  * @param vertexCount The length of caster's polygon in terms of number of vertices.
  * @param start The starting point of the ray.
  * @param dir The direction vector of the ray.
  *
  * @param outEdgeIndex Return the index of the segment (or index of the starting
  *                     vertex) that ray intersect with.
  * @param outEdgeFraction Return the fraction offset from the segment starting
  *                        index.
  * @param outRayDist Return the ray distance from centroid to the intersection.
  */
 void AmbientShadow::calculateIntersection(const Vector3* vertices, int vertexCount,
         const Vector3& start, const Vector2& dir, int& outEdgeIndex,
         float& outEdgeFraction, float& outRayDist) {
     float startX = start.x;
     float startY = start.y;
     float dirX = dir.x;
     float dirY = dir.y;
     // Start the search from the last edge from poly[len-1] to poly[0].
     int p1 = vertexCount - 1;

     for (int p2 = 0; p2 < vertexCount; p2++) {
         float p1x = vertices[p1].x;
         float p1y = vertices[p1].y;
         float p2x = vertices[p2].x;
         float p2y = vertices[p2].y;

         // The math here is derived from:
         // f(t, v) = p1x * (1 - t) + p2x * t - (startX + dirX * v) = 0;
         // g(t, v) = p1y * (1 - t) + p2y * t - (startY + dirY * v) = 0;
         float div = (dirX * (p1y - p2y) + dirY * p2x - dirY * p1x);
         if (div != 0) {
             float t = (dirX * (p1y - startY) + dirY * startX - dirY * p1x) / (div);
             if (t > 0 && t <= 1) {
                 float t2 = (p1x * (startY - p2y)
                             + p2x * (p1y - startY)
                             + startX * (p2y - p1y)) / div;
                 if (t2 > 0) {
                     outEdgeIndex = p1;
                     outRayDist = t2;
                     outEdgeFraction = t;
                     return;
                 }
             }
         }
         p1 = p2;
     }
     return;
 };

 /**
  * Calculate the normal at the intersection point between a ray and the polygon.
  *
  * @param rays The total number of rays.
  * @param currentRayIndex The index of the ray which the normal is based on.
  * @param dir The array of the all the rays directions.
  * @param rayDist The pre-computed ray distances array.
  *
  * @param normal Return the normal.
  */
 void AmbientShadow::calculateNormal(int rays, int currentRayIndex,
         const Vector2* dir, const float* rayDist, Vector2& normal) {
     int preIndex = (currentRayIndex - 1 + rays) % rays;
     int postIndex = (currentRayIndex + 1) % rays;
     Vector2 p1 = dir[preIndex] * rayDist[preIndex];
     Vector2 p2 = dir[postIndex] * rayDist[postIndex];

     // Now the V (deltaX, deltaY) is the vector going CW around the poly.
     Vector2 delta = p2 - p1;
     if (delta.length() != 0) {
         delta.normalize();
         // Calculate the normal , which is CCW 90 rotate to the V.
         // 90 degrees CCW about z-axis: (x, y, z) -> (-y, x, z)
         normal.x = -delta.y;
         normal.y = delta.x;
     }
 }

 }; // namespace uirenderer
 }; // namespace android
	/*
	* Copyright (C) 2013 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.
	*/

	#define LOG_TAG "OpenGLRenderer"

	#include <math.h>
	#include <utils/Log.h>
	#include <utils/Vector.h>

	#include "AmbientShadow.h"
	#include "ShadowTessellator.h"
	#include "Vertex.h"

	namespace android {
	namespace uirenderer {

	/**
	* Calculate the shadows as a triangle strips while alpha value as the
	* shadow values.
	*
	* @param vertices The shadow caster's polygon, which is represented in a Vector3
	* array.
	* @param vertexCount The length of caster's polygon in terms of number of
	* vertices.
	* @param centroid3d The centroid of the shadow caster.
	* @param heightFactor The factor showing the higher the object, the lighter the
	* shadow.
	* @param geomFactor The factor scaling the geometry expansion along the normal.
	*
	* @param shadowVertexBuffer Return an floating point array of (x, y, a)
	* triangle strips mode.
	*/
	void AmbientShadow::createAmbientShadow(const Vector3* vertices, int vertexCount,
	const Vector3& centroid3d, float heightFactor, float geomFactor,
	VertexBuffer& shadowVertexBuffer) {
	const int rays = SHADOW_RAY_COUNT;
	const int layers = SHADOW_LAYER_COUNT;
	// Validate the inputs.
	if (vertexCount < 3 \|\| heightFactor <= 0 \|\| layers <= 0 \|\| rays <= 0
	\|\| geomFactor <= 0) {
	#if DEBUG_SHADOW
	ALOGE("Invalid input for createAmbientShadow(), early return!");
	#endif
	return;
	}

	Vector<Vector2> dir; // TODO: use C++11 unique_ptr
	dir.setCapacity(rays);
	float rayDist[rays];
	float rayHeight[rays];
	calculateRayDirections(rays, dir.editArray());

	// Calculate the length and height of the points along the edge.
	//
	// The math here is:
	// Intersect each ray (starting from the centroid) with the polygon.
	for (int i = 0; i < rays; i++) {
	int edgeIndex;
	float edgeFraction;
	float rayDistance;
	calculateIntersection(vertices, vertexCount, centroid3d, dir[i], edgeIndex,
	edgeFraction, rayDistance);
	rayDist[i] = rayDistance;
	if (edgeIndex < 0 \|\| edgeIndex >= vertexCount) {
	#if DEBUG_SHADOW
	ALOGE("Invalid edgeIndex!");
	#endif
	edgeIndex = 0;
	}
	float h1 = vertices[edgeIndex].z;
	float h2 = vertices[((edgeIndex + 1) % vertexCount)].z;
	rayHeight[i] = h1 + edgeFraction * (h2 - h1);
	}

	// The output buffer length basically is roughly rays * layers, but since we
	// need triangle strips, so we need to duplicate vertices to accomplish that.
	AlphaVertex* shadowVertices = shadowVertexBuffer.alloc<AlphaVertex>(SHADOW_VERTEX_COUNT);

	// Calculate the vertex of the shadows.
	//
	// The math here is:
	// Along the edges of the polygon, for each intersection point P (generated above),
	// calculate the normal N, which should be perpendicular to the edge of the
	// polygon (represented by the neighbor intersection points) .
	// Shadow's vertices will be generated as : P + N * scale.
	int currentVertexIndex = 0;
	for (int layerIndex = 0; layerIndex <= layers; layerIndex++) {
	for (int rayIndex = 0; rayIndex < rays; rayIndex++) {

	Vector2 normal(1.0f, 0.0f);
	calculateNormal(rays, rayIndex, dir.array(), rayDist, normal);

	float opacity = 1.0 / (1 + rayHeight[rayIndex] / heightFactor);

	// The vertex should be start from rayDist[i] then scale the
	// normalizeNormal!
	Vector2 intersection = dir[rayIndex] * rayDist[rayIndex] +
	Vector2(centroid3d.x, centroid3d.y);

	float layerRatio = layerIndex / (float)(layers);
	// The higher the intersection is, the further the ambient shadow expanded.
	float expansionDist = rayHeight[rayIndex] / heightFactor *
	geomFactor * (1 - layerRatio);
	AlphaVertex::set(&shadowVertices[currentVertexIndex++],
	intersection.x + normal.x * expansionDist,
	intersection.y + normal.y * expansionDist,
	layerRatio * opacity);
	}

	}
	float centroidAlpha = 1.0 / (1 + centroid3d.z / heightFactor);
	AlphaVertex::set(&shadowVertices[currentVertexIndex++],
	centroid3d.x, centroid3d.y, centroidAlpha);

	#if DEBUG_SHADOW
	if (currentVertexIndex != SHADOW_VERTEX_COUNT) {
	ALOGE("number of vertex generated for ambient shadow is wrong! "
	"current: %d , expected: %d", currentVertexIndex, SHADOW_VERTEX_COUNT);
	}
	for (int i = 0; i < SHADOW_VERTEX_COUNT; i++) {
	ALOGD("ambient shadow value: i %d, (x:%f, y:%f, a:%f)", i, shadowVertices[i].x,
	shadowVertices[i].y, shadowVertices[i].alpha);
	}
	#endif
	}

	/**
	* Generate an array of rays' direction vectors.
	*
	* @param rays The number of rays shooting out from the centroid.
	* @param dir Return the array of ray vectors.
	*/
	void AmbientShadow::calculateRayDirections(int rays, Vector2* dir) {
	float deltaAngle = 2 * M_PI / rays;

	for (int i = 0; i < rays; i++) {
	dir[i].x = sinf(deltaAngle * i);
	dir[i].y = cosf(deltaAngle * i);
	}
	}

	/**
	* Calculate the intersection of a ray hitting the polygon.
	*
	* @param vertices The shadow caster's polygon, which is represented in a
	* Vector3 array.
	* @param vertexCount The length of caster's polygon in terms of number of vertices.
	* @param start The starting point of the ray.
	* @param dir The direction vector of the ray.
	*
	* @param outEdgeIndex Return the index of the segment (or index of the starting
	* vertex) that ray intersect with.
	* @param outEdgeFraction Return the fraction offset from the segment starting
	* index.
	* @param outRayDist Return the ray distance from centroid to the intersection.
	*/
	void AmbientShadow::calculateIntersection(const Vector3* vertices, int vertexCount,
	const Vector3& start, const Vector2& dir, int& outEdgeIndex,
	float& outEdgeFraction, float& outRayDist) {
	float startX = start.x;
	float startY = start.y;
	float dirX = dir.x;
	float dirY = dir.y;
	// Start the search from the last edge from poly[len-1] to poly[0].
	int p1 = vertexCount - 1;

	for (int p2 = 0; p2 < vertexCount; p2++) {
	float p1x = vertices[p1].x;
	float p1y = vertices[p1].y;
	float p2x = vertices[p2].x;
	float p2y = vertices[p2].y;

	// The math here is derived from:
	// f(t, v) = p1x * (1 - t) + p2x * t - (startX + dirX * v) = 0;
	// g(t, v) = p1y * (1 - t) + p2y * t - (startY + dirY * v) = 0;
	float div = (dirX * (p1y - p2y) + dirY * p2x - dirY * p1x);
	if (div != 0) {
	float t = (dirX * (p1y - startY) + dirY * startX - dirY * p1x) / (div);
	if (t > 0 && t <= 1) {
	float t2 = (p1x * (startY - p2y)
	+ p2x * (p1y - startY)
	+ startX * (p2y - p1y)) / div;
	if (t2 > 0) {
	outEdgeIndex = p1;
	outRayDist = t2;
	outEdgeFraction = t;
	return;
	}
	}
	}
	p1 = p2;
	}
	return;
	};

	/**
	* Calculate the normal at the intersection point between a ray and the polygon.
	*
	* @param rays The total number of rays.
	* @param currentRayIndex The index of the ray which the normal is based on.
	* @param dir The array of the all the rays directions.
	* @param rayDist The pre-computed ray distances array.
	*
	* @param normal Return the normal.
	*/
	void AmbientShadow::calculateNormal(int rays, int currentRayIndex,
	const Vector2* dir, const float* rayDist, Vector2& normal) {
	int preIndex = (currentRayIndex - 1 + rays) % rays;
	int postIndex = (currentRayIndex + 1) % rays;
	Vector2 p1 = dir[preIndex] * rayDist[preIndex];
	Vector2 p2 = dir[postIndex] * rayDist[postIndex];

	// Now the V (deltaX, deltaY) is the vector going CW around the poly.
	Vector2 delta = p2 - p1;
	if (delta.length() != 0) {
	delta.normalize();
	// Calculate the normal , which is CCW 90 rotate to the V.
	// 90 degrees CCW about z-axis: (x, y, z) -> (-y, x, z)
	normal.x = -delta.y;
	normal.y = delta.x;
	}
	}

	}; // namespace uirenderer
	}; // namespace android