The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/Context.h

gfx/angle/src/libGLESv2/Context.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:0cbc592a1b76
1 //
2 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // Context.h: Defines the gl::Context class, managing all GL state and performing
8 // rendering operations. It is the GLES2 specific implementation of EGLContext.
9
10 #ifndef LIBGLESV2_CONTEXT_H_
11 #define LIBGLESV2_CONTEXT_H_
12
13 #define GL_APICALL
14 #include <GLES2/gl2.h>
15 #include <GLES2/gl2ext.h>
16 #define EGLAPI
17 #include <EGL/egl.h>
18
19 #include <string>
20 #include <map>
21 #ifdef _MSC_VER
22 #include <hash_map>
23 #else
24 #include <unordered_map>
25 #endif
26
27 #include "common/angleutils.h"
28 #include "common/RefCountObject.h"
29 #include "libGLESv2/HandleAllocator.h"
30 #include "libGLESv2/angletypes.h"
31 #include "libGLESv2/Constants.h"
32
33 namespace rx
34 {
35 class Renderer;
36 }
37
38 namespace egl
39 {
40 class Display;
41 class Surface;
42 }
43
44 namespace gl
45 {
46 class Shader;
47 class Program;
48 class ProgramBinary;
49 class Texture;
50 class Texture2D;
51 class TextureCubeMap;
52 class Framebuffer;
53 class Renderbuffer;
54 class RenderbufferStorage;
55 class Colorbuffer;
56 class Depthbuffer;
57 class Stencilbuffer;
58 class DepthStencilbuffer;
59 class Fence;
60 class Query;
61 class ResourceManager;
62 class Buffer;
63
64 enum QueryType
65 {
66 QUERY_ANY_SAMPLES_PASSED,
67 QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,
68
69 QUERY_TYPE_COUNT
70 };
71
72 // Helper structure describing a single vertex attribute
73 class VertexAttribute
74 {
75 public:
76 VertexAttribute() : mType(GL_FLOAT), mSize(0), mNormalized(false), mStride(0), mPointer(NULL), mArrayEnabled(false), mDivisor(0)
77 {
78 mCurrentValue[0] = 0.0f;
79 mCurrentValue[1] = 0.0f;
80 mCurrentValue[2] = 0.0f;
81 mCurrentValue[3] = 1.0f;
82 }
83
84 int typeSize() const
85 {
86 switch (mType)
87 {
88 case GL_BYTE: return mSize * sizeof(GLbyte);
89 case GL_UNSIGNED_BYTE: return mSize * sizeof(GLubyte);
90 case GL_SHORT: return mSize * sizeof(GLshort);
91 case GL_UNSIGNED_SHORT: return mSize * sizeof(GLushort);
92 case GL_FIXED: return mSize * sizeof(GLfixed);
93 case GL_FLOAT: return mSize * sizeof(GLfloat);
94 default: UNREACHABLE(); return mSize * sizeof(GLfloat);
95 }
96 }
97
98 GLsizei stride() const
99 {
100 return mStride ? mStride : typeSize();
101 }
102
103 // From glVertexAttribPointer
104 GLenum mType;
105 GLint mSize;
106 bool mNormalized;
107 GLsizei mStride; // 0 means natural stride
108
109 union
110 {
111 const void *mPointer;
112 intptr_t mOffset;
113 };
114
115 BindingPointer<Buffer> mBoundBuffer; // Captured when glVertexAttribPointer is called.
116
117 bool mArrayEnabled; // From glEnable/DisableVertexAttribArray
118 float mCurrentValue[4]; // From glVertexAttrib
119 unsigned int mDivisor;
120 };
121
122 // Helper structure to store all raw state
123 struct State
124 {
125 Color colorClearValue;
126 GLclampf depthClearValue;
127 int stencilClearValue;
128
129 RasterizerState rasterizer;
130 bool scissorTest;
131 Rectangle scissor;
132
133 BlendState blend;
134 Color blendColor;
135 bool sampleCoverage;
136 GLclampf sampleCoverageValue;
137 bool sampleCoverageInvert;
138
139 DepthStencilState depthStencil;
140 GLint stencilRef;
141 GLint stencilBackRef;
142
143 GLfloat lineWidth;
144
145 GLenum generateMipmapHint;
146 GLenum fragmentShaderDerivativeHint;
147
148 Rectangle viewport;
149 float zNear;
150 float zFar;
151
152 unsigned int activeSampler; // Active texture unit selector - GL_TEXTURE0
153 BindingPointer<Buffer> arrayBuffer;
154 BindingPointer<Buffer> elementArrayBuffer;
155 GLuint readFramebuffer;
156 GLuint drawFramebuffer;
157 BindingPointer<Renderbuffer> renderbuffer;
158 GLuint currentProgram;
159
160 VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];
161 BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS];
162 BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
163
164 GLint unpackAlignment;
165 GLint packAlignment;
166 bool packReverseRowOrder;
167 };
168
169 class Context
170 {
171 public:
172 Context(const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess);
173
174 ~Context();
175
176 void makeCurrent(egl::Surface *surface);
177
178 virtual void markContextLost();
179 bool isContextLost();
180
181 // State manipulation
182 void setClearColor(float red, float green, float blue, float alpha);
183
184 void setClearDepth(float depth);
185
186 void setClearStencil(int stencil);
187
188 void setCullFace(bool enabled);
189 bool isCullFaceEnabled() const;
190
191 void setCullMode(GLenum mode);
192
193 void setFrontFace(GLenum front);
194
195 void setDepthTest(bool enabled);
196 bool isDepthTestEnabled() const;
197
198 void setDepthFunc(GLenum depthFunc);
199
200 void setDepthRange(float zNear, float zFar);
201
202 void setBlend(bool enabled);
203 bool isBlendEnabled() const;
204
205 void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
206 void setBlendColor(float red, float green, float blue, float alpha);
207 void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);
208
209 void setStencilTest(bool enabled);
210 bool isStencilTestEnabled() const;
211
212 void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);
213 void setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask);
214 void setStencilWritemask(GLuint stencilWritemask);
215 void setStencilBackWritemask(GLuint stencilBackWritemask);
216 void setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass);
217 void setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass);
218
219 void setPolygonOffsetFill(bool enabled);
220 bool isPolygonOffsetFillEnabled() const;
221
222 void setPolygonOffsetParams(GLfloat factor, GLfloat units);
223
224 void setSampleAlphaToCoverage(bool enabled);
225 bool isSampleAlphaToCoverageEnabled() const;
226
227 void setSampleCoverage(bool enabled);
228 bool isSampleCoverageEnabled() const;
229
230 void setSampleCoverageParams(GLclampf value, bool invert);
231
232 void setScissorTest(bool enabled);
233 bool isScissorTestEnabled() const;
234
235 void setDither(bool enabled);
236 bool isDitherEnabled() const;
237
238 void setLineWidth(GLfloat width);
239
240 void setGenerateMipmapHint(GLenum hint);
241 void setFragmentShaderDerivativeHint(GLenum hint);
242
243 void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
244
245 void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);
246
247 void setColorMask(bool red, bool green, bool blue, bool alpha);
248 void setDepthMask(bool mask);
249
250 void setActiveSampler(unsigned int active);
251
252 GLuint getReadFramebufferHandle() const;
253 GLuint getDrawFramebufferHandle() const;
254 GLuint getRenderbufferHandle() const;
255
256 GLuint getArrayBufferHandle() const;
257
258 GLuint getActiveQuery(GLenum target) const;
259
260 void setEnableVertexAttribArray(unsigned int attribNum, bool enabled);
261 const VertexAttribute &getVertexAttribState(unsigned int attribNum);
262 void setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type,
263 bool normalized, GLsizei stride, const void *pointer);
264 const void *getVertexAttribPointer(unsigned int attribNum) const;
265
266 void setUnpackAlignment(GLint alignment);
267 GLint getUnpackAlignment() const;
268
269 void setPackAlignment(GLint alignment);
270 GLint getPackAlignment() const;
271
272 void setPackReverseRowOrder(bool reverseRowOrder);
273 bool getPackReverseRowOrder() const;
274
275 // These create and destroy methods are merely pass-throughs to
276 // ResourceManager, which owns these object types
277 GLuint createBuffer();
278 GLuint createShader(GLenum type);
279 GLuint createProgram();
280 GLuint createTexture();
281 GLuint createRenderbuffer();
282
283 void deleteBuffer(GLuint buffer);
284 void deleteShader(GLuint shader);
285 void deleteProgram(GLuint program);
286 void deleteTexture(GLuint texture);
287 void deleteRenderbuffer(GLuint renderbuffer);
288
289 // Framebuffers are owned by the Context, so these methods do not pass through
290 GLuint createFramebuffer();
291 void deleteFramebuffer(GLuint framebuffer);
292
293 // Fences are owned by the Context.
294 GLuint createFence();
295 void deleteFence(GLuint fence);
296
297 // Queries are owned by the Context;
298 GLuint createQuery();
299 void deleteQuery(GLuint query);
300
301 void bindArrayBuffer(GLuint buffer);
302 void bindElementArrayBuffer(GLuint buffer);
303 void bindTexture2D(GLuint texture);
304 void bindTextureCubeMap(GLuint texture);
305 void bindReadFramebuffer(GLuint framebuffer);
306 void bindDrawFramebuffer(GLuint framebuffer);
307 void bindRenderbuffer(GLuint renderbuffer);
308 void useProgram(GLuint program);
309 void linkProgram(GLuint program);
310 void setProgramBinary(GLuint program, const void *binary, GLint length);
311
312 void beginQuery(GLenum target, GLuint query);
313 void endQuery(GLenum target);
314
315 void setFramebufferZero(Framebuffer *framebuffer);
316
317 void setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
318
319 void setVertexAttrib(GLuint index, const GLfloat *values);
320 void setVertexAttribDivisor(GLuint index, GLuint divisor);
321
322 Buffer *getBuffer(GLuint handle);
323 Fence *getFence(GLuint handle);
324 Shader *getShader(GLuint handle);
325 Program *getProgram(GLuint handle);
326 Texture *getTexture(GLuint handle);
327 Framebuffer *getFramebuffer(GLuint handle);
328 Renderbuffer *getRenderbuffer(GLuint handle);
329 Query *getQuery(GLuint handle, bool create, GLenum type);
330
331 Buffer *getArrayBuffer();
332 Buffer *getElementArrayBuffer();
333 ProgramBinary *getCurrentProgramBinary();
334 Texture2D *getTexture2D();
335 TextureCubeMap *getTextureCubeMap();
336 Texture *getSamplerTexture(unsigned int sampler, TextureType type);
337 Framebuffer *getReadFramebuffer();
338 Framebuffer *getDrawFramebuffer();
339
340 bool getFloatv(GLenum pname, GLfloat *params);
341 bool getIntegerv(GLenum pname, GLint *params);
342 bool getBooleanv(GLenum pname, GLboolean *params);
343
344 bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);
345
346 void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
347 void clear(GLbitfield mask);
348 void drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances);
349 void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances);
350 void sync(bool block); // flush/finish
351
352 void recordInvalidEnum();
353 void recordInvalidValue();
354 void recordInvalidOperation();
355 void recordOutOfMemory();
356 void recordInvalidFramebufferOperation();
357
358 GLenum getError();
359 GLenum getResetStatus();
360 virtual bool isResetNotificationEnabled();
361
362 int getMajorShaderModel() const;
363 float getMaximumPointSize() const;
364 unsigned int getMaximumCombinedTextureImageUnits() const;
365 int getMaximumRenderbufferDimension() const;
366 int getMaximumTextureDimension() const;
367 int getMaximumCubeTextureDimension() const;
368 int getMaximumTextureLevel() const;
369 unsigned int getMaximumRenderTargets() const;
370 GLsizei getMaxSupportedSamples() const;
371 const char *getExtensionString() const;
372 const char *getRendererString() const;
373 bool supportsEventQueries() const;
374 bool supportsOcclusionQueries() const;
375 bool supportsBGRATextures() const;
376 bool supportsDXT1Textures() const;
377 bool supportsDXT3Textures() const;
378 bool supportsDXT5Textures() const;
379 bool supportsFloat32Textures() const;
380 bool supportsFloat32LinearFilter() const;
381 bool supportsFloat32RenderableTextures() const;
382 bool supportsFloat16Textures() const;
383 bool supportsFloat16LinearFilter() const;
384 bool supportsFloat16RenderableTextures() const;
385 bool supportsLuminanceTextures() const;
386 bool supportsLuminanceAlphaTextures() const;
387 bool supportsDepthTextures() const;
388 bool supports32bitIndices() const;
389 bool supportsNonPower2Texture() const;
390 bool supportsInstancing() const;
391 bool supportsTextureFilterAnisotropy() const;
392
393 bool getCurrentReadFormatType(GLenum *format, GLenum *type);
394
395 float getTextureMaxAnisotropy() const;
396
397 void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
398 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
399 GLbitfield mask);
400
401 private:
402 DISALLOW_COPY_AND_ASSIGN(Context);
403
404 bool applyRenderTarget(GLenum drawMode, bool ignoreViewport);
405 void applyState(GLenum drawMode);
406 void applyShaders();
407 void applyTextures();
408 void applyTextures(SamplerType type);
409
410 void detachBuffer(GLuint buffer);
411 void detachTexture(GLuint texture);
412 void detachFramebuffer(GLuint framebuffer);
413 void detachRenderbuffer(GLuint renderbuffer);
414
415 Texture *getIncompleteTexture(TextureType type);
416
417 bool skipDraw(GLenum drawMode);
418
419 void initExtensionString();
420 void initRendererString();
421
422 rx::Renderer *const mRenderer;
423
424 State mState;
425
426 BindingPointer<Texture2D> mTexture2DZero;
427 BindingPointer<TextureCubeMap> mTextureCubeMapZero;
428
429 #ifndef HASH_MAP
430 # ifdef _MSC_VER
431 # define HASH_MAP stdext::hash_map
432 # else
433 # define HASH_MAP std::unordered_map
434 # endif
435 #endif
436
437 typedef HASH_MAP<GLuint, Framebuffer*> FramebufferMap;
438 FramebufferMap mFramebufferMap;
439 HandleAllocator mFramebufferHandleAllocator;
440
441 typedef HASH_MAP<GLuint, Fence*> FenceMap;
442 FenceMap mFenceMap;
443 HandleAllocator mFenceHandleAllocator;
444
445 typedef HASH_MAP<GLuint, Query*> QueryMap;
446 QueryMap mQueryMap;
447 HandleAllocator mQueryHandleAllocator;
448
449 const char *mExtensionString;
450 const char *mRendererString;
451
452 BindingPointer<Texture> mIncompleteTextures[TEXTURE_TYPE_COUNT];
453
454 // Recorded errors
455 bool mInvalidEnum;
456 bool mInvalidValue;
457 bool mInvalidOperation;
458 bool mOutOfMemory;
459 bool mInvalidFramebufferOperation;
460
461 // Current/lost context flags
462 bool mHasBeenCurrent;
463 bool mContextLost;
464 GLenum mResetStatus;
465 GLenum mResetStrategy;
466 bool mRobustAccess;
467
468 BindingPointer<ProgramBinary> mCurrentProgramBinary;
469 Framebuffer *mBoundDrawFramebuffer;
470
471 int mMajorShaderModel;
472 float mMaximumPointSize;
473 bool mSupportsVertexTexture;
474 bool mSupportsNonPower2Texture;
475 bool mSupportsInstancing;
476 int mMaxViewportDimension;
477 int mMaxRenderbufferDimension;
478 int mMaxTextureDimension;
479 int mMaxCubeTextureDimension;
480 int mMaxTextureLevel;
481 float mMaxTextureAnisotropy;
482 bool mSupportsEventQueries;
483 bool mSupportsOcclusionQueries;
484 bool mSupportsBGRATextures;
485 bool mSupportsDXT1Textures;
486 bool mSupportsDXT3Textures;
487 bool mSupportsDXT5Textures;
488 bool mSupportsFloat32Textures;
489 bool mSupportsFloat32LinearFilter;
490 bool mSupportsFloat32RenderableTextures;
491 bool mSupportsFloat16Textures;
492 bool mSupportsFloat16LinearFilter;
493 bool mSupportsFloat16RenderableTextures;
494 bool mSupportsLuminanceTextures;
495 bool mSupportsLuminanceAlphaTextures;
496 bool mSupportsDepthTextures;
497 bool mSupports32bitIndices;
498 bool mSupportsTextureFilterAnisotropy;
499 int mNumCompressedTextureFormats;
500
501 ResourceManager *mResourceManager;
502 };
503 }
504
505 #endif // INCLUDE_CONTEXT_H_

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial