forked from google/angle
-
Notifications
You must be signed in to change notification settings - Fork 0
/
State.h
1656 lines (1412 loc) · 68.5 KB
/
State.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//
// Copyright 2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// State.h: Defines the State class, encapsulating raw GL state
#ifndef LIBANGLE_STATE_H_
#define LIBANGLE_STATE_H_
#include <bitset>
#include <memory>
#include "common/Color.h"
#include "common/angleutils.h"
#include "common/bitset_utils.h"
#include "libANGLE/ContextMutex.h"
#include "libANGLE/Debug.h"
#include "libANGLE/GLES1State.h"
#include "libANGLE/Overlay.h"
#include "libANGLE/Program.h"
#include "libANGLE/ProgramExecutable.h"
#include "libANGLE/ProgramPipeline.h"
#include "libANGLE/RefCountObject.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Sampler.h"
#include "libANGLE/Texture.h"
#include "libANGLE/TransformFeedback.h"
#include "libANGLE/Version.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/angletypes.h"
namespace egl
{
class ShareGroup;
} // namespace egl
namespace gl
{
class BufferManager;
struct Caps;
class Context;
class FramebufferManager;
class MemoryObjectManager;
class ProgramPipelineManager;
class Query;
class RenderbufferManager;
class SamplerManager;
class SemaphoreManager;
class ShaderProgramManager;
class SyncManager;
class TextureManager;
class VertexArray;
static constexpr Version ES_1_0 = Version(1, 0);
static constexpr Version ES_1_1 = Version(1, 1);
static constexpr Version ES_2_0 = Version(2, 0);
static constexpr Version ES_3_0 = Version(3, 0);
static constexpr Version ES_3_1 = Version(3, 1);
static constexpr Version ES_3_2 = Version(3, 2);
template <typename T>
using BufferBindingMap = angle::PackedEnumMap<BufferBinding, T>;
using BoundBufferMap = BufferBindingMap<BindingPointer<Buffer>>;
using TextureBindingVector = std::vector<BindingPointer<Texture>>;
using TextureBindingMap = angle::PackedEnumMap<TextureType, TextureBindingVector>;
using ActiveQueryMap = angle::PackedEnumMap<QueryType, BindingPointer<Query>>;
class ActiveTexturesCache final : angle::NonCopyable
{
public:
ActiveTexturesCache();
~ActiveTexturesCache();
Texture *operator[](size_t textureIndex) const { return mTextures[textureIndex]; }
void clear();
void set(size_t textureIndex, Texture *texture);
void reset(size_t textureIndex);
bool empty() const;
size_t size() const { return mTextures.size(); }
private:
ActiveTextureArray<Texture *> mTextures;
};
namespace state
{
enum DirtyBitType
{
// Note: process draw framebuffer binding first, so that other dirty bits whose effect
// depend on the current draw framebuffer are not processed while the old framebuffer is
// still bound.
DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING,
DIRTY_BIT_READ_FRAMEBUFFER_BINDING,
DIRTY_BIT_SCISSOR_TEST_ENABLED,
DIRTY_BIT_SCISSOR,
DIRTY_BIT_VIEWPORT,
DIRTY_BIT_DEPTH_RANGE,
DIRTY_BIT_BLEND_ENABLED,
DIRTY_BIT_BLEND_COLOR,
DIRTY_BIT_BLEND_FUNCS,
DIRTY_BIT_BLEND_EQUATIONS,
DIRTY_BIT_COLOR_MASK,
DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED,
DIRTY_BIT_SAMPLE_COVERAGE_ENABLED,
DIRTY_BIT_SAMPLE_COVERAGE,
DIRTY_BIT_SAMPLE_MASK_ENABLED,
DIRTY_BIT_SAMPLE_MASK,
DIRTY_BIT_DEPTH_TEST_ENABLED,
DIRTY_BIT_DEPTH_FUNC,
DIRTY_BIT_DEPTH_MASK,
DIRTY_BIT_STENCIL_TEST_ENABLED,
DIRTY_BIT_STENCIL_FUNCS_FRONT,
DIRTY_BIT_STENCIL_FUNCS_BACK,
DIRTY_BIT_STENCIL_OPS_FRONT,
DIRTY_BIT_STENCIL_OPS_BACK,
DIRTY_BIT_STENCIL_WRITEMASK_FRONT,
DIRTY_BIT_STENCIL_WRITEMASK_BACK,
DIRTY_BIT_CULL_FACE_ENABLED,
DIRTY_BIT_CULL_FACE,
DIRTY_BIT_FRONT_FACE,
DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED,
DIRTY_BIT_POLYGON_OFFSET,
DIRTY_BIT_RASTERIZER_DISCARD_ENABLED,
DIRTY_BIT_LINE_WIDTH,
DIRTY_BIT_PRIMITIVE_RESTART_ENABLED,
DIRTY_BIT_CLEAR_COLOR,
DIRTY_BIT_CLEAR_DEPTH,
DIRTY_BIT_CLEAR_STENCIL,
DIRTY_BIT_UNPACK_STATE,
DIRTY_BIT_UNPACK_BUFFER_BINDING,
DIRTY_BIT_PACK_STATE,
DIRTY_BIT_PACK_BUFFER_BINDING,
DIRTY_BIT_DITHER_ENABLED,
DIRTY_BIT_RENDERBUFFER_BINDING,
DIRTY_BIT_VERTEX_ARRAY_BINDING,
DIRTY_BIT_DRAW_INDIRECT_BUFFER_BINDING,
DIRTY_BIT_DISPATCH_INDIRECT_BUFFER_BINDING,
// Note: Fine-grained dirty bits for each index could be an optimization.
DIRTY_BIT_PROGRAM_BINDING, // Must be before DIRTY_BIT_PROGRAM_EXECUTABLE
DIRTY_BIT_PROGRAM_EXECUTABLE,
// Note: Fine-grained dirty bits for each texture/sampler could be an optimization.
DIRTY_BIT_SAMPLER_BINDINGS,
DIRTY_BIT_TEXTURE_BINDINGS,
DIRTY_BIT_IMAGE_BINDINGS,
DIRTY_BIT_TRANSFORM_FEEDBACK_BINDING,
DIRTY_BIT_UNIFORM_BUFFER_BINDINGS,
DIRTY_BIT_SHADER_STORAGE_BUFFER_BINDING,
DIRTY_BIT_ATOMIC_COUNTER_BUFFER_BINDING,
DIRTY_BIT_MULTISAMPLING,
DIRTY_BIT_SAMPLE_ALPHA_TO_ONE,
DIRTY_BIT_COVERAGE_MODULATION, // CHROMIUM_framebuffer_mixed_samples
DIRTY_BIT_FRAMEBUFFER_SRGB_WRITE_CONTROL_MODE, // GL_EXT_sRGB_write_control
DIRTY_BIT_CURRENT_VALUES,
DIRTY_BIT_PROVOKING_VERTEX,
DIRTY_BIT_SAMPLE_SHADING,
DIRTY_BIT_PATCH_VERTICES,
DIRTY_BIT_EXTENDED, // clip distances, mipmap generation hint, derivative hint,
// EXT_clip_control, EXT_depth_clamp
DIRTY_BIT_INVALID,
DIRTY_BIT_MAX = DIRTY_BIT_INVALID,
};
static_assert(DIRTY_BIT_MAX <= 64, "State dirty bits must be capped at 64");
using DirtyBits = angle::BitSet<DIRTY_BIT_MAX>;
enum ExtendedDirtyBitType
{
EXTENDED_DIRTY_BIT_CLIP_CONTROL, // EXT_clip_control
EXTENDED_DIRTY_BIT_CLIP_DISTANCES, // clip distances
EXTENDED_DIRTY_BIT_DEPTH_CLAMP_ENABLED, // EXT_depth_clamp
EXTENDED_DIRTY_BIT_MIPMAP_GENERATION_HINT, // mipmap generation hint
EXTENDED_DIRTY_BIT_POLYGON_MODE, // NV_polygon_mode
EXTENDED_DIRTY_BIT_POLYGON_OFFSET_POINT_ENABLED, // NV_polygon_mode
EXTENDED_DIRTY_BIT_POLYGON_OFFSET_LINE_ENABLED, // NV_polygon_mode
EXTENDED_DIRTY_BIT_SHADER_DERIVATIVE_HINT, // shader derivative hint
EXTENDED_DIRTY_BIT_SHADING_RATE, // QCOM_shading_rate
EXTENDED_DIRTY_BIT_LOGIC_OP_ENABLED, // ANGLE_logic_op
EXTENDED_DIRTY_BIT_LOGIC_OP, // ANGLE_logic_op
EXTENDED_DIRTY_BIT_BLEND_ADVANCED_COHERENT, // KHR_blend_operation_advanced_coherent
EXTENDED_DIRTY_BIT_INVALID,
EXTENDED_DIRTY_BIT_MAX = EXTENDED_DIRTY_BIT_INVALID,
};
static_assert(EXTENDED_DIRTY_BIT_MAX <= 32, "State extended dirty bits must be capped at 32");
using ExtendedDirtyBits = angle::BitSet32<EXTENDED_DIRTY_BIT_MAX>;
// TODO(jmadill): Consider storing dirty objects in a list instead of by binding.
enum DirtyObjectType
{
DIRTY_OBJECT_ACTIVE_TEXTURES, // Top-level dirty bit. Also see mDirtyActiveTextures.
DIRTY_OBJECT_TEXTURES_INIT,
DIRTY_OBJECT_IMAGES_INIT,
DIRTY_OBJECT_READ_ATTACHMENTS,
DIRTY_OBJECT_DRAW_ATTACHMENTS,
DIRTY_OBJECT_READ_FRAMEBUFFER,
DIRTY_OBJECT_DRAW_FRAMEBUFFER,
DIRTY_OBJECT_VERTEX_ARRAY,
DIRTY_OBJECT_TEXTURES, // Top-level dirty bit. Also see mDirtyTextures.
DIRTY_OBJECT_IMAGES, // Top-level dirty bit. Also see mDirtyImages.
DIRTY_OBJECT_SAMPLERS, // Top-level dirty bit. Also see mDirtySamplers.
DIRTY_OBJECT_PROGRAM_PIPELINE_OBJECT,
DIRTY_OBJECT_INVALID,
DIRTY_OBJECT_MAX = DIRTY_OBJECT_INVALID,
};
using DirtyObjects = angle::BitSet<DIRTY_OBJECT_MAX>;
} // namespace state
// This class represents the portion of the GL context's state that is purely private to the
// context. Manipulating this state does not affect the other contexts in any way, nor do operations
// in other contexts affect this.
//
// Note that "currently bound X" states do not belong here because unbinding most objects could lead
// to object destruction which in turn may trigger a notification to an observer that may affect
// another context.
class PrivateState : angle::NonCopyable
{
public:
PrivateState(const EGLenum clientType,
const Version &clientVersion,
EGLint profileMask,
bool debug,
bool bindGeneratesResourceCHROMIUM,
bool clientArraysEnabled,
bool robustResourceInit,
bool programBinaryCacheEnabled,
bool isExternal);
~PrivateState();
void initialize(Context *context);
void initializeForCapture(const Context *context);
void reset();
EGLenum getClientType() const { return mClientType; }
EGLint getProfileMask() const { return mProfileMask; }
const Version &getClientVersion() const { return mClientVersion; }
GLint getClientMajorVersion() const { return mClientVersion.major; }
GLint getClientMinorVersion() const { return mClientVersion.minor; }
bool isWebGL() const { return getExtensions().webglCompatibilityANGLE; }
bool isWebGL1() const { return isWebGL() && getClientVersion().major == 2; }
bool isGLES1() const { return getClientVersion() < ES_2_0; }
const Caps &getCaps() const { return mCaps; }
const TextureCapsMap &getTextureCaps() const { return mTextureCaps; }
const Extensions &getExtensions() const { return mExtensions; }
const Limitations &getLimitations() const { return mLimitations; }
bool isExternal() const { return mIsExternal; }
Caps *getMutableCaps() { return &mCaps; }
TextureCapsMap *getMutableTextureCaps() { return &mTextureCaps; }
Extensions *getMutableExtensions() { return &mExtensions; }
Limitations *getMutableLimitations() { return &mLimitations; }
// State chunk getters
const RasterizerState &getRasterizerState() const { return mRasterizer; }
const BlendState &getBlendState() const { return mBlendState; }
const BlendStateExt &getBlendStateExt() const { return mBlendStateExt; }
const DepthStencilState &getDepthStencilState() const { return mDepthStencil; }
// Clear values
void setColorClearValue(float red, float green, float blue, float alpha);
void setDepthClearValue(float depth);
void setStencilClearValue(int stencil);
const ColorF &getColorClearValue() const { return mColorClearValue; }
float getDepthClearValue() const { return mDepthClearValue; }
int getStencilClearValue() const { return mStencilClearValue; }
// Write mask manipulation
void setColorMask(bool red, bool green, bool blue, bool alpha);
void setColorMaskIndexed(bool red, bool green, bool blue, bool alpha, GLuint index);
void setDepthMask(bool mask);
// Discard toggle & query
bool isRasterizerDiscardEnabled() const { return mRasterizer.rasterizerDiscard; }
void setRasterizerDiscard(bool enabled);
// Primitive restart
bool isPrimitiveRestartEnabled() const { return mPrimitiveRestart; }
void setPrimitiveRestart(bool enabled);
// Face culling state manipulation
bool isCullFaceEnabled() const { return mRasterizer.cullFace; }
void setCullFace(bool enabled);
void setCullMode(CullFaceMode mode);
void setFrontFace(GLenum front);
// EXT_depth_clamp
bool isDepthClampEnabled() const { return mRasterizer.depthClamp; }
void setDepthClamp(bool enabled);
// Depth test state manipulation
bool isDepthTestEnabled() const { return mDepthStencil.depthTest; }
bool isDepthWriteEnabled() const { return mDepthStencil.depthTest && mDepthStencil.depthMask; }
void setDepthTest(bool enabled);
void setDepthFunc(GLenum depthFunc);
void setDepthRange(float zNear, float zFar);
float getNearPlane() const { return mNearZ; }
float getFarPlane() const { return mFarZ; }
// EXT_clip_control
void setClipControl(ClipOrigin origin, ClipDepthMode depth);
ClipOrigin getClipOrigin() const { return mClipOrigin; }
ClipDepthMode getClipDepthMode() const { return mClipDepthMode; }
bool isClipDepthModeZeroToOne() const { return mClipDepthMode == ClipDepthMode::ZeroToOne; }
// Blend state manipulation
bool isBlendEnabled() const { return mBlendStateExt.getEnabledMask().test(0); }
bool isBlendEnabledIndexed(GLuint index) const
{
ASSERT(static_cast<size_t>(index) < mBlendStateExt.getDrawBufferCount());
return mBlendStateExt.getEnabledMask().test(index);
}
DrawBufferMask getBlendEnabledDrawBufferMask() const { return mBlendStateExt.getEnabledMask(); }
void setBlend(bool enabled);
void setBlendIndexed(bool enabled, GLuint index);
void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
void setBlendFactorsIndexed(GLenum sourceRGB,
GLenum destRGB,
GLenum sourceAlpha,
GLenum destAlpha,
GLuint index);
void setBlendColor(float red, float green, float blue, float alpha);
void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);
void setBlendEquationIndexed(GLenum rgbEquation, GLenum alphaEquation, GLuint index);
const ColorF &getBlendColor() const { return mBlendColor; }
// Stencil state maniupulation
bool isStencilTestEnabled() const { return mDepthStencil.stencilTest; }
bool isStencilWriteEnabled() const
{
return mDepthStencil.stencilTest &&
!(mDepthStencil.isStencilNoOp() && mDepthStencil.isStencilBackNoOp());
}
void setStencilTest(bool enabled);
void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);
void setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask);
void setStencilWritemask(GLuint stencilWritemask);
void setStencilBackWritemask(GLuint stencilBackWritemask);
void setStencilOperations(GLenum stencilFail,
GLenum stencilPassDepthFail,
GLenum stencilPassDepthPass);
void setStencilBackOperations(GLenum stencilBackFail,
GLenum stencilBackPassDepthFail,
GLenum stencilBackPassDepthPass);
GLint getStencilRef() const { return mStencilRef; }
GLint getStencilBackRef() const { return mStencilBackRef; }
PolygonMode getPolygonMode() const { return mRasterizer.polygonMode; }
void setPolygonMode(PolygonMode mode);
// Depth bias/polygon offset state manipulation
bool isPolygonOffsetPointEnabled() const { return mRasterizer.polygonOffsetPoint; }
bool isPolygonOffsetLineEnabled() const { return mRasterizer.polygonOffsetLine; }
bool isPolygonOffsetFillEnabled() const { return mRasterizer.polygonOffsetFill; }
bool isPolygonOffsetEnabled() const { return mRasterizer.isPolygonOffsetEnabled(); }
void setPolygonOffsetPoint(bool enabled);
void setPolygonOffsetLine(bool enabled);
void setPolygonOffsetFill(bool enabled);
void setPolygonOffsetParams(GLfloat factor, GLfloat units, GLfloat clamp);
// Multisample coverage state manipulation
bool isSampleAlphaToCoverageEnabled() const { return mSampleAlphaToCoverage; }
void setSampleAlphaToCoverage(bool enabled);
bool isSampleCoverageEnabled() const { return mSampleCoverage; }
void setSampleCoverage(bool enabled);
void setSampleCoverageParams(GLclampf value, bool invert);
GLclampf getSampleCoverageValue() const { return mSampleCoverageValue; }
bool getSampleCoverageInvert() const { return mSampleCoverageInvert; }
// Multisample mask state manipulation.
bool isSampleMaskEnabled() const { return mSampleMask; }
void setSampleMaskEnabled(bool enabled);
void setSampleMaskParams(GLuint maskNumber, GLbitfield mask);
GLbitfield getSampleMaskWord(GLuint maskNumber) const
{
ASSERT(maskNumber < mMaxSampleMaskWords);
return mSampleMaskValues[maskNumber];
}
SampleMaskArray<GLbitfield> getSampleMaskValues() const { return mSampleMaskValues; }
GLuint getMaxSampleMaskWords() const { return mMaxSampleMaskWords; }
// Multisampling/alpha to one manipulation.
void setSampleAlphaToOne(bool enabled);
bool isSampleAlphaToOneEnabled() const { return mSampleAlphaToOne; }
void setMultisampling(bool enabled);
bool isMultisamplingEnabled() const { return mMultiSampling; }
void setSampleShading(bool enabled);
bool isSampleShadingEnabled() const { return mIsSampleShadingEnabled; }
void setMinSampleShading(float value);
float getMinSampleShading() const { return mMinSampleShading; }
// Scissor test state toggle & query
bool isScissorTestEnabled() const { return mScissorTest; }
void setScissorTest(bool enabled);
void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);
const Rectangle &getScissor() const { return mScissor; }
// Dither state toggle & query
bool isDitherEnabled() const { return mRasterizer.dither; }
void setDither(bool enabled);
// GL_KHR_blend_equation_advanced_coherent
void setBlendAdvancedCoherent(bool enabled);
bool isBlendAdvancedCoherentEnabled() const { return mBlendAdvancedCoherent; }
// GL_CHROMIUM_bind_generates_resource
bool isBindGeneratesResourceEnabled() const { return mBindGeneratesResource; }
// GL_ANGLE_client_arrays
bool areClientArraysEnabled() const { return mClientArraysEnabled; }
// GL_ANGLE_robust_resource_initialization
bool isRobustResourceInitEnabled() const { return mRobustResourceInit; }
// GL_ANGLE_program_cache_control
bool isProgramBinaryCacheEnabled() const { return mProgramBinaryCacheEnabled; }
// Viewport state setter/getter
void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
const Rectangle &getViewport() const { return mViewport; }
// QCOM_shading_rate helpers
void setShadingRate(GLenum rate);
ShadingRate getShadingRate() const { return mShadingRate; }
// Pixel pack state manipulation
void setPackAlignment(GLint alignment);
GLint getPackAlignment() const { return mPack.alignment; }
void setPackReverseRowOrder(bool reverseRowOrder);
bool getPackReverseRowOrder() const { return mPack.reverseRowOrder; }
void setPackRowLength(GLint rowLength);
GLint getPackRowLength() const { return mPack.rowLength; }
void setPackSkipRows(GLint skipRows);
GLint getPackSkipRows() const { return mPack.skipRows; }
void setPackSkipPixels(GLint skipPixels);
GLint getPackSkipPixels() const { return mPack.skipPixels; }
const PixelPackState &getPackState() const { return mPack; }
PixelPackState &getPackState() { return mPack; }
// Pixel unpack state manipulation
void setUnpackAlignment(GLint alignment);
GLint getUnpackAlignment() const { return mUnpack.alignment; }
void setUnpackRowLength(GLint rowLength);
GLint getUnpackRowLength() const { return mUnpack.rowLength; }
void setUnpackImageHeight(GLint imageHeight);
GLint getUnpackImageHeight() const { return mUnpack.imageHeight; }
void setUnpackSkipImages(GLint skipImages);
GLint getUnpackSkipImages() const { return mUnpack.skipImages; }
void setUnpackSkipRows(GLint skipRows);
GLint getUnpackSkipRows() const { return mUnpack.skipRows; }
void setUnpackSkipPixels(GLint skipPixels);
GLint getUnpackSkipPixels() const { return mUnpack.skipPixels; }
const PixelUnpackState &getUnpackState() const { return mUnpack; }
PixelUnpackState &getUnpackState() { return mUnpack; }
// CHROMIUM_framebuffer_mixed_samples coverage modulation
void setCoverageModulation(GLenum components);
GLenum getCoverageModulation() const { return mCoverageModulation; }
// GL_EXT_sRGB_write_control
void setFramebufferSRGB(bool sRGB);
bool getFramebufferSRGB() const { return mFramebufferSRGB; }
// GL_EXT_tessellation_shader
void setPatchVertices(GLuint value);
GLuint getPatchVertices() const { return mPatchVertices; }
// GL_ANGLE_shader_pixel_local_storage
void setPixelLocalStorageActivePlanes(GLsizei n);
GLsizei getPixelLocalStorageActivePlanes() const { return mPixelLocalStorageActivePlanes; }
// Line width state setter
void setLineWidth(GLfloat width);
float getLineWidth() const { return mLineWidth; }
void setActiveSampler(unsigned int active);
unsigned int getActiveSampler() const { return static_cast<unsigned int>(mActiveSampler); }
// Hint setters
void setGenerateMipmapHint(GLenum hint);
GLenum getGenerateMipmapHint() const { return mGenerateMipmapHint; }
GLenum getFragmentShaderDerivativeHint() const { return mFragmentShaderDerivativeHint; }
void setFragmentShaderDerivativeHint(GLenum hint);
ProvokingVertexConvention getProvokingVertex() const { return mProvokingVertex; }
void setProvokingVertex(ProvokingVertexConvention val)
{
mDirtyBits.set(state::DIRTY_BIT_PROVOKING_VERTEX);
mProvokingVertex = val;
}
const VertexAttribCurrentValueData &getVertexAttribCurrentValue(size_t attribNum) const
{
ASSERT(attribNum < mVertexAttribCurrentValues.size());
return mVertexAttribCurrentValues[attribNum];
}
const std::vector<VertexAttribCurrentValueData> &getVertexAttribCurrentValues() const
{
return mVertexAttribCurrentValues;
}
// This actually clears the current value dirty bits.
// TODO(jmadill): Pass mutable dirty bits into Impl.
AttributesMask getAndResetDirtyCurrentValues() const;
ComponentTypeMask getCurrentValuesTypeMask() const { return mCurrentValuesTypeMask; }
const ClipDistanceEnableBits &getEnabledClipDistances() const { return mClipDistancesEnabled; }
void setClipDistanceEnable(int idx, bool enable);
bool noSimultaneousConstantColorAndAlphaBlendFunc() const
{
return mNoSimultaneousConstantColorAndAlphaBlendFunc;
}
GLfloat getBoundingBoxMinX() const { return mBoundingBoxMinX; }
GLfloat getBoundingBoxMinY() const { return mBoundingBoxMinY; }
GLfloat getBoundingBoxMinZ() const { return mBoundingBoxMinZ; }
GLfloat getBoundingBoxMinW() const { return mBoundingBoxMinW; }
GLfloat getBoundingBoxMaxX() const { return mBoundingBoxMaxX; }
GLfloat getBoundingBoxMaxY() const { return mBoundingBoxMaxY; }
GLfloat getBoundingBoxMaxZ() const { return mBoundingBoxMaxZ; }
GLfloat getBoundingBoxMaxW() const { return mBoundingBoxMaxW; }
void setBoundingBox(GLfloat minX,
GLfloat minY,
GLfloat minZ,
GLfloat minW,
GLfloat maxX,
GLfloat maxY,
GLfloat maxZ,
GLfloat maxW);
bool isTextureRectangleEnabled() const { return mTextureRectangleEnabled; }
DrawBufferMask getBlendFuncConstantAlphaDrawBuffers() const
{
return mBlendFuncConstantAlphaDrawBuffers;
}
DrawBufferMask getBlendFuncConstantColorDrawBuffers() const
{
return mBlendFuncConstantColorDrawBuffers;
}
void setLogicOpEnabled(bool enabled);
bool isLogicOpEnabled() const { return mLogicOpEnabled; }
void setLogicOp(LogicalOperation opcode);
LogicalOperation getLogicOp() const { return mLogicOp; }
// Vertex attrib manipulation
void setVertexAttribf(GLuint index, const GLfloat values[4]);
void setVertexAttribu(GLuint index, const GLuint values[4]);
void setVertexAttribi(GLuint index, const GLint values[4]);
// QCOM_tiled_rendering
void setTiledRendering(bool tiledRendering) { mTiledRendering = tiledRendering; }
bool isTiledRendering() const { return mTiledRendering; }
// Debug state
const Debug &getDebug() const { return mDebug; }
Debug &getDebug() { return mDebug; }
// Generic state toggle & query
void setEnableFeature(GLenum feature, bool enabled);
void setEnableFeatureIndexed(GLenum feature, bool enabled, GLuint index);
bool getEnableFeature(GLenum feature) const;
bool getEnableFeatureIndexed(GLenum feature, GLuint index) const;
// State query functions
void getBooleanv(GLenum pname, GLboolean *params) const;
void getFloatv(GLenum pname, GLfloat *params) const;
void getIntegerv(GLenum pname, GLint *params) const;
void getIntegeri_v(GLenum target, GLuint index, GLint *data) const;
void getBooleani_v(GLenum target, GLuint index, GLboolean *data) const;
GLES1State *getMutableGLES1State() { return &mGLES1State; }
const GLES1State &gles1() const { return mGLES1State; }
const state::DirtyBits &getDirtyBits() const { return mDirtyBits; }
void clearDirtyBits() { mDirtyBits.reset(); }
void clearDirtyBits(const state::DirtyBits &bitset) { mDirtyBits &= ~bitset; }
void setAllDirtyBits()
{
mDirtyBits.set();
mExtendedDirtyBits.set();
mDirtyCurrentValues = mAllAttribsMask;
}
const state::ExtendedDirtyBits &getExtendedDirtyBits() const { return mExtendedDirtyBits; }
void clearExtendedDirtyBits() { mExtendedDirtyBits.reset(); }
void clearExtendedDirtyBits(const state::ExtendedDirtyBits &bitset)
{
mExtendedDirtyBits &= ~bitset;
}
const state::DirtyObjects &getDirtyObjects() const { return mDirtyObjects; }
void clearDirtyObjects() { mDirtyObjects.reset(); }
void setPerfMonitorActive(bool active) { mIsPerfMonitorActive = active; }
bool isPerfMonitorActive() const { return mIsPerfMonitorActive; }
private:
bool hasConstantColor(GLenum sourceRGB, GLenum destRGB) const;
bool hasConstantAlpha(GLenum sourceRGB, GLenum destRGB) const;
const EGLenum mClientType;
const EGLint mProfileMask;
const Version mClientVersion;
// Caps to use for validation
Caps mCaps;
TextureCapsMap mTextureCaps;
Extensions mExtensions;
Limitations mLimitations;
const bool mIsExternal;
ColorF mColorClearValue;
GLfloat mDepthClearValue;
int mStencilClearValue;
RasterizerState mRasterizer;
bool mScissorTest;
Rectangle mScissor;
bool mNoUnclampedBlendColor;
BlendState mBlendState; // Buffer zero blend state legacy struct
BlendStateExt mBlendStateExt;
ColorF mBlendColor;
bool mSampleAlphaToCoverage;
bool mSampleCoverage;
GLfloat mSampleCoverageValue;
bool mSampleCoverageInvert;
bool mSampleMask;
GLuint mMaxSampleMaskWords;
SampleMaskArray<GLbitfield> mSampleMaskValues;
bool mIsSampleShadingEnabled;
float mMinSampleShading;
DepthStencilState mDepthStencil;
GLint mStencilRef;
GLint mStencilBackRef;
GLfloat mLineWidth;
GLenum mGenerateMipmapHint;
GLenum mFragmentShaderDerivativeHint;
Rectangle mViewport;
float mNearZ;
float mFarZ;
ClipOrigin mClipOrigin;
ClipDepthMode mClipDepthMode;
// GL_ANGLE_provoking_vertex
ProvokingVertexConvention mProvokingVertex;
using VertexAttribVector = std::vector<VertexAttribCurrentValueData>;
VertexAttribVector mVertexAttribCurrentValues; // From glVertexAttrib
ComponentTypeMask mCurrentValuesTypeMask;
// Mask of all attributes that are available to this context: [0, maxVertexAttributes)
AttributesMask mAllAttribsMask;
// Texture and sampler bindings
GLint mActiveSampler; // Active texture unit selector - GL_TEXTURE0
PixelUnpackState mUnpack;
PixelPackState mPack;
bool mPrimitiveRestart;
bool mMultiSampling;
bool mSampleAlphaToOne;
// GL_KHR_blend_equation_advanced_coherent
bool mBlendAdvancedCoherent;
GLenum mCoverageModulation;
// GL_EXT_sRGB_write_control
bool mFramebufferSRGB;
// GL_ANGLE_webgl_compatibility
bool mTextureRectangleEnabled;
// GL_ANGLE_logic_op
bool mLogicOpEnabled;
LogicalOperation mLogicOp;
// GL_APPLE_clip_distance / GL_EXT_clip_cull_distance / GL_ANGLE_clip_cull_distance
ClipDistanceEnableBits mClipDistancesEnabled;
// GL_EXT_tessellation_shader
GLuint mPatchVertices;
// GL_ANGLE_shader_pixel_local_storage
GLsizei mPixelLocalStorageActivePlanes;
// GLES1 emulation: state specific to GLES1
GLES1State mGLES1State;
// OES_draw_buffers_indexed
DrawBufferMask mBlendFuncConstantAlphaDrawBuffers;
DrawBufferMask mBlendFuncConstantColorDrawBuffers;
bool mNoSimultaneousConstantColorAndAlphaBlendFunc;
// Whether the indexed variants of setBlend* have been called. If so, the call to the
// non-indexed variants are not no-oped.
bool mSetBlendIndexedInvoked;
bool mSetBlendFactorsIndexedInvoked;
bool mSetBlendEquationsIndexedInvoked;
// GL_EXT_primitive_bounding_box
GLfloat mBoundingBoxMinX;
GLfloat mBoundingBoxMinY;
GLfloat mBoundingBoxMinZ;
GLfloat mBoundingBoxMinW;
GLfloat mBoundingBoxMaxX;
GLfloat mBoundingBoxMaxY;
GLfloat mBoundingBoxMaxZ;
GLfloat mBoundingBoxMaxW;
// QCOM_shading_rate
bool mShadingRatePreserveAspectRatio;
ShadingRate mShadingRate;
// GL_ARM_shader_framebuffer_fetch
bool mFetchPerSample;
// Whether perf monitoring is enabled through GL_AMD_performance_monitor.
bool mIsPerfMonitorActive;
// QCOM_tiled_rendering
bool mTiledRendering;
const bool mBindGeneratesResource;
const bool mClientArraysEnabled;
const bool mRobustResourceInit;
const bool mProgramBinaryCacheEnabled;
Debug mDebug;
state::DirtyBits mDirtyBits;
state::ExtendedDirtyBits mExtendedDirtyBits;
state::DirtyObjects mDirtyObjects;
mutable AttributesMask mDirtyCurrentValues;
};
// This class represents all of the GL context's state.
class State : angle::NonCopyable
{
public:
State(const State *shareContextState,
egl::ShareGroup *shareGroup,
TextureManager *shareTextures,
SemaphoreManager *shareSemaphores,
egl::ContextMutex *contextMutex,
const OverlayType *overlay,
const EGLenum clientType,
const Version &clientVersion,
EGLint profileMask,
bool debug,
bool bindGeneratesResourceCHROMIUM,
bool clientArraysEnabled,
bool robustResourceInit,
bool programBinaryCacheEnabled,
EGLenum contextPriority,
bool hasRobustAccess,
bool hasProtectedContent,
bool isExternal);
~State();
void initialize(Context *context);
void reset(const Context *context);
// Getters
ContextID getContextID() const { return mID; }
EGLenum getClientType() const { return mPrivateState.getClientType(); }
EGLint getProfileMask() const { return mPrivateState.getProfileMask(); }
EGLenum getContextPriority() const { return mContextPriority; }
bool hasRobustAccess() const { return mHasRobustAccess; }
bool hasProtectedContent() const { return mHasProtectedContent; }
bool isDebugContext() const { return mIsDebugContext; }
GLint getClientMajorVersion() const { return mPrivateState.getClientMajorVersion(); }
GLint getClientMinorVersion() const { return mPrivateState.getClientMinorVersion(); }
const Version &getClientVersion() const { return mPrivateState.getClientVersion(); }
egl::ShareGroup *getShareGroup() const { return mShareGroup; }
bool isWebGL() const { return mPrivateState.isWebGL(); }
bool isWebGL1() const { return mPrivateState.isWebGL1(); }
bool isGLES1() const { return mPrivateState.isGLES1(); }
const Caps &getCaps() const { return mPrivateState.getCaps(); }
const TextureCapsMap &getTextureCaps() const { return mPrivateState.getTextureCaps(); }
const Extensions &getExtensions() const { return mPrivateState.getExtensions(); }
const Limitations &getLimitations() const { return mPrivateState.getLimitations(); }
bool isExternal() const { return mPrivateState.isExternal(); }
Caps *getMutableCaps() { return mPrivateState.getMutableCaps(); }
TextureCapsMap *getMutableTextureCaps() { return mPrivateState.getMutableTextureCaps(); }
Extensions *getMutableExtensions() { return mPrivateState.getMutableExtensions(); }
Limitations *getMutableLimitations() { return mPrivateState.getMutableLimitations(); }
const TextureCaps &getTextureCap(GLenum internalFormat) const
{
return getTextureCaps().get(internalFormat);
}
bool allActiveDrawBufferChannelsMasked() const;
bool anyActiveDrawBufferChannelMasked() const;
// Texture binding & active texture unit manipulation
void setSamplerTexture(const Context *context, TextureType type, Texture *texture);
Texture *getTargetTexture(TextureType type) const;
Texture *getSamplerTexture(unsigned int sampler, TextureType type) const
{
ASSERT(sampler < mSamplerTextures[type].size());
return mSamplerTextures[type][sampler].get();
}
TextureID getSamplerTextureId(unsigned int sampler, TextureType type) const;
void detachTexture(Context *context, const TextureMap &zeroTextures, TextureID texture);
void initializeZeroTextures(const Context *context, const TextureMap &zeroTextures);
void invalidateTextureBindings(TextureType type);
// Sampler object binding manipulation
void setSamplerBinding(const Context *context, GLuint textureUnit, Sampler *sampler);
SamplerID getSamplerId(GLuint textureUnit) const
{
ASSERT(textureUnit < mSamplers.size());
return mSamplers[textureUnit].id();
}
Sampler *getSampler(GLuint textureUnit) const { return mSamplers[textureUnit].get(); }
const SamplerBindingVector &getSamplers() const { return mSamplers; }
void detachSampler(const Context *context, SamplerID sampler);
// Renderbuffer binding manipulation
void setRenderbufferBinding(const Context *context, Renderbuffer *renderbuffer);
RenderbufferID getRenderbufferId() const { return mRenderbuffer.id(); }
Renderbuffer *getCurrentRenderbuffer() const { return mRenderbuffer.get(); }
void detachRenderbuffer(Context *context, RenderbufferID renderbuffer);
// Framebuffer binding manipulation
void setReadFramebufferBinding(Framebuffer *framebuffer);
void setDrawFramebufferBinding(Framebuffer *framebuffer);
Framebuffer *getTargetFramebuffer(GLenum target) const;
Framebuffer *getReadFramebuffer() const { return mReadFramebuffer; }
Framebuffer *getDrawFramebuffer() const { return mDrawFramebuffer; }
Framebuffer *getDefaultFramebuffer() const;
bool removeReadFramebufferBinding(FramebufferID framebuffer);
bool removeDrawFramebufferBinding(FramebufferID framebuffer);
// Vertex array object binding manipulation
void setVertexArrayBinding(const Context *context, VertexArray *vertexArray);
bool removeVertexArrayBinding(const Context *context, VertexArrayID vertexArray);
VertexArrayID getVertexArrayId() const;
VertexArray *getVertexArray() const
{
ASSERT(mVertexArray != nullptr);
return mVertexArray;
}
// If both a Program and a ProgramPipeline are bound, the Program will
// always override the ProgramPipeline.
ProgramExecutable *getProgramExecutable() const { return mExecutable.get(); }
void ensureNoPendingLink(const Context *context) const
{
if (mProgram)
{
mProgram->resolveLink(context);
}
else if (mProgramPipeline.get())
{
mProgramPipeline->resolveLink(context);
}
}
ProgramExecutable *getLinkedProgramExecutable(const Context *context) const
{
ensureNoPendingLink(context);
return mExecutable.get();
}
// Program binding manipulation
angle::Result setProgram(const Context *context, Program *newProgram);
Program *getProgram() const
{
ASSERT(!mProgram || !mProgram->isLinking());
return mProgram;
}
Program *getLinkedProgram(const Context *context) const
{
if (mProgram)
{
mProgram->resolveLink(context);
}
return mProgram;
}
ProgramPipeline *getProgramPipeline() const { return mProgramPipeline.get(); }
ProgramPipeline *getLinkedProgramPipeline(const Context *context) const
{
if (mProgramPipeline.get())
{
mProgramPipeline->resolveLink(context);
}
return mProgramPipeline.get();
}
// Transform feedback object (not buffer) binding manipulation
void setTransformFeedbackBinding(const Context *context, TransformFeedback *transformFeedback);
TransformFeedback *getCurrentTransformFeedback() const { return mTransformFeedback.get(); }
ANGLE_INLINE bool isTransformFeedbackActive() const
{
TransformFeedback *curTransformFeedback = mTransformFeedback.get();
return curTransformFeedback && curTransformFeedback->isActive();
}
ANGLE_INLINE bool isTransformFeedbackActiveUnpaused() const
{
TransformFeedback *curTransformFeedback = mTransformFeedback.get();
return curTransformFeedback && curTransformFeedback->isActive() &&
!curTransformFeedback->isPaused();
}
bool removeTransformFeedbackBinding(const Context *context,
TransformFeedbackID transformFeedback);
// Query binding manipulation
bool isQueryActive(QueryType type) const;
bool isQueryActive(Query *query) const;
void setActiveQuery(const Context *context, QueryType type, Query *query);
QueryID getActiveQueryId(QueryType type) const;
Query *getActiveQuery(QueryType type) const;
// Program Pipeline binding manipulation
angle::Result setProgramPipelineBinding(const Context *context, ProgramPipeline *pipeline);
void detachProgramPipeline(const Context *context, ProgramPipelineID pipeline);
//// Typed buffer binding point manipulation ////
ANGLE_INLINE void setBufferBinding(const Context *context, BufferBinding target, Buffer *buffer)
{
(this->*(kBufferSetters[target]))(context, buffer);
}
ANGLE_INLINE Buffer *getTargetBuffer(BufferBinding target) const
{
switch (target)
{
case BufferBinding::ElementArray:
return getVertexArray()->getElementArrayBuffer();
default:
return mBoundBuffers[target].get();
}
}
ANGLE_INLINE Buffer *getArrayBuffer() const { return getTargetBuffer(BufferBinding::Array); }
angle::Result setIndexedBufferBinding(const Context *context,
BufferBinding target,
GLuint index,
Buffer *buffer,
GLintptr offset,
GLsizeiptr size);
size_t getAtomicCounterBufferCount() const { return mAtomicCounterBuffers.size(); }
ANGLE_INLINE bool hasValidAtomicCounterBuffer() const
{
return mBoundAtomicCounterBuffersMask.any();
}
const OffsetBindingPointer<Buffer> &getIndexedUniformBuffer(size_t index) const;
const OffsetBindingPointer<Buffer> &getIndexedAtomicCounterBuffer(size_t index) const;
const OffsetBindingPointer<Buffer> &getIndexedShaderStorageBuffer(size_t index) const;
const angle::BitSet<gl::IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS> &getUniformBuffersMask()
const
{
return mBoundUniformBuffersMask;
}