You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
458 lines
29 KiB
458 lines
29 KiB
# -*- coding: utf-8 -*-
|
|
|
|
#-------------------------------------------------------------------------
|
|
# drawElements Quality Program utilities
|
|
# --------------------------------------
|
|
#
|
|
# Copyright 2015 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
from src_util import *
|
|
import re
|
|
|
|
class LogSpec:
|
|
def __init__ (self, argInPrints, argOutPrints = {}, returnPrint = None):
|
|
self.argInPrints = argInPrints
|
|
self.argOutPrints = argOutPrints
|
|
self.returnPrint = returnPrint
|
|
|
|
def enum (group):
|
|
return lambda name: "get%sStr(%s)" % (group, name)
|
|
|
|
def pointer (size):
|
|
return lambda name: "getPointerStr(%s, %s)" % (name, size)
|
|
|
|
def enumPointer (group, size):
|
|
return lambda name: "getEnumPointerStr(%(name)s, %(size)s, %(nameFunc)s)" % {"name": name, "size": size, "nameFunc": ("get%sName" % group)}
|
|
|
|
def booleanPointer (size):
|
|
return lambda name: "getBooleanPointerStr(%s, %s)" % (name, size)
|
|
|
|
def textureUnit (name):
|
|
return "getTextureUnitStr(%s)" % name
|
|
|
|
def voidPointer (name):
|
|
return "toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(%s)))" % name
|
|
|
|
def fnPointer (name):
|
|
return "toHex(reinterpret_cast<deUintptr>(%s))" % name
|
|
|
|
stringVal = lambda name: "getStringStr(%s)" % name
|
|
|
|
# Special rules for printing call arguments
|
|
CALL_LOG_SPECS = {
|
|
"glActiveTexture": LogSpec({0: textureUnit}),
|
|
"glBeginQuery": LogSpec({0: enum("QueryTarget")}),
|
|
"glBeginTransformFeedback": LogSpec({0: enum("PrimitiveType")}),
|
|
"glBindBuffer": LogSpec({0: enum("BufferTarget")}),
|
|
"glBindBufferBase": LogSpec({0: enum("BufferTarget")}),
|
|
"glBindBufferRange": LogSpec({0: enum("BufferTarget")}),
|
|
"glBindFramebuffer": LogSpec({0: enum("FramebufferTarget")}),
|
|
"glBindRenderbuffer": LogSpec({0: enum("FramebufferTarget")}),
|
|
"glBindTexture": LogSpec({0: enum("TextureTarget")}),
|
|
"glBindTransformFeedback": LogSpec({0: enum("TransformFeedbackTarget")}),
|
|
"glBlendEquation": LogSpec({0: enum("BlendEquation")}),
|
|
"glBlendEquationSeparate": LogSpec({0: enum("BlendEquation"), 1: enum("BlendEquation")}),
|
|
"glBlendEquationi": LogSpec({1: enum("BlendEquation")}),
|
|
"glBlendEquationSeparatei": LogSpec({1: enum("BlendEquation"), 2: enum("BlendEquation")}),
|
|
"glBlendFunc": LogSpec({0: enum("BlendFactor"), 1: enum("BlendFactor")}),
|
|
"glBlendFuncSeparate": LogSpec({0: enum("BlendFactor"), 1: enum("BlendFactor"), 2: enum("BlendFactor"), 3: enum("BlendFactor")}),
|
|
"glBlitFramebuffer": LogSpec({8: enum("BufferMask"), 9: enum("TextureFilter")}),
|
|
"glBufferData": LogSpec({0: enum("BufferTarget"), 3: enum("Usage")}),
|
|
"glBufferSubData": LogSpec({0: enum("BufferTarget")}),
|
|
"glCheckFramebufferStatus": LogSpec({0: enum("FramebufferTarget")}, returnPrint = enum("FramebufferStatus")),
|
|
"glClear": LogSpec({0: enum("BufferMask")}),
|
|
"glClearBufferfv": LogSpec({0: enum("Buffer")}),
|
|
"glClearBufferfi": LogSpec({0: enum("Buffer")}),
|
|
"glClearBufferiv": LogSpec({0: enum("Buffer")}),
|
|
"glClearBufferuiv": LogSpec({0: enum("Buffer")}),
|
|
"glCompressedTexImage2D": LogSpec({0: enum("TextureTarget"), 2: enum("CompressedTextureFormat")}),
|
|
"glCompressedTexSubImage2D": LogSpec({0: enum("TextureTarget"), 6: enum("CompressedTextureFormat")}),
|
|
"glCompressedTexImage3D": LogSpec({0: enum("TextureTarget"), 2: enum("CompressedTextureFormat")}),
|
|
"glCompressedTexSubImage3D": LogSpec({0: enum("TextureTarget"), 8: enum("CompressedTextureFormat")}),
|
|
"glCopyTexImage1D": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat")}),
|
|
"glCopyTexImage2D": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat")}),
|
|
"glCreateShader": LogSpec({0: enum("ShaderType")}),
|
|
"glCullFace": LogSpec({0: enum("Face")}),
|
|
"glDeleteBuffers": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteFramebuffers": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteQueries": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteRenderbuffers": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteBuffers": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteTextures": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteVertexArrays": LogSpec({1: pointer(size = "n")}),
|
|
"glDeleteProgramPipelines": LogSpec({1: pointer(size = "n")}),
|
|
"glDepthFunc": LogSpec({0: enum("CompareFunc")}),
|
|
"glDisable": LogSpec({0: enum("EnableCap")}),
|
|
"glDisablei": LogSpec({0: enum("IndexedEnableCap")}),
|
|
"glDrawArrays": LogSpec({0: enum("PrimitiveType")}),
|
|
"glDrawArraysInstanced": LogSpec({0: enum("PrimitiveType")}),
|
|
"glDrawBuffers": LogSpec({1: enumPointer("DrawReadBuffer", size = "n")}),
|
|
"glDrawElements": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glDrawElementsInstanced": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glDrawRangeElements": LogSpec({0: enum("PrimitiveType"), 4: enum("Type")}),
|
|
"glDrawArraysIndirect": LogSpec({0: enum("PrimitiveType")}),
|
|
"glDrawElementsIndirect": LogSpec({0: enum("PrimitiveType"), 1: enum("Type")}),
|
|
"glDrawElementsBaseVertex": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glDrawElementsInstancedBaseVertex": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glDrawRangeElementsBaseVertex": LogSpec({0: enum("PrimitiveType"), 4: enum("Type")}),
|
|
"glMultiDrawArrays": LogSpec({0: enum("PrimitiveType")}),
|
|
"glMultiDrawElements": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glMultiDrawElementsBaseVertex": LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
|
|
"glEnable": LogSpec({0: enum("EnableCap")}),
|
|
"glEnablei": LogSpec({0: enum("IndexedEnableCap")}),
|
|
"glEndQuery": LogSpec({0: enum("QueryTarget")}),
|
|
"glFramebufferRenderbuffer": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment"), 2: enum("FramebufferTarget")}),
|
|
"glFramebufferTexture2D": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment"), 2: enum("TextureTarget")}),
|
|
"glFramebufferTextureLayer": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment")}),
|
|
"glFramebufferTexture": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment")}),
|
|
"glFramebufferParameteri": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferParameter")}),
|
|
"glFrontFace": LogSpec({0: enum("Winding")}),
|
|
"glGenBuffers": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenerateMipmap": LogSpec({0: enum("TextureTarget")}),
|
|
"glGenFramebuffers": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenQueries": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenRenderbuffers": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenTextures": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenTransformFeedbacks": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenVertexArrays": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
"glGenProgramPipelines": LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
|
|
# "glGetActiveAttrib":
|
|
"glGetActiveUniform": LogSpec({}, argOutPrints = {3: pointer(size = "1"), 4: pointer(size = "1"), 5: enumPointer("ShaderVarType", size = "1"), 6: stringVal}),
|
|
"glGetActiveUniformsiv": LogSpec({2: pointer(size = "uniformCount"), 3: enum("UniformParam")}, argOutPrints = {4: pointer(size = "uniformCount")}),
|
|
# "glGetAttachedShaders":
|
|
"glGetBooleanv":
|
|
LogSpec(
|
|
{
|
|
0: enum("GettableState"),
|
|
1: voidPointer # second argument has type of GLboolean* (aka. char*). Prevent
|
|
# wrapper from attempting to print the argument as a C string.
|
|
},
|
|
argOutPrints = {1: booleanPointer(size = "getBasicQueryNumArgsOut(pname)")}),
|
|
"glGetBufferParameteriv": LogSpec({0: enum("BufferTarget"), 1: enum("BufferQuery")}),
|
|
"glGetBufferParameteri64v": LogSpec({0: enum("BufferTarget"), 1: enum("BufferQuery")}),
|
|
"glGetError": LogSpec({}, returnPrint = enum("Error")),
|
|
"glGetFloatv": LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
|
|
"glGetFramebufferAttachmentParameteriv":
|
|
LogSpec(
|
|
{
|
|
0: enum("FramebufferTarget"),
|
|
1: enum("FramebufferAttachment"),
|
|
2: enum("FramebufferAttachmentParameter")
|
|
},
|
|
argOutPrints = {3: lambda name: "getFramebufferAttachmentParameterValueStr(pname, %s)" % name}),
|
|
"glGetFramebufferParameteriv": LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferParameter")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetIntegerv": LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
|
|
"glGetInteger64v": LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
|
|
"glGetIntegeri_v": LogSpec({0: enum("GettableIndexedState")}, argOutPrints = {2:pointer(size = "getIndexedQueryNumArgsOut(target)")}),
|
|
"glGetInteger64i_v": LogSpec({0: enum("GettableIndexedState")}, argOutPrints = {2: pointer(size = "getIndexedQueryNumArgsOut(target)")}),
|
|
"glGetBooleani_v":
|
|
LogSpec(
|
|
{
|
|
0: enum("GettableIndexedState"),
|
|
2: voidPointer # last argument has type of GLboolean* (aka. char*). Prevent
|
|
# wrapper from attempting to print the argument as a C string.
|
|
},
|
|
argOutPrints = {2: booleanPointer(size = "getIndexedQueryNumArgsOut(target)")}),
|
|
"glGetInternalformativ": LogSpec({0: enum("InternalFormatTarget"), 1: enum("UncompressedTextureFormat"), 2: enum("InternalFormatParameter")}, argOutPrints = {4: pointer(size = "bufSize")}),
|
|
"glGetMultisamplefv": LogSpec({0: enum("MultisampleParameter")}, argOutPrints = {2: pointer(size = "2")}),
|
|
"glGetPointerv": LogSpec({0: enum("PointerState")}, argOutPrints = {1: pointer(size = "1")}),
|
|
"glGetProgramiv": LogSpec({1: enum("ProgramParam")}, argOutPrints = {2: pointer(size = "getProgramQueryNumArgsOut(pname)")}),
|
|
"glGetProgramInfoLog": LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetProgramPipelineiv": LogSpec({1: enum("PipelineParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetProgramPipelineInfoLog": LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetQueryiv": LogSpec({0: enum("QueryTarget"), 1: enum("QueryParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetQueryObjectiv": LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetQueryObjectuiv": LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetQueryObjecti64v": LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetQueryObjectui64v": LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetRenderbufferParameteriv": LogSpec({0: enum("FramebufferTarget"), 1: enum("RenderbufferParameter")}),
|
|
"glGetSamplerParameterfv": LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetSamplerParameteriv": LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetSamplerParameterIiv": LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetSamplerParameterIuiv": LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetShaderiv": LogSpec({1: enum("ShaderParam")}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetShaderInfoLog": LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
|
|
"glGetShaderPrecisionFormat": LogSpec({0: enum("ShaderType"), 1: enum("PrecisionFormatType")}),
|
|
# "glGetShaderSource":
|
|
"glGetString": LogSpec({0: enum("GettableString")}, returnPrint=stringVal),
|
|
"glGetStringi": LogSpec({0: enum("GettableString")}, returnPrint=stringVal),
|
|
"glGetTexParameterfv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetTexParameteriv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetTexParameterIiv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetTexParameterIuiv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
|
|
"glGetTexLevelParameterfv": LogSpec({0: enum("TextureTarget"), 2: enum("TextureLevelParameter")}, argOutPrints = {3: pointer(size = "1")}),
|
|
"glGetTexLevelParameteriv": LogSpec({0: enum("TextureTarget"), 2: enum("TextureLevelParameter")}, argOutPrints = {3: pointer(size = "1")}),
|
|
# "glGetUniformfv":
|
|
# "glGetUniformiv":
|
|
"glGetUniformIndices": LogSpec({2: pointer(size = "uniformCount")}, argOutPrints = {3: pointer(size = "uniformCount")}),
|
|
"glGetVertexAttribfv": LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
|
|
"glGetVertexAttribiv": LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
|
|
"glGetVertexAttribIiv": LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
|
|
"glGetVertexAttribIuiv": LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
|
|
# "glGetVertexAttribPointerv":
|
|
"glHint": LogSpec({0: enum("Hint"), 1: enum("HintMode")}),
|
|
"glIsEnabled": LogSpec({0: enum("EnableCap")}),
|
|
"glIsEnabledi": LogSpec({0: enum("IndexedEnableCap")}),
|
|
"glPixelStorei": LogSpec({0: enum("PixelStoreParameter")}),
|
|
"glReadBuffer": LogSpec({0: enum("DrawReadBuffer")}),
|
|
"glReadPixels": LogSpec({4: enum("UncompressedTextureFormat"), 5: enum("Type")}),
|
|
"glRenderbufferStorage": LogSpec({0: enum("FramebufferTarget"), 1: enum("UncompressedTextureFormat")}),
|
|
"glRenderbufferStorageMultisample": LogSpec({0: enum("FramebufferTarget"), 2: enum("UncompressedTextureFormat")}),
|
|
"glStencilFunc": LogSpec({0: enum("CompareFunc")}),
|
|
"glStencilFuncSeparate": LogSpec({0: enum("Face"), 1: enum("CompareFunc")}),
|
|
"glStencilMaskSeparate": LogSpec({0: enum("Face")}),
|
|
"glStencilOp": LogSpec({0: enum("StencilOp"), 1: enum("StencilOp"), 2: enum("StencilOp")}),
|
|
"glStencilOpSeparate": LogSpec({0: enum("Face"), 1: enum("StencilOp"), 2: enum("StencilOp"), 3: enum("StencilOp")}),
|
|
"glTexImage1D": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 5: enum("UncompressedTextureFormat"), 6: enum("Type")}),
|
|
"glTexImage2D": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 6: enum("UncompressedTextureFormat"), 7: enum("Type")}),
|
|
"glTexImage2DMultisample": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 5: enum("Boolean")}),
|
|
"glTexImage3D": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 7: enum("UncompressedTextureFormat"), 8: enum("Type")}),
|
|
"glTexStorage2D": LogSpec({0: enum("TextureTarget"), 2: enum("TextureFormat")}),
|
|
"glTexStorage3D": LogSpec({0: enum("TextureTarget"), 2: enum("TextureFormat")}),
|
|
"glTexStorage2DMultisample": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 5: enum("Boolean")}),
|
|
"glTexStorage3DMultisample": LogSpec({0: enum("TextureTarget"), 2: enum("UncompressedTextureFormat"), 6: enum("Boolean")}),
|
|
# \todo [2012-03-08 pyry] Pointer values..
|
|
"glTexParameterf": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}),
|
|
"glTexParameteri": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: lambda name: "getTextureParameterValueStr(pname, %s)" % name}),
|
|
"glTexParameterfv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glTexParameteriv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glTexParameterIiv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glTexParameterIuiv": LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glSamplerParameterf": LogSpec({1: enum("TextureParameter")}),
|
|
"glSamplerParameteri": LogSpec({1: enum("TextureParameter"), 2: lambda name: "getTextureParameterValueStr(pname, %s)" % name}),
|
|
"glSamplerParameterfv": LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glSamplerParameteriv": LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glSamplerParameterIiv": LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glSamplerParameterIuiv": LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
|
|
"glTexSubImage1D": LogSpec({0: enum("TextureTarget"), 4: enum("UncompressedTextureFormat"), 5: enum("Type")}),
|
|
"glTexSubImage2D": LogSpec({0: enum("TextureTarget"), 6: enum("UncompressedTextureFormat"), 7: enum("Type")}),
|
|
"glTexSubImage3D": LogSpec({0: enum("TextureTarget"), 8: enum("UncompressedTextureFormat"), 9: enum("Type")}),
|
|
"glUniform1fv": LogSpec({2: pointer(size = "(count * 1)")}),
|
|
"glUniform1iv": LogSpec({2: pointer(size = "(count * 1)")}),
|
|
"glUniform1uiv": LogSpec({2: pointer(size = "(count * 1)")}),
|
|
"glUniform2fv": LogSpec({2: pointer(size = "(count * 2)")}),
|
|
"glUniform2iv": LogSpec({2: pointer(size = "(count * 2)")}),
|
|
"glUniform2uiv": LogSpec({2: pointer(size = "(count * 2)")}),
|
|
"glUniform3fv": LogSpec({2: pointer(size = "(count * 3)")}),
|
|
"glUniform3iv": LogSpec({2: pointer(size = "(count * 3)")}),
|
|
"glUniform3uiv": LogSpec({2: pointer(size = "(count * 3)")}),
|
|
"glUniform4fv": LogSpec({2: pointer(size = "(count * 4)")}),
|
|
"glUniform4iv": LogSpec({2: pointer(size = "(count * 4)")}),
|
|
"glUniform4uiv": LogSpec({2: pointer(size = "(count * 4)")}),
|
|
"glUniformMatrix2fv": LogSpec({3: pointer(size = "(count * 2*2)")}),
|
|
"glUniformMatrix3fv": LogSpec({3: pointer(size = "(count * 3*3)")}),
|
|
"glUniformMatrix4fv": LogSpec({3: pointer(size = "(count * 4*4)")}),
|
|
"glUniformMatrix2x3fv": LogSpec({3: pointer(size = "(count * 2*3)")}),
|
|
"glUniformMatrix2x4fv": LogSpec({3: pointer(size = "(count * 2*4)")}),
|
|
"glUniformMatrix3x2fv": LogSpec({3: pointer(size = "(count * 3*2)")}),
|
|
"glUniformMatrix3x4fv": LogSpec({3: pointer(size = "(count * 3*4)")}),
|
|
"glUniformMatrix4x2fv": LogSpec({3: pointer(size = "(count * 4*2)")}),
|
|
"glUniformMatrix4x3fv": LogSpec({3: pointer(size = "(count * 4*3)")}),
|
|
"glUseProgramStages": LogSpec({1: enum("ShaderTypeMask")}),
|
|
"glPatchParameteri": LogSpec({0: enum("PatchParam")}),
|
|
"glProgramParameteri": LogSpec({1: enum("ProgramParam")}),
|
|
"glProgramUniform1fv": LogSpec({3: pointer(size = "(count * 1)")}),
|
|
"glProgramUniform1iv": LogSpec({3: pointer(size = "(count * 1)")}),
|
|
"glProgramUniform1uiv": LogSpec({3: pointer(size = "(count * 1)")}),
|
|
"glProgramUniform2fv": LogSpec({3: pointer(size = "(count * 2)")}),
|
|
"glProgramUniform2iv": LogSpec({3: pointer(size = "(count * 2)")}),
|
|
"glProgramUniform2uiv": LogSpec({3: pointer(size = "(count * 2)")}),
|
|
"glProgramUniform3fv": LogSpec({3: pointer(size = "(count * 3)")}),
|
|
"glProgramUniform3iv": LogSpec({3: pointer(size = "(count * 3)")}),
|
|
"glProgramUniform3uiv": LogSpec({3: pointer(size = "(count * 3)")}),
|
|
"glProgramUniform4fv": LogSpec({3: pointer(size = "(count * 4)")}),
|
|
"glProgramUniform4iv": LogSpec({3: pointer(size = "(count * 4)")}),
|
|
"glProgramUniform4uiv": LogSpec({3: pointer(size = "(count * 4)")}),
|
|
"glProgramUniformMatrix2fv": LogSpec({4: pointer(size = "(count * 2*2)")}),
|
|
"glProgramUniformMatrix3fv": LogSpec({4: pointer(size = "(count * 3*3)")}),
|
|
"glProgramUniformMatrix4fv": LogSpec({4: pointer(size = "(count * 4*4)")}),
|
|
"glProgramUniformMatrix2x3fv": LogSpec({4: pointer(size = "(count * 2*3)")}),
|
|
"glProgramUniformMatrix2x4fv": LogSpec({4: pointer(size = "(count * 2*4)")}),
|
|
"glProgramUniformMatrix3x2fv": LogSpec({4: pointer(size = "(count * 3*2)")}),
|
|
"glProgramUniformMatrix3x4fv": LogSpec({4: pointer(size = "(count * 3*4)")}),
|
|
"glProgramUniformMatrix4x3fv": LogSpec({4: pointer(size = "(count * 4*3)")}),
|
|
"glProgramUniformMatrix4x2fv": LogSpec({4: pointer(size = "(count * 4*2)")}),
|
|
"glProvokingVertex": LogSpec({0: enum("ProvokingVertex")}),
|
|
"glVertexAttrib1fv": LogSpec({1: pointer(size = "1")}),
|
|
"glVertexAttrib2fv": LogSpec({1: pointer(size = "2")}),
|
|
"glVertexAttrib3fv": LogSpec({1: pointer(size = "3")}),
|
|
"glVertexAttrib4fv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib1sv": LogSpec({1: pointer(size = "1")}),
|
|
"glVertexAttrib2sv": LogSpec({1: pointer(size = "2")}),
|
|
"glVertexAttrib3sv": LogSpec({1: pointer(size = "3")}),
|
|
"glVertexAttrib4sv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib1dv": LogSpec({1: pointer(size = "1")}),
|
|
"glVertexAttrib2dv": LogSpec({1: pointer(size = "2")}),
|
|
"glVertexAttrib3dv": LogSpec({1: pointer(size = "3")}),
|
|
"glVertexAttrib4dv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4bv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4iv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4ubv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4usv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4uiv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Nbv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Nsv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Niv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Nubv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Nusv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttrib4Nuiv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI1iv": LogSpec({1: pointer(size = "1")}),
|
|
"glVertexAttribI2iv": LogSpec({1: pointer(size = "2")}),
|
|
"glVertexAttribI3iv": LogSpec({1: pointer(size = "3")}),
|
|
"glVertexAttribI4iv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI1uiv": LogSpec({1: pointer(size = "1")}),
|
|
"glVertexAttribI2uiv": LogSpec({1: pointer(size = "2")}),
|
|
"glVertexAttribI3uiv": LogSpec({1: pointer(size = "3")}),
|
|
"glVertexAttribI4uiv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI4bv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI4sv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI4ubv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribI4usv": LogSpec({1: pointer(size = "4")}),
|
|
"glVertexAttribPointer": LogSpec({2: enum("Type")}),
|
|
"glVertexAttribIPointer": LogSpec({2: enum("Type")}),
|
|
"glVertexAttribFormat": LogSpec({2: enum("Type")}),
|
|
"glVertexAttribIFormat": LogSpec({2: enum("Type")}),
|
|
"glInvalidateFramebuffer": LogSpec({0: enum("FramebufferTarget"), 2: enumPointer("InvalidateAttachment", "numAttachments")}),
|
|
"glInvalidateSubFramebuffer": LogSpec({0: enum("FramebufferTarget"), 2: enumPointer("InvalidateAttachment", "numAttachments")}),
|
|
"glMapBufferRange": LogSpec({0: enum("BufferTarget"), 3: enum("BufferMapFlags")}),
|
|
"glUnmapBuffer": LogSpec({0: enum("BufferTarget")}),
|
|
"glFlushMappedBufferRange": LogSpec({0: enum("BufferTarget")}),
|
|
"glMemoryBarrier": LogSpec({0: enum("MemoryBarrierFlags")}),
|
|
"glBindImageTexture": LogSpec({5: enum("ImageAccess"), 6: enum("UncompressedTextureFormat")}),
|
|
"glGetProgramResourceIndex": LogSpec({1: enum("ProgramInterface")}),
|
|
"glGetProgramResourceiv":
|
|
LogSpec(
|
|
{
|
|
1: enum("ProgramInterface"),
|
|
4: enumPointer("ProgramResourceProperty", "propCount")
|
|
},
|
|
argOutPrints =
|
|
{
|
|
6: pointer(size = "1"),
|
|
7: pointer(size = "((length == DE_NULL) ? (bufSize) : ((bufSize < *length) ? (bufSize) : (*length)))")
|
|
}),
|
|
"glDebugMessageInsert": LogSpec({0: enum("DebugMessageSource"), 1: enum("DebugMessageType"), 3: enum("DebugMessageSeverity")}),
|
|
"glDebugMessageControl": LogSpec({0: enum("DebugMessageSource"), 1: enum("DebugMessageType"), 2: enum("DebugMessageSeverity"), 4: pointer(size = "(count)")}),
|
|
"glDebugMessageCallback": LogSpec({0: fnPointer, 1: voidPointer}),
|
|
"glPushDebugGroup": LogSpec({0: enum("DebugMessageSource")}),
|
|
"glTexBuffer": LogSpec({0: enum("BufferTarget"), 1: enum("UncompressedTextureFormat")}),
|
|
"glTexBufferRange": LogSpec({0: enum("BufferTarget"), 1: enum("UncompressedTextureFormat")}),
|
|
}
|
|
|
|
def glwPrefix (string):
|
|
return re.sub(r'\bGL', 'glw::GL', string)
|
|
|
|
def prefixedParams (command):
|
|
if len(command.params) > 0:
|
|
return ", ".join(glwPrefix(param.declaration) for param in command.params)
|
|
else:
|
|
return "void"
|
|
|
|
def commandLogWrapperMemberDecl (command):
|
|
return "%s\t%s\t(%s);" % (glwPrefix(command.type), command.name, prefixedParams(command))
|
|
|
|
def getVarDefaultPrint (type, varName):
|
|
if re.match(r'^const +GLchar *\*$', type):
|
|
return "getStringStr(%s)" % varName
|
|
elif re.match(r'(GLubyte|GLbyte|GLenum|GLushort|GLbitfield|\*)$', type):
|
|
return "toHex(%s)" % varName
|
|
elif type == 'GLboolean':
|
|
return "getBooleanStr(%s)" % varName
|
|
elif re.match(r'^(const +)?.+ *\*$', type) and not re.match(r'^(const +)?void *\*$', type):
|
|
# non-void pointer type, always cast to void* to avoid unforeseen consequences of
|
|
# implicit assumptions (such as char* should be printed as a zero-terminated string)
|
|
# \note use static_cast to break the build if function pointer is supplied
|
|
return "toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(%s)))" % varName
|
|
else:
|
|
return varName
|
|
|
|
def commandLogWrapperMemberDef (command):
|
|
src = ""
|
|
try:
|
|
logSpec = CALL_LOG_SPECS[command.name]
|
|
except KeyError:
|
|
logSpec = None
|
|
|
|
src += "\n"
|
|
src += "%s CallLogWrapper::%s (%s)\n{\n" % (glwPrefix(command.type), command.name, prefixedParams(command))
|
|
|
|
# Append paramemetrs
|
|
callPrintItems = ["\"%s(\"" % command.name]
|
|
for paramNdx, param in enumerate(command.params):
|
|
if paramNdx > 0:
|
|
callPrintItems.append("\", \"")
|
|
|
|
if logSpec and paramNdx in logSpec.argInPrints:
|
|
callPrintItems.append(logSpec.argInPrints[paramNdx](param.name))
|
|
else:
|
|
callPrintItems.append(getVarDefaultPrint(param.type, param.name))
|
|
|
|
callPrintItems += ["\");\"", "TestLog::EndMessage"]
|
|
|
|
src += "\tif (m_enableLog)\n"
|
|
src += "\t\tm_log << TestLog::Message << %s;\n" % " << ".join(callPrintItems)
|
|
|
|
callStr = "m_gl.%s(%s)" % (getFunctionMemberName(command.name), ", ".join([p.name for p in command.params]))
|
|
|
|
isVoid = command.type == 'void'
|
|
if isVoid:
|
|
src += "\t%s;\n" % callStr
|
|
else:
|
|
src += "\t%s returnValue = %s;\n" % (glwPrefix(command.type), callStr)
|
|
|
|
if logSpec and len(logSpec.argOutPrints) > 0:
|
|
# Print values returned in pointers
|
|
src += "\tif (m_enableLog)\n"
|
|
printouts = ""
|
|
numPrintouts = 0
|
|
|
|
for paramNdx, param in enumerate(command.params):
|
|
if paramNdx in logSpec.argOutPrints:
|
|
printouts += "\t\tm_log << TestLog::Message << \"// %s = \" << %s << TestLog::EndMessage;\n" % (param.name, logSpec.argOutPrints[paramNdx](param.name))
|
|
numPrintouts += 1
|
|
|
|
# If print handlers do not match the actual command, that is very likely an error. Check
|
|
# print handlers is a subset of all arguments.
|
|
if numPrintouts == 0 or len(set(logSpec.argOutPrints.keys()) - set(range(len(command.params)))) > 0:
|
|
raise Exception("Invalid print handlers when processing command %s" % command.name)
|
|
|
|
if numPrintouts != 1:
|
|
src += "\t{\n"
|
|
src += printouts
|
|
if numPrintouts != 1:
|
|
src += "\t}\n"
|
|
|
|
if not isVoid:
|
|
# Print return value
|
|
returnPrint = getVarDefaultPrint(command.type, "returnValue")
|
|
if logSpec and logSpec.returnPrint:
|
|
returnPrint = logSpec.returnPrint("returnValue")
|
|
|
|
src += "\tif (m_enableLog)\n"
|
|
src += "\t\tm_log << TestLog::Message << \"// \" << %s << \" returned\" << TestLog::EndMessage;\n" % returnPrint
|
|
src += "\treturn returnValue;\n"
|
|
|
|
src += "}"
|
|
return src
|
|
|
|
def genCallLogWrapper (iface):
|
|
genCommandList(iface, commandLogWrapperMemberDecl, OPENGL_DIR, "gluCallLogWrapperApi.inl", True)
|
|
genCommandList(iface, commandLogWrapperMemberDef, OPENGL_DIR, "gluCallLogWrapper.inl", False)
|
|
|
|
if __name__ == "__main__":
|
|
genCallLogWrapper(getHybridInterface())
|