BeeEngine/glslang-zig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

CInterface: reformatted according to .clang-format rules

Browse source
This commit is contained in:
Sergey Kosarevsky 2019-12-25 00:00:23 +03:00
parent 8cded6ccb9
commit ca593a98f9
3 changed files with 372 additions and 458 deletions
Download patch file Download diff file Expand all files Collapse all files

632
glslang/CInterface/glslang_c_interface.cpp
View file

@ -28,27 +28,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "glslang_c_interface.h" #include "glslang_c_interface.h"
#include "glslang/Include/ShHandle.h" #include "SPIRV/GlslangToSpv.h"
#include "StandAlone/DirStackFileIncluder.h"
#include "StandAlone/ResourceLimits.h"
#include "SPIRV/Logger.h" #include "SPIRV/Logger.h"
#include "SPIRV/SpvTools.h" #include "SPIRV/SpvTools.h"
#include "SPIRV/GlslangToSpv.h" #include "StandAlone/DirStackFileIncluder.h"
#include "StandAlone/ResourceLimits.h"
#include "glslang/Include/ShHandle.h"
#include "glslang/Include/ResourceLimits.h" #include "glslang/Include/ResourceLimits.h"
#include "glslang/MachineIndependent/Versions.h" #include "glslang/MachineIndependent/Versions.h"
typedef struct glslang_shader_s typedef struct glslang_shader_s {
{ glslang::TShader* shader;
glslang::TShader* shader; std::string preprocessedGLSL;
std::string preprocessedGLSL;
} glslang_shader_t; } glslang_shader_t;
typedef struct glslang_program_s typedef struct glslang_program_s {
{ glslang::TProgram* program;
glslang::TProgram* program; std::vector<unsigned int> spirv;
std::vector<unsigned int> spirv; std::string loggerMessages;
std::string loggerMessages;
} glslang_program_t; } glslang_program_t;
/* Wrapper/Adapter for C glsl_include_callbacks_t functions /* Wrapper/Adapter for C glsl_include_callbacks_t functions
@ -64,439 +62,373 @@ typedef struct glslang_program_s
to allow its lifetime management by another C callback to allow its lifetime management by another C callback
(CallbackIncluder::callbacks::free_include_result) (CallbackIncluder::callbacks::free_include_result)
*/ */
class CallbackIncluder: public glslang::TShader::Includer class CallbackIncluder : public glslang::TShader::Includer {
{
public: public:
/* Wrapper of IncludeResult which stores a glsl_include_result object internally */ /* Wrapper of IncludeResult which stores a glsl_include_result object internally */
class CallbackIncludeResult: public glslang::TShader::Includer::IncludeResult class CallbackIncludeResult : public glslang::TShader::Includer::IncludeResult {
{ public:
public: CallbackIncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength,
CallbackIncludeResult(const std::string& headerName, void* userData, glsl_include_result_t* includeResult)
const char* const headerData, : glslang::TShader::Includer::IncludeResult(headerName, headerData, headerLength, userData),
const size_t headerLength, includeResult(includeResult)
void* userData, {
glsl_include_result_t* includeResult): }
glslang::TShader::Includer::IncludeResult(
headerName, headerData, headerLength, userData),
includeResult(includeResult)
{}
virtual ~CallbackIncludeResult() {} virtual ~CallbackIncludeResult() {}
protected:
friend class CallbackIncluder; protected:
friend class CallbackIncluder;
glsl_include_result_t* includeResult;
};
glsl_include_result_t* includeResult;
};
public: public:
CallbackIncluder(glsl_include_callbacks_t _callbacks, void *_context): CallbackIncluder(glsl_include_callbacks_t _callbacks, void* _context) : callbacks(_callbacks), context(_context) {}
callbacks(_callbacks),
context(_context)
{}
virtual ~CallbackIncluder() {} virtual ~CallbackIncluder() {}
virtual IncludeResult* includeSystem(const char* headerName, virtual IncludeResult* includeSystem(const char* headerName, const char* includerName,
const char* includerName, size_t inclusionDepth) override
size_t inclusionDepth) override {
{ if (this->callbacks.include_system) {
if (this->callbacks.include_system) glsl_include_result_t* result =
{ this->callbacks.include_system(this->context, headerName, includerName, inclusionDepth);
glsl_include_result_t* result =
this->callbacks.include_system(
this->context,
headerName,
includerName,
inclusionDepth);
return new CallbackIncludeResult( return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
std::string(headerName), nullptr, result);
result->header_data, }
result->header_length,
nullptr,
result
);
}
return glslang::TShader::Includer::includeSystem( return glslang::TShader::Includer::includeSystem(headerName, includerName, inclusionDepth);
headerName, includerName, inclusionDepth); }
}
virtual IncludeResult* includeLocal(const char* headerName, virtual IncludeResult* includeLocal(const char* headerName, const char* includerName,
const char* includerName, size_t inclusionDepth) override
size_t inclusionDepth) override {
{ if (this->callbacks.include_local) {
if (this->callbacks.include_local) glsl_include_result_t* result =
{ this->callbacks.include_local(this->context, headerName, includerName, inclusionDepth);
glsl_include_result_t* result =
this->callbacks.include_local(
this->context,
headerName,
includerName,
inclusionDepth);
return new CallbackIncludeResult( return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
std::string(headerName), nullptr, result);
result->header_data, }
result->header_length,
nullptr,
result
);
}
return glslang::TShader::Includer::includeLocal( return glslang::TShader::Includer::includeLocal(headerName, includerName, inclusionDepth);
headerName, includerName, inclusionDepth); }
}
/* This function only calls free_include_result callback /* This function only calls free_include_result callback
when the IncludeResult instance is allocated by a C function */ when the IncludeResult instance is allocated by a C function */
virtual void releaseInclude(IncludeResult* result) override virtual void releaseInclude(IncludeResult* result) override
{ {
if (result == nullptr) if (result == nullptr)
return; return;
if (this->callbacks.free_include_result && (result->userData == nullptr)) if (this->callbacks.free_include_result && (result->userData == nullptr)) {
{ CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult*>(result);
CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult *>(result); /* use internal free() function */
/* use internal free() function */ this->callbacks.free_include_result(this->context, innerResult->includeResult);
this->callbacks.free_include_result(this->context, innerResult->includeResult); /* ignore internal fields of TShader::Includer::IncludeResult */
/* ignore internal fields of TShader::Includer::IncludeResult */ delete result;
delete result; return;
return; }
}
delete[] static_cast<char*>(result->userData);
delete result;
}
delete [] static_cast<char*>(result->userData);
delete result;
}
private: private:
CallbackIncluder() {} CallbackIncluder() {}
/* C callback pointers */ /* C callback pointers */
glsl_include_callbacks_t callbacks; glsl_include_callbacks_t callbacks;
/* User-defined context */ /* User-defined context */
void *context; void* context;
}; };
int glslang_initialize_process() int glslang_initialize_process() { return static_cast<int>(glslang::InitializeProcess()); }
{
return static_cast<int>(glslang::InitializeProcess());
}
void glslang_finalize_process() void glslang_finalize_process() { glslang::FinalizeProcess(); }
{
glslang::FinalizeProcess();
}
static EShLanguage c_shader_stage(glslang_stage_t stage) static EShLanguage c_shader_stage(glslang_stage_t stage)
{ {
switch(stage) switch (stage) {
{ case SH_STAGE_VERTEX:
case SH_STAGE_VERTEX: return EShLangVertex;
return EShLangVertex; case SH_STAGE_TESSCONTROL:
case SH_STAGE_TESSCONTROL: return EShLangTessControl;
return EShLangTessControl; case SH_STAGE_TESSEVALUATION:
case SH_STAGE_TESSEVALUATION: return EShLangTessEvaluation;
return EShLangTessEvaluation; case SH_STAGE_GEOMETRY:
case SH_STAGE_GEOMETRY: return EShLangGeometry;
return EShLangGeometry; case SH_STAGE_FRAGMENT:
case SH_STAGE_FRAGMENT: return EShLangFragment;
return EShLangFragment; case SH_STAGE_COMPUTE:
case SH_STAGE_COMPUTE: return EShLangCompute;
return EShLangCompute; case SH_STAGE_RAYGEN_NV:
case SH_STAGE_RAYGEN_NV: return EShLangRayGenNV;
return EShLangRayGenNV; case SH_STAGE_INTERSECT_NV:
case SH_STAGE_INTERSECT_NV: return EShLangIntersectNV;
return EShLangIntersectNV; case SH_STAGE_ANYHIT_NV:
case SH_STAGE_ANYHIT_NV: return EShLangAnyHitNV;
return EShLangAnyHitNV; case SH_STAGE_CLOSESTHIT_NV:
case SH_STAGE_CLOSESTHIT_NV: return EShLangClosestHitNV;
return EShLangClosestHitNV; case SH_STAGE_MISS_NV:
case SH_STAGE_MISS_NV: return EShLangMissNV;
return EShLangMissNV; case SH_STAGE_CALLABLE_NV:
case SH_STAGE_CALLABLE_NV: return EShLangCallableNV;
return EShLangCallableNV; case SH_STAGE_TASK_NV:
case SH_STAGE_TASK_NV: return EShLangTaskNV;
return EShLangTaskNV; case SH_STAGE_MESH_NV:
case SH_STAGE_MESH_NV: return EShLangMeshNV;
return EShLangMeshNV; default:
default: break;
break; }
} return EShLangCount;
return EShLangCount;
} }
static EShMessages c_shader_messages(glslang_messages_t messages) static EShMessages c_shader_messages(glslang_messages_t messages)
{ {
switch(messages) switch (messages) {
{ case SH_MSG_RELAXED_ERRORS:
case SH_MSG_RELAXED_ERRORS: return EShMsgRelaxedErrors;
return EShMsgRelaxedErrors; case SH_MSG_SUPPRESS_WARNINGS:
case SH_MSG_SUPPRESS_WARNINGS: return EShMsgSuppressWarnings;
return EShMsgSuppressWarnings; case SH_MSG_AST:
case SH_MSG_AST: return EShMsgAST;
return EShMsgAST; case SH_MSG_SPV_RULES:
case SH_MSG_SPV_RULES: return EShMsgSpvRules;
return EShMsgSpvRules; case SH_MSG_VULKAN_RULES:
case SH_MSG_VULKAN_RULES: return EShMsgVulkanRules;
return EShMsgVulkanRules; case SH_MSG_ONLY_PREPROCESSOR:
case SH_MSG_ONLY_PREPROCESSOR: return EShMsgOnlyPreprocessor;
return EShMsgOnlyPreprocessor; case SH_MSG_READ_HLSL:
case SH_MSG_READ_HLSL: return EShMsgReadHlsl;
return EShMsgReadHlsl; case SH_MSG_CASCADING_ERRORS:
case SH_MSG_CASCADING_ERRORS: return EShMsgCascadingErrors;
return EShMsgCascadingErrors; case SH_MSG_KEEP_UNCALLED:
case SH_MSG_KEEP_UNCALLED: return EShMsgKeepUncalled;
return EShMsgKeepUncalled; case SH_MSG_HLSL_OFFSETS:
case SH_MSG_HLSL_OFFSETS: return EShMsgHlslOffsets;
return EShMsgHlslOffsets; case SH_MSG_DEBUG_INFO:
case SH_MSG_DEBUG_INFO: return EShMsgDebugInfo;
return EShMsgDebugInfo; case SH_MSG_HLSL_ENABLE_16BIT_TYPES:
case SH_MSG_HLSL_ENABLE_16BIT_TYPES: return EShMsgHlslEnable16BitTypes;
return EShMsgHlslEnable16BitTypes; case SH_MSG_HLSL_LEGALIZATION:
case SH_MSG_HLSL_LEGALIZATION: return EShMsgHlslLegalization;
return EShMsgHlslLegalization; case SH_MSG_HLSL_DX9_COMPATIBLE:
case SH_MSG_HLSL_DX9_COMPATIBLE: return EShMsgHlslDX9Compatible;
return EShMsgHlslDX9Compatible; case SH_MSG_BUILTIN_SYMBOL_TABLE:
case SH_MSG_BUILTIN_SYMBOL_TABLE: return EShMsgBuiltinSymbolTable;
return EShMsgBuiltinSymbolTable; default:
default: break;
break; }
} return EShMsgDefault;
return EShMsgDefault;
} }
static glslang::EShTargetLanguageVersion c_shader_target_language_version(glslang_target_language_version_t target_language_version) static glslang::EShTargetLanguageVersion
c_shader_target_language_version(glslang_target_language_version_t target_language_version)
{ {
switch(target_language_version) switch (target_language_version) {
{ case SH_TARGET_SPV_1_0:
case SH_TARGET_SPV_1_0: return glslang::EShTargetSpv_1_0;
return glslang::EShTargetSpv_1_0; case SH_TARGET_SPV_1_1:
case SH_TARGET_SPV_1_1: return glslang::EShTargetSpv_1_1;
return glslang::EShTargetSpv_1_1; case SH_TARGET_SPV_1_2:
case SH_TARGET_SPV_1_2: return glslang::EShTargetSpv_1_2;
return glslang::EShTargetSpv_1_2; case SH_TARGET_SPV_1_3:
case SH_TARGET_SPV_1_3: return glslang::EShTargetSpv_1_3;
return glslang::EShTargetSpv_1_3; case SH_TARGET_SPV_1_4:
case SH_TARGET_SPV_1_4: return glslang::EShTargetSpv_1_4;
return glslang::EShTargetSpv_1_4; case SH_TARGET_SPV_1_5:
case SH_TARGET_SPV_1_5: return glslang::EShTargetSpv_1_5;
return glslang::EShTargetSpv_1_5; default:
default: break;
break; }
} return glslang::EShTargetSpv_1_0;
return glslang::EShTargetSpv_1_0;
} }
static glslang::EShClient c_shader_client(glslang_client_t client) static glslang::EShClient c_shader_client(glslang_client_t client)
{ {
switch(client) switch (client) {
{ case SH_CLIENT_VULKAN:
case SH_CLIENT_VULKAN: return glslang::EShClientVulkan;
return glslang::EShClientVulkan; case SH_CLIENT_OPENGL:
case SH_CLIENT_OPENGL: return glslang::EShClientOpenGL;
return glslang::EShClientOpenGL; default:
default: break;
break; }
}
return glslang::EShClientNone; return glslang::EShClientNone;
} }
static glslang::EShTargetClientVersion c_shader_client_version(glslang_target_client_version_t client_version) static glslang::EShTargetClientVersion c_shader_client_version(glslang_target_client_version_t client_version)
{ {
switch(client_version) switch (client_version) {
{ case SH_TARGET_VULKAN_1_1:
case SH_TARGET_VULKAN_1_1: return glslang::EShTargetVulkan_1_1;
return glslang::EShTargetVulkan_1_1; case SH_TARGET_OPENGL_450:
case SH_TARGET_OPENGL_450: return glslang::EShTargetOpenGL_450;
return glslang::EShTargetOpenGL_450; default:
default: break;
break; }
}
return glslang::EShTargetVulkan_1_0; return glslang::EShTargetVulkan_1_0;
} }
static glslang::EShTargetLanguage c_shader_target_language(glslang_target_language_t target_language) static glslang::EShTargetLanguage c_shader_target_language(glslang_target_language_t target_language)
{ {
if (target_language == SH_TARGET_NONE) if (target_language == SH_TARGET_NONE)
return glslang::EShTargetNone; return glslang::EShTargetNone;
return glslang::EShTargetSpv; return glslang::EShTargetSpv;
} }
static glslang::EShSource c_shader_source(glslang_source_t source) static glslang::EShSource c_shader_source(glslang_source_t source)
{ {
switch(source) switch (source) {
{ case SH_SOURCE_GLSL:
case SH_SOURCE_GLSL: return glslang::EShSourceGlsl;
return glslang::EShSourceGlsl; case SH_SOURCE_HLSL:
case SH_SOURCE_HLSL: return glslang::EShSourceHlsl;
return glslang::EShSourceHlsl; default:
default: break;
break; }
}
return glslang::EShSourceNone; return glslang::EShSourceNone;
} }
static EProfile c_shader_profile(glslang_profile_t profile) static EProfile c_shader_profile(glslang_profile_t profile)
{ {
switch(profile) switch (profile) {
{ case SH_BAD_PROFILE:
case SH_BAD_PROFILE: return EBadProfile;
return EBadProfile; case SH_NO_PROFILE:
case SH_NO_PROFILE: return ENoProfile;
return ENoProfile; case SH_CORE_PROFILE:
case SH_CORE_PROFILE: return ECoreProfile;
return ECoreProfile; case SH_COMPATIBILITY_PROFILE:
case SH_COMPATIBILITY_PROFILE: return ECompatibilityProfile;
return ECompatibilityProfile; case SH_ES_PROFILE:
case SH_ES_PROFILE: return EEsProfile;
return EEsProfile; }
}
return EProfile(); return EProfile();
} }
glslang_shader_t *glslang_shader_create(glslang_input_t *input) glslang_shader_t* glslang_shader_create(glslang_input_t* input)
{ {
if ( !input || !input->code ) if (!input || !input->code) {
{ printf("Error creating shader: null input(%p)/input->code\n", input);
printf("Error creating shader: null input(%p)/input->code\n", input);
if (input) if (input)
printf("input->code = %p\n", input->code); printf("input->code = %p\n", input->code);
return nullptr; return nullptr;
} }
glslang_shader_t *shader = new glslang_shader_t(); glslang_shader_t* shader = new glslang_shader_t();
shader->shader = new glslang::TShader( c_shader_stage(input->stage) ); shader->shader = new glslang::TShader(c_shader_stage(input->stage));
shader->shader->setStrings( &input->code, 1 ); shader->shader->setStrings(&input->code, 1);
shader->shader->setEnvInput( c_shader_source(input->language), c_shader_stage(input->stage), c_shader_client(input->client), input->default_version ); shader->shader->setEnvInput(c_shader_source(input->language), c_shader_stage(input->stage),
shader->shader->setEnvClient( c_shader_client(input->client), c_shader_client_version(input->client_version) ); c_shader_client(input->client), input->default_version);
shader->shader->setEnvTarget( c_shader_target_language(input->target_language), c_shader_target_language_version(input->target_language_version) ); shader->shader->setEnvClient(c_shader_client(input->client), c_shader_client_version(input->client_version));
shader->shader->setEnvTarget(c_shader_target_language(input->target_language),
c_shader_target_language_version(input->target_language_version));
return shader; return shader;
} }
const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader) const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader) { return shader->preprocessedGLSL.c_str(); }
int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* i)
{ {
return shader->preprocessedGLSL.c_str(); DirStackFileIncluder Includer;
/* TODO: use custom callbacks if they are available in 'i->callbacks' */
return shader->shader->preprocess(
/* No user-defined resources limit */
&glslang::DefaultTBuiltInResource, i->default_version, c_shader_profile(i->default_profile),
(bool)i->force_default_version_and_profile, (bool)i->forward_compatible, c_shader_messages(i->messages),
&shader->preprocessedGLSL, Includer);
} }
int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* i) int glslang_shader_parse(glslang_shader_t* shader, glslang_input_t* input)
{ {
DirStackFileIncluder Includer; const char* preprocessedCStr = shader->preprocessedGLSL.c_str();
/* TODO: use custom callbacks if they are available in 'i->callbacks' */ shader->shader->setStrings(&preprocessedCStr, 1);
return shader->shader->preprocess(
/* No user-defined resources limit */ return shader->shader->parse(
&glslang::DefaultTBuiltInResource, /* No user-defined resource limits for now */
i->default_version, &glslang::DefaultTBuiltInResource, input->default_version, (bool)input->forward_compatible,
c_shader_profile(i->default_profile), c_shader_messages(input->messages));
(bool)i->force_default_version_and_profile,
(bool)i->forward_compatible,
c_shader_messages(i->messages),
&shader->preprocessedGLSL,
Includer
);
} }
int glslang_shader_parse(glslang_shader_t *shader, glslang_input_t *input) const char* glslang_shader_get_info_log(glslang_shader_t* shader) { return shader->shader->getInfoLog(); }
const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader) { return shader->shader->getInfoDebugLog(); }
void glslang_shader_delete(glslang_shader_t* shader)
{ {
const char* preprocessedCStr = shader->preprocessedGLSL.c_str(); if (!shader)
shader->shader->setStrings( &preprocessedCStr, 1 ); return;
return shader->shader->parse( delete (shader->shader);
/* No user-defined resource limits for now */ delete (shader);
&glslang::DefaultTBuiltInResource,
input->default_version,
(bool)input->forward_compatible,
c_shader_messages(input->messages)
);
} }
const char* glslang_shader_get_info_log(glslang_shader_t *shader) glslang_program_t* glslang_program_create()
{ {
return shader->shader->getInfoLog(); glslang_program_t* p = new glslang_program_t();
p->program = new glslang::TProgram();
return p;
} }
const char* glslang_shader_get_info_debug_log(glslang_shader_t *shader) void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage)
{ {
return shader->shader->getInfoDebugLog(); spv::SpvBuildLogger logger;
glslang::SpvOptions spvOptions;
spvOptions.validate = true;
const glslang::TIntermediate* intermediate = program->program->getIntermediate(c_shader_stage(stage));
glslang::GlslangToSpv(*intermediate, program->spirv, &logger, &spvOptions);
program->loggerMessages = logger.getAllMessages();
} }
void glslang_shader_delete(glslang_shader_t *shader) size_t glslang_program_SPIRV_get_size(glslang_program_t* program) { return program->spirv.size(); }
void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int* out)
{ {
if (!shader) memcpy(out, program->spirv.data(), program->spirv.size() * sizeof(unsigned int));
return;
delete(shader->shader);
delete(shader);
} }
glslang_program_t *glslang_program_create() const char* glslang_program_SPIRV_get_messages(glslang_program_t* program)
{ {
glslang_program_t *p = new glslang_program_t(); return program->loggerMessages.empty() ? nullptr : program->loggerMessages.c_str();
p->program = new glslang::TProgram();
return p;
} }
void glslang_program_SPIRV_generate(glslang_program_t *program, glslang_stage_t stage ) void glslang_program_delete(glslang_program_t* program)
{ {
spv::SpvBuildLogger logger; if (!program)
glslang::SpvOptions spvOptions; return;
spvOptions.validate = true;
const glslang::TIntermediate* intermediate = program->program->getIntermediate( c_shader_stage(stage) ); delete (program->program);
delete (program);
glslang::GlslangToSpv( *intermediate, program->spirv, &logger, &spvOptions );
program->loggerMessages = logger.getAllMessages();
} }
size_t glslang_program_SPIRV_get_size(glslang_program_t *program) void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader)
{ {
return program->spirv.size(); program->program->addShader(shader->shader);
} }
void glslang_program_SPIRV_get(glslang_program_t *program, unsigned int* out) int glslang_program_link(glslang_program_t* program, int messages)
{ {
memcpy( out, program->spirv.data(), program->spirv.size() * sizeof( unsigned int ) ); return (int)program->program->link((EShMessages)messages);
} }
const char* glslang_program_SPIRV_get_messages(glslang_program_t *program) const char* glslang_program_get_info_log(glslang_program_t* program) { return program->program->getInfoLog(); }
const char* glslang_program_get_info_debug_log(glslang_program_t* program)
{ {
return program->loggerMessages.empty() ? nullptr : program->loggerMessages.c_str(); return program->program->getInfoDebugLog();
} }
void glslang_program_delete(glslang_program_t *program)
{
if (!program)
return;
delete(program->program);
delete(program);
}
void glslang_program_add_shader(glslang_program_t *program, glslang_shader_t *shader)
{
program->program->addShader(shader->shader);
}
int glslang_program_link(glslang_program_t *program, int messages)
{
return (int)program->program->link((EShMessages)messages);
}
const char* glslang_program_get_info_log(glslang_program_t *program)
{
return program->program->getInfoLog();
}
const char* glslang_program_get_info_debug_log(glslang_program_t *program)
{
return program->program->getInfoDebugLog();
}

