FCL/sf/mw/uiaccelerator: comparison uiacceltk/hitchcock/coretoolkit/inc/Matrix.h

equal deleted inserted replaced

--1:000000000000
+:15bf7259bb7c
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#ifndef MATRIX_H
+#define MATRIX_H
+#include "Util.h"
+#include <string.h>
+#define _USE_MATH_DEFINES
+#include <math.h>
+namespace shadergen
+{
+static const float s_identityMatrix[16] =
+{
+	1.f, 0.f, 0.f, 0.f,
+	0.f, 1.f, 0.f, 0.f,
+	0.f, 0.f, 1.f, 0.f,
+	0.f, 0.f, 0.f, 1.f
+};
+#define EPSILON (.01f)
+/*!
+* \brief
+* Simple class for simulating OpenGL's matrix operations.
+*/
+class Matrix
+{
+public:
+	/*!
+	 * \brief
+	 * Default constructor.
+	 *
+	 * \remarks
+	 * Does nothing. Could initialize the matrix to identity, but then
+	 * again, why would it? It only hides errors.
+	 */
+	Matrix (void)
+	{
+	}
+	Matrix (const Matrix& mat)
+	{
+		(*this) = mat;
+	}
+	const Matrix& operator= (const Matrix& mat)
+	{
+		memcpy(m, mat.m, 16 * sizeof(float));
+		return *this;
+	}
+	/*!
+	 * \brief
+	 * glLoadMatrix() implementation.
+	 *
+	 * \param nm
+	 * Array of 16 floats.
+	 */
+	void loadMatrix (const float* nm)
+	{
+		memcpy(m, nm, 16 * sizeof(float));
+	}
+	/*!
+	 * \brief
+	 * glLoadIdentity() implementation
+	 */
+	void loadIdentity (void)
+	{
+		memcpy(m, s_identityMatrix, 16 * sizeof(float));
+	}
+	/*!
+	 * \brief
+	 * Check if the matrix is identity or not.
+	 *
+	 * \returns
+	 * Returns true if the matrix is the identity matrix, false otherwise.
+	 */
+	bool isIdentity (void) const
+	{
+		return !memcmp(m, s_identityMatrix, 16 * sizeof(float));
+	}
+	/*!
+	 * \brief
+	 * glMultMatrix() implementation.
+	 *
+	 * \param b
+	 * The other matrix, as floats.
+	 */
+	void multiply (const float* b)
+	{
+		float dst[16];
+		for (int i = 0; i < 4; i++)
+		{
+			for (int j = 0; j < 4; j++)
+			{
+				float sum = 0.f;
+				for (int k = 0; k < 4; k++)
+					sum += m[i + 4 * k] * b[k + 4 * j];
+				dst[i + 4 * j] = sum;
+			}
+		}
+		memcpy(m, dst, 16 * sizeof(float));
+	}
+	/*!
+	 * \brief
+	 * Sums given matrix (4x4) to this matrix (4x4).
+	 *
+	 * \param b
+	 * The other matrix, as floats.
+	 */
+	void plus (const float* b)
+	{
+	    for (int i = 0; i < 4; i++)
+	    {
+	        for (int j = 0; j < 4; j++)
+	        {
+	            m[i + 4 * j] += b[i + 4 * j];
+	        }
+	    }
+	}
+	/*!
+	 * \brief
+	 * glScalef() implementation.
+	 *
+	 * \param sx
+	 * X scale
+	 *
+	 * \param sy
+	 * Y scale
+	 *
+	 * \param sz
+	 * Z scale
+	 */
+	void scale (const float sx, const float sy, const float sz)
+	{
+		const float sm[16] =
+		{
+			sx, 0.f, 0.f, 0.f,
+			0.f,  sy, 0.f, 0.f,
+			0.f, 0.f,  sz, 0.f,
+			0.f, 0.f, 0.f, 1.f
+		};
+		multiply(sm);
+	}
+	/*!
+	 * \brief
+	 * glTranslatef() implementation.
+	 *
+	 * \param tx
+	 * X component of the translation vector
+	 *
+	 * \param ty
+	 * Y component of the translation vector
+	 *
+	 * \param tz
+	 * Z component of the translation vector
+	 */
+	void translate (const float tx, const float ty, const float tz)
+	{
+		const float tm[16] =
+		{
+			1.f, 0.f, 0.f, 0.f,
+			0.f, 1.f, 0.f, 0.f,
+			0.f, 0.f, 1.f, 0.f,
+			tx,  ty,  tz,  1.f
+		};
+		multiply(tm);
+	}
+	/*!
+	 * \brief
+	 * glRotatef() implementation
+	 *
+	 * \param angle
+	 * The amount of rotation
+	 *
+	 * \param x
+	 * X component of the axis about which to rotate
+	 *
+	 * \param y
+	 * Y component of the axis about which to rotate
+	 *
+	 * \param z
+	 * Z component of the axis about which to rotate
+	 */
+	void rotate (const float angle, const float x, const float y, const float z)
+	{
+		static const float deg_to_rad = 2.f * (float)M_PI / 360.f;
+		// normalised vector components
+		float x_n;
+		float y_n;
+		float z_n;
+		float angle_rad = angle * deg_to_rad;
+		// normalise if needed
+		const float length = (float)sqrt(double(x * x) +
+					  double(y * y) +
+					  double(z * z));
+		if(fabs(length - 1.0f) > EPSILON) {
+			// in fp calculations, division by zero -> (+/-)inf
+			// can't really help if it's the case.
+			const float inv_length = 1.f / length;
+			x_n = x * inv_length;
+			y_n = y * inv_length;
+			z_n = z * inv_length;
+		} else {
+			x_n = x;
+			y_n = y;
+			z_n = z;
+		}
+		const float c = cos(angle_rad);
+		const float s = sin(angle_rad);
+		const float c_1 = 1.f - c;
+		const float rm[16] =
+		{
+	x_n * x_n * c_1 + c,	   y_n * x_n * c_1 + z_n * s, x_n * z_n * c_1 - y_n * s, 0.f,
+	x_n * y_n * c_1 - z_n * s, y_n * y_n * c_1 + c,	      y_n * z_n * c_1 + x_n * s, 0.f,
+	x_n * z_n * c_1 + y_n * s, y_n * z_n * c_1 - x_n * s, z_n * z_n * c_1 + c,	 0.f,
+	0.f, 			   0.f,			      0.f,		   	 1.f
+		};
+		multiply(rm);
+	}
+	/*!
+	 * \brief
+	 * glFrustumf() implementation
+	 *
+	 * \param l
+	 * Left
+	 *
+	 * \param r
+	 * Right
+	 *
+	 * \param b
+	 * Bottom
+	 *
+	 * \param t
+	 * Top
+	 *
+	 * \param n
+	 * Near
+	 *
+	 * \param f
+	 * Far
+	 */
+	void frustum (const float l, const float r, const float b, const float t, const float n, const float f)
+	{
+		SG_ASSERT(r != l);
+		SG_ASSERT(t != b);
+		SG_ASSERT(n != f);
+		const float rl = 1.f / (r - l);
+		const float tb = 1.f / (t - b);
+		const float fn = 1.f / (f - n);
+		const float A = (r + l) * rl;
+		const float B = (t + b) * tb;
+		const float C = -(f + n) * fn;
+		const float D = -2.f * f * n * fn;
+		const float fm[16] =
+		{
+			2.f * n * rl,	0.f, 		0.f,	0.f,
+			0.f,		2.f * n * tb,	0.f,	0.f,
+			A,		B,		C,	-1.f,
+			0.f,		0.f,		D,	0.f
+		};
+		multiply(fm);
+	}
+	/*!
+	 * \brief
+	 * glOrthof() implementation
+	 *
+	 * \param l
+	 * Left
+	 *
+	 * \param r
+	 * Right
+	 *
+	 * \param b
+	 * Bottom
+	 *
+	 * \param t
+	 * Top
+	 *
+	 * \param n
+	 * Near
+	 *
+	 * \param f
+	 * Far
+	 */
+	void ortho (const float l, const float r, const float b, const float t, const float n, const float f)
+	{
+		SG_ASSERT(r != l);
+		SG_ASSERT(t != b);
+		SG_ASSERT(n != f);
+		const float rl = 1.f / (r - l);
+		const float tb = 1.f / (t - b);
+		const float fn = 1.f / (f - n);
+		const float tx = -(r + l) * rl;
+		const float ty = -(t + b) * tb;
+		const float tz = -(f + n) * fn;
+		const float om[16] =
+		{
+			2.f * rl,	0.f,		0.f,		0.f,
+			0.f,		2.f * tb,	0.f,		0.f,
+			0.f,		0.f,		-2.f * fn,	0.f,
+			tx,		ty,		tz,		1.f
+		};
+		multiply(om);
+	}
+	/*!
+	 * \brief
+	 * Returns pointer to floats making up the matrix. Suitable for
+	 * glLoadMatrix().
+	 */
+	const float *getMatrix(void) const {
+		return m;
+	}
+private:
+	float m[16];
+};
+} /* namespace shadergen */
+#endif /* MATRIX_H */