void BatchSpriteRenderer::render(F32 x, F32 y, F32 width, F32 height, F32 angleRads) { F32 top = height/2; F32 right = width/2; F32 bottom = -height/2; F32 left = -width/2; F32 verts[] = { left, top, 0, right, top, 0, right, bottom, 0, left, bottom, 0 }; F32 uvs[] = { 0, 0, 1, 0, 1, 1, 0, 1 }; if (context->gConfig->useShaders) { ShaderProgram *shaderProgram = context->glResourceManager->getShaderProgram("quad"); Matrix4f myMvMatrix = context->renderContext->mvMatrix; myMvMatrix.translate(x, y, 0); myMvMatrix.rotate(angleRads * (180 / PI), 0, 0, -1.0f); glVertexAttribPointer(shaderProgram->getVertexAttributeLoc("vPosition"), 3, GL_FLOAT, GL_FALSE, 0, verts); glVertexAttribPointer(shaderProgram->getVertexAttributeLoc("uvMap"), 2, GL_FLOAT, GL_FALSE, 0, uvs); glUniformMatrix4fv(shaderProgram->getUniformLoc("projection_matrix"), 1, GL_FALSE, (GLfloat*) context->renderContext->projMatrix.data); glUniformMatrix4fv(shaderProgram->getUniformLoc("modelview_matrix"), 1, GL_FALSE, (GLfloat*) myMvMatrix.data); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } else { // GL1 rendering branch Vector4f colorFilter = context->renderContext->colorFilter; glColor4f(colorFilter.x,colorFilter.y,colorFilter.z,colorFilter.a); glPushMatrix(); glTranslatef(x, y, 0); glRotatef(angleRads * (180 / PI), 0, 0, 1.0f); glVertexPointer(3, GL_FLOAT, 0, &verts); glTexCoordPointer(2, GL_FLOAT, 0, &uvs); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glPopMatrix(); } }
ShaderProgram & ShaderManager::loadShader(const char * vertexShaderFilename, const char * fragmentShaderFilename) { // Has that shader already been loaded? for(vector<ShaderCacheHandle>::iterator iter = shaderProgramCache.begin(); iter != shaderProgramCache.end(); iter++) { if (iter->vertexShaderFilename.compare(vertexShaderFilename) == 0 && iter->fragmentShaderFilename.compare(fragmentShaderFilename) == 0) { LOG(LOG_RESOURCE, LOG_DEBUG) << "Returning cached shaderprogram: " << iter->shaderProgram->getProgramHandle(); return *iter->shaderProgram; } } bool success = true; // Compile and link the shader program ShaderProgram * shaderProgram = new ShaderProgram(); success = success && shaderProgram->addShaderFromFileResource(ShaderProgram::TYPE_VERTEX_SHADER, FileResource(vertexShaderFilename)); success = success && shaderProgram->addShaderFromFileResource(ShaderProgram::TYPE_FRAGMENT_SHADER, FileResource(fragmentShaderFilename)); success = success && shaderProgram->link(); if (!success) { shaderProgram->unload(); } ShaderCacheHandle cacheHandle; cacheHandle.vertexShaderFilename = vertexShaderFilename; cacheHandle.fragmentShaderFilename = fragmentShaderFilename; cacheHandle.shaderProgram = shaderProgram; shaderProgramCache.push_back(cacheHandle); return * shaderProgram; }
void VertexLayout::enable(ShaderProgram& _program, size_t _byteOffset, void* _ptr) { GLuint glProgram = _program.getGlProgram(); // Enable all attributes for this layout for (auto& attrib : m_attribs) { GLint location = _program.getAttribLocation(attrib.name); if (location != -1) { auto& loc = s_enabledAttribs[location]; // Track currently enabled attribs by the program to which they are bound if (loc != glProgram) { glEnableVertexAttribArray(location); loc = glProgram; } void* data = _ptr ? _ptr : ((unsigned char*) attrib.offset) + _byteOffset; glVertexAttribPointer(location, attrib.size, attrib.type, attrib.normalized, m_stride, data); } } // Disable previously bound and now-unneeded attributes for (auto& locationProgramPair : s_enabledAttribs) { const GLint& location = locationProgramPair.first; GLuint& boundProgram = locationProgramPair.second; if (boundProgram != glProgram && boundProgram != 0) { glDisableVertexAttribArray(location); boundProgram = 0; } } }
jboolean Java_android_filterfw_core_ShaderProgram_setShaderAttributeVertexFrame( JNIEnv* env, jobject thiz, jstring attr_name, jobject vertex_frame, jint type, jint component_count, jint stride, jint offset, jboolean normalize) { ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz); if (program) { // Get the vertex frame VertexFrame* v_frame = ConvertFromJava<VertexFrame>(env, vertex_frame); // Get the program variable to set const std::string attr_string = ToCppString(env, attr_name); ProgramVar program_var = program->GetAttribute(attr_string); // Set the variable if (v_frame && ShaderProgram::IsVarValid(program_var)) { const bool success = program->SetAttributeValues(program_var, v_frame, type, component_count, stride, offset, ToCppBool(normalize)); return ToJBool(success); } } return JNI_FALSE; }
ParticleSystem::ParticleSystem() : textureCount(0), textureSheet(NULL), projectionMatrix(1.0f), viewMatrix(1.0f) { std::vector<Vertex::Element> elements; elements.push_back(Vertex::Element(Vertex::Attribute::Position , Vertex::Element::Float, 3)); elements.push_back(Vertex::Element(Vertex::Attribute::get("a_vel"), Vertex::Element::Float, 3)); elements.push_back(Vertex::Element(Vertex::Attribute::Color , Vertex::Element::Float, 4)); elements.push_back(Vertex::Element(Vertex::Attribute::get("a_size"), Vertex::Element::Float, 1)); elements.push_back(Vertex::Element(Vertex::Attribute::get("a_texIndex"), Vertex::Element::Int, 1)); Vertex::Format format(elements); Mesh* mesh= new Mesh(format, 0, Mesh::STREAM); mesh->setPrimitiveType(Mesh::POINTS); model.mesh = mesh; Meshes.add("particlesMesh",mesh); if(!Programs.exists("__particleShader")) { ShaderProgram* p = new ShaderProgram(); p->makeProgramFromString(vertexShader,geometryShader,fragmentShader); Programs.add("__particleShader",p); } model.program = Programs.get("__particleShader"); setName("particleSystem"); setUpdatePriority(-100); setDrawPriority(100); }
void openGLThread(bool _draw, GLfloat _red) { //WindowGL * window = WindowGL::createWindow(640, 480); Context context; DriverGPU *driver = DriverGPU::get(); Shader vShader(eShaderType::eVertexShader, "../../src/shaders/vTriangleShader.vertex"); Shader fShader(eShaderType::eFragmentShader, "../../src/shaders/fTriangleShader.fragment"); ShaderProgram sProgram; sProgram.attachShader(vShader); sProgram.attachShader(fShader); sProgram.bindAttribute(0, "vPosition"); sProgram.link(); while(running) { //window->peekMessage(); //window->swapBuffers(); //if (_draw) // drawOnBuffer(640, 480, sProgram, _red); } delete driver; }
ShaderProgram* SpriteCache::createDefaultShader () { if (!Gdx::graphics->isGL20Available()) return NULL; std::string vertexShader = "attribute vec4 " + ShaderProgram::POSITION_ATTRIBUTE + ";\n" // "attribute vec4 " + ShaderProgram::COLOR_ATTRIBUTE + ";\n" // "attribute vec2 " + ShaderProgram::TEXCOORD_ATTRIBUTE + "0;\n" // "uniform mat4 u_projectionViewMatrix;\n" // "varying vec4 v_color;\n" // "varying vec2 v_texCoords;\n" // "\n" // "void main()\n" // "{\n" // " v_color = " + ShaderProgram::COLOR_ATTRIBUTE + ";\n" // " v_texCoords = " + ShaderProgram::TEXCOORD_ATTRIBUTE + "0;\n" // " gl_Position = u_projectionViewMatrix * " + ShaderProgram::POSITION_ATTRIBUTE + ";\n" // "}\n"; std::string fragmentShader = "#ifdef GL_ES\n" // "precision mediump float;\n" // "#endif\n" // "varying vec4 v_color;\n" // "varying vec2 v_texCoords;\n" // "uniform sampler2D u_texture;\n" // "void main()\n"// "{\n" // " gl_FragColor = v_color * texture2D(u_texture, v_texCoords);\n" // "}"; ShaderProgram* shader = new ShaderProgram(vertexShader, fragmentShader); if (shader->isCompiled() == false) throw std::runtime_error("Error compiling shader: " + shader->getLog()); return shader; }
void move_it(ShaderProgram program, Matrix& modelMatrix, Matrix& projectionMatrix, Matrix& viewMatrix,float x, float y){ program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); modelMatrix.identity(); modelMatrix.Translate(x, y, 0.0); }
void cannotValidateUnlinkProgram() { ShaderProgram shaderProgram; QVERIFY(!shaderProgram.validate()); QVERIFY(!shaderProgram.getLastValidationLog().empty()); }
void TerrainDeformationProgram::Initialize(){ m_FrameBuffer = new FrameBuffer(); m_FrameBuffer->Init(); glGenTextures(1, &m_BrushTexture); glBindTexture(GL_TEXTURE_2D, m_BrushTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_BRUSH_RES, m_BRUSH_RES, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindTexture(GL_TEXTURE_2D, 0); //fill in brush m_BrushGenProgram = g_ShaderBank.LoadShaderProgram("../../../shader/BrushTexGenProgram.glsl"); ShaderProgram* prog = g_ShaderBank.GetProgramFromHandle(m_BrushGenProgram); prog->Apply(); prog->SetUniformFloat("hardness", 1.0f); glBindImageTexture(0, m_BrushTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8); const int WORK_GROUP_SIZE = 32; GLuint WorkGroupSize = GLuint((m_BRUSH_RES + WORK_GROUP_SIZE - 1) / float(WORK_GROUP_SIZE)); glDispatchCompute(WorkGroupSize, WorkGroupSize, 1); m_DrawProgram = g_ShaderBank.LoadShaderProgram("../../../shader/SpriteShader.glsl"); m_BrushTex = new Texture(); m_BrushTex->Init("../../../binasset/texture/brush.png", TEXTURE_COLOR); m_FilterProgram = g_ShaderBank.LoadShaderProgram("../../../shader/TerrainDeformFilter.glsl"); }
void render(float delta){ float ClearColor[4] = { 0.5f, 0.5f, 0.5f, 1.0f }; // red,green,blue,alpha float ClearColor2[4] = { 0.1f, 0.2f, 0.3f, 1.0f }; // red,green,blue,alpha clearTargetColor(m_pRenderTargetView,ClearColor); clearTargetColor(*backTarget->getTarget(),ClearColor2); clearTargetDepth(m_depthStencilView,1); static float t=0; t+=delta; m_World = XMMatrixRotationY(t); ConstantBuffer cb; cb.mWorld = XMMatrixTranspose( m_World ); cb.mView = XMMatrixTranspose( m_View ); cb.mProjection = XMMatrixTranspose( m_Projection); people->updateConstantbuffer(m_pImmediateContext,0,&cb); m_pImmediateContext->OMSetRenderTargets(1,backTarget->getTarget(),m_depthStencilView); people->draw(m_pImmediateContext); clearTargetDepth(m_depthStencilView,1); m_pImmediateContext->OMSetRenderTargets(1,&m_pRenderTargetView,m_depthStencilView); people->draw(m_pImmediateContext); view_shader->use(m_pImmediateContext); m_pImmediateContext->PSSetShaderResources(0,1,backTarget->getShaderResource()); view_shader->setConstantBuffer(m_pImmediateContext,0,&quard->s_Matrix); //quard->draw(m_pImmediateContext); controller->visite(m_pImmediateContext); //MyLuaManager::getInstance()->doFile("lua/lua_script/render.lua"); presentDraw(); }
/*------------------------------------- * Set the vertex layout locations for an unlinked shader program -------------------------------------*/ bool ShaderProgramAssembly::assign_shader_layouts( const ShaderProgram& prog, const ShaderObject& shdr ) const noexcept { if (prog.get_attached_shader_id(shdr.get_shader_type()) != shdr.gpu_id()) { return false; } // fragment shaders in OpenGLES 3.0 can't have their location manually // specified as glBindFragDataLocation is unavailable. Geometry shaders on // desktop GL versions should not have attribs as it increases the amount // of required maintenance for a feature with limited support. if (shdr.get_shader_type() != shader_stage_t::SHADER_STAGE_VERTEX) { return true; } // Manually assign layout locations so OpenGL doesn't optimize out // perfectly valid locations of variables. const ShaderAttribArray& attribs = shdr.get_attribs(); for (unsigned i = 0; i < attribs.get_num_attribs(); ++i) { const ShaderAttrib& attrib = attribs.get_attrib(i); glBindAttribLocation(prog.gpu_id(), attrib.get_location(), attrib.get_name().get()); LS_LOG_GL_ERR(); } return true; }
void Font::Flush(float deltaTime) { //flush all of the vertices to the GPU for drawing if (!preRenderStage) { timer += deltaTime; if (timer > 1.f / 60.f) //60fps text updating { timer = 0; preRenderStage = true; //clear out the memory to start rendering new ones vertices = new vector<Vertex>(); indices = new vector<int>(); } } else { m->SetVertices(vertices, GL_STREAM_DRAW, true); m->SetIndices(indices, GL_STREAM_DRAW, true); m->FlushBuffers(); preRenderStage = false; } glEnable(GL_BLEND); renderer->Ready(); ShaderProgram *prog = renderer->GetProgram(); prog->SetUniform("MVP", (void*)value_ptr(guiCam->Get())); renderer->Render(); glDisable(GL_BLEND); }
void VertexLayout::enable(RenderState& rs, ShaderProgram& _program, size_t _byteOffset, void* _ptr) { GLuint glProgram = _program.getGlProgram(); // Enable all attributes for this layout for (auto& attrib : m_attribs) { GLint location = _program.getAttribLocation(attrib.name); if (location != -1) { auto& loc = rs.attributeBindings[location]; // Track currently enabled attribs by the program to which they are bound if (loc != glProgram) { GL::enableVertexAttribArray(location); loc = glProgram; } void* data = (unsigned char*)_ptr + attrib.offset + _byteOffset; GL::vertexAttribPointer(location, attrib.size, attrib.type, attrib.normalized, m_stride, data); } } // Disable previously bound and now-unneeded attributes for (size_t i = 0; i < RenderState::MAX_ATTRIBUTES; ++i) { GLuint& boundProgram = rs.attributeBindings[i]; if (boundProgram != glProgram && boundProgram != 0) { GL::disableVertexAttribArray(i); boundProgram = 0; } } }
void Entity::update(float& lastFrameTicks, float& elapsed, Matrix& projectionMatrix, Matrix& viewMatrix, ShaderProgram& program, bool stat) { // Update modelMatrix Matrix modelMatrix; static bool wall = false; if (stat) { modelMatrix.identity(); modelMatrix.Scale(0.5, 2, 0); program.setModelMatrix(modelMatrix); } else { if (y >= -0.65) { if (x > -1.85 && !wall) { x -= elapsed/2; } if (x <= -1.85) { wall = true; y -= elapsed*2; } if (x < 1.85 && wall) { x += elapsed/2; } if (x >= 1.85) { wall = false; y -= elapsed*4; } } modelMatrix.identity(); modelMatrix.Scale(0.5, 2, 0); modelMatrix.Translate(x, y+0.4, 0); program.setModelMatrix(modelMatrix); } }
void cannotLinkProgramWithoutShader() { ShaderProgram shaderProgram; QVERIFY(!shaderProgram.link()); QCOMPARE(shaderProgram.getLastLinkLog().c_str(), "Cannot link program because no shader is attached!"); }
void nativeRender(int camtex, float *mat) { if (!running) return; ShaderEngine::Engine->reset(); ShaderBuffer *oldfbo = ShaderEngine::Engine->setFramebuffer(rdrTgt); ShaderEngine::Engine->setViewport(0, 0, tex->width, tex->height); Matrix4 projection = ShaderEngine::Engine->setOrthoFrustum(0, tex->baseWidth, 0, tex->baseHeight, -1, 1); ShaderEngine::Engine->setProjection(projection); Matrix4 model; ShaderEngine::Engine->setModel(model); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_EXTERNAL_OES, camtex); shader->setConstant(shader->getConstantByName("tMatrix"), ShaderProgram::CMATRIX, 1, mat); shader->setData(ShaderProgram::DataVertex, ShaderProgram::DFLOAT, 2, &vertices[0], vertices.size(), vertices.modified, &vertices.bufferCache); shader->setData(ShaderProgram::DataTexture, ShaderProgram::DFLOAT, 2, &texcoords[0], texcoords.size(), texcoords.modified, &texcoords.bufferCache); shader->drawElements(ShaderProgram::TriangleStrip, indices.size(), ShaderProgram::DUSHORT, &indices[0], indices.modified, &indices.bufferCache); vertices.modified = false; texcoords.modified = false; indices.modified = false; ShaderEngine::Engine->setFramebuffer(oldfbo); }
int main(void){ WindowGL window("render2texture", 640, 480); DriverGPU * driver = DriverGPU::get(); Texture tulipsTex("./Tulips.jpg"); Shader vShader(eShaderType::eVertexShader, "../../src/shaders/flat.vertex"); Shader sobelShader(eShaderType::eFragmentShader, "../../src/shaders/sobel.fragment"); ShaderProgram program; program.attachShader(vShader); program.attachShader(sobelShader); program.link(); #if defined(_WIN32) window.peekMessage(); double t0 = STime::get()->getTime(); drawImage(tulipsTex, program); double t1 = STime::get()->getTime(); #endif std::cout << "Edge detection spent " << t1 - t0 << std::endl; window.swapBuffers(); // delete window; Class has no destructor, undefined behaviour delete driver; system("PAUSE"); return 0; }
void ShadowMap::Render( RenderQueue* rq ) { ShaderProgram* prog = g_ShaderBank.GetProgramFromHandle( m_Shader ); prog->Apply(); glBindFramebuffer( GL_FRAMEBUFFER, m_FrameBuffer ); glEnable( GL_DEPTH_TEST ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK); const GLfloat one = 1.0f; glClearBufferfv( GL_DEPTH, 0, &one ); glViewport( 0, 0, m_Size, m_Size ); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset( 1.0f, 4.0f ); //glm::mat4 viewProj = m_Proj * m_View; //prog->SetUniformMat4( "g_ViewProj", viewProj ); //unsigned int bufferOffset = 0; //unsigned int instanceCount = 0; //g_ModelBank.ApplyBuffers(); //// for each model to be rendered //for ( auto& mo : rq->GetModelQueue() ) { // const Model& model = g_ModelBank.FetchModel( mo.Model ); // instanceCount = mo.InstanceCount; // prog->SetUniformUInt( "g_BufferOffset", bufferOffset ); // // for each mesh // for ( auto& mesh : model.Meshes ) { // glDrawElementsInstanced( GL_TRIANGLES, mesh.Indices, GL_UNSIGNED_INT, // ( GLvoid* )( 0 + ( ( model.IndexHandle + mesh.IndexBufferOffset ) * sizeof( unsigned int ) ) ), instanceCount ); // } // bufferOffset += instanceCount; //} //glDisable(GL_POLYGON_OFFSET_FILL); }
void onDraw(Graphics& g){ g.pointSize(renderMode+0.5); g.color(RGB(1)); mesh.colors().reset(); switch (renderMode) { case 0: // do it on the CPU: for (int k=0; k<N; k++) { for (int j=0; j<N; j++) { for (int i=0; i<N; i++) { Color color; data.read_interp(color.components, i,j,k); mesh.color(color); }}} g.draw(mesh); break; case 1: // use 3D texcoords: tex.bind(); g.draw(mesh); tex.unbind(); break; case 2: // use shader: shader.begin(); tex.bind(); g.draw(mesh); tex.unbind(); shader.end(); break; default:; } }
jboolean Java_android_filterfw_core_ShaderProgram_setShaderAttributeValues( JNIEnv* env, jobject thiz, jstring attr_name, jfloatArray values, jint component_count) { ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz); if (program) { // Get the floats to set jfloat* float_ptr = env->GetFloatArrayElements(values, NULL); const int length = env->GetArrayLength(values); // Get the program variable to set const std::string attr_string = ToCppString(env, attr_name); ProgramVar program_var = program->GetAttribute(attr_string); // Set the variable if (float_ptr && ShaderProgram::IsVarValid(program_var)) { const bool success = program->SetAttributeValues(program_var, reinterpret_cast<float*>(float_ptr), length, component_count); env->ReleaseFloatArrayElements(values, float_ptr, JNI_ABORT); return ToJBool(success); } } return JNI_FALSE; }
void VertexBufferObjectSubData::bind (ShaderProgram& shader) { GL20& gl = *gl20; gl.glBindBuffer(gdx::GL::ARRAY_BUFFER, bufferHandle); if (isDirty) { byteBuffer.limit(buffer.limit() * 4); gl.glBufferSubData(gdx::GL::ARRAY_BUFFER, 0, byteBuffer.limit(), byteBuffer); // gl.glBufferData(gdx::GL::ARRAY_BUFFER, byteBuffer.limit(), // byteBuffer, usage); isDirty = false; } int numAttributes = attributes.size(); for (int i = 0; i < numAttributes; i++) { VertexAttribute& attribute = attributes.get(i); shader.enableVertexAttribute(attribute.alias); int colorType = gdx::GL::FLOAT; bool normalize = false; if (attribute.usage == VertexAttributes::Usage::ColorPacked) { colorType = gdx::GL::UNSIGNED_BYTE; normalize = true; } shader.setVertexAttribute(attribute.alias, attribute.numComponents, colorType, normalize, attributes.vertexSize, attribute.offset); } isBound = true; }
jobject Java_android_filterfw_core_ShaderProgram_getUniformValue(JNIEnv* env, jobject thiz, jstring key) { ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz); const std::string c_key = ToCppString(env, key); return program ? ToJObject(env, program->GetUniformValue(c_key)) : JNI_NULL; }
gfx::ShaderProgramHandle gfx::ShaderBank::LoadShaderProgramWithDefines ( const std::string& filename, ShaderDefineContainer& defines ) { ShaderProgram* program = new ShaderProgram (); #ifdef SHADER_BINARY_PROGRAM ShaderProgramBinary header; if(program->LoadProgramBinaryHeader(filename, header)) { if(strcmp(header.Version, (char*)glGetString(GL_VERSION)) == 0) { program->LoadProgramBinary(filename); ShaderProgramHandle handle = m_Counter++; m_Programs.push_back(program); m_HandleToPrograms.emplace( handle, program ); return handle; } } if(program->LoadCompleteShaderProgramFromFile(filename, true, defines)) { program->SaveProgramBinary(); } #else //program->LoadCompleteShaderProgramFromFile(filename, true, defines); #endif ShaderProgramHandle handle = m_Counter++; m_Programs.push_back(program); m_HandleToPrograms.emplace( handle, program ); return handle; }
int main(void){ WindowGL window("Texture loader", 640, 480); DriverGPU * driver = DriverGPU::get(); Shader vShader(eShaderType::eVertexShader, "../../src/shaders/flat.vertex"); Shader fShader(eShaderType::eFragmentShader, "../../src/shaders/flat.fragment"); ShaderProgram program; program.attachShader(vShader); program.attachShader(fShader); program.link(); bool condition = true; do{ #if defined(_WIN32) window.peekMessage(); drawImage(program); #endif window.swapBuffers(); } while (condition); window.hide(); #ifdef _WIN32 system("PAUSE"); #endif // delete window; Class has no destructor, undefined behaviour delete driver; return 0; }
void VideoLayerAndroid::showPreparingAnimation(const SkRect& rect, const SkRect innerRect) { ShaderProgram* shader = TilesManager::instance()->shader(); VideoLayerManager* manager = TilesManager::instance()->videoLayerManager(); // Paint the video content's background. PureColorQuadData backGroundQuadData(Color(128, 128, 128, 255), LayerQuad, &m_drawTransform, &rect); shader->drawQuad(&backGroundQuadData); TransformationMatrix addReverseRotation; TransformationMatrix addRotation = m_drawTransform; addRotation.translate(innerRect.fLeft, innerRect.fTop); double halfButtonSize = manager->getButtonSize() / 2; addRotation.translate(halfButtonSize, halfButtonSize); addReverseRotation = addRotation; addRotation.rotate(m_rotateDegree); addRotation.translate(-halfButtonSize, -halfButtonSize); SkRect size = SkRect::MakeWH(innerRect.width(), innerRect.height()); TextureQuadData spinnerQuadData(manager->getSpinnerOuterTextureId(), GL_TEXTURE_2D, GL_LINEAR, LayerQuad, &addRotation, &size); shader->drawQuad(&spinnerQuadData); addReverseRotation.rotate(-m_rotateDegree); addReverseRotation.translate(-halfButtonSize, -halfButtonSize); spinnerQuadData.updateTextureId(manager->getSpinnerInnerTextureId()); spinnerQuadData.updateDrawMatrix(&addReverseRotation); shader->drawQuad(&spinnerQuadData); m_rotateDegree += ROTATESTEP; }
//---------------------------------------------------------------------------- void SSDOTriMesh::OnGetShaderConstants() { TriangleMesh::OnGetShaderConstants(); ShaderProgram* program = mMaterial->GetProgram(0, 0); program->GetUniformLocation(&mMaterialColorLoc, "materialColor"); }
static ShaderProgram* createProgram( ShaderProgramIndex index ) { ShaderProgram* program = nullptr; Ptr<Data> vertex_data; Ptr<Data> pixel_data; switch( index ) { case kShaderProgram_Color: { program = new ShaderProgram(); vertex_data = Assets::loadFile( "standard/shaders/test_vertex.glsl" ); pixel_data = Assets::loadFile( "standard/shaders/test_fragment.glsl" ); } break; default: break; } if( vertex_data == nullptr || fragment_data == nullptr ) return nullptr; program->setVertexSource( vertex_data->ptr() ); program->setFragmentSource( fragment_data->ptr() ); if( !program->build() ) return nullptr; if( !program-> ) return program; }
double GLWebViewState::setupDrawing(const IntRect& invScreenRect, const SkRect& visibleContentRect, const IntRect& screenRect, int titleBarHeight, const IntRect& screenClip, float scale) { TilesManager* tilesManager = TilesManager::instance(); // Make sure GL resources are created on the UI thread. // They are created either for the first time, or after EGL context // recreation caused by onTrimMemory in the framework. ShaderProgram* shader = tilesManager->shader(); if (shader->needsInit()) { ALOGD("Reinit shader"); shader->initGLResources(); } TransferQueue* transferQueue = tilesManager->transferQueue(); if (transferQueue->needsInit()) { ALOGD("Reinit transferQueue"); transferQueue->initGLResources(TilesManager::tileWidth(), TilesManager::tileHeight()); } shader->setupDrawing(invScreenRect, visibleContentRect, screenRect, titleBarHeight, screenClip, scale); double currentTime = WTF::currentTime(); setVisibleContentRect(visibleContentRect, scale); return currentTime; }
void SimpleRender::Render(ICamera* camera, const Vector4f& lightPosition) { ShaderProgram* shader = isAo ? m_aoShader : m_simpleShader; // bind shader of the batch. shader->Bind(); m_vertexBuffer->EnableVertexAttribInterleavedWithBind(); shader->SetUniform("textureArray", 0); Texture::SetActiveTextureUnit(0); m_arrayTexture->Bind(); shader->SetUniform("aoOnly", 1.0f); Matrix4f modelMatrix = Matrix4f::CreateIdentity(); //geoObj->GetModelMatrix(); shader->SetPhongUniforms( modelMatrix , camera, lightPosition); for(size_t i = 0; i < m_chunks.size(); ++i) { Chunk* chunk = m_chunks[i]; chunk->m_indexBuffer->Bind(); chunk->m_indexBuffer->DrawIndices(GL_TRIANGLES, (chunk->m_numTriangles)*3); chunk->m_indexBuffer->Unbind(); } m_vertexBuffer->DisableVertexAttribInterleavedWithBind(); m_arrayTexture->Unbind(); }