libagl shouldn't export anything (7d3916ff) · Commits · e / os / android_frameworks_base

include/private/opengles/gl_context.h

deleted100644 → 0

+0 −640

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2006 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.
		*/

		#ifndef ANDROID_OPENGLES_CONTEXT_H
		#define ANDROID_OPENGLES_CONTEXT_H

		#include <stdint.h>
		#include <stddef.h>
		#include <sys/types.h>
		#include <pthread.h>
		#ifdef HAVE_ANDROID_OS
		#include <bionic_tls.h>
		#endif

		#include <private/pixelflinger/ggl_context.h>
		#include <hardware/gralloc.h>

		#include <GLES/gl.h>
		#include <GLES/glext.h>

		namespace android {


		const unsigned int OGLES_NUM_COMPRESSED_TEXTURE_FORMATS = 10
		#ifdef GL_OES_compressed_ETC1_RGB8_texture
		+ 1
		#endif
		;

		class EGLTextureObject;
		class EGLSurfaceManager;
		class EGLBufferObjectManager;

		namespace gl {

		struct ogles_context_t;
		struct matrixx_t;
		struct transform_t;
		struct buffer_t;

		ogles_context_t* getGlContext();

		template<typename T>
		static inline void swap(T& a, T& b) {
		T t(a); a = b; b = t;
		}
		template<typename T>
		inline T max(T a, T b) {
		return a<b ? b : a;
		}
		template<typename T>
		inline T max(T a, T b, T c) {
		return max(a, max(b, c));
		}
		template<typename T>
		inline T min(T a, T b) {
		return a<b ? a : b;
		}
		template<typename T>
		inline T min(T a, T b, T c) {
		return min(a, min(b, c));
		}
		template<typename T>
		inline T min(T a, T b, T c, T d) {
		return min(min(a,b), min(c,d));
		}

		// ----------------------------------------------------------------------------
		// vertices
		// ----------------------------------------------------------------------------

		struct vec3_t {
		union {
		struct { GLfixed x, y, z; };
		struct { GLfixed r, g, b; };
		struct { GLfixed S, T, R; };
		GLfixed v[3];
		};
		};

		struct vec4_t {
		union {
		struct { GLfixed x, y, z, w; };
		struct { GLfixed r, g, b, a; };
		struct { GLfixed S, T, R, Q; };
		GLfixed v[4];
		};
		};

		struct vertex_t {
		enum {
		// these constant matter for our clipping
		CLIP_L = 0x0001, // clipping flags
		CLIP_R = 0x0002,
		CLIP_B = 0x0004,
		CLIP_T = 0x0008,
		CLIP_N = 0x0010,
		CLIP_F = 0x0020,

		EYE = 0x0040,
		RESERVED = 0x0080,

		USER_CLIP_0 = 0x0100, // user clipping flags
		USER_CLIP_1 = 0x0200,
		USER_CLIP_2 = 0x0400,
		USER_CLIP_3 = 0x0800,
		USER_CLIP_4 = 0x1000,
		USER_CLIP_5 = 0x2000,

		LIT = 0x4000, // lighting has been applied
		TT = 0x8000, // texture coords transformed

		FRUSTUM_CLIP_ALL= 0x003F,
		USER_CLIP_ALL = 0x3F00,
		CLIP_ALL = 0x3F3F,
		};

		// the fields below are arranged to minimize d-cache usage
		// we group together, by cache-line, the fields most likely to be used

		union {
		vec4_t obj;
		vec4_t eye;
		};
		vec4_t clip;

		uint32_t flags;
		size_t index; // cache tag, and vertex index
		GLfixed fog;
		uint8_t locked;
		uint8_t mru;
		uint8_t reserved[2];
		vec4_t window;

		vec4_t color;
		vec4_t texture[GGL_TEXTURE_UNIT_COUNT];
		uint32_t reserved1[4];

		inline void clear() {
		flags = index = locked = mru = 0;
		}
		};

		struct point_size_t {
		GGLcoord size;
		GLboolean smooth;
		};

		struct line_width_t {
		GGLcoord width;
		GLboolean smooth;
		};

		struct polygon_offset_t {
		GLfixed factor;
		GLfixed units;
		GLboolean enable;
		};

		// ----------------------------------------------------------------------------
		// arrays
		// ----------------------------------------------------------------------------

		struct array_t {
		typedef void (fetcher_t)(ogles_context_t, GLfixed, const GLvoid);
		fetcher_t fetch;
		GLvoid const* physical_pointer;
		GLint size;
		GLsizei stride;
		GLvoid const* pointer;
		buffer_t const* bo;
		uint16_t type;
		GLboolean enable;
		GLboolean pad;
		GLsizei bounds;
		void init(GLint, GLenum, GLsizei, const GLvoid , const buffer_t, GLsizei);
		inline void resolve();
		inline const GLubyte* element(GLint i) const {
		return (const GLubyte)physical_pointer + i stride;
		}
		};

		struct array_machine_t {
		array_t vertex;
		array_t normal;
		array_t color;
		array_t texture[GGL_TEXTURE_UNIT_COUNT];
		uint8_t activeTexture;
		uint8_t tmu;
		uint16_t cull;
		uint32_t flags;
		GLenum indicesType;
		buffer_t const* array_buffer;
		buffer_t const* element_array_buffer;

		void (compileElements)(ogles_context_t, vertex_t*, GLint, GLsizei);
		void (compileElement)(ogles_context_t, vertex_t*, GLint);

		void (mvp_transform)(transform_t const, vec4_t, vec4_t const);
		void (mv_transform)(transform_t const, vec4_t, vec4_t const);
		void (tex_transform[2])(transform_t const, vec4_t, vec4_t const);
		void (perspective)(ogles_context_tc, vertex_t* v);
		void (clipVertex)(ogles_context_t c, vertex_t* nv,
		GGLfixed t, const vertex_t* s, const vertex_t* p);
		void (clipEye)(ogles_context_t c, vertex_t* nv,
		GGLfixed t, const vertex_t* s, const vertex_t* p);
		};

		struct vertex_cache_t {
		enum {
		// must be at least 4
		// 3 vertice for triangles
		// or 2 + 2 for indexed triangles w/ cache contention
		VERTEX_BUFFER_SIZE = 8,
		// must be a power of two and at least 3
		VERTEX_CACHE_SIZE = 64, // 8 KB

		INDEX_BITS = 16,
		INDEX_MASK = ((1LU<<INDEX_BITS)-1),
		INDEX_SEQ = 1LU<<INDEX_BITS,
		};
		vertex_t* vBuffer;
		vertex_t* vCache;
		uint32_t sequence;
		void* base;
		uint32_t total;
		uint32_t misses;
		int64_t startTime;
		void init();
		void uninit();
		void clear();
		void dump_stats(GLenum mode);
		};

		// ----------------------------------------------------------------------------
		// fog
		// ----------------------------------------------------------------------------

		struct fog_t {
		GLfixed density;
		GLfixed start;
		GLfixed end;
		GLfixed invEndMinusStart;
		GLenum mode;
		GLfixed (fog)(ogles_context_t c, GLfixed z);
		};

		// ----------------------------------------------------------------------------
		// user clip planes
		// ----------------------------------------------------------------------------

		const unsigned int OGLES_MAX_CLIP_PLANES = 6;

		struct clip_plane_t {
		vec4_t equation;
		};

		struct user_clip_planes_t {
		clip_plane_t plane[OGLES_MAX_CLIP_PLANES];
		uint32_t enable;
		};

		// ----------------------------------------------------------------------------
		// lighting
		// ----------------------------------------------------------------------------

		const unsigned int OGLES_MAX_LIGHTS = 8;

		struct light_t {
		vec4_t ambient;
		vec4_t diffuse;
		vec4_t specular;
		vec4_t implicitAmbient;
		vec4_t implicitDiffuse;
		vec4_t implicitSpecular;
		vec4_t position; // position in eye space
		vec4_t objPosition;
		vec4_t normalizedObjPosition;
		vec4_t spotDir;
		vec4_t normalizedSpotDir;
		GLfixed spotExp;
		GLfixed spotCutoff;
		GLfixed spotCutoffCosine;
		GLfixed attenuation[3];
		GLfixed rConstAttenuation;
		GLboolean enable;
		};

		struct material_t {
		vec4_t ambient;
		vec4_t diffuse;
		vec4_t specular;
		vec4_t emission;
		GLfixed shininess;
		};

		struct light_model_t {
		vec4_t ambient;
		GLboolean twoSide;
		};

		struct color_material_t {
		GLenum face;
		GLenum mode;
		GLboolean enable;
		};

		struct lighting_t {
		light_t lights[OGLES_MAX_LIGHTS];
		material_t front;
		light_model_t lightModel;
		color_material_t colorMaterial;
		vec4_t implicitSceneEmissionAndAmbient;
		vec4_t objViewer;
		uint32_t enabledLights;
		GLboolean enable;
		GLenum shadeModel;
		typedef void (light_fct_t)(ogles_context_t, vertex_t*);
		void (lightVertex)(ogles_context_t c, vertex_t* v);
		void (lightTriangle)(ogles_context_t c,
		vertex_t* v0, vertex_t* v1, vertex_t* v2);
		};

		struct culling_t {
		GLenum cullFace;
		GLenum frontFace;
		GLboolean enable;
		};

		// ----------------------------------------------------------------------------
		// textures
		// ----------------------------------------------------------------------------

		struct texture_unit_t {
		GLuint name;
		EGLTextureObject* texture;
		uint8_t dirty;
		};

		struct texture_state_t
		{
		texture_unit_t tmu[GGL_TEXTURE_UNIT_COUNT];
		int active; // active tmu
		EGLTextureObject* defaultTexture;
		GGLContext* ggl;
		uint8_t packAlignment;
		uint8_t unpackAlignment;
		};

		// ----------------------------------------------------------------------------
		// transformation and matrices
		// ----------------------------------------------------------------------------

		struct matrixf_t;

		struct matrixx_t {
		GLfixed m[16];
		void load(const matrixf_t& rhs);
		};

		struct matrix_stack_t;


		struct matrixf_t {
		void loadIdentity();
		void load(const matrixf_t& rhs);

		inline GLfloat* editElements() { return m; }
		inline GLfloat const* elements() const { return m; }

		void set(const GLfixed* rhs);
		void set(const GLfloat* rhs);

		static void multiply(matrixf_t& r,
		const matrixf_t& lhs, const matrixf_t& rhs);

		void dump(const char* what);

		private:
		friend struct matrix_stack_t;
		GLfloat m[16];
		void load(const GLfixed* rhs);
		void load(const GLfloat* rhs);
		void multiply(const matrixf_t& rhs);
		void translate(GLfloat x, GLfloat y, GLfloat z);
		void scale(GLfloat x, GLfloat y, GLfloat z);
		void rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z);
		};

		enum {
		OP_IDENTITY = 0x00,
		OP_TRANSLATE = 0x01,
		OP_UNIFORM_SCALE = 0x02,
		OP_SCALE = 0x05,
		OP_ROTATE = 0x08,
		OP_SKEW = 0x10,
		OP_ALL = 0x1F
		};

		struct transform_t {
		enum {
		FLAGS_2D_PROJECTION = 0x1
		};
		matrixx_t matrix;
		uint32_t flags;
		uint32_t ops;

		union {
		struct {
		void (point2)(transform_t const t, vec4_t, vec4_t const);
		void (point3)(transform_t const t, vec4_t, vec4_t const);
		void (point4)(transform_t const t, vec4_t, vec4_t const);
		};
		void (pointv[3])(transform_t const t, vec4_t, vec4_t const);
		};

		void loadIdentity();
		void picker();
		void dump(const char* what);
		};

		struct mvui_transform_t : public transform_t
		{
		void picker();
		};

		struct matrix_stack_t {
		enum {
		DO_PICKER = 0x1,
		DO_FLOAT_TO_FIXED = 0x2
		};
		transform_t transform;
		uint8_t maxDepth;
		uint8_t depth;
		uint8_t dirty;
		uint8_t reserved;
		matrixf_t *stack;
		uint8_t *ops;
		void init(int depth);
		void uninit();
		void loadIdentity();
		void load(const GLfixed* rhs);
		void load(const GLfloat* rhs);
		void multiply(const matrixf_t& rhs);
		void translate(GLfloat x, GLfloat y, GLfloat z);
		void scale(GLfloat x, GLfloat y, GLfloat z);
		void rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z);
		GLint push();
		GLint pop();
		void validate();
		matrixf_t& top() { return stack[depth]; }
		const matrixf_t& top() const { return stack[depth]; }
		uint32_t top_ops() const { return ops[depth]; }
		inline bool isRigidBody() const {
		return !(ops[depth] & ~(OP_TRANSLATE\|OP_UNIFORM_SCALE\|OP_ROTATE));
		}
		};

		struct vp_transform_t {
		transform_t transform;
		matrixf_t matrix;
		GLfloat zNear;
		GLfloat zFar;
		void loadIdentity();
		};

		struct transform_state_t {
		enum {
		MODELVIEW = 0x01,
		PROJECTION = 0x02,
		VIEWPORT = 0x04,
		TEXTURE = 0x08,
		MVUI = 0x10,
		MVIT = 0x20,
		MVP = 0x40,
		};
		matrix_stack_t *current;
		matrix_stack_t modelview;
		matrix_stack_t projection;
		matrix_stack_t texture[GGL_TEXTURE_UNIT_COUNT];

		// modelview * projection
		transform_t mvp __attribute__((aligned(32)));
		// viewport transformation
		vp_transform_t vpt __attribute__((aligned(32)));
		// same for 4-D vertices
		transform_t mvp4;
		// full modelview inverse transpose
		transform_t mvit4;
		// upper 3x3 of mv-inverse-transpose (for normals)
		mvui_transform_t mvui;

		GLenum matrixMode;
		GLenum rescaleNormals;
		uint32_t dirty;
		void invalidate();
		void update_mvp();
		void update_mvit();
		void update_mvui();
		};

		struct viewport_t {
		GLint x;
		GLint y;
		GLsizei w;
		GLsizei h;
		struct {
		GLint x;
		GLint y;
		} surfaceport;
		struct {
		GLint x;
		GLint y;
		GLsizei w;
		GLsizei h;
		} scissor;
		};

		// ----------------------------------------------------------------------------
		// Lerping
		// ----------------------------------------------------------------------------

		struct compute_iterators_t
		{
		void initTriangle(
		vertex_t const* v0,
		vertex_t const* v1,
		vertex_t const* v2);

		void initLine(
		vertex_t const* v0,
		vertex_t const* v1);

		inline void initLerp(vertex_t const* v0, uint32_t enables);

		int iteratorsScale(int32_t it[3],
		int32_t c0, int32_t c1, int32_t c2) const;

		void iterators1616(GGLfixed it[3],
		GGLfixed c0, GGLfixed c1, GGLfixed c2) const;

		void iterators0032(int32_t it[3],
		int32_t c0, int32_t c1, int32_t c2) const;

		void iterators0032(int64_t it[3],
		int32_t c0, int32_t c1, int32_t c2) const;

		GGLcoord area() const { return m_area; }

		private:
		// don't change order of members here -- used by iterators.S
		GGLcoord m_dx01, m_dy10, m_dx20, m_dy02;
		GGLcoord m_x0, m_y0;
		GGLcoord m_area;
		uint8_t m_scale;
		uint8_t m_area_scale;
		uint8_t m_reserved[2];

		};

		// ----------------------------------------------------------------------------
		// state
		// ----------------------------------------------------------------------------

		#ifdef HAVE_ANDROID_OS
		// We have a dedicated TLS slot in bionic
		inline void setGlThreadSpecific(ogles_context_t *value) {
		((uint32_t *)__get_tls())[TLS_SLOT_OPENGL] = (uint32_t)value;
		}
		inline ogles_context_t* getGlThreadSpecific() {
		return (ogles_context_t )(((unsigned )__get_tls())[TLS_SLOT_OPENGL]);
		}
		#else
		extern pthread_key_t gGLKey;
		inline void setGlThreadSpecific(ogles_context_t *value) {
		pthread_setspecific(gGLKey, value);
		}
		inline ogles_context_t* getGlThreadSpecific() {
		return static_cast<ogles_context_t*>(pthread_getspecific(gGLKey));
		}
		#endif


		struct prims_t {
		typedef ogles_context_t* GL;
		void (renderPoint)(GL, vertex_t);
		void (renderLine)(GL, vertex_t, vertex_t*);
		void (renderTriangle)(GL, vertex_t, vertex_t, vertex_t);
		};

		struct ogles_context_t {
		context_t rasterizer;
		array_machine_t arrays __attribute__((aligned(32)));
		texture_state_t textures;
		transform_state_t transforms;
		vertex_cache_t vc;
		prims_t prims;
		culling_t cull;
		lighting_t lighting;
		user_clip_planes_t clipPlanes;
		compute_iterators_t lerp; __attribute__((aligned(32)));
		vertex_t current;
		vec4_t currentColorClamped;
		vec3_t currentNormal;
		viewport_t viewport;
		point_size_t point;
		line_width_t line;
		polygon_offset_t polygonOffset;
		fog_t fog;
		uint32_t perspective : 1;
		uint32_t transformTextures : 1;
		EGLSurfaceManager* surfaceManager;
		EGLBufferObjectManager* bufferObjectManager;

		GLenum error;

		static inline ogles_context_t* get() {
		return getGlThreadSpecific();
		}

		};

		}; // namespace gl
		}; // namespace android

		#endif // ANDROID_OPENGLES_CONTEXT_H

opengl/libagl/context.h

+640 −18

File changed.

Preview size limit exceeded, changes collapsed.