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()); }