Beatmup::GL::FragmentShader Class Reference

GLSL fragment shader. More...

#include <program.h>

Inheritance diagram for Beatmup::GL::FragmentShader:

Public Member Functions
	FragmentShader (const GraphicPipeline &gpu)
	FragmentShader (const GraphicPipeline &gpu, const std::string &source, Extensions extensions=Extensions::NONE)
void	compile (const GraphicPipeline &gpu, const std::string &source, Extensions extensions=Extensions::NONE)
Public Member Functions inherited from Beatmup::GL::Shader
	~Shader ()

Static Public Attributes
static const char *	DIALECT_SAMPLER_DECL_TYPE = "beatmupSampler"
	glsl type name to declare a texture in Beatmup dialect More...
static const char *	DIALECT_TEXTURE_SAMPLING_FUNC = "beatmupTexture"
	glsl function name to sample a texture in Beatmup dialect More...

Additional Inherited Members
Protected Member Functions inherited from Beatmup::GL::Shader
	Shader (const GraphicPipeline &gpu, const uint32_t type)
handle_t	getHandle () const
uint32_t	getType () const
void	compile (const GraphicPipeline &gpu, const char *source)

Detailed Description

GLSL fragment shader.

Definition at line 107 of file program.h.

Constructor & Destructor Documentation

FragmentShader() [1/2]

FragmentShader::FragmentShader

(

const GraphicPipeline &

gpu

)

Definition at line 118 of file program.cpp.

                                                         : Shader(gpu, GL_FRAGMENT_SHADER) {
}

FragmentShader() [2/2]

Beatmup::GL::FragmentShader::FragmentShader ( const GraphicPipeline &  gpu, const std::string &  source, Extensions  extensions = Extensions::NONE  )

inline

Definition at line 113 of file program.h.

                                                                                                                        : FragmentShader(gpu)
            {
                compile(gpu, source.c_str(), extensions);
            }

Member Function Documentation

compile()

void FragmentShader::compile	(	const GraphicPipeline &	gpu,
		const std::string &	source,
		Extensions	extensions = Extensions::NONE
	)

Definition at line 121 of file program.cpp.

                                                                                                       {
    std::string src(source);
 
    // process extensions
    Extensions ext = extensions;
    if (ext & Extensions::BEATMUP_DIALECT) {
        ext -= Extensions::BEATMUP_DIALECT;
 
        // add version and dialect mapping preprocessor directives
        bool mapToModernGlsl = false;
        if (gpu.isGlEsCompliant())
            if (gpu.getGlslVersion() == 100)
                // ES 2.0 case
                src = "#version 100\n";
            else {
                // ES 3.0+
                src = "#version 300 es\n";
                mapToModernGlsl = true;
            }
        else
            if (gpu.getGlslVersion() < 130)
                // GLSL < 1.20 not supported; falling back to ES 2.0
                src = "#version 100\n";
            else {
                // 1.30+: capping at 1.30
                src = "#version 130\n";
                mapToModernGlsl = true;
            }
 
        // declare sampler type, add external texture extension header if needed
        if (ext & Extensions::EXTERNAL_TEXTURE) {
            ext -= Extensions::EXTERNAL_TEXTURE;
            src += "#ifdef GL_OES_EGL_image_external_essl3\n"
                   "#extension GL_OES_EGL_image_external_essl3 : require\n"                                 // use GL_OES_EGL_image_external_essl3 is available
                   "#define " + std::string(DIALECT_TEXTURE_SAMPLING_FUNC) + "(S, C) texture(S, C)\n"       // sampling function is texture()
                   "#else\n"
                   "#extension GL_OES_EGL_image_external : require\n"                                       // fall back to GL_OES_EGL_image_external
                   "lowp vec4 " + std::string(DIALECT_TEXTURE_SAMPLING_FUNC) + "(samplerExternalOES sampler, mediump vec2 coord) { return texture2D(sampler, coord); }\n"
                   "#endif\n"
                   "#define " + std::string(DIALECT_SAMPLER_DECL_TYPE) + " samplerExternalOES\n";
        }
        else
            src += "#define " + std::string(DIALECT_SAMPLER_DECL_TYPE) + " sampler2D\n"
                   "#define " + std::string(DIALECT_TEXTURE_SAMPLING_FUNC) + "(S, C) texture2D(S, C)\n";
 
        // add the rest after declaring extensions
        if (mapToModernGlsl)
            src += "#define varying in\n"
                   "#define texture2D(S, C) texture(S, C)\n"
                   "#define gl_FragColor beatmupFrgClrVar\n"
                   "out mediump vec4 beatmupFrgClrVar;\n";
 
        // append the source code
        src += "#line 0\n" + source;
    }
 
    // check for external texture extension (not supported without dialect)
    if (ext & Extensions::EXTERNAL_TEXTURE)
        throw GL::GLException("External texture extension is only supported with Beatmup dialect extension");
 
    // check if all extensions are processed
    if (ext)
        throw GL::GLException("Cannot interpret extensions set " + std::to_string(extensions));
 
    // compile
    Shader::compile(gpu, src.c_str());
}

Member Data Documentation

DIALECT_SAMPLER_DECL_TYPE

const char * FragmentShader::DIALECT_SAMPLER_DECL_TYPE = "beatmupSampler"

static

glsl type name to declare a texture in Beatmup dialect

Definition at line 109 of file program.h.

DIALECT_TEXTURE_SAMPLING_FUNC

const char * FragmentShader::DIALECT_TEXTURE_SAMPLING_FUNC = "beatmupTexture"

static

glsl function name to sample a texture in Beatmup dialect

Definition at line 110 of file program.h.

---

The documentation for this class was generated from the following files:

• core/gpu/program.h
• core/gpu/program.cpp