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