| # -*- 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()) |
