framework/opengl/gluCallLogWrapper.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief GL call wrapper for logging.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluCallLogWrapper.hpp"
  25 #include "gluStrUtil.hpp"
  26 #include "glwFunctions.hpp"
  27 #include "glwEnums.hpp"
  28
  29 using tcu::TestLog;
  30 using tcu::toHex;
  31
  32 namespace glu
  33 {
  34
  35 CallLogWrapper::CallLogWrapper (const glw::Functions& gl, tcu::TestLog& log)
  36         : m_gl                  (gl)
  37         , m_log                 (log)
  38         , m_enableLog   (false)
  39 {
  40 }
  41
  42 CallLogWrapper::~CallLogWrapper (void)
  43 {
  44 }
  45
  46 template <typename T>
  47 inline tcu::Format::ArrayPointer<T> getPointerStr (const T* arr, deUint32 size)
  48 {
  49         return tcu::formatArray(arr, (int)size);
  50 }
  51
  52 template <typename T>
  53 inline tcu::Format::ArrayPointer<T> getPointerStr (const T* arr, int size)
  54 {
  55         return tcu::formatArray(arr, de::max(size, 0));
  56 }
  57
  58 inline detail::EnumPointerFmt getEnumPointerStr (const deUint32* value, glw::GLsizei size, detail::EnumPointerFmt::GetEnumNameFunc getName)
  59 {
  60         return detail::EnumPointerFmt(value, (deUint32)de::max(0, size), getName);
  61 }
  62
  63 inline detail::BooleanPointerFmt getBooleanPointerStr (const deUint8* value, glw::GLsizei size)
  64 {
  65         return detail::BooleanPointerFmt(value, (deUint32)de::max(0, size));
  66 }
  67
  68 // String formatter.
  69
  70 class StringFmt
  71 {
  72 public:
  73         const glw::GLchar* str;
  74         StringFmt (const glw::GLchar* str_) : str(str_) {}
  75 };
  76
  77 inline std::ostream& operator<< (std::ostream& str, StringFmt fmt)
  78 {
  79         return str << (fmt.str ? (const char*)fmt.str : "NULL");
  80 }
  81
  82 inline StringFmt getStringStr (const char*                      value)  { return StringFmt(value);                              }
  83 inline StringFmt getStringStr (const glw::GLubyte*      value)  { return StringFmt((const char*)value); }
  84
  85 // Framebuffer parameter pointer formatter.
  86
  87 class FboParamPtrFmt
  88 {
  89 public:
  90         deUint32        param;
  91         const int*      value;
  92
  93         FboParamPtrFmt (deUint32 param_, const int* value_) : param(param_), value(value_) {}
  94 };
  95
  96 std::ostream& operator<< (std::ostream& str, FboParamPtrFmt fmt)
  97 {
  98         if (fmt.value)
  99         {
 100                 switch (fmt.param)
 101                 {
 102                         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
 103                                 return str << tcu::Format::Enum<int, 2>(getFramebufferAttachmentTypeName, *fmt.value);
 104
 105                         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
 106                                 return str << tcu::Format::Enum<int, 2>(getCubeMapFaceName, *fmt.value);
 107
 108                         case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
 109                                 return str << tcu::Format::Enum<int, 2>(getTypeName, *fmt.value);
 110
 111                         case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
 112                                 return str << tcu::Format::Enum<int, 2>(getFramebufferColorEncodingName, *fmt.value);
 113
 114                         case GL_FRAMEBUFFER_ATTACHMENT_LAYERED:
 115                                 return str << tcu::Format::Enum<int, 2>(getBooleanName, *fmt.value);
 116
 117                         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
 118                         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
 119                         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
 120                         case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
 121                         case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
 122                         case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
 123                         case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
 124                         case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
 125                         case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
 126                                 return str << *fmt.value;
 127
 128                         default:
 129                                 return str << tcu::toHex(*fmt.value);
 130                 }
 131         }
 132         else
 133                 return str << "(null)";
 134 }
 135
 136 inline FboParamPtrFmt getFramebufferAttachmentParameterValueStr (deUint32 param, const int* value)
 137 {
 138         return FboParamPtrFmt(param, value);
 139 }
 140
 141 #include "gluQueryUtil.inl"
 142
 143 // API entry-point implementations are auto-generated
 144 #include "gluCallLogWrapper.inl"
 145
 146 } // glu