void QSGMaterialShader::compile()
{
Q_ASSERT_X(!m_program.isLinked(), "QSGSMaterialShader::compile()", "Compile called multiple times!");
program()->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShader());
program()->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShader());
char const *const *attr = attributeNames();
#ifndef QT_NO_DEBUG
int maxVertexAttribs = 0;
QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
funcs->glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
for (int i = 0; attr[i]; ++i) {
if (i >= maxVertexAttribs) {
qFatal("List of attribute names is either too long or not null-terminated.\n"
"Maximum number of attributes on this hardware is %i.\n"
"Vertex shader:\n%s\n"
"Fragment shader:\n%s\n",
maxVertexAttribs, vertexShader(), fragmentShader());
}
if (*attr[i])
program()->bindAttributeLocation(attr[i], i);
}
#else
for (int i = 0; attr[i]; ++i) {
if (*attr[i])
program()->bindAttributeLocation(attr[i], i);
}
#endif
if (!program()->link()) {
qWarning("QSGMaterialShader: Shader compilation failed:");
qWarning() << program()->log();
}
}
void GLWidgetShader::initializeGL()
{
qglClearColor(Qt::white);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_COLOR_MATERIAL);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glEnable(GL_MULTISAMPLE);
qglClearColor(Qt::white);
#ifdef APPLE
QString vertexShader("/Users/rs/workspace/cncsvisioncmake/data/glslshaders/RasterScanLineShader.vert");
QString fragmentShader("/Users/rs/workspace/cncsvisioncmake/data/glslshaders/RasterScanLineShader.frag");
#else
QString vertexShader( "/home/carlo/workspace/cncsvisioncmake/data/glslshaders/LightFieldVertexShader.vert");
QString fragmentShader("/home/carlo/workspace/cncsvisioncmake/data/glslshaders/LightFieldFragmentShader.frag");
#endif
this->makeCurrent();
this->loadShader(vertexShader,fragmentShader);
}
void VideoShader::compile(QOpenGLShaderProgram *shaderProgram)
{
Q_ASSERT_X(!shaderProgram->isLinked(), "VideoShader::compile()", "Compile called multiple times!");
shaderProgram->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShader());
shaderProgram->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShader());
int maxVertexAttribs = 0;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
char const *const *attr = attributeNames();
for (int i = 0; attr[i]; ++i) {
if (i >= maxVertexAttribs) {
qFatal("List of attribute names is either too long or not null-terminated.\n"
"Maximum number of attributes on this hardware is %i.\n"
"Vertex shader:\n%s\n"
"Fragment shader:\n%s\n",
maxVertexAttribs, vertexShader(), fragmentShader());
}
// why must min location == 0?
if (*attr[i])
shaderProgram->bindAttributeLocation(attr[i], i);
}
if (!shaderProgram->link()) {
qWarning("QSGMaterialShader: Shader compilation failed:");
qWarning() << shaderProgram->log();
}
}
void Setup(CPlatform * const pPlatform)
{
CShader vertexShader(CShader::VERT, &pVertexShader, 1);
CShader fragmentShader(CShader::FRAG, &pFragmentShader, 1);
CShaderProgram program;
//setup the shaders
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
glGenVertexArrays(1,&vao); //vertex array object
glGenBuffers(1, &ab); //array buffer
//fill buffers
glBindBuffer(GL_ARRAY_BUFFER, ab);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
//bind vao and ste it's data
glBindVertexArray(vao);
//glBindBuffer(GL_ARRAY_BUFFER, ab);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, BUFFER_OFFSET(0)); //P
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, BUFFER_OFFSET(sizeof(float)*3)); //C
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
//set rendering states
glEnable(GL_CULL_FACE);
glClearColor(0,0,0,0);
program.Start(); //even when glDeleteProgram is called the program won't be deleted untilit7s out of use
}
bool Graphics_Default::Init(int argc, char *argv[])
{
Shutdown();
m_pWindow = new sf::Window(sf::VideoMode(800, 600), "Look at me!");
glewInit();
glClearColor(.1f, .2f, .3f, 1);
Shader vertexShader(VERTEX_SHADER);
Shader fragmentShader(FRAGMENT_SHADER);
vertexShader.LoadFromFile("build/debug/data/shader/vertex.glsl");
fragmentShader.LoadFromFile("build/debug/data/shader/fragment.glsl");
m_pPolygonPipeline = new Pipeline();
m_pPolygonPipeline->AttachShader(vertexShader);
m_pPolygonPipeline->AttachShader(fragmentShader);
m_pPolygonPipeline->Link();
m_pPolygonPipeline->DetachShader(vertexShader);
m_pPolygonPipeline->DetachShader(fragmentShader);
m_pBuffer = reinterpret_cast<void*>(new unsigned char[BUFFER_SIZE]);
m_pPolygonPoser = new PolygonPoser(m_pPolygonPipeline);
m_pPolygonPoser->SetBuffer(m_pBuffer, BUFFER_SIZE);
return true;
}
GLProgram::GLProgram(const char* vShaderFile, const char* fShaderFile)
{
m_program = glCreateProgram();
CHECK_GL_ERROR_DEBUG();
if(m_program == 0) {
return;
}
// VERTEX SHADER
fzBuffer source = ResourcesManager::Instance().loadResource(vShaderFile);
GLShader vertexShader(source.getPointer(), GL_VERTEX_SHADER);
source.free();
// FRAGMENT SHADER (we can reuse the fzBuffer object)
source = ResourcesManager::Instance().loadResource(fShaderFile);
GLShader fragmentShader(source.getPointer(), GL_FRAGMENT_SHADER);
source.free();
// ATTACH SHADERS
glAttachShader(m_program, vertexShader.getShader());
glAttachShader(m_program, fragmentShader.getShader());
CHECK_GL_ERROR_DEBUG();
}
void TessMeshApp::initMeshShader(){
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile("shaders/tess.vert");
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile("shaders/tess.frag");
fragmentShader.compile();
Shader geometryShader(GL_GEOMETRY_SHADER);
geometryShader.loadFromFile("shaders/tess.geom");
geometryShader.compile();
Shader tesselationControlShader(GL_TESS_CONTROL_SHADER);
tesselationControlShader.loadFromFile("shaders/tess.tcs");
tesselationControlShader.compile();
Shader tesselationEvaluationShader(GL_TESS_EVALUATION_SHADER);
tesselationEvaluationShader.loadFromFile("shaders/tess.tes");
tesselationEvaluationShader.compile();
meshShaderProgram = new ShaderProgram();
meshShaderProgram->attachShader(vertexShader);
meshShaderProgram->attachShader(fragmentShader);
meshShaderProgram->attachShader(geometryShader);
meshShaderProgram->attachShader(tesselationControlShader);
meshShaderProgram->attachShader(tesselationEvaluationShader);
meshShaderProgram->linkProgram();
}
void GameOfLifeWorldRenderer::initializeShaders()
{
VertexShader vertexShader(
"#version 330 core\n"
"layout (location = 0) in vec2 position;\n"
"layout (location = 1) in vec2 offset;\n"
"layout (location = 2) in vec3 color;\n"
"out vec3 fColor;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(position + offset, 0.0f, 1.0f);\n"
" fColor = color;\n"
"}\n"
);
FragmentShader fragmentShader(
"#version 330 core\n"
"in vec3 fColor;\n"
"out vec4 color;\n"
"void main()\n"
"{\n"
" color = vec4(fColor, 1.0f);\n"
"}\n"
);
program = ShaderProgram(vertexShader, fragmentShader);
}
void Setup(CPlatform * const pPlatform)
{
CShader vertexShader(CShader::VERT, &pVertexShader, 1);
CShader fragmentShader(CShader::FRAG, &pFragmentShader, 1);
// - - - - - - - - - -
//setup the shaders
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
mt = program.GetUniformLocation("mt");
// - - - - - - - - - -
// setup vertex buffers etc
vao = WRender::CreateVertexArrayObject();
eab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(indices), indices);
ab = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(vertices), vertices);
WRender::BindVertexArrayObject(vao);
WRender::BindBuffer(WRender::ELEMENTS, eab);
WRender::VertexAttribute va[3] = {
{ab, 0, 3, WRender::FLOAT, 0, sizeof(float)*6, 0, 0},
{ab, 1, 3, WRender::FLOAT, 0, sizeof(float)*6, sizeof(float)*3, 0},
};
WRender::SetAttributeFormat( va, 2, 0);
program.Start();
}
void Water::createShaderWaterStateSet(osg::Node* node, Reflection* reflection, Refraction* refraction)
{
// use a define map to conditionally compile the shader
std::map<std::string, std::string> defineMap;
defineMap.insert(std::make_pair(std::string("refraction_enabled"), std::string(refraction ? "1" : "0")));
Shader::ShaderManager& shaderMgr = mResourceSystem->getSceneManager()->getShaderManager();
osg::ref_ptr<osg::Shader> vertexShader (shaderMgr.getShader("water_vertex.glsl", defineMap, osg::Shader::VERTEX));
osg::ref_ptr<osg::Shader> fragmentShader (shaderMgr.getShader("water_fragment.glsl", defineMap, osg::Shader::FRAGMENT));
osg::ref_ptr<osg::Texture2D> normalMap (new osg::Texture2D(readPngImage(mResourcePath + "/shaders/water_nm.png")));
if (normalMap->getImage())
normalMap->getImage()->flipVertical();
normalMap->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
normalMap->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
normalMap->setMaxAnisotropy(16);
normalMap->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
normalMap->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
osg::ref_ptr<osg::StateSet> shaderStateset = new osg::StateSet;
shaderStateset->addUniform(new osg::Uniform("normalMap", 0));
shaderStateset->addUniform(new osg::Uniform("reflectionMap", 1));
shaderStateset->setTextureAttributeAndModes(0, normalMap, osg::StateAttribute::ON);
shaderStateset->setTextureAttributeAndModes(1, reflection->getReflectionTexture(), osg::StateAttribute::ON);
if (refraction)
{
shaderStateset->setTextureAttributeAndModes(2, refraction->getRefractionTexture(), osg::StateAttribute::ON);
shaderStateset->setTextureAttributeAndModes(3, refraction->getRefractionDepthTexture(), osg::StateAttribute::ON);
shaderStateset->addUniform(new osg::Uniform("refractionMap", 2));
shaderStateset->addUniform(new osg::Uniform("refractionDepthMap", 3));
shaderStateset->setRenderBinDetails(MWRender::RenderBin_Default, "RenderBin");
}
else
{
shaderStateset->setMode(GL_BLEND, osg::StateAttribute::ON);
shaderStateset->setRenderBinDetails(MWRender::RenderBin_Water, "RenderBin");
osg::ref_ptr<osg::Depth> depth (new osg::Depth);
depth->setWriteMask(false);
shaderStateset->setAttributeAndModes(depth, osg::StateAttribute::ON);
}
shaderStateset->setMode(GL_CULL_FACE, osg::StateAttribute::OFF);
shaderStateset->addUniform(mRainIntensityUniform.get());
osg::ref_ptr<osg::Program> program (new osg::Program);
program->addShader(vertexShader);
program->addShader(fragmentShader);
shaderStateset->setAttributeAndModes(program, osg::StateAttribute::ON);
node->setStateSet(shaderStateset);
node->setUpdateCallback(NULL);
}
void initialize() {
glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
std::string vertexShaderSource;
if (!contentsOfFile("vertex.glsl", vertexShaderSource)) {
exit(1);
}
std::string fragmentShaderSource;
if (!contentsOfFile("fragment.glsl", fragmentShaderSource)) {
exit(1);
}
Shader vertexShader(GL_VERTEX_SHADER);
if (!vertexShader.compile(vertexShaderSource)) {
debugPrint("Failed to compile vertex shader: %s", vertexShader.getCompileStatus().c_str());
exit(1);
}
Shader fragmentShader(GL_FRAGMENT_SHADER);
if (!fragmentShader.compile(fragmentShaderSource)) {
debugPrint("Failed to compile fragment shader: %s", fragmentShader.getCompileStatus().c_str());
exit(1);
}
Program shaderProgram(vertexShader, fragmentShader);
if (!shaderProgram.link()) {
debugPrint("Failed to link shader program: %s", shaderProgram.getLinkStatus().c_str());
exit(1);
}
GLuint programID = shaderProgram.getGLID();
glUseProgram(programID);
GLint posAttrib = glGetAttribLocation(programID, "position");
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0);
GLint colorAttrib = glGetAttribLocation(programID, "color");
glEnableVertexAttribArray(colorAttrib);
glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(2 * sizeof(float)));
glEnableVertexAttribArray(posAttrib);
ball.setLeftPlayer(&leftPlayer);
ball.setRightPlayer(&rightPlayer);
}
Game::Game( String&& windowName, const WindowConfig& windowConfig, OpenGlConfig& openGlConfig ) : _lastId( 0 ), _window( nullptr ), _defaultShaders( nullptr )
{
// open a window
_window = new Window( std::move( windowName ), windowConfig, openGlConfig );
// load default shaders
Shader vertexShader( "assets/shaders/shader.vert", GL_VERTEX_SHADER );
Shader fragmentShader( "assets/shaders/shader.frag", GL_FRAGMENT_SHADER );
_defaultShaders = new ShaderProgram( );
_defaultShaders->addShader( &vertexShader );
_defaultShaders->addShader( &fragmentShader );
}
void GLC_ContextSharedData::initDefaultShader()
{
QFile vertexShader(":/GLC_lib_Shaders/default_vert");
Q_ASSERT(vertexShader.exists());
QFile fragmentShader(":/GLC_lib_Shaders/default_frag");
Q_ASSERT(fragmentShader.exists());
m_pDefaultShader= new GLC_Shader(vertexShader, fragmentShader);
m_pDefaultShader->createAndCompileProgrammShader();
}
void ShaderVisitor::createProgram(const ShaderRequirements &reqs, osg::Node& node)
{
osg::StateSet* writableStateSet = NULL;
if (mAllowedToModifyStateSets)
writableStateSet = node.getOrCreateStateSet();
else
writableStateSet = getWritableStateSet(node);
ShaderManager::DefineMap defineMap;
for (unsigned int i=0; i<sizeof(defaultTextures)/sizeof(defaultTextures[0]); ++i)
{
defineMap[defaultTextures[i]] = "0";
defineMap[std::string(defaultTextures[i]) + std::string("UV")] = "0";
}
for (std::map<int, std::string>::const_iterator texIt = reqs.mTextures.begin(); texIt != reqs.mTextures.end(); ++texIt)
{
defineMap[texIt->second] = "1";
defineMap[texIt->second + std::string("UV")] = boost::lexical_cast<std::string>(texIt->first);
}
if (!reqs.mColorMaterial)
defineMap["colorMode"] = "0";
else
{
switch (reqs.mVertexColorMode)
{
default:
case GL_AMBIENT_AND_DIFFUSE:
defineMap["colorMode"] = "2";
break;
case GL_EMISSION:
defineMap["colorMode"] = "1";
break;
}
}
defineMap["forcePPL"] = mForcePerPixelLighting ? "1" : "0";
defineMap["clamp"] = mClampLighting ? "1" : "0";
osg::ref_ptr<osg::Shader> vertexShader (mShaderManager.getShader(mDefaultVsTemplate, defineMap, osg::Shader::VERTEX));
osg::ref_ptr<osg::Shader> fragmentShader (mShaderManager.getShader(mDefaultFsTemplate, defineMap, osg::Shader::FRAGMENT));
if (vertexShader && fragmentShader)
{
writableStateSet->setAttributeAndModes(mShaderManager.getProgram(vertexShader, fragmentShader), osg::StateAttribute::ON);
for (std::map<int, std::string>::const_iterator texIt = reqs.mTextures.begin(); texIt != reqs.mTextures.end(); ++texIt)
{
writableStateSet->addUniform(new osg::Uniform(texIt->second.c_str(), texIt->first), osg::StateAttribute::ON);
}
}
}
void Program::attachShaders()
{
if (vertexShader() != 0)
{
// attach registered vertex shader
glAttachShader(id_, vertexShader_->id());
}
if (fragmentShader() != 0)
{
// attach registered fragment shader
glAttachShader(id_, fragmentShader_->id());
}
}
void canLinkProgramWhenShadersCompiled()
{
ShaderProgram shaderProgram;
Shader fragmentShader(Shader::FRAGMENT_SHADER);
shaderProgram.attach(fragmentShader);
fragmentShader.compile(VALID_FRAGMENT_SHADER_SOURCE);
QVERIFY(shaderProgram.link());
Shader vertexShader(Shader::VERTEX_SHADER);
vertexShader.compile(VALID_VERTEX_SHADER_SOURCE);
shaderProgram.attach(vertexShader);
QVERIFY(shaderProgram.link());
}
void Setup(CPlatform * const pPlatform)
{
CShader vertexShader(CShader::VERT, &pVertexShader, 1);
CShader vertexShader2(CShader::VERT, &pVertexShader2, 1);
CShader fragmentShader(CShader::FRAG, &pFragmentShader, 1);
// - - - - - - - - - -
//setup the shaders
program[0].Initialise();
program[0].AddShader(&vertexShader);
program[0].AddShader(&fragmentShader);
program[0].Link();
program[1].Initialise();
program[1].AddShader(&vertexShader2);
program[1].AddShader(&fragmentShader);
program[1].Link();
int blockAlign = CShaderProgram::GetUniformBlockAlignment();
int blockLoc = program[0].GetUniformBlockBinding(program[0].GetUniformBlockLocation("Transforms")); //should be 5 :)
int blockSiz = program[0].GetUniformBlockSize(program[0].GetUniformBlockLocation("Transforms")); //should be 5 :)
int namelength = program[0].GetUniformBlockInfo(program[0].GetUniformBlockLocation("Transforms"),CShaderProgram::NAME_LENGTH);
int activeUniforms = program[0].GetUniformBlockInfo(program[0].GetUniformBlockLocation("Transforms"),CShaderProgram::BLK_ACTIVE_UNIFORMS);
int uniformindices[100];
program[0].GetUniformBlockInfo(program[0].GetUniformBlockLocation("Transforms"),CShaderProgram::BLK_ACTIVE_UNIFORMS_INDICES, uniformindices);
// - - - - - - - - - -
// setup vertex buffers etc
//glGenVertexArrays(1,&vao); //vertex array object
vao = WRender::CreateVertexArrayObject();
eab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(indices), indices);
ab = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(vertices), vertices);
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
WRender::BindVertexArrayObject(vao);
WRender::BindBuffer(WRender::ELEMENTS, eab);
WRender::VertexAttribute va[2] = {
{ab, 0, 3, WRender::FLOAT, 0, sizeof(float)*6, 0, 0},
{ab, 1, 3, WRender::FLOAT, 0, sizeof(float)*6, sizeof(float)*3, 0},
};
WRender::SetAttributeFormat( va, 2, 0);
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 10.0f);
WRender::SetClearColour(0,0,0,0);
}
void Setup(CPlatform * const pPlatform)
{
unsigned int got = 0;
const char *pVertStr[2] = {0,0}, *pFragStr[2] = {0,0};
float *pFrustumVertices = 0;
float colour[] = {1.0f,0.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,0.0f,1.0f};
int nFacets = 0;
glswInit();
glswSetPath( "../resources/", ".glsl" );
WRender::SetClearColour(0,0,0,0);
WRender::EnableCulling(true);
// - - - - - - - - - - - - - - - - - - - -
// - - - - - - - - - - - - - - - - - - - -
glswGetShadersAlt( "shaders.Shared+shaders.Skymap.Vertex", pVertStr, 2);
glswGetShadersAlt( "shaders.Shared+shaders.Skymap.Fragment", pFragStr, 2);
CShader vertexShader(CShader::VERT, pVertStr, 2);
CShader fragmentShader(CShader::FRAG, pFragStr, 2);
//setup the shaders
program_cube.Initialise();
program_cube.AddShader(&vertexShader);
program_cube.AddShader(&fragmentShader);
program_cube.Link();
program_cube.Start();
program_cube.SetTextureUnit("cube_map",0);
// - - - - - - - - - -
//set up shapes
box = CreateShapeCube();
sphere = CreateShapeSphereNormals();
//sphere = CreateShapeSphere();
//sphere = CreateShapeCylinder();
//sphere = CreateShapeCone();
//sphere = CreateShapeTorus();
// - - - - - - - - - -
// set up cubemap
CreateCubeMapTextures();
//ubo for cameras etc
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
Transform::CreateProjectionMatrix(transforms.proj, -0.1f, 0.1f, -0.1f, 0.1f, 0.1f, 50.0f);
}
bool GLProgram::loadSource(const std::string& vertex, const std::string& fragment)
{
bool success = true;
GLShader vertexShader(GL::VERTEX_SHADER);
vertexShader.setSource(vertex);
success = vertexShader.compile() && success;
gl::AttachShader(m_Handle, vertexShader.handle());
GLShader fragmentShader(GL::FRAGMENT_SHADER);
fragmentShader.setSource(fragment);
success = fragmentShader.compile() && success;
gl::AttachShader(m_Handle, fragmentShader.handle());
bindAttribLocations();
return success && link() && enumerateStandardUniforms();
}
ParticleBasicMaterial::ParticleBasicMaterial() : Material(kParticleBasicMaterial)
{
// equivalent to three.js setMaterialShaders
initUniforms(uniforms);
vertexShader(ParticleBasicMaterial::kVertexShader);
fragmentShader(ParticleBasicMaterial::kFragmentShader);
color() = Color( 0xffffff );
// map = null;
size() = 1.0f;
sizeAttenuation() = true;
vertexColors() = false;
fog() = true;
}
/** Creates and links a shader program with a vertex and fragment shader */
GLShaderProgram::GLShaderProgram(const char* vs_filename, const char* fs_filename)
: mShaderProg(glCreateProgram())
{
GLShader vertexShader(GL_VERTEX_SHADER, vs_filename);
GLShader fragmentShader(GL_FRAGMENT_SHADER, fs_filename);
if (!vertexShader.isValid() || !fragmentShader.isValid())
{
fprintf(stderr, "Failed to create shader program\n");
return;
}
// Attach shaders
glAttachShader(mShaderProg.get(), vertexShader);
glAttachShader(mShaderProg.get(), fragmentShader);
// Link program
glLinkProgram(mShaderProg.get());
}
void ResourceManager::insertEffect(const std::string& name, const std::string& source) {
std::shared_ptr<Opengl::RenderEffect> effect(new Opengl::RenderEffect());
std::stringstream version;
version << "#version " << effect->getVersion() << "\n";
std::string vertexShader(source);
vertexShader.replace(vertexShader.find(TOKEN_VERSION), sizeof(TOKEN_VERSION), version.str());
vertexShader.replace(vertexShader.find(TOKEN_TYPE), sizeof(TOKEN_TYPE), "#define TYPE_VERTEX\n");
effect->attachShader(vertexShader, Opengl::RenderEffect::ShaderType::TYPE_VERTEX);
std::string fragmentShader(source);
fragmentShader.replace(fragmentShader.find(TOKEN_VERSION), sizeof(TOKEN_VERSION), version.str());
fragmentShader.replace(fragmentShader.find(TOKEN_TYPE), sizeof(TOKEN_TYPE), "#define TYPE_FRAGMENT\n");
effect->attachShader(fragmentShader, Opengl::RenderEffect::ShaderType::TYPE_FRAGMENT);
effect->enable(); // Compile
this->effectCache.insert(std::make_pair(name, effect));
}
std::auto_ptr< ShaderProgram >
createShaderProgram(
const char * vertexFilename,
const char * fragmentFilename
)
{
ShaderSource vertexSource;
vertexSource.loadShaderSource( vertexFilename );
Shader vertexShader( Shader::VertexShader );
vertexShader.setSource( vertexSource );
ShaderSource fragmentSource;
fragmentSource.loadShaderSource( fragmentFilename );
Shader fragmentShader( Shader::FragmentShader );
fragmentShader.setSource( fragmentSource );
std::auto_ptr< ShaderProgram > program( new ShaderProgram() );
program->attachShader( vertexShader );
program->attachShader( fragmentShader );
program->link();
return program;
}
ShaderProgram::ShaderProgram(std::string vertexshader,std::string fragmentshader)
{
// Initially, we have zero shaders attached to the program
m_shadercount = 0;
m_shaderProgramHandle = glCreateProgram();
//set up shaders
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile(SHADERS_PATH + vertexshader);
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile(SHADERS_PATH + fragmentshader);
fragmentShader.compile();
//set up shaderprogram
attachShader(vertexShader);
attachShader(fragmentShader);
link();
}
void canCopyProgram()
{
ShaderProgram shaderProgram;
Shader fragmentShader(Shader::FRAGMENT_SHADER);
fragmentShader.compile(VALID_FRAGMENT_SHADER_SOURCE);
shaderProgram.attach(fragmentShader);
Shader vertexShader(Shader::VERTEX_SHADER);
vertexShader.compile(VALID_VERTEX_SHADER_SOURCE);
shaderProgram.attach(vertexShader);
ShaderProgram copy = shaderProgram;
QVERIFY(copy.exists());
QVERIFY(copy.getId() != 0);
QVERIFY(glIsProgram(copy.getId()));
QVERIFY(copy.has(fragmentShader));
QVERIFY(copy.has(vertexShader));
QVERIFY(copy.link());
}
bool GLProgram::load(InputStream* input)
{
Z_LOG("Loading OpenGL program \"" << input->name() << "\".");
std::vector<std::string> vertex;
std::vector<std::string> fragment;
bool success = parseProgramSource(input, vertex, fragment);
GLShader vertexShader(GL::VERTEX_SHADER);
vertexShader.setSource(vertex);
success = vertexShader.compile() && success;
gl::AttachShader(m_Handle, vertexShader.handle());
GLShader fragmentShader(GL::FRAGMENT_SHADER);
fragmentShader.setSource(fragment);
success = fragmentShader.compile() && success;
gl::AttachShader(m_Handle, fragmentShader.handle());
bindAttribLocations();
return success && link() && enumerateStandardUniforms();
}
GLuint CompileShaders(const GLchar** vertexShaderSource, const GLchar** fragmentShaderSource )
{
//Compile vertex shader
GLuint vertexShader( glCreateShader( GL_VERTEX_SHADER ) );
glShaderSource( vertexShader, 1, vertexShaderSource, NULL );
glCompileShader( vertexShader );
//Compile fragment shader
GLuint fragmentShader( glCreateShader( GL_FRAGMENT_SHADER ) );
glShaderSource( fragmentShader, 1, fragmentShaderSource, NULL );
glCompileShader( fragmentShader );
//Link vertex and fragment shader together
GLuint program( glCreateProgram() );
glAttachShader( program, vertexShader );
glAttachShader( program, fragmentShader );
glLinkProgram( program );
//Delete shaders objects
glDeleteShader( vertexShader );
glDeleteShader( fragmentShader );
return program;
}
void canAssignProgram()
{
ShaderProgram shaderProgram;
Shader fragmentShader(Shader::FRAGMENT_SHADER);
fragmentShader.compile(VALID_FRAGMENT_SHADER_SOURCE);
shaderProgram.attach(fragmentShader);
Shader vertexShader(Shader::VERTEX_SHADER);
vertexShader.compile(VALID_VERTEX_SHADER_SOURCE);
shaderProgram.attach(vertexShader);
ShaderProgram copy;
Shader anotherShader(Shader::VERTEX_SHADER);
copy.attach(anotherShader);
QVERIFY(copy.has(anotherShader));
copy = shaderProgram;
QVERIFY(copy.has(fragmentShader));
QVERIFY(copy.has(vertexShader));
QVERIFY(!copy.has(anotherShader));
QVERIFY(copy.link());
}
void Setup(CPlatform * const pPlatform)
{
//for the shapes
unsigned int nTorusFloats;
float *pTorusVertices = 0;
float *pPlaneVertices = 0;
float colour[] = {1.0f,0.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,0.0f,1.0f};
unsigned int torusSegments = 36, torusTubeSegments = 36;
//for the shaders
const char *pVertStr[3] = {0,0,0}, *pFragStr = 0;
const char *pFragTexStr = 0, *pVertTexStr = 0;
//fbo stuff
WRender::Texture::SDescriptor descDepth = {WRender::Texture::TEX_2D, WRender::Texture::DEPTH_COMPONENT, TEX_DIMENSIONS, TEX_DIMENSIONS, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::CLAMP_TO_EDGE},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
};
glswInit();
glswSetPath("../resources/", ".glsl");
WRender::SetClearColour(0,0,0,0);
WRender::EnableCulling(true);
// - - - - - - - - - -
//setup the shaders
// - - - - - - - - - -
//normal shader
glswGetShadersAlt("shaders.Version+shaders.Shared+shaders.SingleShadow.Vertex", pVertStr, 3);
pFragStr = glswGetShaders("shaders.Version+shaders.SingleShadow.Fragment");
CShader vertexShader(CShader::VERT, pVertStr, 3);
CShader fragmentShader(CShader::FRAG, &pFragStr, 1);
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
uShadowMtx = program.GetUniformLocation("shadowMtx");
program.Start();
program.SetTextureUnit("shadowMap", 0);
program.Stop();
//debug shader for textures in screen space
pVertTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Vertex");
pFragTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Fragment");
CShader vTexShader(CShader::VERT, &pVertTexStr, 1);
CShader fTexShader(CShader::FRAG, &pFragTexStr, 1);
textureShader.Initialise();
textureShader.AddShader(&vTexShader);
textureShader.AddShader(&fTexShader);
textureShader.Link();
textureShader.Start();
textureShader.SetTextureUnit("texture",0);
textureShader.Stop();
// - - - - - - - - - -
//set up shapes
// - - - - - - - - - -
//shared colours
abColour = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(colour), colour);
//Torus
nTorusVertices = 2*torusTubeSegments*torusSegments*3;
nTorusFloats = nTorusVertices*3;
pTorusVertices = new float[nTorusFloats];
CreateTorus(pTorusVertices, torusSegments, 3.0f, torusTubeSegments, 1.0f);
vaoTorus = WRender::CreateVertexArrayObject();
abTorus = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*nTorusFloats, pTorusVertices);
WRender::BindVertexArrayObject(vaoTorus);
WRender::VertexAttribute vaTorus[2] = {
{abTorus, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*6, 1},
};
WRender::SetAttributeFormat( vaTorus, 2, 0);
delete[] pTorusVertices;
//Plane
pPlaneVertices = new float[4*3*3];
CreatePlane(pPlaneVertices, 20.0f, 20.0f);
vaoPlane = WRender::CreateVertexArrayObject();
abPlane = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*4*3*3, pPlaneVertices);
WRender::BindVertexArrayObject(vaoPlane);
WRender::VertexAttribute vaFrustum[2] = {
{abPlane, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*3, 1},
};
WRender::SetAttributeFormat( vaFrustum, 2, 0);
delete[] pPlaneVertices;
//for screen aligned texture
sqVao = WRender::CreateVertexArrayObject();
sqEab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(sqIndices), sqIndices);
sqAb = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(sqVertices), sqVertices);
WRender::BindVertexArrayObject(sqVao);
WRender::BindBuffer(WRender::ELEMENTS, sqEab);
WRender::VertexAttribute sqVa[2] = {
{sqAb, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0}, //vertices
{sqAb, 1, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}, //texture coordinates
};
WRender::SetAttributeFormat( sqVa, 2, 0);
WRender::UnbindVertexArrayObject();
// - - - - - - - - - -
//ubo for cameras etc
// - - - - - - - - - -
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
//create the texture and FBO for rendering to when drawing
//during shadow stage
WRender::CreateBaseTexture(depthTexture, descDepth);
WRender::SetTextureParams(depthTexture,param,4);
WRender::CreateFrameBuffer(fbo);
WRender::AddTextureRenderBuffer(fbo, depthTexture, WRender::ATT_DEPTH, 0);
WRender::BindFrameBuffer(WRender::FrameBuffer::DRAW, fbo);
WRender::SetDrawBuffer(WRender::DB_NONE);
WRender::CheckFrameBuffer(fbo);
//set the projection matrix
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 50.0f);
WRender::BindTexture(depthTexture,WRender::Texture::UNIT_0);
}
const char* sipQSGMaterialShader::sipProtectVirt_fragmentShader(bool sipSelfWasArg) const
{
return (sipSelfWasArg ? QSGMaterialShader::fragmentShader() : fragmentShader());
}
