void GlMesh::destroyGL(){ glAssert(glDeleteVertexArrays(1, &vertexArrayObject_)); vertexArrayObject_ = 0; glAssert(glDeleteBuffers(2, vertexBufferObjects_)); vertexBufferObjects_[0] = 0; vertexBufferObjects_[1] = 1; }
void BSplinePatch::destroyGL(){ glAssert(glDeleteVertexArrays(1, &mVertexArrayObject)); mVertexArrayObject = 0; glAssert(glDeleteBuffers(2, mVertexBufferObjects)); mVertexBufferObjects[0] = 0; mVertexBufferObjects[1] = 1; }
//------------------------------------------- // Initialisation des resources globales //------------------------------------------- void Renderer::initRessources() { // Initialisation des paramètres OpenGL. { // 1 - Activer le test de profondeur glAssert(glEnable(GL_DEPTH_TEST)); // 2 - Positionner le mode de dessin glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)); // Fin du code à écrire } // Viewing parameters initialisation initView(); // Loading or building geometric data. initGeometry(); // Set up lighting initLighting(); // Shaders initialisation initShaders(); }
void Texture::useMipMap(GLenum minFliter, GLenum magFilter) { glAssert(glBindTexture(GL_TEXTURE_2D, mTexId)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFliter)); glAssert(glGenerateMipmap(GL_TEXTURE_2D)); }
void SpikeGuideRenderer::doRender(RenderContext& renderContext) { ActiveShader shader(renderContext.shaderManager(), Shaders::VaryingPCShader); m_spikeArray.render(GL_LINES); glAssert(glPointSize(3.0f)); m_pointArray.render(GL_POINTS); glAssert(glPointSize(1.0f)); }
std::string BackgroundSubtractorLOBSTER_<ParallelUtils::eGLSL>::getComputeShaderSource(size_t nStage) const { lvDbgExceptionWatch; glAssert(m_bInitialized); glAssert(nStage<m_nComputeStages); if(nStage==0) return getComputeShaderSource_LOBSTER(); else //nStage==1 && BGSLOBSTER_GLSL_USE_POSTPROC return getComputeShaderSource_PostProc(); }
void FrameBuffer::initColorAttachments() { if(fbo != 0 && attachments.size() != 0) { bindFBO(); glAssert(glDrawBuffers(attachments.size(), attachments.data())); } else glAssert(glDrawBuffer(GL_NONE)); check(); }
/** * Draws the VartexArrayObjects of the mesh. */ void GlMesh::drawGL() { // Début du code à écrire // 1 - Activer le VAO glAssert( glBindVertexArray(vertexArrayObject_) ); // 2 - Dessiner les triangles. Les sommets des triangles étant indexés et non consécutifs (sauf cas très particulier) // on utilisera la fonction glDrawElements(...) glAssert( glDrawElements(GL_TRIANGLES, 3*nbTriangles_, GL_UNSIGNED_INT, NULL) ); // Fin du code à écrire }
void printProgramInfoLog(GLint program) { int infoLogLen = 0; int charsWritten = 0; GLchar *infoLog; glAssert(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen)); if (infoLogLen > 0) { infoLog = new GLchar[infoLogLen]; // error check for fail to allocate memory omitted glAssert(glGetProgramInfoLog(program, infoLogLen, &charsWritten, infoLog)); std::cerr << "InfoLog:" << std::endl << infoLog << std::endl; delete [] infoLog; } }
int Renderer::handleKeyEvent(char key) { switch (key) { case 'w': glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)); break; case 'f': glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)); break; } return 1; }
bool FrameBuffer::check() { GLenum err; glAssert(err = glCheckFramebufferStatus(GL_FRAMEBUFFER)); if (err != GL_FRAMEBUFFER_COMPLETE) { std::cerr << "FBO not complete (error = " << err << ") : "; switch (err) { case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: std::cerr << "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; break; case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: std::cerr << "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; break; case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: std::cerr << "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"; break; case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: std::cerr << "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"; break; case GL_FRAMEBUFFER_UNSUPPORTED: std::cerr << "GL_FRAMEBUFFER_UNSUPPORTED"; break; default: std::cerr << "Unknown ERROR"; } std::cerr << std::endl; } return err == GL_FRAMEBUFFER_COMPLETE; }
/// @todo add more shader type void ShaderObject::create(GLenum type) { glAssert(mId = glCreateShader(type)); mType = type; switch (mType) { case GL_VERTEX_SHADER : mTypeString = "Vertex "; break; case GL_FRAGMENT_SHADER : mTypeString = "Fragment "; break; /** @todo : find a way to define automagically these strings ... */ case GL_GEOMETRY_SHADER : mTypeString = "Geometry "; break; case GL_TESS_CONTROL_SHADER : mTypeString = "Tess control "; break; case GL_TESS_EVALUATION_SHADER : mTypeString = "Tess eval "; break; default: std::cerr <<"shader type " << type << "not supported"<<std::endl; break; } }
void EdgeDetector_<ParallelUtils::eGLSL>::getLatestEdgeMask(cv::OutputArray _oLastEdgeMask) { _oLastEdgeMask.create(m_oFrameSize,CV_8UC1); cv::Mat oLastEdgeMask = _oLastEdgeMask.getMat(); if(!GLImageProcAlgo::m_bFetchingOutput) glAssert(GLImageProcAlgo::setOutputFetching(true)) GLImageProcAlgo::fetchLastOutput(oLastEdgeMask); }
void BackgroundSubtractorLOBSTER_<ParallelUtils::eGLSL>::getBackgroundDescriptorsImage(cv::OutputArray oBGDescImg) const { lvDbgExceptionWatch; CV_Assert(m_bInitialized); glAssert(m_bGLInitialized && !m_vnBGModelData.empty()); CV_Assert(LBSP::DESC_SIZE==2); oBGDescImg.create(m_oFrameSize,CV_16UC(int(m_nImgChannels))); cv::Mat oOutputImg = oBGDescImg.getMatRef(); glBindBuffer(GL_SHADER_STORAGE_BUFFER,getSSBOId(BackgroundSubtractorLOBSTER_::eLOBSTERStorageBuffer_BGModelBinding)); glGetBufferSubData(GL_SHADER_STORAGE_BUFFER,0,m_nBGModelSize*sizeof(uint),(void*)m_vnBGModelData.data()); glErrorCheck; for(size_t nRowIdx=0; nRowIdx<(size_t)m_oFrameSize.height; ++nRowIdx) { const size_t nModelRowOffset = nRowIdx*m_nRowStepSize; const size_t nImgRowOffset = nRowIdx*oOutputImg.step.p[0]; for(size_t nColIdx=0; nColIdx<(size_t)m_oFrameSize.width; ++nColIdx) { const size_t nModelColOffset = nColIdx*m_nColStepSize+nModelRowOffset; const size_t nImgColOffset = nColIdx*oOutputImg.step.p[1]+nImgRowOffset; std::array<float,4> afCurrPxSum = {0.0f,0.0f,0.0f,0.0f}; for(size_t nSampleIdx=0; nSampleIdx<m_nBGSamples; ++nSampleIdx) { const size_t nModelPxOffset_color = nSampleIdx*m_nSampleStepSize+nModelColOffset; const size_t nModelPxOffset_desc = nModelPxOffset_color+(m_nBGSamples*m_nSampleStepSize); for(size_t nChannelIdx=0; nChannelIdx<m_nImgChannels; ++nChannelIdx) { const size_t nModelTotOffset = nChannelIdx+nModelPxOffset_desc; afCurrPxSum[nChannelIdx] += m_vnBGModelData[nModelTotOffset]; } } for(size_t nChannelIdx=0; nChannelIdx<m_nImgChannels; ++nChannelIdx) { const size_t nSampleChannelIdx = ((nChannelIdx==3||m_nImgChannels==1)?nChannelIdx:2-nChannelIdx); const size_t nImgTotOffset = nSampleChannelIdx*2+nImgColOffset; *(ushort*)(oOutputImg.data+nImgTotOffset) = (ushort)(afCurrPxSum[nChannelIdx]/m_nBGSamples); } } } }
void IBackgroundSubtractor_GLSL::initialize_gl(const cv::Mat& oInitImg, const cv::Mat& oROI) { glAssert(!oInitImg.empty()); cv::Mat oCurrROI = oROI; if(oCurrROI.empty()) oCurrROI = cv::Mat(oInitImg.size(),CV_8UC1,cv::Scalar_<uchar>(255)); ParallelUtils::IParallelAlgo_GLSL::initialize_gl(oInitImg,oROI); }
std::string BackgroundSubtractorLOBSTER_<ParallelUtils::eGLSL>::getComputeShaderSource_PostProc() const { lvDbgExceptionWatch; glAssert(m_nDefaultMedianBlurKernelSize>0); std::stringstream ssSrc; //////////////////////////////////////////////////////////////////////////////////////////////////////////////// ssSrc << "#version 430\n" "layout(local_size_x=" << m_vDefaultWorkGroupSize.x << ",local_size_y=" << m_vDefaultWorkGroupSize.y << ") in;\n" //"layout(binding=" << GLImageProcAlgo::eImage_ROIBinding << ", r8ui) readonly uniform uimage2D mROI;\n" "layout(binding=" << GLImageProcAlgo::eImage_OutputBinding << ", r8ui) uniform uimage2D mOutput;\n" << GLShader::getComputeShaderFunctionSource_BinaryMedianBlur(size_t(m_nDefaultMedianBlurKernelSize),BGSLOBSTER_GLSL_USE_SHAREDMEM,m_vDefaultWorkGroupSize); //////////////////////////////////////////////////////////////////////////////////////////////////////////////// ssSrc << "void main() {\n" " ivec2 vImgCoords = ivec2(gl_GlobalInvocationID.xy);\n" //" uint nROIVal = imageLoad(mROI,vImgCoords).r;\n" #if BGSLOBSTER_GLSL_USE_SHAREDMEM " preload_data(mOutput);\n" " barrier();\n" " uint nFinalSegmRes = BinaryMedianBlur(vImgCoords);\n" #else //!BGSLOBSTER_GLSL_USE_SHAREDMEM " uint nFinalSegmRes = BinaryMedianBlur(mOutput,vImgCoords);\n" " barrier();\n" #endif //!BGSLOBSTER_GLSL_USE_SHAREDMEM " imageStore(mOutput,vImgCoords,uvec4(nFinalSegmRes));\n" "}\n"; //////////////////////////////////////////////////////////////////////////////////////////////////////////////// return ssSrc.str(); }
void ShaderProgram::del() { int status; glAssert(glGetProgramiv(mId, GL_DELETE_STATUS, &status)); std::cerr << "delete status " << status << std::endl; glAssert(glDeleteProgram(mId)); std::cerr <<" delete shader " << mId << " " << (GL_TRUE == glIsProgram(mId)) << std::endl; if(glIsProgram(mId)){ glAssert(glGetProgramiv(mId, GL_DELETE_STATUS, &status)); std::cerr << "delete status " << status << std::endl; } else{ std::cerr << mId << " is not a program " << std::endl; } glCheckError(); mId = -1; }
void IBackgroundSubtractor_GLSL::apply_gl(cv::InputArray _oNextImage, bool bRebindAll, double dLearningRate) { glAssert(m_bInitialized && m_bModelInitialized); m_dCurrLearningRate = dLearningRate; cv::Mat oNextInputImg = _oNextImage.getMat(); CV_Assert(oNextInputImg.type()==m_nImgType && oNextInputImg.size()==m_oImgSize); CV_Assert(oNextInputImg.isContinuous()); ++m_nFrameIdx; GLImageProcAlgo::apply_gl(oNextInputImg,bRebindAll); oNextInputImg.copyTo(m_oLastColorFrame); }
void Compass::doRender(RenderContext& renderContext) { const Camera& camera = renderContext.camera(); const Camera::Viewport& viewport = camera.unzoomedViewport(); const int viewWidth = viewport.width; const int viewHeight = viewport.height; const Mat4x4f projection = orthoMatrix(0.0f, 1000.0f, -viewWidth / 2.0f, viewHeight / 2.0f, viewWidth / 2.0f, -viewHeight / 2.0f); const Mat4x4f view = viewMatrix(Vec3f::PosY, Vec3f::PosZ) * translationMatrix(500.0f * Vec3f::PosY); const ReplaceTransformation ortho(renderContext.transformation(), projection, view); const Mat4x4f compassTransformation = translationMatrix(Vec3f(-viewWidth / 2.0f + 55.0f, 0.0f, -viewHeight / 2.0f + 55.0f)) * scalingMatrix<4>(2.0f); const MultiplyModelMatrix compass(renderContext.transformation(), compassTransformation); const Mat4x4f cameraTransformation = cameraRotationMatrix(camera); glAssert(glClear(GL_DEPTH_BUFFER_BIT)); renderBackground(renderContext); glAssert(glClear(GL_DEPTH_BUFFER_BIT)); doRenderCompass(renderContext, cameraTransformation); }
void BackgroundSubtractor_<ParallelUtils::eGLSL>::getLatestForegroundMask(cv::OutputArray _oLastFGMask) { _oLastFGMask.create(m_oImgSize,CV_8UC1); cv::Mat oLastFGMask = _oLastFGMask.getMat(); if(!GLImageProcAlgo::m_bFetchingOutput) glAssert(GLImageProcAlgo::setOutputFetching(true)) else if(m_nFrameIdx>0) GLImageProcAlgo::fetchLastOutput(oLastFGMask); else oLastFGMask = cv::Scalar_<uchar>(0); }
Shader::Shader(const IO::Path& path, const GLenum type) : m_name(path.lastComponent().asString()), m_type(type), m_shaderId(0) { assert(m_type == GL_VERTEX_SHADER || m_type == GL_FRAGMENT_SHADER); glAssert(m_shaderId = glCreateShader(m_type)); if (m_shaderId == 0) throw RenderException("Cannot create shader " + m_name); const StringList source = loadSource(path); const char** linePtrs = new const char*[source.size()]; for (size_t i = 0; i < source.size(); i++) linePtrs[i] = source[i].c_str(); glAssert(glShaderSource(m_shaderId, static_cast<GLsizei>(source.size()), linePtrs, NULL)); delete[] linePtrs; glAssert(glCompileShader(m_shaderId)); GLint compileStatus; glAssert(glGetShaderiv(m_shaderId, GL_COMPILE_STATUS, &compileStatus)); if (compileStatus == 0) { RenderException ex; ex << "Cannot compile shader " << m_name << ": "; GLint infoLogLength; glAssert(glGetShaderiv(m_shaderId, GL_INFO_LOG_LENGTH, &infoLogLength)); if (infoLogLength > 0) { char* infoLog = new char[infoLogLength]; glGetShaderInfoLog(m_shaderId, infoLogLength, &infoLogLength, infoLog); infoLog[infoLogLength-1] = 0; ex << infoLog; delete [] infoLog; } else { ex << "Unknown error"; } throw ex; } }
void BSpline3D::compileGL(){ glAssert( glGenVertexArrays(1, &mVertexArrayObject) ); glAssert( glGenBuffers(2, mVertexBufferObjects) ); glAssert( glBindVertexArray(mVertexArrayObject) ); glAssert( glBindBuffer(GL_ARRAY_BUFFER, mVertexBufferObjects[VBO_VERTICES]) ); glAssert( glBufferData(GL_ARRAY_BUFFER, mMesh.size() * sizeof(glm::vec3), &(mMesh[0]), GL_STATIC_DRAW) ); GLuint stride = sizeof(glm::vec3); GLboolean normalized = GL_FALSE; GLenum type = GL_FLOAT; GLuint index = 0; GLint size = 3; GLvoid *pointer = BUFFER_OFFSET(0); glAssert( glVertexAttribPointer(index, size, type, normalized, stride, pointer) ); glAssert( glEnableVertexAttribArray(index) ); glAssert( glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mVertexBufferObjects[VBO_INDICES]) ); glAssert( glBufferData(GL_ELEMENT_ARRAY_BUFFER, mIndices.size() * sizeof(int), &(mIndices[0]), GL_STATIC_DRAW) ); glAssert( glBindVertexArray(0) ); }
int ShaderObject::check() { GLint compiled; glAssert(glGetShaderiv(mId, GL_COMPILE_STATUS, &compiled)); if (!compiled) { std::cerr << mTypeString << " shader not compiled : " << mFileName << std::endl; printShaderInfoLog(mId); return 0; } return 1; }
void Renderer::renderDebug(const glm::mat4x4 &modelViewMatrix, const glm::mat4x4 &projectionMatrix) { glm::mat4x4 localprojectionMatrix = glm::perspective(90.f, (float)width_ / (float)height_, 0.1f, 10.0f); glm::mat4x4 localmodelViewMatrix = viewMatrix_; GLint transformationLoc[4]; GLint colorLocation; glAssert(glUseProgram(programLine_)); glAssert(transformationLoc[0] = glGetUniformLocation(programLine_, "modelViewMatrix")); glAssert(transformationLoc[1] = glGetUniformLocation(programLine_, "projectionMatrix")); glAssert(transformationLoc[2] = glGetUniformLocation(programLine_, "normalMatrix")); glAssert(transformationLoc[3] = glGetUniformLocation(programLine_, "MVP")); glAssert(colorLocation = glGetUniformLocation(programLine_, "color")); }
void BackgroundSubtractorLOBSTER_<ParallelUtils::eGLSL>::dispatch(size_t nStage, GLShader& oShader) { lvDbgExceptionWatch; glAssert(nStage<m_nComputeStages); if(nStage==0) { if(m_dCurrLearningRate>0) oShader.setUniform1ui("nResamplingRate",(GLuint)ceil(m_dCurrLearningRate)); else oShader.setUniform1ui("nResamplingRate",BGSLOBSTER_DEFAULT_LEARNING_RATE); } else //nStage==1 && BGSLOBSTER_GLSL_USE_POSTPROC glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT); glDispatchCompute((GLuint)ceil((float)m_oFrameSize.width/m_vDefaultWorkGroupSize.x),(GLuint)ceil((float)m_oFrameSize.height/m_vDefaultWorkGroupSize.y),1); }
void DirectionSampler::compileGL() { std::vector<glm::vec4> lambdaomega; #ifdef HALTON_SEQUENCE Halton_sampler halton_sampler; halton_sampler.init_faure(); for (int i=0; i< nbDirections_; ++i) { float value = halton_sampler.sample(0, i+3); lambdaomega.push_back(glm::vec4(directions_[i], value )); } #else // TODO : find or implement a better random generator (cf halton sequence) std::default_random_engine generator; std::uniform_real_distribution<float> distribution(0.0f, 1.0f); for (int i=0; i< nbDirections_; ++i) { float value = distribution(generator) ; lambdaomega.push_back(glm::vec4(directions_[i], value)); } #endif glAssert(glGenVertexArrays(1, &mVertexArrayObject)); // bind vertex Array glAssert(glBindVertexArray(mVertexArrayObject)); // always generate all buffers : one for vertexdata one for indices glAssert(glGenBuffers(1, mVertexBufferObjects)); // bind vertexdata glAssert(glBindBuffer(GL_ARRAY_BUFFER, mVertexBufferObjects[VBO_VERTICES])); glAssert(glBufferData(GL_ARRAY_BUFFER, nbDirections_ * sizeof(glm::vec4), &(lambdaomega[0]), GL_STATIC_DRAW)); // global values GLuint stride = 0; GLboolean normalized = GL_FALSE; GLenum type = GL_FLOAT; // point GLuint index = 0; GLint size = 4; GLvoid *pointer = BUFFER_OFFSET(0); glAssert(glVertexAttribPointer(index, size, type, normalized, stride, pointer)); glAssert(glEnableVertexAttribArray(index)); if (mTexture_) delete mTexture_; mTexture_= new Texture("spheresamples", GL_TEXTURE_RECTANGLE, Texture::TEX_RECT); mTexture_->textureFloatInitGL(GL_RGBA32F, nbDirections_, 1, GL_RGBA, GL_FLOAT, &(lambdaomega[0])); }
int ShaderProgram::check() { GLint linked; glAssert(glGetProgramiv(mId, GL_LINK_STATUS, &linked)); if (!linked) { std::cerr << "Program not linked" << std::endl; for (unsigned int i = 0; i < mShaderObjects.size(); ++i) { std::cerr << mShaderObjects[i]->getFileName() << std::endl; } printProgramInfoLog(mId); return 0; } return 1; }
std::string LBSP::getShaderFunctionSource(size_t nChannels, bool bUseSharedDataPreload, const glm::uvec2& vWorkGroupSize) { glAssert(nChannels==4 || nChannels==1); std::stringstream ssSrc; // @@@@@ split lookup/threshold? if(!bUseSharedDataPreload) ssSrc << "uvec3 lbsp(in uvec3 t, in uvec3 ref, in layout(" << (nChannels==4?"rgba8ui":"r8ui") << ") readonly uimage2D mData, in ivec2 vCoords) {\n" " return (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-1, 1)).rgb)-ivec3(ref))),t)) << 15)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 1,-1)).rgb)-ivec3(ref))),t)) << 14)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 1, 1)).rgb)-ivec3(ref))),t)) << 13)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-1,-1)).rgb)-ivec3(ref))),t)) << 12)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 1, 0)).rgb)-ivec3(ref))),t)) << 11)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 0,-1)).rgb)-ivec3(ref))),t)) << 10)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-1, 0)).rgb)-ivec3(ref))),t)) << 9)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 0, 1)).rgb)-ivec3(ref))),t)) << 8)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-2,-2)).rgb)-ivec3(ref))),t)) << 7)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 2, 2)).rgb)-ivec3(ref))),t)) << 6)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 2,-2)).rgb)-ivec3(ref))),t)) << 5)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-2, 2)).rgb)-ivec3(ref))),t)) << 4)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 0, 2)).rgb)-ivec3(ref))),t)) << 3)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 0,-2)).rgb)-ivec3(ref))),t)) << 2)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2( 2, 0)).rgb)-ivec3(ref))),t)) << 1)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(imageLoad(mData,vCoords+ivec2(-2, 0)).rgb)-ivec3(ref))),t)));\n" "}\n"; else { ssSrc << GLShader::getComputeShaderFunctionSource_SharedDataPreLoad(nChannels,vWorkGroupSize,LBSP::PATCH_SIZE/2) << "uvec3 lbsp(in uvec3 t, in uvec3 ref, in ivec2 vCoords) {\n" " ivec2 vLocalCoords = vCoords-ivec2(gl_GlobalInvocationID.xy)+ivec2(gl_LocalInvocationID.xy)+ivec2(" << LBSP::PATCH_SIZE/2 << ");\n" " return (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+1][vLocalCoords.x-1].rgb)-ivec3(ref))),t)) << 15)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-1][vLocalCoords.x+1].rgb)-ivec3(ref))),t)) << 14)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+1][vLocalCoords.x+1].rgb)-ivec3(ref))),t)) << 13)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-1][vLocalCoords.x-1].rgb)-ivec3(ref))),t)) << 12)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y ][vLocalCoords.x+1].rgb)-ivec3(ref))),t)) << 11)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-1][vLocalCoords.x ].rgb)-ivec3(ref))),t)) << 10)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y ][vLocalCoords.x-1].rgb)-ivec3(ref))),t)) << 9)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+1][vLocalCoords.x ].rgb)-ivec3(ref))),t)) << 8)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-2][vLocalCoords.x-2].rgb)-ivec3(ref))),t)) << 7)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+2][vLocalCoords.x+2].rgb)-ivec3(ref))),t)) << 6)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-2][vLocalCoords.x+2].rgb)-ivec3(ref))),t)) << 5)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+2][vLocalCoords.x-2].rgb)-ivec3(ref))),t)) << 4)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y+2][vLocalCoords.x ].rgb)-ivec3(ref))),t)) << 3)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y-2][vLocalCoords.x ].rgb)-ivec3(ref))),t)) << 2)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y ][vLocalCoords.x+2].rgb)-ivec3(ref))),t)) << 1)\n" " + (uvec3(greaterThan(uvec3(abs(ivec3(avPreloadData[vLocalCoords.y ][vLocalCoords.x-2].rgb)-ivec3(ref))),t)));\n" "}\n"; } return ssSrc.str(); }
void Compass::renderAxisOutline(RenderContext& renderContext, const Mat4x4f& transformation, const Color& color) { glAssert(glDepthMask(GL_FALSE)); glAssert(glLineWidth(3.0f)); glAssert(glPolygonMode(GL_FRONT, GL_LINE)); ActiveShader shader(renderContext.shaderManager(), Shaders::CompassOutlineShader); shader.set("Color", color); renderAxis(renderContext, transformation); glAssert(glDepthMask(GL_TRUE)); glAssert(glLineWidth(1.0f)); glAssert(glPolygonMode(GL_FRONT, GL_FILL)); }
void Texture::initGL(int bytesperpixel, int width, int height, int format, int type, unsigned char * data) { mWidth=width; mHeight=height; mFormat = (bytesperpixel == GL_RGBA); mPixOrder = (GL_RGB == format); mPixels = new unsigned char[mWidth*mHeight*(3+mFormat)]; memcpy(mPixels, data, mWidth*mHeight*(3+mFormat)*sizeof(unsigned char)); glAssert(glGenTextures(1, &mTexId)); glAssert(glBindTexture(GL_TEXTURE_2D, mTexId)); glAssert(glTexImage2D(GL_TEXTURE_2D, 0, bytesperpixel, width, height, 0, format, type, data)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); glAssert(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); }