87
glslang/Include/c_shader_types.h
View file

@ -46,24 +46,24 @@ typedef enum {
SH_STAGE_TASK_NV, SH_STAGE_TASK_NV,
SH_STAGE_MESH_NV, SH_STAGE_MESH_NV,
SH_STAGE_COUNT, SH_STAGE_COUNT,
} glslang_stage_t; // would be better as stage, but this is ancient now } glslang_stage_t; // would be better as stage, but this is ancient now
/* EShLanguageMask counterpart */ /* EShLanguageMask counterpart */
typedef enum { typedef enum {
SH_STAGE_VERTEX_MASK = (1 << SH_STAGE_VERTEX), SH_STAGE_VERTEX_MASK = (1 << SH_STAGE_VERTEX),
SH_STAGE_TESSCONTROL_MASK = (1 << SH_STAGE_TESSCONTROL), SH_STAGE_TESSCONTROL_MASK = (1 << SH_STAGE_TESSCONTROL),
SH_STAGE_TESSEVALUATION_MASK = (1 << SH_STAGE_TESSEVALUATION), SH_STAGE_TESSEVALUATION_MASK = (1 << SH_STAGE_TESSEVALUATION),
SH_STAGE_GEOMETRY_MASK = (1 << SH_STAGE_GEOMETRY), SH_STAGE_GEOMETRY_MASK = (1 << SH_STAGE_GEOMETRY),
SH_STAGE_FRAGMENT_MASK = (1 << SH_STAGE_FRAGMENT), SH_STAGE_FRAGMENT_MASK = (1 << SH_STAGE_FRAGMENT),
SH_STAGE_COMPUTE_MASK = (1 << SH_STAGE_COMPUTE), SH_STAGE_COMPUTE_MASK = (1 << SH_STAGE_COMPUTE),
SH_STAGE_RAYGEN_NV_MASK = (1 << SH_STAGE_RAYGEN_NV), SH_STAGE_RAYGEN_NV_MASK = (1 << SH_STAGE_RAYGEN_NV),
SH_STAGE_INTERSECT_NV_MASK = (1 << SH_STAGE_INTERSECT_NV), SH_STAGE_INTERSECT_NV_MASK = (1 << SH_STAGE_INTERSECT_NV),
SH_STAGE_ANYHIT_NV_MASK = (1 << SH_STAGE_ANYHIT_NV), SH_STAGE_ANYHIT_NV_MASK = (1 << SH_STAGE_ANYHIT_NV),
SH_STAGE_CLOSESTHIT_NV_MASK = (1 << SH_STAGE_CLOSESTHIT_NV), SH_STAGE_CLOSESTHIT_NV_MASK = (1 << SH_STAGE_CLOSESTHIT_NV),
SH_STAGE_MISS_NV_MASK = (1 << SH_STAGE_MISS_NV), SH_STAGE_MISS_NV_MASK = (1 << SH_STAGE_MISS_NV),
SH_STAGE_CALLABLE_NV_MASK = (1 << SH_STAGE_CALLABLE_NV), SH_STAGE_CALLABLE_NV_MASK = (1 << SH_STAGE_CALLABLE_NV),
SH_STAGE_TASK_NV_MASK = (1 << SH_STAGE_TASK_NV), SH_STAGE_TASK_NV_MASK = (1 << SH_STAGE_TASK_NV),
SH_STAGE_MESH_NV_MASK = (1 << SH_STAGE_MESH_NV), SH_STAGE_MESH_NV_MASK = (1 << SH_STAGE_MESH_NV),
} glslang_stage_mask_t; } glslang_stage_mask_t;
/* EShSource counterpart */ /* EShSource counterpart */
@ -104,10 +104,7 @@ typedef enum {
} glslang_target_language_version_t; } glslang_target_language_version_t;
/* EShExecutable counterpart */ /* EShExecutable counterpart */
typedef enum { typedef enum { SH_EX_VERTEX_FRAGMENT, SH_EX_FRAGMENT } glslang_executable_t;
SH_EX_VERTEX_FRAGMENT,
SH_EX_FRAGMENT
} glslang_executable_t;
/* EShOptimizationLevel counterpart */ /* EShOptimizationLevel counterpart */
typedef enum { typedef enum {
@ -125,44 +122,42 @@ typedef enum {
/* EShMessages counterpart */ /* EShMessages counterpart */
typedef enum { typedef enum {
SH_MSG_DEFAULT = 0, SH_MSG_DEFAULT = 0,
SH_MSG_RELAXED_ERRORS = (1 << 0), SH_MSG_RELAXED_ERRORS = (1 << 0),
SH_MSG_SUPPRESS_WARNINGS = (1 << 1), SH_MSG_SUPPRESS_WARNINGS = (1 << 1),
SH_MSG_AST = (1 << 2), SH_MSG_AST = (1 << 2),
SH_MSG_SPV_RULES = (1 << 3), SH_MSG_SPV_RULES = (1 << 3),
SH_MSG_VULKAN_RULES = (1 << 4), SH_MSG_VULKAN_RULES = (1 << 4),
SH_MSG_ONLY_PREPROCESSOR = (1 << 5), SH_MSG_ONLY_PREPROCESSOR = (1 << 5),
SH_MSG_READ_HLSL = (1 << 6), SH_MSG_READ_HLSL = (1 << 6),
SH_MSG_CASCADING_ERRORS = (1 << 7), SH_MSG_CASCADING_ERRORS = (1 << 7),
SH_MSG_KEEP_UNCALLED = (1 << 8), SH_MSG_KEEP_UNCALLED = (1 << 8),
SH_MSG_HLSL_OFFSETS = (1 << 9), SH_MSG_HLSL_OFFSETS = (1 << 9),
SH_MSG_DEBUG_INFO = (1 << 10), SH_MSG_DEBUG_INFO = (1 << 10),
SH_MSG_HLSL_ENABLE_16BIT_TYPES = (1 << 11), SH_MSG_HLSL_ENABLE_16BIT_TYPES = (1 << 11),
SH_MSG_HLSL_LEGALIZATION = (1 << 12), SH_MSG_HLSL_LEGALIZATION = (1 << 12),
SH_MSG_HLSL_DX9_COMPATIBLE = (1 << 13), SH_MSG_HLSL_DX9_COMPATIBLE = (1 << 13),
SH_MSG_BUILTIN_SYMBOL_TABLE = (1 << 14), SH_MSG_BUILTIN_SYMBOL_TABLE = (1 << 14),
} glslang_messages_t; } glslang_messages_t;
/* EShReflectionOptions counterpart */ /* EShReflectionOptions counterpart */
typedef enum typedef enum {
{ SH_REFLECTION_DEFAULT = 0,
SH_REFLECTION_DEFAULT = 0,
SH_REFLECTION_STRICT_ARRAY_SUFFIX = (1 << 0), SH_REFLECTION_STRICT_ARRAY_SUFFIX = (1 << 0),
SH_REFLECTION_BASIC_ARRAY_SUFFIX = (1 << 1), SH_REFLECTION_BASIC_ARRAY_SUFFIX = (1 << 1),
SH_REFLECTION_INTERMEDIATE_IOO = (1 << 2), SH_REFLECTION_INTERMEDIATE_IOO = (1 << 2),
SH_REFLECTION_SEPARATE_BUFFERS = (1 << 3), SH_REFLECTION_SEPARATE_BUFFERS = (1 << 3),
SH_REFLECTION_ALL_BLOCK_VARIABLES = (1 << 4), SH_REFLECTION_ALL_BLOCK_VARIABLES = (1 << 4),
SH_REFLECTION_UNWRAP_IO_BLOCKS = (1 << 5), SH_REFLECTION_UNWRAP_IO_BLOCKS = (1 << 5),
} glslang_reflection_options_t; } glslang_reflection_options_t;
/* EProfile counterpart (from Versions.h) */ /* EProfile counterpart (from Versions.h) */
typedef enum { typedef enum {
SH_BAD_PROFILE = 0, SH_BAD_PROFILE = 0,
SH_NO_PROFILE = (1 << 0), SH_NO_PROFILE = (1 << 0),
SH_CORE_PROFILE = (1 << 1), SH_CORE_PROFILE = (1 << 1),
SH_COMPATIBILITY_PROFILE = (1 << 2), SH_COMPATIBILITY_PROFILE = (1 << 2),
SH_ES_PROFILE = (1 << 3) SH_ES_PROFILE = (1 << 3)
} glslang_profile_t; } glslang_profile_t;
#endif #endif

111
glslang/Include/glslang_c_interface.h
View file

@ -36,92 +36,79 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
typedef struct glslang_shader_s glslang_shader_t; typedef struct glslang_shader_s glslang_shader_t;
typedef struct glslang_program_s glslang_program_t; typedef struct glslang_program_s glslang_program_t;
typedef struct glslang_input_s typedef struct glslang_input_s {
{ glslang_source_t language;
glslang_source_t language; glslang_stage_t stage;
glslang_stage_t stage; glslang_client_t client;
glslang_client_t client; glslang_target_client_version_t client_version;
glslang_target_client_version_t client_version; glslang_target_language_t target_language;
glslang_target_language_t target_language; glslang_target_language_version_t target_language_version;
glslang_target_language_version_t target_language_version; /** Shader source code */
/** Shader source code */ const char* code;
const char* code; int default_version;
int default_version; glslang_profile_t default_profile;
glslang_profile_t default_profile; int force_default_version_and_profile;
int force_default_version_and_profile; int forward_compatible;
int forward_compatible; glslang_messages_t messages;
glslang_messages_t messages;
} glslang_input_t; } glslang_input_t;
/* Inclusion result structure allocated by C include_local/include_system callbacks */ /* Inclusion result structure allocated by C include_local/include_system callbacks */
typedef struct glsl_include_result_s typedef struct glsl_include_result_s {
{ /* Header file name or NULL if inclusion failed */
/* Header file name or NULL if inclusion failed */ const char* header_name;
const char *header_name;
/* Header contents or NULL */ /* Header contents or NULL */
const char *header_data; const char* header_data;
size_t header_length; size_t header_length;
} glsl_include_result_t; } glsl_include_result_t;
/* Callback for local file inclusion */ /* Callback for local file inclusion */
typedef glsl_include_result_t* (*glsl_include_local_func)( typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name,
void *ctx, size_t include_depth);
const char *header_name,
const char *includer_name,
size_t include_depth);
/* Callback for system file inclusion */ /* Callback for system file inclusion */
typedef glsl_include_result_t* (*glsl_include_system_func)( typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name,
void *ctx, const char* includer_name, size_t include_depth);
const char *header_name,
const char *includer_name,
size_t include_depth);
/* Callback for include result destruction */ /* Callback for include result destruction */
typedef int (*glsl_free_include_result_func)( typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result);
void *ctx,
glsl_include_result_t *result);
/* Collection of callbacks for GLSL preprocessor */ /* Collection of callbacks for GLSL preprocessor */
typedef struct glsl_include_callbacks_s typedef struct glsl_include_callbacks_s {
{ glsl_include_system_func include_system;
glsl_include_system_func include_system; glsl_include_local_func include_local;
glsl_include_local_func include_local; glsl_free_include_result_func free_include_result;
glsl_free_include_result_func free_include_result;
} glsl_include_callbacks_t; } glsl_include_callbacks_t;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C" {
{
#endif #endif
int glslang_initialize_process(); int glslang_initialize_process();
void glslang_finalize_process(); void glslang_finalize_process();
glslang_shader_t *glslang_shader_create(glslang_input_t *input); glslang_shader_t* glslang_shader_create(glslang_input_t* input);
void glslang_shader_delete(glslang_shader_t *shader); void glslang_shader_delete(glslang_shader_t* shader);
int glslang_shader_preprocess(glslang_shader_t *shader, glslang_input_t *input); int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* input);
int glslang_shader_parse(glslang_shader_t *shader, glslang_input_t *input); int glslang_shader_parse(glslang_shader_t* shader, glslang_input_t* input);
const char* glslang_shader_get_preprocessed_code(glslang_shader_t *shader); const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader);
const char* glslang_shader_get_info_log(glslang_shader_t *shader); const char* glslang_shader_get_info_log(glslang_shader_t* shader);
const char* glslang_shader_get_info_debug_log(glslang_shader_t *shader); const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
glslang_program_t *glslang_program_create(); glslang_program_t* glslang_program_create();
void glslang_program_delete(glslang_program_t *program); void glslang_program_delete(glslang_program_t* program);
void glslang_program_add_shader(glslang_program_t *program, glslang_shader_t *shader); void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
int glslang_program_link(glslang_program_t *program, int messages); int glslang_program_link(glslang_program_t* program, int messages);
void glslang_program_SPIRV_generate(glslang_program_t *program, glslang_stage_t stage); void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
size_t glslang_program_SPIRV_get_size(glslang_program_t *program); size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
void glslang_program_SPIRV_get(glslang_program_t *program, unsigned int *); void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*);
const char* glslang_program_SPIRV_get_messages(glslang_program_t *program); const char* glslang_program_SPIRV_get_messages(glslang_program_t* program);
const char* glslang_program_get_info_log(glslang_program_t *program); const char* glslang_program_get_info_log(glslang_program_t* program);
const char* glslang_program_get_info_debug_log(glslang_program_t *program); const char* glslang_program_get_info_debug_log(glslang_program_t* program);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */ #endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */