framework/opengl/gluShaderProgram.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 Wrapper for GL program object.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluShaderProgram.hpp"
  25 #include "gluRenderContext.hpp"
  26 #include "glwFunctions.hpp"
  27 #include "glwEnums.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "deClock.h"
  30
  31 #include <cstring>
  32
  33 using std::string;
  34
  35 namespace glu
  36 {
  37
  38 // Shader
  39
  40 Shader::Shader (const RenderContext& renderCtx, ShaderType shaderType)
  41         : m_gl          (renderCtx.getFunctions())
  42         , m_shader      (0)
  43 {
  44         m_info.type     = shaderType;
  45         m_shader        = m_gl.createShader(getGLShaderType(shaderType));
  46         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateShader()");
  47         TCU_CHECK(m_shader);
  48 }
  49
  50 Shader::Shader (const glw::Functions& gl, ShaderType shaderType)
  51         : m_gl          (gl)
  52         , m_shader      (0)
  53 {
  54         m_info.type     = shaderType;
  55         m_shader        = m_gl.createShader(getGLShaderType(shaderType));
  56         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateShader()");
  57         TCU_CHECK(m_shader);
  58 }
  59
  60 Shader::~Shader (void)
  61 {
  62         m_gl.deleteShader(m_shader);
  63 }
  64
  65 void Shader::setSources (int numSourceStrings, const char* const* sourceStrings, const int* lengths)
  66 {
  67         m_gl.shaderSource(m_shader, numSourceStrings, sourceStrings, lengths);
  68         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glShaderSource()");
  69
  70         m_info.source.clear();
  71         for (int ndx = 0; ndx < numSourceStrings; ndx++)
  72         {
  73                 const size_t length = lengths && lengths[ndx] >= 0 ? lengths[ndx] : strlen(sourceStrings[ndx]);
  74                 m_info.source += std::string(sourceStrings[ndx], length);
  75         }
  76 }
  77
  78 void Shader::compile (void)
  79 {
  80         m_info.compileOk                = false;
  81         m_info.compileTimeUs    = 0;
  82         m_info.infoLog.clear();
  83
  84         {
  85                 deUint64 compileStart = deGetMicroseconds();
  86                 m_gl.compileShader(m_shader);
  87                 m_info.compileTimeUs = deGetMicroseconds() - compileStart;
  88         }
  89
  90         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCompileShader()");
  91
  92         // Query status
  93         {
  94                 int compileStatus = 0;
  95
  96                 m_gl.getShaderiv(m_shader, GL_COMPILE_STATUS, &compileStatus);
  97                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");
  98
  99                 m_info.compileOk = compileStatus != GL_FALSE;
 100         }
 101
 102         // Query log
 103         {
 104                 int infoLogLen = 0;
 105                 int unusedLen;
 106
 107                 m_gl.getShaderiv(m_shader, GL_INFO_LOG_LENGTH, &infoLogLen);
 108                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");
 109
 110                 if (infoLogLen > 0)
 111                 {
 112                         // The INFO_LOG_LENGTH query and the buffer query implementations have
 113                         // very commonly off-by-one errors. Try to work around these issues.
 114
 115                         // add tolerance for off-by-one in log length, buffer write, and for terminator
 116                         std::vector<char> infoLog(infoLogLen + 3, '\0');
 117
 118                         // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
 119                         m_gl.getShaderInfoLog(m_shader, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);
 120
 121                         if (infoLog[(int)(infoLog.size()) - 1] != '\0')
 122                         {
 123                                 // return whole buffer if null terminator was overwritten
 124                                 m_info.infoLog = std::string(&infoLog[0], infoLog.size());
 125                         }
 126                         else
 127                         {
 128                                 // read as C string. infoLog is guaranteed to be 0-terminated
 129                                 m_info.infoLog = std::string(&infoLog[0]);
 130                         }
 131                 }
 132         }
 133 }
 134
 135 void Shader::specialize (const char* entryPoint, glw::GLuint numSpecializationConstants,
 136                                                  const glw::GLuint* constantIndex, const glw::GLuint* constantValue)
 137 {
 138         m_info.compileOk                = false;
 139         m_info.compileTimeUs    = 0;
 140         m_info.infoLog.clear();
 141
 142         {
 143                 deUint64 compileStart = deGetMicroseconds();
 144                 m_gl.specializeShader(m_shader, entryPoint, numSpecializationConstants, constantIndex, constantValue);
 145                 m_info.compileTimeUs = deGetMicroseconds() - compileStart;
 146         }
 147
 148         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glSpecializeShader()");
 149
 150         // Query status
 151         {
 152                 int compileStatus = 0;
 153
 154                 m_gl.getShaderiv(m_shader, GL_COMPILE_STATUS, &compileStatus);
 155                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");
 156
 157                 m_info.compileOk = compileStatus != GL_FALSE;
 158         }
 159
 160         // Query log
 161         {
 162                 int infoLogLen = 0;
 163                 int unusedLen;
 164
 165                 m_gl.getShaderiv(m_shader, GL_INFO_LOG_LENGTH, &infoLogLen);
 166                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");
 167
 168                 if (infoLogLen > 0)
 169                 {
 170                         // The INFO_LOG_LENGTH query and the buffer query implementations have
 171                         // very commonly off-by-one errors. Try to work around these issues.
 172
 173                         // add tolerance for off-by-one in log length, buffer write, and for terminator
 174                         std::vector<char> infoLog(infoLogLen + 3, '\0');
 175
 176                         // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
 177                         m_gl.getShaderInfoLog(m_shader, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);
 178                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderInfoLog()");
 179
 180                         if (infoLog[(int)(infoLog.size()) - 1] != '\0')
 181                         {
 182                                 // return whole buffer if null terminator was overwritten
 183                                 m_info.infoLog = std::string(&infoLog[0], infoLog.size());
 184                         }
 185                         else
 186                         {
 187                                 // read as C string. infoLog is guaranteed to be 0-terminated
 188                                 m_info.infoLog = std::string(&infoLog[0]);
 189                         }
 190                 }
 191         }
 192 }
 193
 194 // Program
 195
 196 static bool getProgramLinkStatus (const glw::Functions& gl, deUint32 program)
 197 {
 198         int     linkStatus                              = 0;
 199
 200         gl.getProgramiv(program, GL_LINK_STATUS, &linkStatus);
 201         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");
 202         return (linkStatus != GL_FALSE);
 203 }
 204
 205 static std::string getProgramInfoLog (const glw::Functions& gl, deUint32 program)
 206 {
 207         int infoLogLen = 0;
 208         int unusedLen;
 209
 210         gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
 211         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");
 212
 213         if (infoLogLen > 0)
 214         {
 215                 // The INFO_LOG_LENGTH query and the buffer query implementations have
 216                 // very commonly off-by-one errors. Try to work around these issues.
 217
 218                 // add tolerance for off-by-one in log length, buffer write, and for terminator
 219                 std::vector<char> infoLog(infoLogLen + 3, '\0');
 220
 221                 // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
 222                 gl.getProgramInfoLog(program, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);
 223
 224                 // return whole buffer if null terminator was overwritten
 225                 if (infoLog[(int)(infoLog.size()) - 1] != '\0')
 226                         return std::string(&infoLog[0], infoLog.size());
 227
 228                 // read as C string. infoLog is guaranteed to be 0-terminated
 229                 return std::string(&infoLog[0]);
 230         }
 231         return std::string();
 232 }
 233
 234 Program::Program (const RenderContext& renderCtx)
 235         : m_gl          (renderCtx.getFunctions())
 236         , m_program     (0)
 237 {
 238         m_program = m_gl.createProgram();
 239         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateProgram()");
 240 }
 241
 242 Program::Program (const glw::Functions& gl)
 243         : m_gl          (gl)
 244         , m_program     (0)
 245 {
 246         m_program = m_gl.createProgram();
 247         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateProgram()");
 248 }
 249
 250 Program::Program (const RenderContext& renderCtx, deUint32 program)
 251         : m_gl          (renderCtx.getFunctions())
 252         , m_program     (program)
 253 {
 254         m_info.linkOk   = getProgramLinkStatus(m_gl, program);
 255         m_info.infoLog  = getProgramInfoLog(m_gl, program);
 256 }
 257
 258 Program::~Program (void)
 259 {
 260         m_gl.deleteProgram(m_program);
 261 }
 262
 263 void Program::attachShader (deUint32 shader)
 264 {
 265         m_gl.attachShader(m_program, shader);
 266         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glAttachShader()");
 267 }
 268
 269 void Program::detachShader (deUint32 shader)
 270 {
 271         m_gl.detachShader(m_program, shader);
 272         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDetachShader()");
 273 }
 274
 275 void Program::bindAttribLocation (deUint32 location, const char* name)
 276 {
 277         m_gl.bindAttribLocation(m_program, location, name);
 278         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glBindAttribLocation()");
 279 }
 280
 281 void Program::transformFeedbackVaryings (int count, const char* const* varyings, deUint32 bufferMode)
 282 {
 283         m_gl.transformFeedbackVaryings(m_program, count, varyings, bufferMode);
 284         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glTransformFeedbackVaryings()");
 285 }
 286
 287 void Program::link (void)
 288 {
 289         m_info.linkOk           = false;
 290         m_info.linkTimeUs       = 0;
 291         m_info.infoLog.clear();
 292
 293         {
 294                 deUint64 linkStart = deGetMicroseconds();
 295                 m_gl.linkProgram(m_program);
 296                 m_info.linkTimeUs = deGetMicroseconds() - linkStart;
 297         }
 298         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glLinkProgram()");
 299
 300         m_info.linkOk   = getProgramLinkStatus(m_gl, m_program);
 301         m_info.infoLog  = getProgramInfoLog(m_gl, m_program);
 302 }
 303
 304 bool Program::isSeparable (void) const
 305 {
 306         int separable = GL_FALSE;
 307
 308         m_gl.getProgramiv(m_program, GL_PROGRAM_SEPARABLE, &separable);
 309         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetProgramiv()");
 310
 311         return (separable != GL_FALSE);
 312 }
 313
 314 void Program::setSeparable (bool separable)
 315 {
 316         m_gl.programParameteri(m_program, GL_PROGRAM_SEPARABLE, separable);
 317         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glProgramParameteri()");
 318 }
 319
 320 // ProgramPipeline
 321
 322 ProgramPipeline::ProgramPipeline (const RenderContext& renderCtx)
 323         : m_gl                  (renderCtx.getFunctions())
 324         , m_pipeline    (0)
 325 {
 326         m_gl.genProgramPipelines(1, &m_pipeline);
 327         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGenProgramPipelines()");
 328 }
 329
 330 ProgramPipeline::ProgramPipeline (const glw::Functions& gl)
 331         : m_gl                  (gl)
 332         , m_pipeline    (0)
 333 {
 334         m_gl.genProgramPipelines(1, &m_pipeline);
 335         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGenProgramPipelines()");
 336 }
 337
 338 ProgramPipeline::~ProgramPipeline (void)
 339 {
 340         m_gl.deleteProgramPipelines(1, &m_pipeline);
 341 }
 342
 343 void ProgramPipeline::useProgramStages (deUint32 stages, deUint32 program)
 344 {
 345         m_gl.useProgramStages(m_pipeline, stages, program);
 346         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgramStages()");
 347 }
 348
 349 void ProgramPipeline::activeShaderProgram (deUint32 program)
 350 {
 351         m_gl.activeShaderProgram(m_pipeline, program);
 352         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glActiveShaderProgram()");
 353 }
 354
 355 bool ProgramPipeline::isValid (void)
 356 {
 357         glw::GLint status = GL_FALSE;
 358         m_gl.validateProgramPipeline(m_pipeline);
 359         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glValidateProgramPipeline()");
 360
 361         m_gl.getProgramPipelineiv(m_pipeline, GL_VALIDATE_STATUS, &status);
 362
 363         return (status != GL_FALSE);
 364 }
 365
 366 // ShaderProgram
 367
 368 ShaderProgram::ShaderProgram (const RenderContext& renderCtx, const ProgramSources& sources)
 369         : m_program(renderCtx.getFunctions())
 370 {
 371         init(renderCtx.getFunctions(), sources);
 372 }
 373
 374 ShaderProgram::ShaderProgram (const RenderContext& renderCtx, const ProgramBinaries& binaries)
 375         : m_program(renderCtx.getFunctions())
 376 {
 377         init(renderCtx.getFunctions(), binaries);
 378 }
 379
 380 ShaderProgram::ShaderProgram (const glw::Functions& gl, const ProgramSources& sources)
 381         : m_program(gl)
 382 {
 383         init(gl, sources);
 384 }
 385
 386 ShaderProgram::ShaderProgram (const glw::Functions& gl, const ProgramBinaries& binaries)
 387         : m_program(gl)
 388 {
 389         init(gl, binaries);
 390 }
 391
 392 void ShaderProgram::init (const glw::Functions& gl, const ProgramSources& sources)
 393 {
 394         try
 395         {
 396                 bool shadersOk = true;
 397
 398                 for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 399                 {
 400                         for (int shaderNdx = 0; shaderNdx < (int)sources.sources[shaderType].size(); ++shaderNdx)
 401                         {
 402                                 const char* source      = sources.sources[shaderType][shaderNdx].c_str();
 403                                 const int       length  = (int)sources.sources[shaderType][shaderNdx].size();
 404
 405                                 m_shaders[shaderType].reserve(m_shaders[shaderType].size() + 1);
 406
 407                                 m_shaders[shaderType].push_back(new Shader(gl, ShaderType(shaderType)));
 408                                 m_shaders[shaderType].back()->setSources(1, &source, &length);
 409                                 m_shaders[shaderType].back()->compile();
 410
 411                                 shadersOk = shadersOk && m_shaders[shaderType].back()->getCompileStatus();
 412                         }
 413                 }
 414
 415                 if (shadersOk)
 416                 {
 417                         for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 418                                 for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
 419                                         m_program.attachShader(m_shaders[shaderType][shaderNdx]->getShader());
 420
 421                         for (std::vector<AttribLocationBinding>::const_iterator binding = sources.attribLocationBindings.begin(); binding != sources.attribLocationBindings.end(); ++binding)
 422                                 m_program.bindAttribLocation(binding->location, binding->name.c_str());
 423
 424                         DE_ASSERT((sources.transformFeedbackBufferMode == GL_NONE) == sources.transformFeedbackVaryings.empty());
 425                         if (sources.transformFeedbackBufferMode != GL_NONE)
 426                         {
 427                                 std::vector<const char*> tfVaryings(sources.transformFeedbackVaryings.size());
 428                                 for (int ndx = 0; ndx < (int)tfVaryings.size(); ndx++)
 429                                         tfVaryings[ndx] = sources.transformFeedbackVaryings[ndx].c_str();
 430
 431                                 m_program.transformFeedbackVaryings((int)tfVaryings.size(), &tfVaryings[0], sources.transformFeedbackBufferMode);
 432                         }
 433
 434                         if (sources.separable)
 435                                 m_program.setSeparable(true);
 436
 437                         m_program.link();
 438                 }
 439         }
 440         catch (...)
 441         {
 442                 for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 443                         for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
 444                                 delete m_shaders[shaderType][shaderNdx];
 445                 throw;
 446         }
 447 }
 448
 449 void ShaderProgram::init (const glw::Functions& gl, const ProgramBinaries& binaries)
 450 {
 451         try
 452         {
 453                 bool shadersOk = true;
 454
 455                 for (deUint32 binaryNdx = 0; binaryNdx < binaries.binaries.size(); ++binaryNdx)
 456                 {
 457                         ShaderBinary shaderBinary = binaries.binaries[binaryNdx];
 458                         if (!shaderBinary.binary.empty())
 459                         {
 460                                 const char* binary      = (const char*)shaderBinary.binary.data();
 461                                 const int       length  = (int)(shaderBinary.binary.size() * sizeof(deUint32));
 462
 463                                 DE_ASSERT(shaderBinary.shaderEntryPoints.size() == shaderBinary.shaderTypes.size());
 464
 465                                 std::vector<Shader*> shaders;
 466                                 for (deUint32 shaderTypeNdx = 0; shaderTypeNdx < shaderBinary.shaderTypes.size(); ++shaderTypeNdx)
 467                                 {
 468                                         ShaderType shaderType = shaderBinary.shaderTypes[shaderTypeNdx];
 469
 470                                         Shader* shader = new Shader(gl, ShaderType(shaderType));
 471
 472                                         m_shaders[shaderType].reserve(m_shaders[shaderType].size() + 1);
 473                                         m_shaders[shaderType].push_back(shader);
 474                                         shaders.push_back(shader);
 475                                 }
 476
 477                                 setBinary(gl, shaders, binaries.binaryFormat, binary, length);
 478
 479                                 for (deUint32 shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
 480                                 {
 481                                         shaders[shaderNdx]->specialize(shaderBinary.shaderEntryPoints[shaderNdx].c_str(),
 482                                                                                                    (deUint32)shaderBinary.specializationIndices.size(),
 483                                                                                                    shaderBinary.specializationIndices.data(),
 484                                                                                                    shaderBinary.specializationValues.data());
 485
 486                                         shadersOk = shadersOk && shaders[shaderNdx]->getCompileStatus();
 487                                 }
 488                         }
 489                 }
 490
 491                 if (shadersOk)
 492                 {
 493                         for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 494                                 for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
 495                                         m_program.attachShader(m_shaders[shaderType][shaderNdx]->getShader());
 496
 497                         m_program.link();
 498                 }
 499         }
 500         catch (...)
 501         {
 502                 for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 503                         for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
 504                                 delete m_shaders[shaderType][shaderNdx];
 505                 throw;
 506         }
 507 }
 508
 509 void ShaderProgram::setBinary (const glw::Functions& gl, std::vector<Shader*>& shaders, glw::GLenum binaryFormat, const void* binaryData, const int length)
 510 {
 511         std::vector<glw::GLuint> shaderVec;
 512         for (deUint32 shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
 513                 shaderVec.push_back(shaders[shaderNdx]->getShader());
 514
 515         gl.shaderBinary((glw::GLsizei)shaderVec.size(), shaderVec.data(), binaryFormat, binaryData, length);
 516         GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderBinary");
 517
 518         for (deUint32 shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
 519         {
 520                 glw::GLint shaderState;
 521                 gl.getShaderiv(shaders[shaderNdx]->getShader(), GL_SPIR_V_BINARY_ARB, &shaderState);
 522                 GLU_EXPECT_NO_ERROR(gl.getError(), "getShaderiv");
 523
 524                 DE_ASSERT(shaderState == GL_TRUE);
 525         }
 526 }
 527
 528 ShaderProgram::~ShaderProgram (void)
 529 {
 530         for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 531                 for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
 532                         delete m_shaders[shaderType][shaderNdx];
 533 }
 534
 535 // Utilities
 536
 537 deUint32 getGLShaderType (ShaderType shaderType)
 538 {
 539         static const deUint32 s_typeMap[] =
 540         {
 541                 GL_VERTEX_SHADER,
 542                 GL_FRAGMENT_SHADER,
 543                 GL_GEOMETRY_SHADER,
 544                 GL_TESS_CONTROL_SHADER,
 545                 GL_TESS_EVALUATION_SHADER,
 546                 GL_COMPUTE_SHADER
 547         };
 548         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typeMap) == SHADERTYPE_LAST);
 549         DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typeMap)));
 550         return s_typeMap[shaderType];
 551 }
 552
 553 deUint32 getGLShaderTypeBit (ShaderType shaderType)
 554 {
 555         static const deUint32 s_typebitMap[] =
 556         {
 557                 GL_VERTEX_SHADER_BIT,
 558                 GL_FRAGMENT_SHADER_BIT,
 559                 GL_GEOMETRY_SHADER_BIT,
 560                 GL_TESS_CONTROL_SHADER_BIT,
 561                 GL_TESS_EVALUATION_SHADER_BIT,
 562                 GL_COMPUTE_SHADER_BIT
 563         };
 564         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typebitMap) == SHADERTYPE_LAST);
 565         DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typebitMap)));
 566         return s_typebitMap[shaderType];
 567 }
 568
 569 qpShaderType getLogShaderType (ShaderType shaderType)
 570 {
 571         static const qpShaderType s_typeMap[] =
 572         {
 573                 QP_SHADER_TYPE_VERTEX,
 574                 QP_SHADER_TYPE_FRAGMENT,
 575                 QP_SHADER_TYPE_GEOMETRY,
 576                 QP_SHADER_TYPE_TESS_CONTROL,
 577                 QP_SHADER_TYPE_TESS_EVALUATION,
 578                 QP_SHADER_TYPE_COMPUTE
 579         };
 580         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typeMap) == SHADERTYPE_LAST);
 581         DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typeMap)));
 582         return s_typeMap[shaderType];
 583 }
 584
 585 tcu::TestLog& operator<< (tcu::TestLog& log, const ShaderInfo& shaderInfo)
 586 {
 587         return log << tcu::TestLog::Shader(getLogShaderType(shaderInfo.type), shaderInfo.source, shaderInfo.compileOk, shaderInfo.infoLog);
 588 }
 589
 590 tcu::TestLog& operator<< (tcu::TestLog& log, const Shader& shader)
 591 {
 592         return log << tcu::TestLog::ShaderProgram(false, "Plain shader") << shader.getInfo() << tcu::TestLog::EndShaderProgram;
 593 }
 594
 595 static void logShaderProgram (tcu::TestLog& log, const ProgramInfo& programInfo, size_t numShaders, const ShaderInfo* const* shaderInfos)
 596 {
 597         log << tcu::TestLog::ShaderProgram(programInfo.linkOk, programInfo.infoLog);
 598         try
 599         {
 600                 for (size_t shaderNdx = 0; shaderNdx < numShaders; ++shaderNdx)
 601                         log << *shaderInfos[shaderNdx];
 602         }
 603         catch (...)
 604         {
 605                 log << tcu::TestLog::EndShaderProgram;
 606                 throw;
 607         }
 608         log << tcu::TestLog::EndShaderProgram;
 609
 610         // Write statistics.
 611         {
 612                 static const struct
 613                 {
 614                         const char*             name;
 615                         const char*             description;
 616                 } s_compileTimeDesc[] =
 617                 {
 618                         { "VertexCompileTime",                  "Vertex shader compile time"                                    },
 619                         { "FragmentCompileTime",                "Fragment shader compile time"                                  },
 620                         { "GeometryCompileTime",                "Geometry shader compile time"                                  },
 621                         { "TessControlCompileTime",             "Tesselation control shader compile time"               },
 622                         { "TessEvaluationCompileTime",  "Tesselation evaluation shader compile time"    },
 623                         { "ComputeCompileTime",                 "Compute shader compile time"                                   },
 624                 };
 625                 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_compileTimeDesc) == SHADERTYPE_LAST);
 626
 627                 bool allShadersOk = true;
 628
 629                 for (size_t shaderNdx = 0; shaderNdx < numShaders; ++shaderNdx)
 630                 {
 631                         const ShaderInfo&       shaderInfo      = *shaderInfos[shaderNdx];
 632
 633                         log << tcu::TestLog::Float(s_compileTimeDesc[shaderInfo.type].name,
 634                                                                            s_compileTimeDesc[shaderInfo.type].description,
 635                                                                            "ms", QP_KEY_TAG_TIME, (float)shaderInfo.compileTimeUs / 1000.0f);
 636
 637                         allShadersOk = allShadersOk && shaderInfo.compileOk;
 638                 }
 639
 640                 if (allShadersOk)
 641                         log << tcu::TestLog::Float("LinkTime", "Link time", "ms", QP_KEY_TAG_TIME, (float)programInfo.linkTimeUs / 1000.0f);
 642         }
 643 }
 644
 645 tcu::TestLog& operator<< (tcu::TestLog& log, const ShaderProgramInfo& shaderProgramInfo)
 646 {
 647         std::vector<const ShaderInfo*>  shaderPtrs      (shaderProgramInfo.shaders.size());
 648
 649         for (size_t ndx = 0; ndx < shaderPtrs.size(); ndx++)
 650                 shaderPtrs[ndx] = &shaderProgramInfo.shaders[ndx];
 651
 652         logShaderProgram(log, shaderProgramInfo.program, shaderPtrs.size(), shaderPtrs.empty() ? DE_NULL : &shaderPtrs[0]);
 653
 654         return log;
 655 }
 656
 657 tcu::TestLog& operator<< (tcu::TestLog& log, const ShaderProgram& shaderProgram)
 658 {
 659         std::vector<const ShaderInfo*>  shaderPtrs;
 660
 661         for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 662         {
 663                 for (int shaderNdx = 0; shaderNdx < shaderProgram.getNumShaders((ShaderType)shaderType); shaderNdx++)
 664                         shaderPtrs.push_back(&shaderProgram.getShaderInfo((ShaderType)shaderType, shaderNdx));
 665         }
 666
 667         logShaderProgram(log, shaderProgram.getProgramInfo(), shaderPtrs.size(), shaderPtrs.empty() ? DE_NULL : &shaderPtrs[0]);
 668
 669         return log;
 670 }
 671
 672 tcu::TestLog& operator<< (tcu::TestLog& log, const ProgramSources& sources)
 673 {
 674         log << tcu::TestLog::ShaderProgram(false, "(Source only)");
 675
 676         try
 677         {
 678                 for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
 679                 {
 680                         for (size_t shaderNdx = 0; shaderNdx < sources.sources[shaderType].size(); shaderNdx++)
 681                         {
 682                                 log << tcu::TestLog::Shader(getLogShaderType((ShaderType)shaderType),
 683                                                                                         sources.sources[shaderType][shaderNdx],
 684                                                                                         false, "");
 685                         }
 686                 }
 687         }
 688         catch (...)
 689         {
 690                 log << tcu::TestLog::EndShaderProgram;
 691                 throw;
 692         }
 693
 694         log << tcu::TestLog::EndShaderProgram;
 695
 696         return log;
 697 }
 698
 699 } // glu