1 #ifndef _SGLRREFERENCECONTEXT_HPP
2 #define _SGLRREFERENCECONTEXT_HPP
3 /*-------------------------------------------------------------------------
4 * drawElements Quality Program OpenGL ES Utilities
5 * ------------------------------------------------
6 *
7 * Copyright 2014 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Reference Rendering Context.
24 *//*--------------------------------------------------------------------*/
25
26 #include "tcuDefs.hpp"
27 #include "sglrContext.hpp"
28 #include "tcuPixelFormat.hpp"
29 #include "tcuSurface.hpp"
30 #include "tcuTexture.hpp"
31 #include "tcuVector.hpp"
32 #include "gluRenderContext.hpp"
33 #include "rrFragmentOperations.hpp"
34 #include "rrRenderState.hpp"
35 #include "rrRenderer.hpp"
36 #include "rrMultisamplePixelBufferAccess.hpp"
37 #include "gluShaderUtil.hpp"
38
39 #include <map>
40 #include <vector>
41
42 namespace sglr
43 {
44 namespace rc
45 {
46
47 enum
48 {
49 MAX_TEXTURE_SIZE_LOG2 = 14,
50 MAX_TEXTURE_SIZE = 1<<MAX_TEXTURE_SIZE_LOG2
51 };
52
53 class NamedObject
54 {
55 public:
~NamedObject(void)56 virtual ~NamedObject (void) {}
57
getName(void) const58 deUint32 getName (void) const { return m_name; }
59
getRefCount(void) const60 int getRefCount (void) const { return m_refCount; }
incRefCount(void)61 void incRefCount (void) { m_refCount += 1; }
decRefCount(void)62 void decRefCount (void) { DE_ASSERT(m_refCount > 0); m_refCount -= 1; }
63
64 protected:
NamedObject(deUint32 name)65 NamedObject (deUint32 name) : m_name(name), m_refCount(1) {}
66
67 private:
68 deUint32 m_name;
69 int m_refCount;
70 };
71
72 class Texture : public NamedObject
73 {
74 public:
75 enum Type
76 {
77 TYPE_1D,
78 TYPE_2D,
79 TYPE_CUBE_MAP,
80 TYPE_2D_ARRAY,
81 TYPE_3D,
82 TYPE_CUBE_MAP_ARRAY,
83
84 TYPE_LAST
85 };
86
87 Texture (deUint32 name, Type type);
~Texture(void)88 virtual ~Texture (void) {}
89
getType(void) const90 Type getType (void) const { return m_type; }
91
getBaseLevel(void) const92 int getBaseLevel (void) const { return m_baseLevel; }
getMaxLevel(void) const93 int getMaxLevel (void) const { return m_maxLevel; }
isImmutable(void) const94 bool isImmutable (void) const { return m_immutable; }
95
setBaseLevel(int baseLevel)96 void setBaseLevel (int baseLevel) { m_baseLevel = baseLevel; }
setMaxLevel(int maxLevel)97 void setMaxLevel (int maxLevel) { m_maxLevel = maxLevel; }
setImmutable(void)98 void setImmutable (void) { m_immutable = true; }
99
getSampler(void) const100 const tcu::Sampler& getSampler (void) const { return m_sampler; }
getSampler(void)101 tcu::Sampler& getSampler (void) { return m_sampler; }
102
103 private:
104 Type m_type;
105
106 bool m_immutable;
107
108 tcu::Sampler m_sampler;
109 int m_baseLevel;
110 int m_maxLevel;
111 };
112
113 //! Class for managing list of texture levels.
114 class TextureLevelArray
115 {
116 public:
117 TextureLevelArray (void);
118 ~TextureLevelArray (void);
119
hasLevel(int level) const120 bool hasLevel (int level) const { return level < DE_LENGTH_OF_ARRAY(m_data) && m_data[level]; }
getLevel(int level)121 const tcu::PixelBufferAccess& getLevel (int level) { DE_ASSERT(hasLevel(level)); return m_access[level]; }
getLevel(int level) const122 const tcu::ConstPixelBufferAccess& getLevel (int level) const { DE_ASSERT(hasLevel(level)); return m_access[level]; }
123
getLevels(void) const124 const tcu::ConstPixelBufferAccess* getLevels (void) const { return &m_access[0]; }
125
126 void allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int depth);
127 void clearLevel (int level);
128
129 void clear (void);
130
131 private:
132 deUint8* m_data[MAX_TEXTURE_SIZE_LOG2];
133 tcu::PixelBufferAccess m_access[MAX_TEXTURE_SIZE_LOG2];
134 };
135
136 class Texture1D : public Texture
137 {
138 public:
139 Texture1D (deUint32 name = 0);
140 virtual ~Texture1D (void);
141
clearLevels(void)142 void clearLevels (void) { m_levels.clear(); }
143
hasLevel(int level) const144 bool hasLevel (int level) const { return m_levels.hasLevel(level); }
getLevel(int level) const145 const tcu::ConstPixelBufferAccess& getLevel (int level) const { return m_levels.getLevel(level); }
getLevel(int level)146 const tcu::PixelBufferAccess& getLevel (int level) { return m_levels.getLevel(level); }
147
148 void allocLevel (int level, const tcu::TextureFormat& format, int width);
149
150 bool isComplete (void) const;
151
152 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
153
154 tcu::Vec4 sample (float s, float lod) const;
155 void sample4 (tcu::Vec4 output[4], const float packetTexcoords[4], float lodBias = 0.0f) const;
156
157 private:
158 TextureLevelArray m_levels;
159 tcu::Texture2DView m_view;
160 };
161
162 class Texture2D : public Texture
163 {
164 public:
165 Texture2D (deUint32 name = 0);
166 virtual ~Texture2D (void);
167
clearLevels(void)168 void clearLevels (void) { m_levels.clear(); }
169
hasLevel(int level) const170 bool hasLevel (int level) const { return m_levels.hasLevel(level); }
getLevel(int level) const171 const tcu::ConstPixelBufferAccess& getLevel (int level) const { return m_levels.getLevel(level); }
getLevel(int level)172 const tcu::PixelBufferAccess& getLevel (int level) { return m_levels.getLevel(level); }
173
174 void allocLevel (int level, const tcu::TextureFormat& format, int width, int height);
175
176 bool isComplete (void) const;
177
178 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
179
180 tcu::Vec4 sample (float s, float t, float lod) const;
181 void sample4 (tcu::Vec4 output[4], const tcu::Vec2 packetTexcoords[4], float lodBias = 0.0f) const;
182
183 private:
184 TextureLevelArray m_levels;
185 tcu::Texture2DView m_view;
186 };
187
188 class TextureCube : public Texture
189 {
190 public:
191 TextureCube (deUint32 name = 0);
192 virtual ~TextureCube (void);
193
194 void clearLevels (void);
195
hasFace(int level,tcu::CubeFace face) const196 bool hasFace (int level, tcu::CubeFace face) const { return m_levels[face].hasLevel(level); }
getFace(int level,tcu::CubeFace face)197 const tcu::PixelBufferAccess& getFace (int level, tcu::CubeFace face) { return m_levels[face].getLevel(level); }
getFace(int level,tcu::CubeFace face) const198 const tcu::ConstPixelBufferAccess& getFace (int level, tcu::CubeFace face) const { return m_levels[face].getLevel(level); }
199
200 void allocFace (int level, tcu::CubeFace face, const tcu::TextureFormat& format, int width, int height);
201
202 bool isComplete (void) const;
203 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
204
205 tcu::Vec4 sample (float s, float t, float p, float lod) const;
206 void sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const;
207
208 private:
209 TextureLevelArray m_levels[tcu::CUBEFACE_LAST];
210 tcu::TextureCubeView m_view;
211 };
212
213 class Texture2DArray : public Texture
214 {
215 public:
216 Texture2DArray (deUint32 name = 0);
217 virtual ~Texture2DArray (void);
218
clearLevels(void)219 void clearLevels (void) { m_levels.clear(); }
220
hasLevel(int level) const221 bool hasLevel (int level) const { return m_levels.hasLevel(level); }
getLevel(int level) const222 const tcu::ConstPixelBufferAccess& getLevel (int level) const { return m_levels.getLevel(level); }
getLevel(int level)223 const tcu::PixelBufferAccess& getLevel (int level) { return m_levels.getLevel(level); }
224
225 void allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int numLayers);
226
227 bool isComplete (void) const;
228
229 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
230
231 tcu::Vec4 sample (float s, float t, float r, float lod) const;
232 void sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const;
233
234 private:
235 TextureLevelArray m_levels;
236 tcu::Texture2DArrayView m_view;
237 };
238
239 class Texture3D : public Texture
240 {
241 public:
242 Texture3D (deUint32 name = 0);
243 virtual ~Texture3D (void);
244
clearLevels(void)245 void clearLevels (void) { m_levels.clear(); }
246
hasLevel(int level) const247 bool hasLevel (int level) const { return m_levels.hasLevel(level); }
getLevel(int level) const248 const tcu::ConstPixelBufferAccess& getLevel (int level) const { return m_levels.getLevel(level); }
getLevel(int level)249 const tcu::PixelBufferAccess& getLevel (int level) { return m_levels.getLevel(level); }
250
251 void allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int numLayers);
252
253 bool isComplete (void) const;
254
255 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
256
257 tcu::Vec4 sample (float s, float t, float r, float lod) const;
258 void sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const;
259
260 private:
261 TextureLevelArray m_levels;
262 tcu::Texture3DView m_view;
263 };
264
265 class TextureCubeArray : public Texture
266 {
267 public:
268 TextureCubeArray (deUint32 name = 0);
269 virtual ~TextureCubeArray (void);
270
clearLevels(void)271 void clearLevels (void) { m_levels.clear(); }
272
hasLevel(int level) const273 bool hasLevel (int level) const { return m_levels.hasLevel(level); }
getLevel(int level) const274 const tcu::ConstPixelBufferAccess& getLevel (int level) const { return m_levels.getLevel(level); }
getLevel(int level)275 const tcu::PixelBufferAccess& getLevel (int level) { return m_levels.getLevel(level); }
276
277 void allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int numLayers);
278
279 bool isComplete (void) const;
280
281 void updateView (void); // \note View must be refreshed after texture parameter/size changes, before calling sample*()
282
283 tcu::Vec4 sample (float s, float t, float r, float q, float lod) const;
284 void sample4 (tcu::Vec4 output[4], const tcu::Vec4 packetTexcoords[4], float lodBias = 0.0f) const;
285
286 private:
287 TextureLevelArray m_levels;
288 tcu::TextureCubeArrayView m_view;
289 };
290
291 class Renderbuffer : public NamedObject
292 {
293 public:
294 enum Format
295 {
296 FORMAT_DEPTH_COMPONENT16,
297 FORMAT_RGBA4,
298 FORMAT_RGB5_A1,
299 FORMAT_RGB565,
300 FORMAT_STENCIL_INDEX8,
301
302 FORMAT_LAST
303 };
304
305 Renderbuffer (deUint32 name);
306 virtual ~Renderbuffer (void);
307
308 void setStorage (const tcu::TextureFormat& format, int width, int height);
309
getWidth(void) const310 int getWidth (void) const { return m_data.getWidth(); }
getHeight(void) const311 int getHeight (void) const { return m_data.getHeight(); }
getFormat(void) const312 tcu::TextureFormat getFormat (void) const { return m_data.getFormat(); }
313
getAccess(void)314 tcu::PixelBufferAccess getAccess (void) { return m_data.getAccess(); }
getAccess(void) const315 tcu::ConstPixelBufferAccess getAccess (void) const { return m_data.getAccess(); }
316
317 private:
318 tcu::TextureLevel m_data;
319 };
320
321 class Framebuffer : public NamedObject
322 {
323 public:
324 enum AttachmentPoint
325 {
326 ATTACHMENTPOINT_COLOR0,
327 ATTACHMENTPOINT_DEPTH,
328 ATTACHMENTPOINT_STENCIL,
329
330 ATTACHMENTPOINT_LAST
331 };
332
333 enum AttachmentType
334 {
335 ATTACHMENTTYPE_RENDERBUFFER,
336 ATTACHMENTTYPE_TEXTURE,
337
338 ATTACHMENTTYPE_LAST
339 };
340
341 enum TexTarget
342 {
343 TEXTARGET_2D,
344 TEXTARGET_CUBE_MAP_POSITIVE_X,
345 TEXTARGET_CUBE_MAP_POSITIVE_Y,
346 TEXTARGET_CUBE_MAP_POSITIVE_Z,
347 TEXTARGET_CUBE_MAP_NEGATIVE_X,
348 TEXTARGET_CUBE_MAP_NEGATIVE_Y,
349 TEXTARGET_CUBE_MAP_NEGATIVE_Z,
350 TEXTARGET_2D_ARRAY,
351 TEXTARGET_3D,
352 TEXTARGET_CUBE_MAP_ARRAY,
353
354 TEXTARGET_LAST
355 };
356
357 struct Attachment
358 {
359 AttachmentType type;
360 deUint32 name;
361 TexTarget texTarget;
362 int level;
363 int layer;
364
Attachmentsglr::rc::Framebuffer::Attachment365 Attachment (void)
366 : type (ATTACHMENTTYPE_LAST)
367 , name (0)
368 , texTarget (TEXTARGET_LAST)
369 , level (0)
370 , layer (0)
371 {
372 }
373 };
374
375 Framebuffer (deUint32 name);
376 virtual ~Framebuffer (void);
377
getAttachment(AttachmentPoint point)378 Attachment& getAttachment (AttachmentPoint point) { return m_attachments[point]; }
getAttachment(AttachmentPoint point) const379 const Attachment& getAttachment (AttachmentPoint point) const { return m_attachments[point]; }
380
381 private:
382
383 Attachment m_attachments[ATTACHMENTPOINT_LAST];
384 };
385
386 class DataBuffer : public NamedObject
387 {
388 public:
DataBuffer(deUint32 name)389 DataBuffer (deUint32 name) : NamedObject(name) {}
~DataBuffer(void)390 ~DataBuffer (void) {}
391
setStorage(int size)392 void setStorage (int size) { m_data.resize(size); }
393
getSize(void) const394 int getSize (void) const { return (int)m_data.size(); }
getData(void) const395 const deUint8* getData (void) const { return m_data.empty() ? DE_NULL : &m_data[0]; }
getData(void)396 deUint8* getData (void) { return m_data.empty() ? DE_NULL : &m_data[0]; }
397
398 private:
399 std::vector<deUint8> m_data;
400 };
401
402 class VertexArray : public NamedObject
403 {
404 public:
405 struct VertexAttribArray
406 {
407 bool enabled;
408 int size;
409 int stride;
410 deUint32 type;
411
412 bool normalized;
413 bool integer;
414 int divisor;
415
416 /**
417 ! These three variables define the state. bufferDeleted is needed to distinguish
418 ! drawing from user pointer and offset to a deleted buffer from each other.
419 !
420 ! Only these three combinations are possible:
421 ! 1) bufferDeleted = false, bufferBinding = NULL, pointer = user_ptr. < render from a user ptr
422 ! 2) bufferDeleted = false, bufferBinding = ptr, pointer = offset. < render from a buffer with offset
423 ! 3) bufferDeleted = true, bufferBinding = NULL, pointer = offset < render from a deleted buffer. Don't do anything
424 !
425 ! (bufferFreed = true) implies (bufferBinding = NULL)
426 */
427 bool bufferDeleted;
428 rc::DataBuffer* bufferBinding;
429 const void* pointer;
430 };
431
432 VertexArray (deUint32 name, int maxVertexAttribs);
~VertexArray(void)433 ~VertexArray (void) {}
434
435 rc::DataBuffer* m_elementArrayBufferBinding;
436 std::vector<VertexAttribArray> m_arrays;
437 };
438
439 class ShaderProgramObjectContainer : public NamedObject
440 {
441 public:
442 ShaderProgramObjectContainer (deUint32 name, ShaderProgram* program);
443 ~ShaderProgramObjectContainer (void);
444
445 ShaderProgram* m_program;
446 bool m_deleteFlag;
447 };
448
449 template <typename T>
450 class ObjectManager
451 {
452 public:
453 ObjectManager (void);
454 ~ObjectManager (void);
455
456 deUint32 allocateName (void);
457 void insert (T* object);
458 T* find (deUint32 name);
459
460 void acquireReference (T* object);
461 void releaseReference (T* object);
462
getCount(void) const463 int getCount (void) const { return (int)m_objects.size(); }
464 void getAll (typename std::vector<T*>& objects) const;
465
466 private:
467 ObjectManager (const ObjectManager<T>& other);
468 ObjectManager& operator= (const ObjectManager<T>& other);
469
470 deUint32 m_lastName;
471 std::map<deUint32, T*> m_objects;
472 };
473
474 template <typename T>
ObjectManager(void)475 ObjectManager<T>::ObjectManager (void)
476 : m_lastName(0)
477 {
478 }
479
480 template <typename T>
~ObjectManager(void)481 ObjectManager<T>::~ObjectManager (void)
482 {
483 DE_ASSERT(m_objects.size() == 0);
484 }
485
486 template <typename T>
allocateName(void)487 deUint32 ObjectManager<T>::allocateName (void)
488 {
489 TCU_CHECK(m_lastName != 0xffffffff);
490 return ++m_lastName;
491 }
492
493 template <typename T>
insert(T * object)494 void ObjectManager<T>::insert (T* object)
495 {
496 deUint32 name = object->getName();
497 DE_ASSERT(object->getName() != 0);
498
499 if (name > m_lastName)
500 m_lastName = name;
501
502 m_objects.insert(std::pair<deUint32, T*>(name, object));
503 }
504
505 template <typename T>
find(deUint32 name)506 T* ObjectManager<T>::find (deUint32 name)
507 {
508 typename std::map<deUint32, T*>::iterator it = m_objects.find(name);
509 if (it != m_objects.end())
510 return it->second;
511 else
512 return DE_NULL;
513 }
514
515 template <typename T>
acquireReference(T * object)516 void ObjectManager<T>::acquireReference (T* object)
517 {
518 DE_ASSERT(find(object->getName()) == object);
519 object->incRefCount();
520 }
521
522 template <typename T>
releaseReference(T * object)523 void ObjectManager<T>::releaseReference (T* object)
524 {
525 DE_ASSERT(find(object->getName()) == object);
526 object->decRefCount();
527
528 if (object->getRefCount() == 0)
529 {
530 m_objects.erase(object->getName());
531 delete object;
532 }
533 }
534
535 template <typename T>
getAll(typename std::vector<T * > & objects) const536 void ObjectManager<T>::getAll (typename std::vector<T*>& objects) const
537 {
538 objects.resize(m_objects.size());
539 typename std::vector<T*>::iterator dst = objects.begin();
540
541 for (typename std::map<deUint32, T*>::const_iterator i = m_objects.begin();
542 i != m_objects.end(); i++)
543 {
544 *dst++ = i->second;
545 }
546 }
547
548 } // rc
549
550 struct ReferenceContextLimits
551 {
ReferenceContextLimitssglr::ReferenceContextLimits552 ReferenceContextLimits (void)
553 : contextType (glu::ApiType::es(3,0))
554 , maxTextureImageUnits (16)
555 , maxTexture2DSize (2048)
556 , maxTextureCubeSize (2048)
557 , maxTexture2DArrayLayers (256)
558 , maxTexture3DSize (256)
559 , maxRenderbufferSize (2048)
560 , maxVertexAttribs (16)
561 {
562 }
563
564 ReferenceContextLimits (const glu::RenderContext& renderCtx);
565
566 void addExtension (const char* extension);
567
568 glu::ContextType contextType;
569
570 int maxTextureImageUnits;
571 int maxTexture2DSize;
572 int maxTextureCubeSize;
573 int maxTexture2DArrayLayers;
574 int maxTexture3DSize;
575 int maxRenderbufferSize;
576 int maxVertexAttribs;
577
578 // Both variants are needed since there are glGetString() and glGetStringi()
579 std::vector<std::string> extensionList;
580 std::string extensionStr;
581 };
582
583 class ReferenceContextBuffers
584 {
585 public:
586 ReferenceContextBuffers (const tcu::PixelFormat& colorBits, int depthBits, int stencilBits, int width, int height, int samples = 1);
587
getColorbuffer(void)588 rr::MultisamplePixelBufferAccess getColorbuffer (void) { return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_colorbuffer.getAccess()); }
getDepthbuffer(void)589 rr::MultisamplePixelBufferAccess getDepthbuffer (void) { return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_depthbuffer.getAccess()); }
getStencilbuffer(void)590 rr::MultisamplePixelBufferAccess getStencilbuffer (void) { return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_stencilbuffer.getAccess()); }
591
592 private:
593 tcu::TextureLevel m_colorbuffer;
594 tcu::TextureLevel m_depthbuffer;
595 tcu::TextureLevel m_stencilbuffer;
596 };
597
598 class ReferenceContext : public Context
599 {
600 public:
601 ReferenceContext (const ReferenceContextLimits& limits, const rr::MultisamplePixelBufferAccess& colorbuffer, const rr::MultisamplePixelBufferAccess& depthbuffer, const rr::MultisamplePixelBufferAccess& stencilbuffer);
602 virtual ~ReferenceContext (void);
603
getWidth(void) const604 virtual int getWidth (void) const { return m_defaultColorbuffer.raw().getHeight(); }
getHeight(void) const605 virtual int getHeight (void) const { return m_defaultColorbuffer.raw().getDepth(); }
606
viewport(int x,int y,int width,int height)607 virtual void viewport (int x, int y, int width, int height) { m_viewport = tcu::IVec4(x, y, width, height); }
608 virtual void activeTexture (deUint32 texture);
609
610 virtual void bindTexture (deUint32 target, deUint32 texture);
611 virtual void genTextures (int numTextures, deUint32* textures);
612 virtual void deleteTextures (int numTextures, const deUint32* textures);
613
614 virtual void bindFramebuffer (deUint32 target, deUint32 framebuffer);
615 virtual void genFramebuffers (int numFramebuffers, deUint32* framebuffers);
616 virtual void deleteFramebuffers (int numFramebuffers, const deUint32* framebuffers);
617
618 virtual void bindRenderbuffer (deUint32 target, deUint32 renderbuffer);
619 virtual void genRenderbuffers (int numRenderbuffers, deUint32* renderbuffers);
620 virtual void deleteRenderbuffers (int numRenderbuffers, const deUint32* renderbuffers);
621
622 virtual void pixelStorei (deUint32 pname, int param);
623 virtual void texImage1D (deUint32 target, int level, deUint32 internalFormat, int width, int border, deUint32 format, deUint32 type, const void* data);
624 virtual void texImage2D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int border, deUint32 format, deUint32 type, const void* data);
625 virtual void texImage3D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int depth, int border, deUint32 format, deUint32 type, const void* data);
626 virtual void texSubImage1D (deUint32 target, int level, int xoffset, int width, deUint32 format, deUint32 type, const void* data);
627 virtual void texSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int width, int height, deUint32 format, deUint32 type, const void* data);
628 virtual void texSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, deUint32 format, deUint32 type, const void* data);
629 virtual void copyTexImage1D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int border);
630 virtual void copyTexImage2D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int height, int border);
631 virtual void copyTexSubImage1D (deUint32 target, int level, int xoffset, int x, int y, int width);
632 virtual void copyTexSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int x, int y, int width, int height);
633 virtual void copyTexSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
634
635 virtual void texStorage2D (deUint32 target, int levels, deUint32 internalFormat, int width, int height);
636 virtual void texStorage3D (deUint32 target, int levels, deUint32 internalFormat, int width, int height, int depth);
637
638 virtual void texParameteri (deUint32 target, deUint32 pname, int value);
639
640 virtual void framebufferTexture2D (deUint32 target, deUint32 attachment, deUint32 textarget, deUint32 texture, int level);
641 virtual void framebufferTextureLayer (deUint32 target, deUint32 attachment, deUint32 texture, int level, int layer);
642 virtual void framebufferRenderbuffer (deUint32 target, deUint32 attachment, deUint32 renderbuffertarget, deUint32 renderbuffer);
643 virtual deUint32 checkFramebufferStatus (deUint32 target);
644
645 virtual void getFramebufferAttachmentParameteriv (deUint32 target, deUint32 attachment, deUint32 pname, int* params);
646
647 virtual void renderbufferStorage (deUint32 target, deUint32 internalformat, int width, int height);
648 virtual void renderbufferStorageMultisample (deUint32 target, int samples, deUint32 internalFormat, int width, int height);
649
650 virtual void bindBuffer (deUint32 target, deUint32 buffer);
651 virtual void genBuffers (int numBuffers, deUint32* buffers);
652 virtual void deleteBuffers (int numBuffers, const deUint32* buffers);
653
654 virtual void bufferData (deUint32 target, deIntptr size, const void* data, deUint32 usage);
655 virtual void bufferSubData (deUint32 target, deIntptr offset, deIntptr size, const void* data);
656
657 virtual void clearColor (float red, float green, float blue, float alpha);
658 virtual void clearDepthf (float depth);
659 virtual void clearStencil (int stencil);
660
661 virtual void clear (deUint32 buffers);
662 virtual void clearBufferiv (deUint32 buffer, int drawbuffer, const int* value);
663 virtual void clearBufferfv (deUint32 buffer, int drawbuffer, const float* value);
664 virtual void clearBufferuiv (deUint32 buffer, int drawbuffer, const deUint32* value);
665 virtual void clearBufferfi (deUint32 buffer, int drawbuffer, float depth, int stencil);
666 virtual void scissor (int x, int y, int width, int height);
667
668 virtual void enable (deUint32 cap);
669 virtual void disable (deUint32 cap);
670
671 virtual void stencilFunc (deUint32 func, int ref, deUint32 mask);
672 virtual void stencilOp (deUint32 sfail, deUint32 dpfail, deUint32 dppass);
673 virtual void stencilFuncSeparate (deUint32 face, deUint32 func, int ref, deUint32 mask);
674 virtual void stencilOpSeparate (deUint32 face, deUint32 sfail, deUint32 dpfail, deUint32 dppass);
675
676 virtual void depthFunc (deUint32 func);
677 virtual void depthRangef (float n, float f);
678 virtual void depthRange (double n, double f);
679
680 virtual void polygonOffset (float factor, float units);
681 virtual void provokingVertex (deUint32 convention);
682 virtual void primitiveRestartIndex (deUint32 index);
683
684 virtual void blendEquation (deUint32 mode);
685 virtual void blendEquationSeparate (deUint32 modeRGB, deUint32 modeAlpha);
686 virtual void blendFunc (deUint32 src, deUint32 dst);
687 virtual void blendFuncSeparate (deUint32 srcRGB, deUint32 dstRGB, deUint32 srcAlpha, deUint32 dstAlpha);
688 virtual void blendColor (float red, float green, float blue, float alpha);
689
690 virtual void colorMask (deBool r, deBool g, deBool b, deBool a);
691 virtual void depthMask (deBool mask);
692 virtual void stencilMask (deUint32 mask);
693 virtual void stencilMaskSeparate (deUint32 face, deUint32 mask);
694
695 virtual void blitFramebuffer (int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, deUint32 mask, deUint32 filter);
696
697 virtual void invalidateSubFramebuffer(deUint32 target, int numAttachments, const deUint32* attachments, int x, int y, int width, int height);
698 virtual void invalidateFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments);
699
700 virtual void bindVertexArray (deUint32 array);
701 virtual void genVertexArrays (int numArrays, deUint32* vertexArrays);
702 virtual void deleteVertexArrays (int numArrays, const deUint32* vertexArrays);
703
704 virtual void vertexAttribPointer (deUint32 index, int size, deUint32 type, deBool normalized, int stride, const void *pointer);
705 virtual void vertexAttribIPointer (deUint32 index, int size, deUint32 type, int stride, const void *pointer);
706 virtual void enableVertexAttribArray (deUint32 index);
707 virtual void disableVertexAttribArray(deUint32 index);
708 virtual void vertexAttribDivisor (deUint32 index, deUint32 divisor);
709
710 virtual void vertexAttrib1f (deUint32 index, float);
711 virtual void vertexAttrib2f (deUint32 index, float, float);
712 virtual void vertexAttrib3f (deUint32 index, float, float, float);
713 virtual void vertexAttrib4f (deUint32 index, float, float, float, float);
714 virtual void vertexAttribI4i (deUint32 index, deInt32, deInt32, deInt32, deInt32);
715 virtual void vertexAttribI4ui (deUint32 index, deUint32, deUint32, deUint32, deUint32);
716
717 virtual deInt32 getAttribLocation (deUint32 program, const char *name);
718
719 virtual void uniform1f (deInt32 location, float);
720 virtual void uniform1i (deInt32 location, deInt32);
721 virtual void uniform1fv (deInt32 index, deInt32 count, const float*);
722 virtual void uniform2fv (deInt32 index, deInt32 count, const float*);
723 virtual void uniform3fv (deInt32 index, deInt32 count, const float*);
724 virtual void uniform4fv (deInt32 index, deInt32 count, const float*);
725 virtual void uniform1iv (deInt32 index, deInt32 count, const deInt32*);
726 virtual void uniform2iv (deInt32 index, deInt32 count, const deInt32*);
727 virtual void uniform3iv (deInt32 index, deInt32 count, const deInt32*);
728 virtual void uniform4iv (deInt32 index, deInt32 count, const deInt32*);
729 virtual void uniformMatrix3fv (deInt32 location, deInt32 count, deInt32 transpose, const float *value);
730 virtual void uniformMatrix4fv (deInt32 location, deInt32 count, deInt32 transpose, const float *value);
731 virtual deInt32 getUniformLocation (deUint32 program, const char *name);
732
733 virtual void lineWidth (float);
734
735 virtual void drawArrays (deUint32 mode, int first, int count);
736 virtual void drawArraysInstanced (deUint32 mode, int first, int count, int instanceCount);
737 virtual void drawElements (deUint32 mode, int count, deUint32 type, const void *indices);
738 virtual void drawElementsBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int baseVertex);
739 virtual void drawElementsInstanced (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount);
740 virtual void drawElementsInstancedBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount, int baseVertex);
741 virtual void drawRangeElements (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices);
742 virtual void drawRangeElementsBaseVertex (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices, int baseVertex);
743 virtual void drawArraysIndirect (deUint32 mode, const void *indirect);
744 virtual void drawElementsIndirect (deUint32 mode, deUint32 type, const void *indirect);
745
746 virtual void multiDrawArrays (deUint32 mode, const int* first, const int* count, int primCount);
747 virtual void multiDrawElements (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount);
748 virtual void multiDrawElementsBaseVertex (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount, const int* baseVertex);
749
750 virtual deUint32 createProgram (ShaderProgram* program);
751 virtual void useProgram (deUint32 program);
752 virtual void deleteProgram (deUint32 program);
753
754 virtual void readPixels (int x, int y, int width, int height, deUint32 format, deUint32 type, void* data);
755 virtual deUint32 getError (void);
756 virtual void finish (void);
757
758 virtual void getIntegerv (deUint32 pname, int* params);
759 virtual const char* getString (deUint32 pname);
760
761 // Expose helpers from Context.
762 using Context::readPixels;
763 using Context::texImage2D;
764 using Context::texSubImage2D;
765
766 private:
767 ReferenceContext (const ReferenceContext& other); // Not allowed!
768 ReferenceContext& operator= (const ReferenceContext& other); // Not allowed!
769
770 void deleteTexture (rc::Texture* texture);
771 void deleteFramebuffer (rc::Framebuffer* framebuffer);
772 void deleteRenderbuffer (rc::Renderbuffer* renderbuffer);
773 void deleteBuffer (rc::DataBuffer* buffer);
774 void deleteVertexArray (rc::VertexArray* vertexArray);
775 void deleteProgramObject (rc::ShaderProgramObjectContainer* sp);
776
777 void acquireFboAttachmentReference (const rc::Framebuffer::Attachment& attachment);
778 void releaseFboAttachmentReference (const rc::Framebuffer::Attachment& attachment);
779 tcu::PixelBufferAccess getFboAttachment (const rc::Framebuffer& framebuffer, rc::Framebuffer::AttachmentPoint point);
780
781 deUint32 blitResolveMultisampleFramebuffer (deUint32 mask, const tcu::IVec4& srcRect, const tcu::IVec4& dstRect, bool flipX, bool flipY);
782
getDrawColorbuffer(void)783 rr::MultisamplePixelBufferAccess getDrawColorbuffer (void) { return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_COLOR0))) : (m_defaultColorbuffer); }
getDrawDepthbuffer(void)784 rr::MultisamplePixelBufferAccess getDrawDepthbuffer (void) { return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_DEPTH))) : (m_defaultDepthbuffer); }
getDrawStencilbuffer(void)785 rr::MultisamplePixelBufferAccess getDrawStencilbuffer (void) { return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_STENCIL))) : (m_defaultStencilbuffer); }
getReadColorbuffer(void)786 rr::MultisamplePixelBufferAccess getReadColorbuffer (void) { return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_COLOR0))) : (m_defaultColorbuffer); }
getReadDepthbuffer(void)787 rr::MultisamplePixelBufferAccess getReadDepthbuffer (void) { return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_DEPTH))) : (m_defaultDepthbuffer); }
getReadStencilbuffer(void)788 rr::MultisamplePixelBufferAccess getReadStencilbuffer (void) { return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment(*m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_STENCIL))) : (m_defaultStencilbuffer); }
789
790 const rc::Texture2D& getTexture2D (int unitNdx) const;
791 const rc::TextureCube& getTextureCube (int unitNdx) const;
getViewport(void) const792 const tcu::IVec4& getViewport (void) const { return m_viewport; }
793
794 void setError (deUint32 error);
795
796 void setTex1DBinding (int unit, rc::Texture1D* tex1D);
797 void setTex2DBinding (int unit, rc::Texture2D* tex2D);
798 void setTexCubeBinding (int unit, rc::TextureCube* texCube);
799 void setTex2DArrayBinding (int unit, rc::Texture2DArray* tex2DArray);
800 void setTex3DBinding (int unit, rc::Texture3D* tex3D);
801 void setTexCubeArrayBinding (int unit, rc::TextureCubeArray* texCubeArray);
802
803 void setBufferBinding (deUint32 target, rc::DataBuffer* buffer);
804 rc::DataBuffer* getBufferBinding (deUint32 target) const;
805
getPixelPackPtr(void * ptrOffset) const806 void* getPixelPackPtr (void* ptrOffset) const { return m_pixelPackBufferBinding ? (void*)((deUintptr)m_pixelPackBufferBinding->getData()+(deUintptr)ptrOffset) : ptrOffset; }
getPixelUnpackPtr(const void * ptrOffset) const807 const void* getPixelUnpackPtr (const void* ptrOffset) const { return m_pixelUnpackBufferBinding ? (const void*)((deUintptr)m_pixelUnpackBufferBinding->getData()+(deUintptr)ptrOffset) : ptrOffset; }
808
809 bool predrawErrorChecks (deUint32 mode);
810 void drawWithReference (const rr::PrimitiveList& primitives, int instanceCount);
811
812 // Helpers for getting valid access object based on current unpack state.
813 tcu::ConstPixelBufferAccess getUnpack2DAccess (const tcu::TextureFormat& format, int width, int height, const void* data);
814 tcu::ConstPixelBufferAccess getUnpack3DAccess (const tcu::TextureFormat& format, int width, int height, int depth, const void* data);
815
816 void uniformv (deInt32 index, glu::DataType type, deInt32 count, const void*);
817
818 struct TextureUnit
819 {
820
821 rc::Texture1D* tex1DBinding;
822 rc::Texture2D* tex2DBinding;
823 rc::TextureCube* texCubeBinding;
824 rc::Texture2DArray* tex2DArrayBinding;
825 rc::Texture3D* tex3DBinding;
826 rc::TextureCubeArray* texCubeArrayBinding;
827
828 rc::Texture1D default1DTex;
829 rc::Texture2D default2DTex;
830 rc::TextureCube defaultCubeTex;
831 rc::Texture2DArray default2DArrayTex;
832 rc::Texture3D default3DTex;
833 rc::TextureCubeArray defaultCubeArrayTex;
834
TextureUnitsglr::ReferenceContext::TextureUnit835 TextureUnit (void)
836 : tex1DBinding (DE_NULL)
837 , tex2DBinding (DE_NULL)
838 , texCubeBinding (DE_NULL)
839 , tex2DArrayBinding (DE_NULL)
840 , tex3DBinding (DE_NULL)
841 , texCubeArrayBinding (DE_NULL)
842 , default1DTex (0)
843 , default2DTex (0)
844 , defaultCubeTex (0)
845 , default2DArrayTex (0)
846 , default3DTex (0)
847 , defaultCubeArrayTex (0)
848 {
849 }
850 };
851
852 struct StencilState
853 {
854 deUint32 func;
855 int ref;
856 deUint32 opMask;
857 deUint32 opStencilFail;
858 deUint32 opDepthFail;
859 deUint32 opDepthPass;
860 deUint32 writeMask;
861
862 StencilState (void);
863 };
864
865 ReferenceContextLimits m_limits;
866
867 rr::MultisamplePixelBufferAccess m_defaultColorbuffer;
868 rr::MultisamplePixelBufferAccess m_defaultDepthbuffer;
869 rr::MultisamplePixelBufferAccess m_defaultStencilbuffer;
870 rc::VertexArray m_clientVertexArray;
871
872 tcu::IVec4 m_viewport;
873
874 rc::ObjectManager<rc::Texture> m_textures;
875 rc::ObjectManager<rc::Framebuffer> m_framebuffers;
876 rc::ObjectManager<rc::Renderbuffer> m_renderbuffers;
877 rc::ObjectManager<rc::DataBuffer> m_buffers;
878 rc::ObjectManager<rc::VertexArray> m_vertexArrays;
879 rc::ObjectManager<rc::ShaderProgramObjectContainer> m_programs;
880
881 int m_activeTexture;
882 std::vector<TextureUnit> m_textureUnits;
883 rc::Texture1D m_emptyTex1D;
884 rc::Texture2D m_emptyTex2D;
885 rc::TextureCube m_emptyTexCube;
886 rc::Texture2DArray m_emptyTex2DArray;
887 rc::Texture3D m_emptyTex3D;
888 rc::TextureCubeArray m_emptyTexCubeArray;
889
890 int m_pixelUnpackRowLength;
891 int m_pixelUnpackSkipRows;
892 int m_pixelUnpackSkipPixels;
893 int m_pixelUnpackImageHeight;
894 int m_pixelUnpackSkipImages;
895 int m_pixelUnpackAlignment;
896 int m_pixelPackAlignment;
897
898 rc::Framebuffer* m_readFramebufferBinding;
899 rc::Framebuffer* m_drawFramebufferBinding;
900 rc::Renderbuffer* m_renderbufferBinding;
901 rc::VertexArray* m_vertexArrayBinding;
902 rc::ShaderProgramObjectContainer* m_currentProgram;
903
904 rc::DataBuffer* m_arrayBufferBinding;
905 rc::DataBuffer* m_pixelPackBufferBinding;
906 rc::DataBuffer* m_pixelUnpackBufferBinding;
907 rc::DataBuffer* m_transformFeedbackBufferBinding;
908 rc::DataBuffer* m_uniformBufferBinding;
909 rc::DataBuffer* m_copyReadBufferBinding;
910 rc::DataBuffer* m_copyWriteBufferBinding;
911 rc::DataBuffer* m_drawIndirectBufferBinding;
912
913 tcu::Vec4 m_clearColor;
914 float m_clearDepth;
915 int m_clearStencil;
916
917 bool m_scissorEnabled;
918 tcu::IVec4 m_scissorBox;
919
920 bool m_stencilTestEnabled;
921 StencilState m_stencil[rr::FACETYPE_LAST];
922
923 bool m_depthTestEnabled;
924 deUint32 m_depthFunc;
925 float m_depthRangeNear;
926 float m_depthRangeFar;
927
928 float m_polygonOffsetFactor;
929 float m_polygonOffsetUnits;
930 bool m_polygonOffsetFillEnabled;
931
932 bool m_provokingFirstVertexConvention;
933
934 bool m_blendEnabled;
935 deUint32 m_blendModeRGB;
936 deUint32 m_blendModeAlpha;
937 deUint32 m_blendFactorSrcRGB;
938 deUint32 m_blendFactorDstRGB;
939 deUint32 m_blendFactorSrcAlpha;
940 deUint32 m_blendFactorDstAlpha;
941 tcu::Vec4 m_blendColor;
942
943 bool m_sRGBUpdateEnabled;
944
945 bool m_depthClampEnabled;
946
947 tcu::BVec4 m_colorMask;
948 bool m_depthMask;
949
950 std::vector<rr::GenericVec4> m_currentAttribs;
951 float m_lineWidth;
952
953 bool m_primitiveRestartFixedIndex;
954 bool m_primitiveRestartSettableIndex;
955 deUint32 m_primitiveRestartIndex;
956
957 deUint32 m_lastError;
958
959 rr::FragmentProcessor m_fragmentProcessor;
960 std::vector<rr::Fragment> m_fragmentBuffer;
961 std::vector<float> m_fragmentDepths;
962 };
963
964 } // sglr
965
966 #endif // _SGLRREFERENCECONTEXT_HPP
967