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

236
glslang/CInterface/glslang_c_interface.cpp
View file

@ -28,24 +28,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "glslang_c_interface.h"
#include "glslang/Include/ShHandle.h"
#include "StandAlone/DirStackFileIncluder.h"
#include "StandAlone/ResourceLimits.h"
#include "SPIRV/GlslangToSpv.h"
#include "SPIRV/Logger.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/MachineIndependent/Versions.h"
typedef struct glslang_shader_s
{
typedef struct glslang_shader_s {
glslang::TShader* shader;
std::string preprocessedGLSL;
} glslang_shader_t;
typedef struct glslang_program_s
{
typedef struct glslang_program_s {
glslang::TProgram* program;
std::vector<unsigned int> spirv;
std::string loggerMessages;
@ -64,87 +62,57 @@ typedef struct glslang_program_s
to allow its lifetime management by another C callback
(CallbackIncluder::callbacks::free_include_result)
*/
class CallbackIncluder: public glslang::TShader::Includer
{
class CallbackIncluder : public glslang::TShader::Includer {
public:
/* 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:
CallbackIncludeResult(const std::string& headerName,
const char* const headerData,
const size_t headerLength,
void* userData,
glsl_include_result_t* includeResult):
glslang::TShader::Includer::IncludeResult(
headerName, headerData, headerLength, userData),
CallbackIncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength,
void* userData, glsl_include_result_t* includeResult)
: glslang::TShader::Includer::IncludeResult(headerName, headerData, headerLength, userData),
includeResult(includeResult)
{}
{
}
virtual ~CallbackIncludeResult() {}
protected:
friend class CallbackIncluder;
glsl_include_result_t* includeResult;
};
public:
CallbackIncluder(glsl_include_callbacks_t _callbacks, void *_context):
callbacks(_callbacks),
context(_context)
{}
CallbackIncluder(glsl_include_callbacks_t _callbacks, void* _context) : callbacks(_callbacks), context(_context) {}
virtual ~CallbackIncluder() {}
virtual IncludeResult* includeSystem(const char* headerName,
const char* includerName,
virtual IncludeResult* includeSystem(const char* headerName, const char* includerName,
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);
this->callbacks.include_system(this->context, headerName, includerName, inclusionDepth);
return new CallbackIncludeResult(
std::string(headerName),
result->header_data,
result->header_length,
nullptr,
result
);
return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
nullptr, result);
}
return glslang::TShader::Includer::includeSystem(
headerName, includerName, inclusionDepth);
return glslang::TShader::Includer::includeSystem(headerName, includerName, inclusionDepth);
}
virtual IncludeResult* includeLocal(const char* headerName,
const char* includerName,
virtual IncludeResult* includeLocal(const char* headerName, const char* includerName,
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);
this->callbacks.include_local(this->context, headerName, includerName, inclusionDepth);
return new CallbackIncludeResult(
std::string(headerName),
result->header_data,
result->header_length,
nullptr,
result
);
return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
nullptr, result);
}
return glslang::TShader::Includer::includeLocal(
headerName, includerName, inclusionDepth);
return glslang::TShader::Includer::includeLocal(headerName, includerName, inclusionDepth);
}
/* This function only calls free_include_result callback
@ -154,9 +122,8 @@ public:
if (result == nullptr)
return;
if (this->callbacks.free_include_result && (result->userData == nullptr))
{
CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult *>(result);
if (this->callbacks.free_include_result && (result->userData == nullptr)) {
CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult*>(result);
/* use internal free() function */
this->callbacks.free_include_result(this->context, innerResult->includeResult);
/* ignore internal fields of TShader::Includer::IncludeResult */
@ -164,32 +131,26 @@ public:
return;
}
delete [] static_cast<char*>(result->userData);
delete[] static_cast<char*>(result->userData);
delete result;
}
private:
CallbackIncluder() {}
/* C callback pointers */
glsl_include_callbacks_t callbacks;
/* User-defined context */
void *context;
void* context;
};
int glslang_initialize_process()
{
return static_cast<int>(glslang::InitializeProcess());
}
int glslang_initialize_process() { return static_cast<int>(glslang::InitializeProcess()); }
void glslang_finalize_process()
{
glslang::FinalizeProcess();
}
void glslang_finalize_process() { glslang::FinalizeProcess(); }
static EShLanguage c_shader_stage(glslang_stage_t stage)
{
switch(stage)
{
switch (stage) {
case SH_STAGE_VERTEX:
return EShLangVertex;
case SH_STAGE_TESSCONTROL:
@ -226,8 +187,7 @@ static EShLanguage c_shader_stage(glslang_stage_t stage)
static EShMessages c_shader_messages(glslang_messages_t messages)
{
switch(messages)
{
switch (messages) {
case SH_MSG_RELAXED_ERRORS:
return EShMsgRelaxedErrors;
case SH_MSG_SUPPRESS_WARNINGS:
@ -264,10 +224,10 @@ static EShMessages c_shader_messages(glslang_messages_t messages)
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:
return glslang::EShTargetSpv_1_0;
case SH_TARGET_SPV_1_1:
@ -288,8 +248,7 @@ static glslang::EShTargetLanguageVersion c_shader_target_language_version(glslan
static glslang::EShClient c_shader_client(glslang_client_t client)
{
switch(client)
{
switch (client) {
case SH_CLIENT_VULKAN:
return glslang::EShClientVulkan;
case SH_CLIENT_OPENGL:
@ -303,8 +262,7 @@ static glslang::EShClient c_shader_client(glslang_client_t client)
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:
return glslang::EShTargetVulkan_1_1;
case SH_TARGET_OPENGL_450:
@ -326,8 +284,7 @@ static glslang::EShTargetLanguage c_shader_target_language(glslang_target_langua
static glslang::EShSource c_shader_source(glslang_source_t source)
{
switch(source)
{
switch (source) {
case SH_SOURCE_GLSL:
return glslang::EShSourceGlsl;
case SH_SOURCE_HLSL:
@ -341,8 +298,7 @@ static glslang::EShSource c_shader_source(glslang_source_t source)
static EProfile c_shader_profile(glslang_profile_t profile)
{
switch(profile)
{
switch (profile) {
case SH_BAD_PROFILE:
return EBadProfile;
case SH_NO_PROFILE:
@ -358,10 +314,9 @@ static EProfile c_shader_profile(glslang_profile_t profile)
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);
if (input)
@ -370,21 +325,20 @@ glslang_shader_t *glslang_shader_create(glslang_input_t *input)
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->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->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) );
shader->shader = new glslang::TShader(c_shader_stage(input->stage));
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->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;
}
const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader)
{
return shader->preprocessedGLSL.c_str();
}
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)
{
@ -392,111 +346,89 @@ int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* i)
/* 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
);
&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_parse(glslang_shader_t *shader, glslang_input_t *input)
int glslang_shader_parse(glslang_shader_t* shader, glslang_input_t* input)
{
const char* preprocessedCStr = shader->preprocessedGLSL.c_str();
shader->shader->setStrings( &preprocessedCStr, 1 );
shader->shader->setStrings(&preprocessedCStr, 1);
return shader->shader->parse(
/* No user-defined resource limits for now */
&glslang::DefaultTBuiltInResource,
input->default_version,
(bool)input->forward_compatible,
c_shader_messages(input->messages)
);
&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)
{
return shader->shader->getInfoLog();
}
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();
}
const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader) { return shader->shader->getInfoDebugLog(); }
void glslang_shader_delete(glslang_shader_t *shader)
void glslang_shader_delete(glslang_shader_t* shader)
{
if (!shader)
return;
delete(shader->shader);
delete(shader);
delete (shader->shader);
delete (shader);
}
glslang_program_t *glslang_program_create()
glslang_program_t* glslang_program_create()
{
glslang_program_t *p = new glslang_program_t();
glslang_program_t* p = new glslang_program_t();
p->program = new glslang::TProgram();
return p;
}
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)
{
spv::SpvBuildLogger logger;
glslang::SpvOptions spvOptions;
spvOptions.validate = true;
const glslang::TIntermediate* intermediate = program->program->getIntermediate( c_shader_stage(stage) );
const glslang::TIntermediate* intermediate = program->program->getIntermediate(c_shader_stage(stage));
glslang::GlslangToSpv( *intermediate, program->spirv, &logger, &spvOptions );
glslang::GlslangToSpv(*intermediate, program->spirv, &logger, &spvOptions);
program->loggerMessages = logger.getAllMessages();
}
size_t glslang_program_SPIRV_get_size(glslang_program_t *program)
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)
{
return program->spirv.size();
memcpy(out, program->spirv.data(), program->spirv.size() * sizeof(unsigned int));
}
void glslang_program_SPIRV_get(glslang_program_t *program, unsigned int* out)
{
memcpy( out, program->spirv.data(), program->spirv.size() * sizeof( unsigned int ) );
}
const char* glslang_program_SPIRV_get_messages(glslang_program_t *program)
const char* glslang_program_SPIRV_get_messages(glslang_program_t* program)
{
return program->loggerMessages.empty() ? nullptr : program->loggerMessages.c_str();
}
void glslang_program_delete(glslang_program_t *program)
void glslang_program_delete(glslang_program_t* program)
{
if (!program)
return;
delete(program->program);
delete(program);
delete (program->program);
delete (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)
{
program->program->addShader(shader->shader);
}
int glslang_program_link(glslang_program_t *program, int messages)
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_log(glslang_program_t* program) { return program->program->getInfoLog(); }
const char* glslang_program_get_info_debug_log(glslang_program_t *program)
const char* glslang_program_get_info_debug_log(glslang_program_t* program)
{
return program->program->getInfoDebugLog();
}

9
glslang/Include/c_shader_types.h
View file

@ -104,10 +104,7 @@ typedef enum {
} glslang_target_language_version_t;
/* EShExecutable counterpart */
typedef enum {
SH_EX_VERTEX_FRAGMENT,
SH_EX_FRAGMENT
} glslang_executable_t;
typedef enum { SH_EX_VERTEX_FRAGMENT, SH_EX_FRAGMENT } glslang_executable_t;
/* EShOptimizationLevel counterpart */
typedef enum {
@ -144,8 +141,7 @@ typedef enum {
} glslang_messages_t;
/* EShReflectionOptions counterpart */
typedef enum
{
typedef enum {
SH_REFLECTION_DEFAULT = 0,
SH_REFLECTION_STRICT_ARRAY_SUFFIX = (1 << 0),
SH_REFLECTION_BASIC_ARRAY_SUFFIX = (1 << 1),
@ -165,4 +161,3 @@ typedef enum {
} glslang_profile_t;
#endif

67
glslang/Include/glslang_c_interface.h
View file

@ -36,8 +36,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
typedef struct glslang_shader_s glslang_shader_t;
typedef struct glslang_program_s glslang_program_t;
typedef struct glslang_input_s
{
typedef struct glslang_input_s {
glslang_source_t language;
glslang_stage_t stage;
glslang_client_t client;
@ -54,74 +53,62 @@ typedef struct glslang_input_s
} glslang_input_t;
/* 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 */
const char *header_name;
const char* header_name;
/* Header contents or NULL */
const char *header_data;
const char* header_data;
size_t header_length;
} glsl_include_result_t;
/* Callback for local file inclusion */
typedef glsl_include_result_t* (*glsl_include_local_func)(
void *ctx,
const char *header_name,
const char *includer_name,
typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name,
size_t include_depth);
/* Callback for system file inclusion */
typedef glsl_include_result_t* (*glsl_include_system_func)(
void *ctx,
const char *header_name,
const char *includer_name,
size_t include_depth);
typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name,
const char* includer_name, size_t include_depth);
/* Callback for include result destruction */
typedef int (*glsl_free_include_result_func)(
void *ctx,
glsl_include_result_t *result);
typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result);
/* 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_local_func include_local;
glsl_free_include_result_func free_include_result;
} glsl_include_callbacks_t;
#ifdef __cplusplus
extern "C"
{
extern "C" {
#endif
int glslang_initialize_process();
void glslang_finalize_process();
glslang_shader_t *glslang_shader_create(glslang_input_t *input);
void glslang_shader_delete(glslang_shader_t *shader);
int glslang_shader_preprocess(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_info_log(glslang_shader_t *shader);
const char* glslang_shader_get_info_debug_log(glslang_shader_t *shader);
glslang_shader_t* glslang_shader_create(glslang_input_t* input);
void glslang_shader_delete(glslang_shader_t* shader);
int glslang_shader_preprocess(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_info_log(glslang_shader_t* shader);
const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
glslang_program_t *glslang_program_create();
void glslang_program_delete(glslang_program_t *program);
void glslang_program_add_shader(glslang_program_t *program, glslang_shader_t *shader);
int glslang_program_link(glslang_program_t *program, int messages);
void glslang_program_SPIRV_generate(glslang_program_t *program, glslang_stage_t stage);
size_t glslang_program_SPIRV_get_size(glslang_program_t *program);
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_get_info_log(glslang_program_t *program);
const char* glslang_program_get_info_debug_log(glslang_program_t *program);
glslang_program_t* glslang_program_create();
void glslang_program_delete(glslang_program_t* program);
void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
int glslang_program_link(glslang_program_t* program, int messages);
void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
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_get_info_log(glslang_program_t* program);
const char* glslang_program_get_info_debug_log(glslang_program_t* program);
#ifdef __cplusplus
}
#endif
#endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */