From 0797b5b3c9f796c5ef9aab2f82a7853395c23b2a Mon Sep 17 00:00:00 2001
From: Florent Berthaut <florent.berthaut@univ-lille.fr>
Date: Wed, 20 Mar 2024 16:07:36 +0100
Subject: [PATCH] Fix audio uniforms
---
src/audio/AudioManager.cpp | 184 ++---
src/modules/ProjectorModule.cpp | 1186 +++++++++++++++----------------
src/shaders/render43.fs | 994 +++++++++++++-------------
3 files changed, 1182 insertions(+), 1182 deletions(-)
diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index 05ad254..a565d93 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -24,7 +24,7 @@
void* audioThreadFunction(void* pvParam) {
AudioManager *pThis=(AudioManager*)pvParam;
- pThis->startStream();
+ pThis->startStream();
return 0;
}
@@ -48,116 +48,116 @@ int AudioManager::getMixSize(){
}
int AudioManager::rtaudio_callback(void *outbuf, void *inbuf, unsigned int nFrames,
- double streamtime, RtAudioStreamStatus status, void *userdata) {
+ double streamtime, RtAudioStreamStatus status, void *userdata) {
(void)inbuf;
- float *buf = (float*)outbuf;
- AudioManager::CallbackData *data = (AudioManager::CallbackData*) userdata;
-
- //if we've reached the first buffer again, retrieve values from the ring
- if(data->bufCounter==0) {
- if(ringbuffer_read_space(data->ringBuffer) >= data->bufSize) {
-
- //read all the audio values
- ringbuffer_read(data->ringBuffer, data->buffer, data->bufSize);
-
- //mix the first buffer with the last of the previous
- float step = 1.0/float(nFrames);
- float cnt = 0.0;
- for(int i=0; i < nFrames; ++i) {
- buf[i*2] = data->buffer[i]*cnt + data->mixBuffer[i]*(1.0-cnt);
- buf[i*2+1] = buf[i*2];
- cnt+=step;
- }
-
- //save the last buffer for crossfading
- memcpy(&data->mixBuffer[0],
- data->buffer+(data->bufSize-data->mixSize),
- data->mixSize*sizeof(float));
- }
- else {
- memset(buf, 0, nFrames*data->nChannel*sizeof(float));
- memset(data->buffer, 0, data->bufSize*sizeof(float));
- memset(data->mixBuffer, 0, nFrames*sizeof(float));
- //cout<<"AudioManager : Could not read buffer"<<endl;
- }
- }
- else {
- //read the next buffer
- for(int i=0; i<nFrames; ++i) {
- buf[i*2] = data->buffer[data->bufCounter*nFrames+i];
- buf[i*2+1] = buf[i*2];
- }
- }
-
- //move to the next buffer
- data->bufCounter=(data->bufCounter+1)%(data->nbBufs-1);
-
- return 0;
+ float *buf = (float*)outbuf;
+ AudioManager::CallbackData *data = (AudioManager::CallbackData*) userdata;
+
+ //if we've reached the first buffer again, retrieve values from the ring
+ if(data->bufCounter==0) {
+ if(ringbuffer_read_space(data->ringBuffer) >= data->bufSize) {
+
+ //read all the audio values
+ ringbuffer_read(data->ringBuffer, data->buffer, data->bufSize);
+
+ //mix the first buffer with the last of the previous
+ float step = 1.0/float(nFrames);
+ float cnt = 0.0;
+ for(int i=0; i < nFrames; ++i) {
+ buf[i*2] = data->buffer[i]*cnt + data->mixBuffer[i]*(1.0-cnt);
+ buf[i*2+1] = buf[i*2];
+ cnt+=step;
+ }
+
+ //save the last buffer for crossfading
+ memcpy(&data->mixBuffer[0],
+ data->buffer+(data->bufSize-data->mixSize),
+ data->mixSize*sizeof(float));
+ }
+ else {
+ memset(buf, 0, nFrames*data->nChannel*sizeof(float));
+ memset(data->buffer, 0, data->bufSize*sizeof(float));
+ memset(data->mixBuffer, 0, nFrames*sizeof(float));
+ //cout<<"AudioManager : Could not read buffer"<<endl;
+ }
+ }
+ else {
+ //read the next buffer
+ for(int i=0; i<nFrames; ++i) {
+ buf[i*2] = data->buffer[data->bufCounter*nFrames+i];
+ buf[i*2+1] = buf[i*2];
+ }
+ }
+
+ //move to the next buffer
+ data->bufCounter=(data->bufCounter+1)%(data->nbBufs-1);
+
+ return 0;
}
AudioManager::AudioManager() {
- m_init=false;
+ m_init=false;
}
void AudioManager::init() {
- //m_rtAudio = new RtAudio(RtAudio::LINUX_PULSE);
+ //m_rtAudio = new RtAudio(RtAudio::LINUX_PULSE);
m_rtAudio = new RtAudio(RtAudio::UNIX_JACK);
param = new RtAudio::StreamParameters();
param->deviceId = m_rtAudio->getDefaultOutputDevice();
param->nChannels = 2;
- options = new RtAudio::StreamOptions();
- options->streamName = "Rivill";
+ options = new RtAudio::StreamOptions();
+ options->streamName = "Rivill";
data.nRate = m_rtAudio->getDeviceInfo(param->deviceId).preferredSampleRate;
- m_rtBufSize = 1024;
+ m_rtBufSize = 1024;
- bool init=true;
+ bool init=true;
try{
- m_rtAudio->openStream(param, NULL, RTAUDIO_FLOAT32, data.nRate,
- &m_rtBufSize,
- AudioManager::rtaudio_callback, &data, options);
- }
- catch(const exception& e) {
- init=false;
- }
-
- if(init) {
- int nbBufs = 5;
- m_bufSize = m_rtBufSize*nbBufs;
-
- data.ringBuffer = ringbuffer_create(m_bufSize*3);
-
- data.nChannel = param->nChannels;
- data.bufSize = m_bufSize;
- data.buffer = new float[m_bufSize];
- data.nbBufs = nbBufs;
- data.bufCounter = 0;
- memset(&data.buffer[0], 0, data.bufSize*sizeof(float));
-
- data.mixSize = m_rtBufSize;
- data.mixBuffer = new float[data.mixSize];
- memset(&data.mixBuffer[0], 0, data.mixSize*sizeof(float));
-
- m_thread = new std::thread(audioThreadFunction, this);
- m_init = true;
- }
+ m_rtAudio->openStream(param, NULL, RTAUDIO_FLOAT32, data.nRate,
+ &m_rtBufSize,
+ AudioManager::rtaudio_callback, &data, options);
+ }
+ catch(const exception& e) {
+ init=false;
+ }
+
+ if(init) {
+ int nbBufs = 6-m_rtBufSize/256;
+ m_bufSize = m_rtBufSize*nbBufs;
+
+ data.ringBuffer = ringbuffer_create(m_bufSize*3);
+
+ data.nChannel = param->nChannels;
+ data.bufSize = m_bufSize;
+ data.buffer = new float[m_bufSize];
+ data.nbBufs = nbBufs;
+ data.bufCounter = 0;
+ memset(&data.buffer[0], 0, data.bufSize*sizeof(float));
+
+ data.mixSize = m_rtBufSize;
+ data.mixBuffer = new float[data.mixSize];
+ memset(&data.mixBuffer[0], 0, data.mixSize*sizeof(float));
+
+ m_thread = new std::thread(audioThreadFunction, this);
+ m_init = true;
+ }
}
bool AudioManager::changeBuf(float* outputBuf, float maxSinValue) {
- if(m_init) {
- //check if there is space to write the new values
- size_t write_space = ringbuffer_write_space(data.ringBuffer);
- if(write_space >= m_bufSize) {
- //write all data to the ringbuffer
- ringbuffer_write(data.ringBuffer, outputBuf, data.bufSize);
- return true;
- }
- else {
- //cout<<"AudioManager : Could not write buffer"<<endl;
- }
- }
- return false;
+ if(m_init) {
+ //check if there is space to write the new values
+ size_t write_space = ringbuffer_write_space(data.ringBuffer);
+ if(write_space >= m_bufSize) {
+ //write all data to the ringbuffer
+ ringbuffer_write(data.ringBuffer, outputBuf, data.bufSize);
+ return true;
+ }
+ else {
+ //cout<<"AudioManager : Could not write buffer"<<endl;
+ }
+ }
+ return false;
}
diff --git a/src/modules/ProjectorModule.cpp b/src/modules/ProjectorModule.cpp
index 1fe803f..45037c0 100644
--- a/src/modules/ProjectorModule.cpp
+++ b/src/modules/ProjectorModule.cpp
@@ -21,7 +21,7 @@
*/
/*////////////
-Calibration heavily relies on code from :
+ Calibration heavily relies on code from :
https://github.com/Kj1/ofxProjectorKinectCalibration
https://github.com/kylemcdonald/ofxCv
*/////////////////////
@@ -59,11 +59,11 @@ ProjectorModule::ProjectorModule(): Module() {
m_audioProcessType=0;
m_active=true;
m_postFilter=0;
- m_transparentBackground=false;
+ m_transparentBackground=false;
//create window
m_projWindow = glfwCreateWindow(m_width, m_height,
- "Rivill - Projector", NULL, NULL);
+ "Rivill - Projector", NULL, NULL);
if(!m_projWindow) {
glfwTerminate();
exit(EXIT_FAILURE);
@@ -74,34 +74,34 @@ ProjectorModule::ProjectorModule(): Module() {
glfwSetWindowSizeCallback(m_projWindow, windowSizeCallback);
glfwSetWindowPosCallback(m_projWindow, windowPositionCallback);
glfwSetFramebufferSizeCallback(m_projWindow, framebufferSizeCallback);
- glfwSetInputMode(m_projWindow, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+ glfwSetInputMode(m_projWindow, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
addNameAttribute();
addRemoveAttribute();
addAttribute(new Attribute("active",
- Attribute::BOOL_ATTRIBUTE,
- activeCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::BOOL_ATTRIBUTE,
+ activeCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("window_dimensions",
- Attribute::INT_ATTRIBUTE,
- windowDimensionsCallback, this, 4,
- Attribute::LOCAL));
+ Attribute::INT_ATTRIBUTE,
+ windowDimensionsCallback, this, 4,
+ Attribute::LOCAL));
addAttribute(new Attribute("fullscreen_monitor",
- Attribute::STRING_ATTRIBUTE,
- fullscreenMonitorCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::STRING_ATTRIBUTE,
+ fullscreenMonitorCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("view_matrix",
- Attribute::FLOAT_ATTRIBUTE,
- viewMatrixCallback, this, 16,
- Attribute::HIDDEN));
+ Attribute::FLOAT_ATTRIBUTE,
+ viewMatrixCallback, this, 16,
+ Attribute::HIDDEN));
addAttribute(new Attribute("projection_matrix",
- Attribute::FLOAT_ATTRIBUTE,
- projectionMatrixCallback, this, 16,
- Attribute::HIDDEN));
+ Attribute::FLOAT_ATTRIBUTE,
+ projectionMatrixCallback, this, 16,
+ Attribute::HIDDEN));
addAttribute(new Attribute("mirrored",
- Attribute::BOOL_ATTRIBUTE,
- mirroredCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::BOOL_ATTRIBUTE,
+ mirroredCallback, this, 1,
+ Attribute::LOCAL));
addTransformationAttributes();
m_attributesMap["scale"]->setAccessibility(Attribute::HIDDEN);
@@ -110,52 +110,52 @@ ProjectorModule::ProjectorModule(): Module() {
m_attributesMap["position"]->setFloats(posVec);
addAttribute(new Attribute("attached_to_camera",
- Attribute::STRING_ATTRIBUTE,
- attachToCamCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::STRING_ATTRIBUTE,
+ attachToCamCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("calibrate_with_camera",
- Attribute::ACTION_STRING_ATTRIBUTE,
- calibrateCallback, this, 1,
- Attribute::LOCAL,
- false));
+ Attribute::ACTION_STRING_ATTRIBUTE,
+ calibrateCallback, this, 1,
+ Attribute::LOCAL,
+ false));
addAttribute(new Attribute("output_revealed",
- Attribute::BOOL_ATTRIBUTE,
- outputRevealedCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::BOOL_ATTRIBUTE,
+ outputRevealedCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("post_filter",
- Attribute::INT_ATTRIBUTE,
- postFilterCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::INT_ATTRIBUTE,
+ postFilterCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("transparent_window",
- Attribute::BOOL_ATTRIBUTE,
- transparentWindowCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::BOOL_ATTRIBUTE,
+ transparentWindowCallback, this, 1,
+ Attribute::LOCAL));
addAttribute(new Attribute("audio_process",
- Attribute::STRING_ATTRIBUTE,
- audioProcessTypeCallback, this, 1,
- Attribute::LOCAL));
+ Attribute::STRING_ATTRIBUTE,
+ audioProcessTypeCallback, this, 1,
+ Attribute::LOCAL));
m_audioProcessTypes.push_back("none");
m_audioProcessTypes.push_back("additiveSynthesis");
m_audioProcessTypes.push_back("pitchedAdditiveSynthesis");
m_attributesMap["audio_process"]
- ->editStringValuesChoices().assign(1, m_audioProcessTypes);
+ ->editStringValuesChoices().assign(1, m_audioProcessTypes);
m_attributesMap["audio_process"]
- ->setStrings(vector<string>(1,m_audioProcessTypes[0]));
+ ->setStrings(vector<string>(1,m_audioProcessTypes[0]));
//initialize attributes
vector<string> labels;
labels.push_back("none");
m_attributesMap["attached_to_camera"]
- ->editStringValuesChoices().assign(1, labels);
+ ->editStringValuesChoices().assign(1, labels);
m_attributesMap["attached_to_camera"]
- ->initStrings(vector<string>(1, labels[0]));
+ ->initStrings(vector<string>(1, labels[0]));
m_attributesMap["calibrate_with_camera"]
- ->editStringValuesChoices().assign(1, labels);
+ ->editStringValuesChoices().assign(1, labels);
m_attributesMap["calibrate_with_camera"]
- ->initStrings(vector<string>(1, labels[0]));
+ ->initStrings(vector<string>(1, labels[0]));
refreshMonitors();
m_attributesMap["fullscreen_monitor"]
- ->initStrings(vector<string>(1, "windowed"));
+ ->initStrings(vector<string>(1, "windowed"));
m_attachedToCam=NULL;
m_attributesMap["output_revealed"]->initBools(vector<bool>(1, true));
m_attributesMap["post_filter"]->initInts(vector<int>(1, 0));
@@ -165,20 +165,20 @@ ProjectorModule::ProjectorModule(): Module() {
//initialize matrices
m_viewMat = lookAt(vec3(0.0, 0.0, 0.0),
- vec3(0.0, 0.0, 1.0),
- vec3(0.0, 1.0, 0.0));
+ vec3(0.0, 0.0, 1.0),
+ vec3(0.0, 1.0, 0.0));
mat4 glCoordsMat(-1, 0, 0, 0,
- 0, 1, 0, 0,
- 0, 0, 1, 0,
- 0, 0, 0, 1);
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1);
m_viewMat=glCoordsMat*m_viewMat;
m_attributesMap["view_matrix"]->setFloats(vector<float>(
- value_ptr(m_viewMat),
- value_ptr(m_viewMat)+16));
+ value_ptr(m_viewMat),
+ value_ptr(m_viewMat)+16));
m_projMat = perspective(45.0, 4.0/3.0, 100.0, 10000.0);
m_attributesMap["projection_matrix"]->setFloats(vector<float>(
- value_ptr(m_projMat),
- value_ptr(m_projMat)+16));
+ value_ptr(m_projMat),
+ value_ptr(m_projMat)+16));
vector<int> dims(4,0);
dims[0]=m_posX;
@@ -197,15 +197,15 @@ ProjectorModule::ProjectorModule(): Module() {
m_patternPosOffset = Size(0,0);
- //audio
- m_nbTracks=3000;
+ //audio
+ m_nbTracks=200;
m_maxAudioValue = (std::numeric_limits<int>::max())/(m_width * m_height);
m_audioMixSize = AudioManager::getInstance()->getMixSize();
m_audioBufSize = AudioManager::getInstance()->getBufferSize();
- m_imgBufSize = m_audioBufSize+3;
+ m_imgBufSize = m_audioBufSize+3;
m_audioBuffer = new float[m_audioBufSize];
memset(&m_audioBuffer[0], 0, m_audioBufSize*sizeof(float));
- m_audioNextBuf=1;
+ m_audioNextBuf=1;
Reveal::getInstance()->addContextHandler(this);
@@ -238,22 +238,22 @@ void ProjectorModule::draw() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(m_programs[Reveal::SLICEPROG]);
glUniform1f(m_uniforms[Reveal::SLICEPROG][Reveal::MIRRORED],
- float(m_mirrored));
+ float(m_mirrored));
glUniformMatrix4fv(m_uniforms[Reveal::SLICEPROG][Reveal::VIEWPROJMAT], 1,
- GL_FALSE, value_ptr(m_viewProjMat));
+ GL_FALSE, value_ptr(m_viewProjMat));
glUniformMatrix4fv(m_uniforms[Reveal::SLICEPROG][Reveal::VIEWMAT], 1,
- GL_FALSE, value_ptr(m_transViewMat));
+ GL_FALSE, value_ptr(m_transViewMat));
const vector<Geometry*>& depthGeoms = m_space->getGeoms();
vector<Geometry*>::const_iterator itDGeom=depthGeoms.begin();
for(; itDGeom!=depthGeoms.end(); ++itDGeom) {
(*itDGeom)->draw(m_contextHandlerID,
- Reveal::SLICEPROG,
- m_uniforms[Reveal::SLICEPROG],
- m_visibilityMask);
+ Reveal::SLICEPROG,
+ m_uniforms[Reveal::SLICEPROG],
+ m_visibilityMask);
}
- //select to texture for 3D models only
+ //select to texture for 3D models only
glBindFramebuffer(GL_FRAMEBUFFER, m_selectFBO);
glViewport(0, 0, m_rttWidth, m_rttHeight);
glEnable(GL_DEPTH_TEST);
@@ -266,26 +266,26 @@ void ProjectorModule::draw() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(m_programs[Reveal::SELECTPROG]);
glUniform1f(m_uniforms[Reveal::SELECTPROG][Reveal::MIRRORED],
- float(m_mirrored));
+ float(m_mirrored));
glUniformMatrix4fv(m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPROJMAT], 1,
- GL_FALSE, value_ptr(m_viewProjMat));
+ GL_FALSE, value_ptr(m_viewProjMat));
glUniformMatrix4fv(m_uniforms[Reveal::SELECTPROG][Reveal::VIEWMAT], 1,
- GL_FALSE, value_ptr(m_transViewMat));
+ GL_FALSE, value_ptr(m_transViewMat));
glUniform1f(m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTWIDTH],
- m_rttWidth);
+ m_rttWidth);
glUniform1f(m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTHEIGHT],
- m_rttHeight);
+ m_rttHeight);
glUniform1i(m_uniforms[Reveal::SELECTPROG][Reveal::SLICETEX], 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_sliceRttTex);
const vector<Geometry*>& sceneGeoms = Reveal::getInstance()->getGeoms();
for(auto& geom : sceneGeoms) {
- if(geom->getIsModel()) {
- geom->draw(m_contextHandlerID,
- Reveal::SELECTPROG,
- m_uniforms[Reveal::SELECTPROG],
- m_visibilityMask);
- }
+ if(geom->getIsModel()) {
+ geom->draw(m_contextHandlerID,
+ Reveal::SELECTPROG,
+ m_uniforms[Reveal::SELECTPROG],
+ m_visibilityMask);
+ }
}
@@ -301,7 +301,7 @@ void ProjectorModule::draw() {
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glEnable(GL_CULL_FACE);
- if(m_mirrored) {
+ if(m_mirrored) {
glCullFace(GL_FRONT);
}
else {
@@ -314,22 +314,22 @@ void ProjectorModule::draw() {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUseProgram(m_programs[Reveal::RENDERPROG]);
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::MIRRORED],
- float(m_mirrored));
+ float(m_mirrored));
glUniformMatrix4fv(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPROJMAT], 1,
- GL_FALSE, value_ptr(m_viewProjMat));
+ GL_FALSE, value_ptr(m_viewProjMat));
glUniformMatrix4fv(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWMAT], 1,
GL_FALSE, value_ptr(m_transViewMat));
if(m_postFilter>0) {
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTWIDTH],
- m_rttWidth);
+ m_rttWidth);
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTHEIGHT],
- m_rttHeight);
+ m_rttHeight);
}
else {
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTWIDTH],
- m_width);
+ m_width);
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTHEIGHT],
- m_height);
+ m_height);
}
glActiveTexture(GL_TEXTURE0);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::SLICETEX], 0);
@@ -338,44 +338,44 @@ void ProjectorModule::draw() {
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::SELECTTEX], 1);
glBindTexture(GL_TEXTURE_2D, m_selectTex);
#ifdef GL43
- //glActiveTexture(GL_TEXTURE7);
+ //glActiveTexture(GL_TEXTURE7);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::OUTPUTTEX], 0);
glBindImageTexture(0, m_outputTex, 0, GL_FALSE, 0,
- GL_READ_WRITE, GL_R32UI);
+ GL_READ_WRITE, GL_R32UI);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::OUTSHAPESIZE],
- m_outShapeSize);
+ m_outShapeSize);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::OUTDEPTHSIZE],
- m_outDepthSize);
+ m_outDepthSize);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::OUTNBDEPTH],
- m_outNbDepth);
+ m_outNbDepth);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::PROCESSAUDIO],
- m_audioProcessType);
+ m_audioProcessType);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOTEX], 1);
glBindImageTexture(1, m_audioTex, 0, GL_FALSE, 0,
- GL_READ_WRITE, GL_R32I);
+ GL_READ_WRITE, GL_R32I);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIORATE],
- AudioManager::getInstance()->getRate());
+ AudioManager::getInstance()->getRate());
glUniform1f(m_uniforms[Reveal::RENDERPROG][Reveal::MAXAUDIOVALUE],
- m_maxAudioValue);
+ m_maxAudioValue);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOBUFSIZE],
- m_audioBufSize);
+ m_audioBufSize);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOMIXSIZE],
- m_audioMixSize);
+ m_audioMixSize);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONEXTBUF],
- m_audioNextBuf);
+ m_audioNextBuf);
glUniform1i(m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONBTRACKS],
- m_nbTracks);
+ m_nbTracks);
#endif
- //Draw everything
+ //Draw everything
for(auto& geom : sceneGeoms) {
geom->draw(m_contextHandlerID,
- Reveal::RENDERPROG,
- m_uniforms[Reveal::RENDERPROG],
- m_visibilityMask);
+ Reveal::RENDERPROG,
+ m_uniforms[Reveal::RENDERPROG],
+ m_visibilityMask);
}
//POST PROCESSING
@@ -392,11 +392,11 @@ void ProjectorModule::draw() {
glUniform1i(m_uniforms[Reveal::POSTPROG][Reveal::RENDERTEX], 0);
glBindTexture(GL_TEXTURE_2D, m_renderTex);
glUniform1f(m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTWIDTH],
- m_width);
+ m_width);
glUniform1f(m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTHEIGHT],
- m_height);
+ m_height);
glUniform1f(m_uniforms[Reveal::POSTPROG][Reveal::POSTFILTER],
- m_postFilter);
+ m_postFilter);
m_calibGeom->drawDirect(m_contextHandlerID);
}
@@ -409,16 +409,16 @@ void ProjectorModule::draw() {
if(m_processOutput) {
processOutput();
}
- if(m_audioProcessType>0) {
- processAudio();
- }
+ if(m_audioProcessType>0) {
+ processAudio();
+ }
#endif
}
void ProjectorModule::initGL() {
- #ifdef OSX
- glewExperimental = GL_TRUE;
- #endif
+#ifdef OSX
+ glewExperimental = GL_TRUE;
+#endif
glewInit();
@@ -426,362 +426,362 @@ void ProjectorModule::initGL() {
{
#ifdef GL43
- m_programs[Reveal::POSTPROG]
- = Reveal::getInstance()->createProgram(post43VS.c_str(),
- post43FS.c_str());
+ m_programs[Reveal::POSTPROG]
+ = Reveal::getInstance()->createProgram(post43VS.c_str(),
+ post43FS.c_str());
#else
- m_programs[Reveal::POSTPROG]
- = Reveal::getInstance()->createProgram(post30VS.c_str(),
- post30FS.c_str());
+ m_programs[Reveal::POSTPROG]
+ = Reveal::getInstance()->createProgram(post30VS.c_str(),
+ post30FS.c_str());
#endif
- m_uniforms[Reveal::POSTPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
- m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTWIDTH]
- = glGetUniformLocation(m_programs[Reveal::POSTPROG],"viewportWidth");
- m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTHEIGHT]
- = glGetUniformLocation(m_programs[Reveal::POSTPROG],"viewportHeight");
- m_uniforms[Reveal::POSTPROG][Reveal::POSTFILTER]
- = glGetUniformLocation(m_programs[Reveal::POSTPROG],"postFilter");
- m_uniforms[Reveal::POSTPROG][Reveal::RENDERTEX]
- = glGetUniformLocation(m_programs[Reveal::POSTPROG],"renderTex");
+ m_uniforms[Reveal::POSTPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
+ m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTWIDTH]
+ = glGetUniformLocation(m_programs[Reveal::POSTPROG],"viewportWidth");
+ m_uniforms[Reveal::POSTPROG][Reveal::VIEWPORTHEIGHT]
+ = glGetUniformLocation(m_programs[Reveal::POSTPROG],"viewportHeight");
+ m_uniforms[Reveal::POSTPROG][Reveal::POSTFILTER]
+ = glGetUniformLocation(m_programs[Reveal::POSTPROG],"postFilter");
+ m_uniforms[Reveal::POSTPROG][Reveal::RENDERTEX]
+ = glGetUniformLocation(m_programs[Reveal::POSTPROG],"renderTex");
}
//RENDER
{
#ifdef GL43
- m_programs[Reveal::RENDERPROG]
- = Reveal::getInstance()->createProgram(render43VS.c_str(),
- render43FS.c_str());
+ m_programs[Reveal::RENDERPROG]
+ = Reveal::getInstance()->createProgram(render43VS.c_str(),
+ render43FS.c_str());
#else
- m_programs[Reveal::RENDERPROG]
- = Reveal::getInstance()->createProgram(render30VS.c_str(),
- render30FS.c_str());
+ m_programs[Reveal::RENDERPROG]
+ = Reveal::getInstance()->createProgram(render30VS.c_str(),
+ render30FS.c_str());
#endif
- m_uniforms[Reveal::RENDERPROG] = map<Reveal::REVIL_UNIFORM, GLint>();
- m_uniforms[Reveal::RENDERPROG][Reveal::MIRRORED]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "mirrored");
- m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPROJMAT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewProjMat");
- m_uniforms[Reveal::RENDERPROG][Reveal::VIEWMAT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewMat");
- m_uniforms[Reveal::RENDERPROG][Reveal::MODELMAT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "modelMat");
- m_uniforms[Reveal::RENDERPROG][Reveal::INVMODELMAT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "invModelMat");
- m_uniforms[Reveal::RENDERPROG][Reveal::MODELSCALE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "modelScale");
- m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTWIDTH]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewportWidth");
- m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTHEIGHT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG],"viewportHeight");
- m_uniforms[Reveal::RENDERPROG][Reveal::SLICETEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "sliceTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::SELECTTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "selectTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::INSIDETEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::COORDSTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "coordsTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::TEXGRAY]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texGray");
- m_uniforms[Reveal::RENDERPROG][Reveal::REACTTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "reactTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::SURFDISTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfDistTex");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEID]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeID");
- m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEIDBIT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeIDBit");
- m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEGEOM]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeGeom");
- m_uniforms[Reveal::RENDERPROG][Reveal::SHAPECOLOR]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeColor");
- m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPEID]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "subShapeID");
- m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPESNB]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "subShapesNb");
- m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPEINVMAT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG],"subShapeInvMat");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVEALEDBY]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revealedBy");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::SURFACE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surface");
- m_uniforms[Reveal::RENDERPROG][Reveal::SURFACECOLOR]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfaceColor");
- m_uniforms[Reveal::RENDERPROG][Reveal::SURFACETHICKNESS]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "thickness");
- m_uniforms[Reveal::RENDERPROG][Reveal::SURFACETEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfaceTex");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::INSIDEVISIBLE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideVisible");
- m_uniforms[Reveal::RENDERPROG][Reveal::INSIDESTRUCT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideStructure");
- m_uniforms[Reveal::RENDERPROG][Reveal::STRUCTRATIO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "structureRatio");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTALPHA]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientAlpha");
- m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTTYPE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientType");
- m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTSTEPS]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientSteps");
- m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTCURVERATIO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientCurveRatio");
- m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTTEXTURE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientTex");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYALPHA]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityAlpha");
- m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYTYPE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityType");
- m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYRATIO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityRatio");
- m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densitySize");
- m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYCURVERATIO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityCurveRatio");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::TEXALPHA]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texAlpha");
- m_uniforms[Reveal::RENDERPROG][Reveal::TEXOFFSET]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texOffset");
- m_uniforms[Reveal::RENDERPROG][Reveal::TEXSCALE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texScale");
- m_uniforms[Reveal::RENDERPROG][Reveal::REACTIVITY]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "reactivity");
-
-
- m_uniforms[Reveal::RENDERPROG][Reveal::BBOXMIN]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxMin");
- m_uniforms[Reveal::RENDERPROG][Reveal::BBOXSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::BBOXLOCALSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxLocalSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::BBOXROT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxRot");
+ m_uniforms[Reveal::RENDERPROG] = map<Reveal::REVIL_UNIFORM, GLint>();
+ m_uniforms[Reveal::RENDERPROG][Reveal::MIRRORED]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "mirrored");
+ m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPROJMAT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewProjMat");
+ m_uniforms[Reveal::RENDERPROG][Reveal::VIEWMAT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewMat");
+ m_uniforms[Reveal::RENDERPROG][Reveal::MODELMAT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "modelMat");
+ m_uniforms[Reveal::RENDERPROG][Reveal::INVMODELMAT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "invModelMat");
+ m_uniforms[Reveal::RENDERPROG][Reveal::MODELSCALE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "modelScale");
+ m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTWIDTH]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "viewportWidth");
+ m_uniforms[Reveal::RENDERPROG][Reveal::VIEWPORTHEIGHT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG],"viewportHeight");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SLICETEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "sliceTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SELECTTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "selectTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::INSIDETEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::COORDSTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "coordsTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::TEXGRAY]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texGray");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REACTTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "reactTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SURFDISTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfDistTex");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEID]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeID");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEIDBIT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeIDBit");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SHAPEGEOM]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeGeom");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SHAPECOLOR]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeColor");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPEID]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "subShapeID");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPESNB]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "subShapesNb");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SUBSHAPEINVMAT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG],"subShapeInvMat");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVEALEDBY]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revealedBy");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::SURFACE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surface");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SURFACECOLOR]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfaceColor");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SURFACETHICKNESS]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "thickness");
+ m_uniforms[Reveal::RENDERPROG][Reveal::SURFACETEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "surfaceTex");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::INSIDEVISIBLE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideVisible");
+ m_uniforms[Reveal::RENDERPROG][Reveal::INSIDESTRUCT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "insideStructure");
+ m_uniforms[Reveal::RENDERPROG][Reveal::STRUCTRATIO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "structureRatio");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTALPHA]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientAlpha");
+ m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTTYPE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientType");
+ m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTSTEPS]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientSteps");
+ m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTCURVERATIO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientCurveRatio");
+ m_uniforms[Reveal::RENDERPROG][Reveal::GRADIENTTEXTURE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "gradientTex");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYALPHA]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityAlpha");
+ m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYTYPE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityType");
+ m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYRATIO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityRatio");
+ m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densitySize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::DENSITYCURVERATIO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "densityCurveRatio");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::TEXALPHA]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texAlpha");
+ m_uniforms[Reveal::RENDERPROG][Reveal::TEXOFFSET]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texOffset");
+ m_uniforms[Reveal::RENDERPROG][Reveal::TEXSCALE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "texScale");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REACTIVITY]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "reactivity");
+
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::BBOXMIN]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxMin");
+ m_uniforms[Reveal::RENDERPROG][Reveal::BBOXSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::BBOXLOCALSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxLocalSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::BBOXROT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "bboxRot");
#ifdef GL43
- //output texture
- m_outputImg = new unsigned int[m_outputImgSize*m_outputImgSize];
- m_outputImgInit = new unsigned int[m_outputImgSize*m_outputImgSize];
- memset(&m_outputImgInit[0], 0, m_outputImgSize*m_outputImgSize*4);
- glGenTextures(1, &m_outputTex);
- glBindTexture(GL_TEXTURE_2D, m_outputTex);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI,
- m_outputImgSize, m_outputImgSize, 0,
- GL_RED_INTEGER, GL_UNSIGNED_INT, m_outputImgInit);
-
- //Audio texture
- m_audioImg = new int[m_imgBufSize*m_nbTracks];
- memset(&m_audioImg[0], 0, m_imgBufSize*m_nbTracks*sizeof(int));
- m_audioImgInit = new int[3*m_nbTracks];
- memset(&m_audioImgInit[0], 0, 3*m_nbTracks*sizeof(int));
- glGenTextures(1, &m_audioTex);
- glBindTexture(GL_TEXTURE_2D, m_audioTex);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I,
- m_imgBufSize, m_nbTracks, 0,
- GL_RED_INTEGER, GL_INT, m_audioImg);
-
- m_uniforms[Reveal::RENDERPROG][Reveal::PROCESSAUDIO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "processAudio");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOMIXSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioMixSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOBUFSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioBufSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::MAXAUDIOVALUE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "maxAudioValue");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIORATE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioRate");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONEXTBUF]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioNextBuf");
- m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONBTRACKS]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioNbTracks");
-
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTPUTTEX]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "outputTex");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVSURFACE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revSurface");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVINSIDE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revInside");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVCENTER]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revCenter");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVCURSOR]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revCursor");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVCOLOR]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revColor");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVHISTO]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revHisto");
- m_uniforms[Reveal::RENDERPROG][Reveal::REVVOXELS]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revVoxels");
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTSHAPESIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeOutSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTHISTOSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "histoOutSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTVOXELSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "voxelOutSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTDEPTHSIZE]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "depthOutSize");
- m_uniforms[Reveal::RENDERPROG][Reveal::OUTNBDEPTH]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "depthOutNb");
- m_uniforms[Reveal::RENDERPROG][Reveal::BRECT]
- = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "boundingRect");
- createRTT(m_renderTex, m_renderFBO, m_rttWidth, m_rttHeight, false);
+ //output texture
+ m_outputImg = new unsigned int[m_outputImgSize*m_outputImgSize];
+ m_outputImgInit = new unsigned int[m_outputImgSize*m_outputImgSize];
+ memset(&m_outputImgInit[0], 0, m_outputImgSize*m_outputImgSize*4);
+ glGenTextures(1, &m_outputTex);
+ glBindTexture(GL_TEXTURE_2D, m_outputTex);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI,
+ m_outputImgSize, m_outputImgSize, 0,
+ GL_RED_INTEGER, GL_UNSIGNED_INT, m_outputImgInit);
+
+ //Audio texture
+ m_audioImg = new int[m_imgBufSize*m_nbTracks];
+ memset(&m_audioImg[0], 0, m_imgBufSize*m_nbTracks*sizeof(int));
+ m_audioImgInit = new int[3*m_nbTracks];
+ memset(&m_audioImgInit[0], 0, 3*m_nbTracks*sizeof(int));
+ glGenTextures(1, &m_audioTex);
+ glBindTexture(GL_TEXTURE_2D, m_audioTex);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I,
+ m_imgBufSize, m_nbTracks, 0,
+ GL_RED_INTEGER, GL_INT, m_audioImg);
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::PROCESSAUDIO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "processAudio");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOMIXSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioMixSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIOBUFSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioBufSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::MAXAUDIOVALUE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "maxAudioValue");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIORATE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioRate");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONEXTBUF]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioNextBuf");
+ m_uniforms[Reveal::RENDERPROG][Reveal::AUDIONBTRACKS]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "audioNbTracks");
+
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTPUTTEX]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "outputTex");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVSURFACE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revSurface");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVINSIDE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revInside");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVCENTER]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revCenter");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVCURSOR]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revCursor");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVCOLOR]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revColor");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVHISTO]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revHisto");
+ m_uniforms[Reveal::RENDERPROG][Reveal::REVVOXELS]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "revVoxels");
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTSHAPESIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "shapeOutSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTHISTOSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "histoOutSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTVOXELSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "voxelOutSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTDEPTHSIZE]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "depthOutSize");
+ m_uniforms[Reveal::RENDERPROG][Reveal::OUTNBDEPTH]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "depthOutNb");
+ m_uniforms[Reveal::RENDERPROG][Reveal::BRECT]
+ = glGetUniformLocation(m_programs[Reveal::RENDERPROG], "boundingRect");
+ createRTT(m_renderTex, m_renderFBO, m_rttWidth, m_rttHeight, false);
#endif
}
- {
- //select prog
+ {
+ //select prog
#ifdef GL43
- m_programs[Reveal::SELECTPROG]
- = Reveal::getInstance()->createProgram(select43VS.c_str(),
- select43FS.c_str());
+ m_programs[Reveal::SELECTPROG]
+ = Reveal::getInstance()->createProgram(select43VS.c_str(),
+ select43FS.c_str());
#else
- m_programs[Reveal::SELECTPROG]
- = Reveal::getInstance()->createProgram(select30VS.c_str(),
- select30FS.c_str());
+ m_programs[Reveal::SELECTPROG]
+ = Reveal::getInstance()->createProgram(select30VS.c_str(),
+ select30FS.c_str());
#endif
- m_uniforms[Reveal::SELECTPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
- m_uniforms[Reveal::SELECTPROG][Reveal::MIRRORED]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "mirrored");
- m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPROJMAT]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewProjMat");
- m_uniforms[Reveal::SELECTPROG][Reveal::VIEWMAT]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewMat");
- m_uniforms[Reveal::SELECTPROG][Reveal::MODELMAT]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "modelMat");
- m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTWIDTH]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewportWidth");
- m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTHEIGHT]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG],"viewportHeight");
- m_uniforms[Reveal::SELECTPROG][Reveal::SLICETEX]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "sliceTex");
- m_uniforms[Reveal::SELECTPROG][Reveal::SHAPEID]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "shapeID");
- m_uniforms[Reveal::SELECTPROG][Reveal::SHAPEIDBIT]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "shapeIDBit");
- m_uniforms[Reveal::SELECTPROG][Reveal::SURFACETHICKNESS]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "thickness");
- m_uniforms[Reveal::SELECTPROG][Reveal::SURFACE]
- = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "surface");
- createRTT(m_selectTex, m_selectFBO, m_rttWidth, m_rttHeight, false);
+ m_uniforms[Reveal::SELECTPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
+ m_uniforms[Reveal::SELECTPROG][Reveal::MIRRORED]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "mirrored");
+ m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPROJMAT]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewProjMat");
+ m_uniforms[Reveal::SELECTPROG][Reveal::VIEWMAT]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewMat");
+ m_uniforms[Reveal::SELECTPROG][Reveal::MODELMAT]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "modelMat");
+ m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTWIDTH]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "viewportWidth");
+ m_uniforms[Reveal::SELECTPROG][Reveal::VIEWPORTHEIGHT]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG],"viewportHeight");
+ m_uniforms[Reveal::SELECTPROG][Reveal::SLICETEX]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "sliceTex");
+ m_uniforms[Reveal::SELECTPROG][Reveal::SHAPEID]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "shapeID");
+ m_uniforms[Reveal::SELECTPROG][Reveal::SHAPEIDBIT]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "shapeIDBit");
+ m_uniforms[Reveal::SELECTPROG][Reveal::SURFACETHICKNESS]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "thickness");
+ m_uniforms[Reveal::SELECTPROG][Reveal::SURFACE]
+ = glGetUniformLocation(m_programs[Reveal::SELECTPROG], "surface");
+ createRTT(m_selectTex, m_selectFBO, m_rttWidth, m_rttHeight, false);
}
//SLICE
{
#ifdef GL43
- m_programs[Reveal::SLICEPROG]
- = Reveal::getInstance()->createProgram(slice43VS.c_str(),
- slice43FS.c_str());
+ m_programs[Reveal::SLICEPROG]
+ = Reveal::getInstance()->createProgram(slice43VS.c_str(),
+ slice43FS.c_str());
#else
- m_programs[Reveal::SLICEPROG]
- = Reveal::getInstance()->createProgram(slice30VS.c_str(),
- slice30FS.c_str());
+ m_programs[Reveal::SLICEPROG]
+ = Reveal::getInstance()->createProgram(slice30VS.c_str(),
+ slice30FS.c_str());
#endif
- m_uniforms[Reveal::SLICEPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
- m_uniforms[Reveal::SLICEPROG][Reveal::BACKGROUND]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "background");
- m_uniforms[Reveal::SLICEPROG][Reveal::MIRRORED]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "mirrored");
- m_uniforms[Reveal::SLICEPROG][Reveal::VIEWPROJMAT]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "viewProjMat");
- m_uniforms[Reveal::SLICEPROG][Reveal::VIEWMAT]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "viewMat");
- m_uniforms[Reveal::SLICEPROG][Reveal::MODELMAT]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "modelMat");
- m_uniforms[Reveal::SLICEPROG][Reveal::DEPTHTYPE]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthType");
- m_uniforms[Reveal::SLICEPROG][Reveal::DEPTHID]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthID");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMXRESO]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camXReso");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMYRESO]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camYReso");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMXZFACTOR]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camXZFactor");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMYZFACTOR]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camYZFactor");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMTEX]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthCamTex");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMTEXFIL]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthCamTexFil");
- m_uniforms[Reveal::SLICEPROG][Reveal::MARKTEX]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "markersTex");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMFILTER]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camFilter");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMCONTOURTHRESH]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camContThresh");
- m_uniforms[Reveal::SLICEPROG][Reveal::CAMMARKERS]
- = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camMarkers");
- createRTT(m_sliceRttTex, m_sliceFBO, m_rttWidth, m_rttHeight, false);
+ m_uniforms[Reveal::SLICEPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
+ m_uniforms[Reveal::SLICEPROG][Reveal::BACKGROUND]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "background");
+ m_uniforms[Reveal::SLICEPROG][Reveal::MIRRORED]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "mirrored");
+ m_uniforms[Reveal::SLICEPROG][Reveal::VIEWPROJMAT]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "viewProjMat");
+ m_uniforms[Reveal::SLICEPROG][Reveal::VIEWMAT]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "viewMat");
+ m_uniforms[Reveal::SLICEPROG][Reveal::MODELMAT]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "modelMat");
+ m_uniforms[Reveal::SLICEPROG][Reveal::DEPTHTYPE]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthType");
+ m_uniforms[Reveal::SLICEPROG][Reveal::DEPTHID]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthID");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMXRESO]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camXReso");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMYRESO]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camYReso");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMXZFACTOR]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camXZFactor");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMYZFACTOR]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camYZFactor");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMTEX]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthCamTex");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMTEXFIL]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "depthCamTexFil");
+ m_uniforms[Reveal::SLICEPROG][Reveal::MARKTEX]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "markersTex");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMFILTER]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camFilter");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMCONTOURTHRESH]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camContThresh");
+ m_uniforms[Reveal::SLICEPROG][Reveal::CAMMARKERS]
+ = glGetUniformLocation(m_programs[Reveal::SLICEPROG], "camMarkers");
+ createRTT(m_sliceRttTex, m_sliceFBO, m_rttWidth, m_rttHeight, false);
}
//Calibration
{
#ifdef GL43
- m_programs[Reveal::CALIBPROG]
- = Reveal::getInstance()->createProgram(calib43VS.c_str(),
- calib43FS.c_str());
+ m_programs[Reveal::CALIBPROG]
+ = Reveal::getInstance()->createProgram(calib43VS.c_str(),
+ calib43FS.c_str());
#else
- m_programs[Reveal::CALIBPROG]
- = Reveal::getInstance()->createProgram(calib30VS.c_str(),
- calib30FS.c_str());
+ m_programs[Reveal::CALIBPROG]
+ = Reveal::getInstance()->createProgram(calib30VS.c_str(),
+ calib30FS.c_str());
#endif
- m_uniforms[Reveal::CALIBPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
- m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTWIDTH]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"viewportWidth");
- m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTHEIGHT]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"viewportHeight");
-
- /*
- m_uniforms[Reveal::CALIBPROG][Reveal::PATTERNTEX]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patternTex");
- */
-
-
- m_uniforms[Reveal::CALIBPROG][Reveal::PATW]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patW");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSX]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patPosX");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSY]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patPosY");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATNBX]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patNbX");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATNBY]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patNbY");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATRANGE]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patRange");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATOFFSET]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patOffset");
- m_uniforms[Reveal::CALIBPROG][Reveal::PATBRIGHT]
- = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patBright");
-
-
- m_calibGeom = new QuadGeometry();
+ m_uniforms[Reveal::CALIBPROG]=map<Reveal::REVIL_UNIFORM, GLint>();
+ m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTWIDTH]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"viewportWidth");
+ m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTHEIGHT]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"viewportHeight");
+
+ /*
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATTERNTEX]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patternTex");
+ */
+
+
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATW]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patW");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSX]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patPosX");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSY]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patPosY");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATNBX]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patNbX");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATNBY]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patNbY");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATRANGE]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patRange");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATOFFSET]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patOffset");
+ m_uniforms[Reveal::CALIBPROG][Reveal::PATBRIGHT]
+ = glGetUniformLocation(m_programs[Reveal::CALIBPROG],"patBright");
+
+
+ m_calibGeom = new QuadGeometry();
}
}
void ProjectorModule::createRTT(GLuint& tex, GLuint& fbo,
- const int& width, const int& height,
- bool filter) {
+ const int& width, const int& height,
+ bool filter) {
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height,
- 0, GL_RGBA, GL_FLOAT, 0);
+ 0, GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
- filter?GL_LINEAR:GL_NEAREST);
+ filter?GL_LINEAR:GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
- filter?GL_LINEAR:GL_NEAREST);
+ filter?GL_LINEAR:GL_NEAREST);
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0);
@@ -791,9 +791,9 @@ void ProjectorModule::createRTT(GLuint& tex, GLuint& fbo,
glGenRenderbuffers(1, &idDepthrenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, idDepthrenderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
- width, height);
+ width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_RENDERBUFFER, idDepthrenderbuffer);
+ GL_RENDERBUFFER, idDepthrenderbuffer);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
@@ -817,9 +817,9 @@ void ProjectorModule::refreshDepthCamList(const vector<DepthCamModule*> cams) {
labels.push_back((*itCam)->getName());
}
m_attributesMap["attached_to_camera"]
- ->editStringValuesChoices().assign(1, labels);
+ ->editStringValuesChoices().assign(1, labels);
m_attributesMap["calibrate_with_camera"]
- ->editStringValuesChoices().assign(1, labels);
+ ->editStringValuesChoices().assign(1, labels);
}
void ProjectorModule::attachToCam(const string& camName) {
@@ -835,7 +835,7 @@ void ProjectorModule::attachToCam(const string& camName) {
}
void ProjectorModule::setWindowDimensions(const int& x, const int& y,
- const int& w, const int& h) {
+ const int& w, const int& h) {
glfwSetWindowPos(m_projWindow, x, y);
glfwSetWindowSize(m_projWindow, w, h);
m_width=w;
@@ -870,7 +870,7 @@ void ProjectorModule::fullscreenMonitor(const std::string& monitorName) {
m_posX=posX;
m_posY=posY;
glfwSetWindowMonitor(m_projWindow, monitor, 0, 0,
- m_width, m_height, GLFW_DONT_CARE);
+ m_width, m_height, GLFW_DONT_CARE);
updateWindowDims();
refreshMonitors();
}
@@ -889,17 +889,17 @@ void ProjectorModule::refreshMonitors(){
void ProjectorModule::setViewMatrix(const vector<float>& vals) {
m_viewMat = mat4(vals[0], vals[1], vals[2], vals[3],
- vals[4], vals[5], vals[6], vals[7],
- vals[8], vals[9], vals[10], vals[11],
- vals[12], vals[13], vals[14], vals[15]);
+ vals[4], vals[5], vals[6], vals[7],
+ vals[8], vals[9], vals[10], vals[11],
+ vals[12], vals[13], vals[14], vals[15]);
updateViewProjMatrix();
}
void ProjectorModule::setProjectionMatrix(const vector<float>& vals) {
m_projMat = mat4(vals[0], vals[1], vals[2], vals[3],
- vals[4], vals[5], vals[6], vals[7],
- vals[8], vals[9], vals[10], vals[11],
- vals[12], vals[13], vals[14], vals[15]);
+ vals[4], vals[5], vals[6], vals[7],
+ vals[8], vals[9], vals[10], vals[11],
+ vals[12], vals[13], vals[14], vals[15]);
updateViewProjMatrix();
}
@@ -954,52 +954,52 @@ void ProjectorModule::processOutput() {
if(revModules.size()>0 || camModules.size()>0) {
//retrieve output image
glBindTexture(GL_TEXTURE_2D, m_outputTex);
- glGetTexImage(GL_TEXTURE_2D, 0, GL_RED_INTEGER,
- GL_INT,
- m_outputImg);
+ glGetTexImage(GL_TEXTURE_2D, 0, GL_RED_INTEGER,
+ GL_INT,
+ m_outputImg);
}
//process shape revealing output
if(revModules.size()>0) {
- m_outNbDepth = m_space->getNbDepthModulesFromID();
+ m_outNbDepth = m_space->getNbDepthModulesFromID();
//get output values for revealed modules with active output
vector<RevealedModule*>::iterator itSh = revModules.begin();
for(; itSh!=revModules.end(); ++itSh) {
- //test if shape is visible from this projector
- if((*itSh)->getVisibilityMask() & m_visibilityMask) {
- for(int d=1; d<m_outNbDepth+1; ++d) {
- DepthModule* mod = m_space->getDepthModuleFromID(d);
- if(mod) {
- if(mod->isDepthVisible(d)) {
- (*itSh)->processReveal(d,
- mod->getName(),
- m_outNbDepth,
- m_outputImg);
- outputProcessed=true;
- }
- }
- }
- }
+ //test if shape is visible from this projector
+ if((*itSh)->getVisibilityMask() & m_visibilityMask) {
+ for(int d=1; d<m_outNbDepth+1; ++d) {
+ DepthModule* mod = m_space->getDepthModuleFromID(d);
+ if(mod) {
+ if(mod->isDepthVisible(d)) {
+ (*itSh)->processReveal(d,
+ mod->getName(),
+ m_outNbDepth,
+ m_outputImg);
+ outputProcessed=true;
+ }
+ }
+ }
+ }
}
}
/*
//process cam
if(camModules.size()>0) {
- unsigned int curs;
- vector<float> pos(3,0);
- vector<DepthCamModule*>::iterator itCa = camModules.begin();
- for(; itCa!=camModules.end(); ++itCa) {
- extractOutputValue((*itCa)->getDepthID()+500, 0, curs);
- pos[0] = (int(curs) - int(curs/1000)*1000)*10-5000;
- pos[1] = (int(curs/1000) - int(curs/1000000)*1000)*10-5000;
- pos[2] = 10000-int(curs/1000000)*10;
- //cout<<"got cursor "<<curs<<" from cam at pos "
- // <<pos[0]<<" "<<pos[1]<<" "<<pos[2]<<endl;
- (*itCa)->processCursor(pos);
- }
- outputProcessed=true;
+ unsigned int curs;
+ vector<float> pos(3,0);
+ vector<DepthCamModule*>::iterator itCa = camModules.begin();
+ for(; itCa!=camModules.end(); ++itCa) {
+ extractOutputValue((*itCa)->getDepthID()+500, 0, curs);
+ pos[0] = (int(curs) - int(curs/1000)*1000)*10-5000;
+ pos[1] = (int(curs/1000) - int(curs/1000000)*1000)*10-5000;
+ pos[2] = 10000-int(curs/1000000)*10;
+ //cout<<"got cursor "<<curs<<" from cam at pos "
+ // <<pos[0]<<" "<<pos[1]<<" "<<pos[2]<<endl;
+ (*itCa)->processCursor(pos);
+ }
+ outputProcessed=true;
}
*/
@@ -1009,14 +1009,14 @@ void ProjectorModule::processOutput() {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
- m_outputImgSize, m_outputImgSize,
- GL_RED_INTEGER, GL_UNSIGNED_INT, m_outputImgInit);
- /*
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
- m_outputImgSize, m_outputImgSize, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, m_outputImgInit);
- */
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
+ m_outputImgSize, m_outputImgSize,
+ GL_RED_INTEGER, GL_UNSIGNED_INT, m_outputImgInit);
+ /*
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
+ m_outputImgSize, m_outputImgSize, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, m_outputImgInit);
+ */
}
}
@@ -1027,59 +1027,59 @@ void ProjectorModule::setAudioProcessType(const std::string& type) {
if(ptype == type) {
m_audioProcessType = t;
}
- ++t;
+ ++t;
}
}
void ProjectorModule::processAudio() {
glBindTexture(GL_TEXTURE_2D, m_audioTex);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RED_INTEGER,
- GL_INT,
- m_audioImg);
-
- //FIXME mix in a compute shader
+ GL_INT,
+ m_audioImg);
+
+ //FIXME mix in a compute shader
float totalGains = 0;
for(int i = 0; i<m_nbTracks; i++) {
- //check if the note has to be played this frame
- float trackGain = m_audioImg[m_imgBufSize * i];
+ //check if the note has to be played this frame
+ float trackGain = m_audioImg[m_imgBufSize * i];
if(trackGain>0) {
- totalGains += trackGain;
- //Mix all tracks with gain from number of voxels
+ totalGains += trackGain;
+ //Mix all tracks with gain from number of voxels
for(int j=0; j<m_audioBufSize; j++) {
m_audioBuffer[j] += trackGain
- * (float(m_audioImg[(m_imgBufSize*i)+3+j])
- / m_maxAudioValue);
+ * (float(m_audioImg[(m_imgBufSize*i)+3+j])
+ / m_maxAudioValue);
}
- //copy the old and new phases
- m_audioImgInit[3*i+1] = m_audioImg[m_imgBufSize*i+1];
- m_audioImgInit[3*i+2] = m_audioImg[m_imgBufSize*i+2];
+ //copy the old and new phases
+ m_audioImgInit[3*i+1] = m_audioImg[m_imgBufSize*i+1];
+ m_audioImgInit[3*i+2] = m_audioImg[m_imgBufSize*i+2];
}
}
- float gain = 0.4;
+ float gain = 0.4;
if(totalGains > 0) {
for(int i=0; i<m_audioBufSize; i++) {
m_audioBuffer[i] = gain*m_audioBuffer[i]/totalGains;
}
m_audioNextBuf = AudioManager::getInstance()->changeBuf(m_audioBuffer,
- m_maxAudioValue);
+ m_maxAudioValue);
memset(&m_audioBuffer[0], 0, (m_audioBufSize)*sizeof(float));
}
else{
memset(&m_audioBuffer[0], 0, (m_audioBufSize)*sizeof(float));
m_audioNextBuf = AudioManager::getInstance()->changeBuf(m_audioBuffer,
- m_maxAudioValue);
- }
-
- //reset the gain and transfer the old and new phases
+ m_maxAudioValue);
+ }
+
+ //reset the gain and transfer the old and new phases
glBindTexture(GL_TEXTURE_2D, m_audioTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 3, m_nbTracks,
- GL_RED_INTEGER, GL_INT, &m_audioImgInit[0]);
-
+ GL_RED_INTEGER, GL_INT, &m_audioImgInit[0]);
+
}
void ProjectorModule::updateWindowSize(const int& w, const int& h) {
@@ -1107,12 +1107,12 @@ void ProjectorModule::updateWindowDims() {
//-------------------------Calibration----------------------------------
/*
-static void cbPatternSquareWidth(int w, void* mod) {
- if(w>10) {
- ProjectorModule* proj = static_cast<ProjectorModule*>(mod);
- proj->setPatternSquareWidth(w);
- }
-}*/
+ static void cbPatternSquareWidth(int w, void* mod) {
+ if(w>10) {
+ ProjectorModule* proj = static_cast<ProjectorModule*>(mod);
+ proj->setPatternSquareWidth(w);
+ }
+ }*/
void ProjectorModule::setPatternSquareWidth(const int& w) {
m_patternSquareWidth=w;
@@ -1223,17 +1223,17 @@ void ProjectorModule::calibrate(const std::string& camName) {
namedWindow("DepthCamRGB");
namedWindow("Controls");
createTrackbar("Pattern Offset X", "Controls",
- &m_patternPosOffset.width, 1000, cbPatternPosOX, this);
+ &m_patternPosOffset.width, 1000, cbPatternPosOX, this);
createTrackbar("Pattern Offset Y", "Controls",
- &m_patternPosOffset.height, 500, cbPatternPosOY, this);
+ &m_patternPosOffset.height, 500, cbPatternPosOY, this);
createTrackbar("Pattern Range X", "Controls",
- &m_patternPosRange.width, 1920, cbPatternPosRX, this);
+ &m_patternPosRange.width, 1920, cbPatternPosRX, this);
createTrackbar("Pattern Range Y", "Controls",
- &m_patternPosRange.height, 1080, cbPatternPosRY, this);
+ &m_patternPosRange.height, 1080, cbPatternPosRY, this);
createTrackbar("Pattern Brightness", "Controls",
- &m_patternBrightness, 100, cbPatternBrightness, this);
+ &m_patternBrightness, 100, cbPatternBrightness, this);
createTrackbar("Calibrate (1:Start, 0:Cancel)", "Controls",
- NULL, 1, cbCalib, this);
+ NULL, 1, cbCalib, this);
vector<vector<Point3f> > objectPoints;
vector<vector<Point2f> > imagePoints;
Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
@@ -1247,16 +1247,16 @@ void ProjectorModule::calibrate(const std::string& camName) {
m_patternSquareWidth = m_height/20;
m_patternPosition.width = (m_patternPosRange.width-m_patternSquareWidth)
- / sqrt(m_neededFramesNb)
- *(fmod(f,sqrt(m_neededFramesNb)))
- +m_patternSquareWidth
- +m_patternPosOffset.width;
+ / sqrt(m_neededFramesNb)
+ *(fmod(f,sqrt(m_neededFramesNb)))
+ +m_patternSquareWidth
+ +m_patternPosOffset.width;
m_patternPosition.height=(m_patternPosRange.height-m_patternSquareWidth)
- / sqrt(m_neededFramesNb)
- *(floor(f/sqrt(m_neededFramesNb)))
- +m_patternSquareWidth
- +m_patternPosOffset.height;
+ / sqrt(m_neededFramesNb)
+ *(floor(f/sqrt(m_neededFramesNb)))
+ +m_patternSquareWidth
+ +m_patternPosOffset.height;
updateCalibrationPattern();
//display frame with calibration pattern
@@ -1268,25 +1268,25 @@ void ProjectorModule::calibrate(const std::string& camName) {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUseProgram(m_programs[Reveal::CALIBPROG]);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTWIDTH],
- m_width);
+ m_width);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::VIEWPORTHEIGHT],
- m_height);
+ m_height);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATW],
- m_patternSquareWidth);
+ m_patternSquareWidth);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSX],
- m_patternPosition.width);
+ m_patternPosition.width);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATPOSY],
- m_patternPosition.height);
+ m_patternPosition.height);
glUniform2f(m_uniforms[Reveal::CALIBPROG][Reveal::PATOFFSET],
- m_patternPosOffset.width, m_patternPosOffset.height);
+ m_patternPosOffset.width, m_patternPosOffset.height);
glUniform2f(m_uniforms[Reveal::CALIBPROG][Reveal::PATRANGE],
- m_patternPosRange.width, m_patternPosRange.height);
+ m_patternPosRange.width, m_patternPosRange.height);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATNBX],
- m_patternSize.width);
+ m_patternSize.width);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATNBY],
- m_patternSize.height);
+ m_patternSize.height);
glUniform1f(m_uniforms[Reveal::CALIBPROG][Reveal::PATBRIGHT],
- float(m_patternBrightness)/100.0);
+ float(m_patternBrightness)/100.0);
m_calibGeom->drawDirect(m_contextHandlerID);
glfwSwapBuffers(m_projWindow);
@@ -1303,7 +1303,7 @@ void ProjectorModule::calibrate(const std::string& camName) {
for(int i=0; i<m_imageSize.width; ++i) {
cv::Vec3b& pix = kinectRgbImg.at<cv::Vec3b>(j,i);
int coord=0;
- coord=j*m_imageSize.width+i;
+ coord=j*m_imageSize.width+i;
openni::RGB888Pixel colorPix =
((openni::RGB888Pixel*) colorFrame.getData())[coord];
pix[0]=colorPix.r;
@@ -1318,19 +1318,19 @@ void ProjectorModule::calibrate(const std::string& camName) {
m_foundCorners.clear();
//find chessboard in image
bool patternFound = findChessboardCorners(
- kinectRgbImg,
- m_patternSize,
- m_foundCorners,
- CALIB_CB_ADAPTIVE_THRESH);
+ kinectRgbImg,
+ m_patternSize,
+ m_foundCorners,
+ CALIB_CB_ADAPTIVE_THRESH);
//if we found it
if(patternFound) {
//refine
Mat gray;
cvtColor(kinectRgbImg, gray, COLOR_RGB2GRAY);
cornerSubPix(gray, m_foundCorners,
- cv::Size(1, 1), cv::Size(-1, -1),
- TermCriteria(TermCriteria::EPS,
- 30, 0.1));
+ cv::Size(1, 1), cv::Size(-1, -1),
+ TermCriteria(TermCriteria::EPS,
+ 30, 0.1));
bool validDepths=true;
@@ -1339,27 +1339,27 @@ void ProjectorModule::calibrate(const std::string& camName) {
vector<Point2f>::iterator itPnt=m_foundCorners.begin();
for(; itPnt!=m_foundCorners.end(); ++itPnt) {
float posX, posY, posZ;
- Point2f coord = Point2f((*itPnt).x,(*itPnt).y);
- Point2f depthCoord = coord;
+ Point2f coord = Point2f((*itPnt).x,(*itPnt).y);
+ Point2f depthCoord = coord;
openni::DepthPixel depthPix =
((openni::DepthPixel*)depthFrame.getData())[int(
- depthCoord.y*m_imageSize.width +
- depthCoord.x)];
+ depthCoord.y*m_imageSize.width +
+ depthCoord.x)];
posZ=depthPix;
//filter the depth
int size=6;
vector<double> vals;
for(int x=depthCoord.x-size/2;
- x<depthCoord.x+size/2; ++x) {
+ x<depthCoord.x+size/2; ++x) {
for(int y=depthCoord.y-size/2;
y<depthCoord.y+size/2; ++y) {
if(x>=0 && x<m_imageSize.width &&
y>=0 && y<m_imageSize.height) {
vals.push_back(
- ((openni::DepthPixel*)depthFrame.getData())
- [int(y*m_imageSize.width + x)]);
+ ((openni::DepthPixel*)depthFrame.getData())
+ [int(y*m_imageSize.width + x)]);
}
}
}
@@ -1368,11 +1368,11 @@ void ProjectorModule::calibrate(const std::string& camName) {
depthPix=posZ;
openni::CoordinateConverter::convertDepthToWorld(
- cam->getDepthStream(),
- int(depthCoord.x),
- int(depthCoord.y),
- depthPix,
- &posX, &posY, &posZ);
+ cam->getDepthStream(),
+ int(depthCoord.x),
+ int(depthCoord.y),
+ depthPix,
+ &posX, &posY, &posZ);
//if(reversed) {
// posX=-posX;
// posY=-posY;
@@ -1400,22 +1400,22 @@ void ProjectorModule::calibrate(const std::string& camName) {
//draw corners
drawChessboardCorners(kinectRgbImg, m_patternSize,
- m_foundCorners, patternFound);
+ m_foundCorners, patternFound);
imshow("DepthCamRGB", kinectRgbImg);
waitKey(10);
//wait
- #ifdef POSIX
- sleep(1);
- #else
- Sleep(1000);
- #endif
+#ifdef POSIX
+ sleep(1);
+#else
+ Sleep(1000);
+#endif
//increase frame count
++f;
- }
+ }
}
}
waitKey(10);
@@ -1440,20 +1440,20 @@ void ProjectorModule::calibrate(const std::string& camName) {
float w = m_width;
float h = m_height;
cameraMatrix = (Mat1d(3, 3) << w, 0, w/2.,
- 0, h, h / 2.,
- 0, 0, 1);
+ 0, h, h / 2.,
+ 0, 0, 1);
distCoeffs = Mat::zeros(8, 1, CV_64F);
rms=calibrateCamera(vvo, vvi,
- Size(w, h), cameraMatrix,
- distCoeffs, rvecs, tvecs,
- CALIB_FIX_K1+
- CALIB_FIX_K2+
- CALIB_FIX_K3+
- CALIB_FIX_K4+
- CALIB_FIX_K5+
- CALIB_FIX_K6+
- CALIB_ZERO_TANGENT_DIST+
- CALIB_USE_INTRINSIC_GUESS);
+ Size(w, h), cameraMatrix,
+ distCoeffs, rvecs, tvecs,
+ CALIB_FIX_K1+
+ CALIB_FIX_K2+
+ CALIB_FIX_K3+
+ CALIB_FIX_K4+
+ CALIB_FIX_K5+
+ CALIB_FIX_K6+
+ CALIB_ZERO_TANGENT_DIST+
+ CALIB_USE_INTRINSIC_GUESS);
cout<<"... done , RMS="<<rms<<endl;
@@ -1464,24 +1464,24 @@ void ProjectorModule::calibrate(const std::string& camName) {
Rodrigues(rot, rotMat);
mat4 viewMatrix(rotMat.at<double>(0,0), rotMat.at<double>(1,0),
- rotMat.at<double>(2,0), 0,
- rotMat.at<double>(0,1), rotMat.at<double>(1,1),
- rotMat.at<double>(2,1), 0,
- rotMat.at<double>(0,2), rotMat.at<double>(1,2),
- rotMat.at<double>(2,2), 0,
- tvecs[0].at<double>(0,0), tvecs[0].at<double>(1,0),
- tvecs[0].at<double>(2,0), 1);
+ rotMat.at<double>(2,0), 0,
+ rotMat.at<double>(0,1), rotMat.at<double>(1,1),
+ rotMat.at<double>(2,1), 0,
+ rotMat.at<double>(0,2), rotMat.at<double>(1,2),
+ rotMat.at<double>(2,2), 0,
+ tvecs[0].at<double>(0,0), tvecs[0].at<double>(1,0),
+ tvecs[0].at<double>(2,0), 1);
mat4 glCoordsMat(-1, 0, 0, 0,
- 0, 1, 0, 0,
- 0, 0, 1, 0,
- 0, 0, 0, 1);
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1);
m_viewMat=glCoordsMat*viewMatrix;
m_attributesMap["view_matrix"]->setFloats(
- vector<float>(
- value_ptr(m_viewMat),
- value_ptr(m_viewMat)+16));
+ vector<float>(
+ value_ptr(m_viewMat),
+ value_ptr(m_viewMat)+16));
//build the opengl projection matrix
double fx=cameraMatrix.at<double>(0,0);
double cx=cameraMatrix.at<double>(0,2);
@@ -1499,8 +1499,8 @@ void ProjectorModule::calibrate(const std::string& camName) {
1.0-2.0*(cx)/w,-1.0+(2.0*(cy)+2.0)/h, (f+n)/(n-f), -1,
0, 0, (2.0*f*n)/(n-f), 0);
m_attributesMap["projection_matrix"]->setFloats(
- vector<float>(value_ptr(projMatrix),
- value_ptr(projMatrix)+16));
+ vector<float>(value_ptr(projMatrix),
+ value_ptr(projMatrix)+16));
m_attributesMap["attached_to_camera"]
->setStrings(vector<string>(1, cam->getName()));
}
@@ -1528,19 +1528,19 @@ void ProjectorModule::calibrate(const std::string& camName) {
openni::DepthPixel depthPix =
((openni::DepthPixel*)depthFrame.getData())[coord];
openni::CoordinateConverter::convertDepthToWorld(
- cam->getDepthStream(),
- i, j, depthPix,
- &posX, &posY, &posZ);
+ cam->getDepthStream(),
+ i, j, depthPix,
+ &posX, &posY, &posZ);
objPnts.push_back(Point3f(posX,posY,posZ));
const openni::RGB888Pixel& colorPix =
((openni::RGB888Pixel*) colorFrame.getData())[coord];
kinPnts.push_back(cv::Vec3b(colorPix.r,
- colorPix.g,
- colorPix.b));
+ colorPix.g,
+ colorPix.b));
}
}
projectPoints(objPnts, rvecs[0], tvecs[0],
- cameraMatrix, distCoeffs, imgPnts);
+ cameraMatrix, distCoeffs, imgPnts);
//for each of the image points
vector<Point2f>::iterator itPnt=imgPnts.begin();
@@ -1553,8 +1553,8 @@ void ProjectorModule::calibrate(const std::string& camName) {
(*itPnt).x>0 &&
(*itPnt).y>0) {
reconstructionImg.at<cv::Vec3b>(
- (*itPnt).y,
- (*itPnt).x)
+ (*itPnt).y,
+ (*itPnt).x)
=(*itKin);
}
}
diff --git a/src/shaders/render43.fs b/src/shaders/render43.fs
index 6730d51..e3efbf8 100644
--- a/src/shaders/render43.fs
+++ b/src/shaders/render43.fs
@@ -23,13 +23,13 @@ layout(binding=6) uniform sampler2D gradientTex;
layout(r32ui, binding=0) uniform coherent uimage2D outputTex;
layout(r32i, binding=1) uniform coherent iimage2D audioTex;
-uniform int audioMixSize;
-uniform int audioBufSize;
-uniform float maxAudioValue;
-uniform int audioRate;
-uniform int processAudio;
-uniform int audioNextBuf;
-uniform int audioNbTracks;
+layout(location=100) uniform int audioMixSize;
+layout(location=101) uniform int audioBufSize;
+layout(location=102) uniform float maxAudioValue;
+layout(location=103) uniform int audioRate;
+layout(location=104) uniform int processAudio;
+layout(location=105) uniform int audioNextBuf;
+layout(location=106) uniform int audioNbTracks;
uniform float viewportWidth;
uniform float viewportHeight;
@@ -94,513 +94,513 @@ uniform int depthOutNb;
uniform vec4 boundingRect;
vec3 rgb2hsv(vec3 c){
- vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
- vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
- vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
- float d = q.x - min(q.w, q.y);
- float e = 1.0e-10;
- return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),d/(q.x + e), q.x);
+ vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+ vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+ vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+ float d = q.x - min(q.w, q.y);
+ float e = 1.0e-10;
+ return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),d/(q.x + e), q.x);
}
float random (vec3 st){
- return fract(sin(dot(st.xyz,
- vec3(12.9898,78.233, 102.234)))*
- 43758.5453123);
+ return fract(sin(dot(st.xyz,
+ vec3(12.9898,78.233, 102.234)))*
+ 43758.5453123);
}
out vec4 color;
void additiveSynth(vec4 color) {
- float note = 20.0
- + floor(color.x * float(audioNbTracks))/float(audioNbTracks)*80.0;
- int ind = int(color.x*float(audioNbTracks));
- float freq=0.0;
-
- //count this fragment
- if(imageAtomicAdd(audioTex, ivec2(0, ind), 1)<1) {
- //if the audio has not been generated by another fragment
- //compute frequency
- freq = float(440.0 * pow(2.0, (note-69.0)/12.0));
- //retrieve either new or old phase, depending on if audio was processed
- float phase = float(imageLoad(audioTex, ivec2(1, ind)).x);
- if(audioNextBuf>0) {//if new phase
- //retrieve it
- phase = float(imageLoad(audioTex, ivec2(2, ind)).x);
- //store it as previous phase
- imageStore(audioTex, ivec2(1, ind), ivec4(int(phase)));
- }
-
- float outputPhase = phase;
- float samplesPerPeriod = (audioRate/freq);
- float phaseStep = 1.0;
- for(int i=0; i<audioBufSize; i++) {
- //compute and store value starting from 3rd column
- float s = sin((phase/samplesPerPeriod) * 2.0 * M_PI);
- imageStore(audioTex, ivec2(i+3, ind), ivec4(int(s*maxAudioValue)));
-
- //increase phase
- phase=mod(phase + phaseStep, samplesPerPeriod);
- }
-
- //remove audioMixSize steps and write phase to output
- outputPhase=mod(outputPhase+phaseStep*(audioBufSize-audioMixSize),
- samplesPerPeriod);
- imageStore(audioTex, ivec2(2, ind), ivec4(int(outputPhase)));
- }
+ float note = 20.0
+ + floor(color.x * float(audioNbTracks))/float(audioNbTracks)*80.0;
+ int ind = int(color.x*float(audioNbTracks));
+ float freq=0.0;
+
+ //count this fragment
+ if(imageAtomicAdd(audioTex, ivec2(0, ind), 1)<1) {
+ //if the audio has not been generated by another fragment
+ //compute frequency
+ freq = float(440.0 * pow(2.0, (note-69.0)/12.0));
+ //retrieve either new or old phase, depending on if audio was processed
+ float phase = float(imageLoad(audioTex, ivec2(1, ind)).x);
+ if(audioNextBuf>0) {//if new phase
+ //retrieve it
+ phase = float(imageLoad(audioTex, ivec2(2, ind)).x);
+ //store it as previous phase
+ imageStore(audioTex, ivec2(1, ind), ivec4(int(phase)));
+ }
+
+ float outputPhase = phase;
+ float samplesPerPeriod = (audioRate/freq);
+ float phaseStep = 1.0;
+ for(int i=0; i<audioBufSize; i++) {
+ //compute and store value starting from 3rd column
+ float s = sin((phase/samplesPerPeriod) * 2.0 * M_PI);
+ imageStore(audioTex, ivec2(i+3, ind), ivec4(int(s*maxAudioValue)));
+
+ //increase phase
+ phase=mod(phase + phaseStep, samplesPerPeriod);
+ }
+
+ //remove audioMixSize steps and write phase to output
+ outputPhase=mod(outputPhase+phaseStep*(audioBufSize-audioMixSize),
+ samplesPerPeriod);
+ imageStore(audioTex, ivec2(2, ind), ivec4(int(outputPhase)));
+ }
}
void pitchedAdditiveSynth(vec4 color) {
- float freq=0.0;
- float note = 20 + color.x * 80;
- int ind=0;
-
- int octave = int(note/12);
- float modNote = mod(note, 12.0);
-
- if(modNote >= 8.5){
- note = octave * 12 + 10;
- ind = 4 * octave + 3;
- }
- else if(modNote >= 5.5){
- note = octave * 12 + 7;
- ind = 4 * octave + 2;
- }
- else if(modNote >= 2.0){
- note = octave * 12 + 4;
- ind = 4 * octave + 1;
- }
- else{
- note = octave * 12;
- ind = 4 * octave;
- }
-
- //count this fragment
- if(imageAtomicAdd(audioTex, ivec2(0, ind), 1)<1) {
- //if the audio has not been generated by another fragment
- //compute frequency
- freq = float(440.0 * pow(2.0, (note-69.0)/12.0));
- //retrieve either new or old phase, depending on if audio was processed
- float phase = float(imageLoad(audioTex, ivec2(1, ind)).x);
- if(audioNextBuf>0) {//if new phase
- //retrieve it
- phase = float(imageLoad(audioTex, ivec2(2, ind)).x);
- //store it as previous phase
- imageStore(audioTex, ivec2(1, ind), ivec4(int(phase)));
- }
-
- float outputPhase = phase;
- float samplesPerPeriod = (audioRate/freq);
- float phaseStep = 1.0;
- for(int i=0; i<audioBufSize; i++) {
- //compute and store value starting from 3rd column
- float s = sin((phase/samplesPerPeriod) * 2.0 * M_PI);
- imageStore(audioTex, ivec2(i+3, ind), ivec4(int(s*maxAudioValue)));
-
- //increase phase
- phase=mod(phase + phaseStep, samplesPerPeriod);
- }
-
- //remove audioMixSize steps and write phase to output
- outputPhase=mod(outputPhase+phaseStep*(audioBufSize-audioMixSize),
- samplesPerPeriod);
- imageStore(audioTex, ivec2(2, ind), ivec4(int(outputPhase)));
- }
+ float freq=0.0;
+ float note = 20 + color.x * 80;
+ int ind=0;
+
+ int octave = int(note/12);
+ float modNote = mod(note, 12.0);
+
+ if(modNote >= 8.5){
+ note = octave * 12 + 10;
+ ind = 4 * octave + 3;
+ }
+ else if(modNote >= 5.5){
+ note = octave * 12 + 7;
+ ind = 4 * octave + 2;
+ }
+ else if(modNote >= 2.0){
+ note = octave * 12 + 4;
+ ind = 4 * octave + 1;
+ }
+ else{
+ note = octave * 12;
+ ind = 4 * octave;
+ }
+
+ //count this fragment
+ if(imageAtomicAdd(audioTex, ivec2(0, ind), 1)<1) {
+ //if the audio has not been generated by another fragment
+ //compute frequency
+ freq = float(440.0 * pow(2.0, (note-69.0)/12.0));
+ //retrieve either new or old phase, depending on if audio was processed
+ float phase = float(imageLoad(audioTex, ivec2(1, ind)).x);
+ if(audioNextBuf>0) {//if new phase
+ //retrieve it
+ phase = float(imageLoad(audioTex, ivec2(2, ind)).x);
+ //store it as previous phase
+ imageStore(audioTex, ivec2(1, ind), ivec4(int(phase)));
+ }
+
+ float outputPhase = phase;
+ float samplesPerPeriod = (audioRate/freq);
+ float phaseStep = 1.0;
+ for(int i=0; i<audioBufSize; i++) {
+ //compute and store value starting from 3rd column
+ float s = sin((phase/samplesPerPeriod) * 2.0 * M_PI);
+ imageStore(audioTex, ivec2(i+3, ind), ivec4(int(s*maxAudioValue)));
+
+ //increase phase
+ phase=mod(phase + phaseStep, samplesPerPeriod);
+ }
+
+ //remove audioMixSize steps and write phase to output
+ outputPhase=mod(outputPhase+phaseStep*(audioBufSize-audioMixSize),
+ samplesPerPeriod);
+ imageStore(audioTex, ivec2(2, ind), ivec4(int(outputPhase)));
+ }
}
void main(void) {
- //get fragment coordinates
- float coordX = (gl_FragCoord.x-0.5)/viewportWidth;
- float coordY = (gl_FragCoord.y-0.5)/viewportHeight;
- ivec2 sliSize = textureSize(sliceTex, 0);
-
- //retrieve pixel in slicing texture
- vec4 sli = texelFetch(sliceTex, ivec2(coordX*float(sliSize.x), coordY*float(sliSize.y)), 0);
- float pixZ=abs(gl_FragCoord.z);
- float cutZ=abs(sli.z);
- int depthID=int(sli.y)-1;
-
- int outCols=imageSize(outputTex).x;
- int outOffset=(int(shapeID-1)*depthOutNb+(depthID-1))*revSize;
-
- int rendered=0;
- vec3 finalColor = shapeColor;
- float alpha=0;
- vec3 pixelPosW;
- vec3 pixelPos = vec3(0.0, 0.0, 1.0);
- vec3 ratioWithinBox = vec3(0.0, 0.0, 0.0);
- vec3 outRatioWithinBox = vec3(0.0, 0.0, 0.0);
-
- //if there is a slicing pixel aligned with our coordinate
- //and we are revealed by this depth module
- if(cutZ>0 && (revealedBy & (1<<(1+depthID)))>0 ) {
- //compute the slicing pixel world position
- pixelPosW = vec3(viewMat[3][0], viewMat[3][1], viewMat[3][2]) + vec3(normalize(viewRay) * sli.w);
- pixelPosW.x = pixelPosW.x*(-2.0*(1-mirrored)+1.0);
- //compute the slicing pixel position in model coords
- pixelPos = (invModelMat * vec4(pixelPosW,1.0)).xyz;
-
- //depending on type, test if slicing pixel inside
- //and retrieve distance to the surface on each axis
- vec3 diffMin = vec3(1.0);
- vec3 diffMax = vec3(1.0);
-
- switch(shapeGeom) {
- case PATH : {
- //use min/max/size of current segment
- pixelPos = (subShapeInvMat*vec4(pixelPos,1.0)).xyz;
- if(length(vec2(pixelPos.x, pixelPos.y))<=0.5 && (pixelPos.z>-0.5 && pixelPos.z<0.5)) {
- float xx = (pixelPos.x)*(pixelPos.x);
- float yy = (pixelPos.y)*(pixelPos.y);
- float ax = sqrt(0.25-yy);
- diffMin.x = pixelPos.x+ax;
- diffMax.x = ax-pixelPos.x;
- float ay = sqrt(0.25-xx);
- diffMin.y = pixelPos.y+ay;
- diffMax.y = ay-pixelPos.y;
- diffMin.z = pixelPos.z+0.5;
- diffMax.z = 0.5-pixelPos.z;
- rendered=1;
- }
- } break;
- case CONE : {
- if(pixelPos.y<0.5 && pixelPos.y>-0.5) {
- float xx = (pixelPos.x)*(pixelPos.x);
- float yy = (pixelPos.y-0.5)*(pixelPos.y-0.5);
- float zz = (pixelPos.z)*(pixelPos.z);
- if((xx+zz)/yy<0.25){
- float ax = sqrt(0.25*yy-zz);
- diffMin.x = pixelPos.x+ax;
- diffMax.x = ax-pixelPos.x;
- float ay = sqrt((yy+xx)/0.25);
- diffMin.y = pixelPos.y+0.5;
- diffMax.y = 0.5-pixelPos.y;
- float az = sqrt(0.25*yy-xx);
- diffMin.z = pixelPos.z+az;
- diffMax.z = az-pixelPos.z;
- rendered=1;
- }
- }
- } break;
- case TUBE : {
- if(length(vec2(pixelPos.x, pixelPos.z))<=0.5 && (pixelPos.y>-0.5 && pixelPos.y<0.5)) {
- float xx = (pixelPos.x)*(pixelPos.x);
- float zz = (pixelPos.z)*(pixelPos.z);
- float ax = sqrt(0.25-zz);
- diffMin.x = pixelPos.x+ax;
- diffMax.x = ax-pixelPos.x;
- float az = sqrt(0.25-xx);
- diffMin.z = pixelPos.z+az;
- diffMax.z = az-pixelPos.z;
- diffMin.y = pixelPos.y+0.5;
- diffMax.y = 0.5-pixelPos.y;
- rendered=1;
- }
- } break;
- case SPHERE : {
- if(length(pixelPos)<=0.5) {
- float xx = (pixelPos.x)*(pixelPos.x);
- float yy = (pixelPos.y)*(pixelPos.y);
- float zz = (pixelPos.z)*(pixelPos.z);
- float ax = sqrt(0.25-yy-zz);
- diffMin.x = pixelPos.x+ax;
- diffMax.x = ax-pixelPos.x;
- float ay = sqrt(0.25-xx-zz);
- diffMin.y = pixelPos.y+ay;
- diffMax.y = ay-pixelPos.y;
- float az = sqrt(0.25-xx-yy);
- diffMin.z = pixelPos.z+az;
- diffMax.z = az-pixelPos.z;
- rendered=1;
- }
- } break;
- case BOX : {
- diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
- diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
- if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0 && diffMax.y>0
- && diffMin.z>0 && diffMax.z>0){
- rendered=1;
- }
- } break;
- case FRAME : {
- diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
- diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
- if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0 && diffMax.y>0
- && diffMin.z>0 && diffMax.z>0){
- rendered=1;
- }
- } break;
- case MODEL : {
- ivec2 selSize = textureSize(selectTex, 0);
- vec4 sel = texelFetch(selectTex,
- ivec2(coordX*float(selSize.x), coordY*float(selSize.y)), 0);
- //get front surfaces before depth map
- if(pixZ<=cutZ+thickness/1000.0) {
- if(sel.z==0) {
- if(sel.x==shapeID) {
- rendered=1;
- }
- else if((int(shapeIDBit)&int(sel.w))>0) {
- diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
- diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
- if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0
- && diffMax.y>0 && diffMin.z>0
- && diffMax.z>0){
- rendered=1;
- }
- }
- }
- if(surface>0
- && (pixZ>cutZ || (sel.z>0
- && (int(shapeIDBit)&int(sel.w))>0))) {
- rendered=2;
- }
- }
- } break;
- }
- if(rendered>0) {
- ratioWithinBox = (pixelPos)+0.5;
- //test if on the surface
- if(diffMin.x*modelScale.x<thickness
- || diffMax.x*modelScale.x<thickness
- || diffMin.y*modelScale.y<thickness
- || diffMax.y*modelScale.y<thickness
- || diffMin.z*modelScale.z<thickness
- || diffMax.z*modelScale.z<thickness) {
- rendered=2;
- }
- //extend ratiowithinbox to multiplesubshapes
- //and get gradient ratio according to type
- float gradRatio = 0;
- vec3 subAdd;
- vec3 subDiv;
- if(insideStructure==0) {
- //from center
- subAdd = vec3(subShapeID, subShapeID, subShapeID);
- subDiv = vec3(subShapesNb, subShapesNb, subShapesNb);
- ratioWithinBox.xyz=(ratioWithinBox.xyz+subAdd)/subDiv;
- outRatioWithinBox.xyz=ratioWithinBox.xyz;
- gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
- }
- else {
- //from surface or along axes
- subAdd = vec3(0,0, subShapeID);
- subDiv = vec3(1,1, subShapesNb);
- ratioWithinBox.xyz=(ratioWithinBox.xyz+subAdd)/subDiv;
- outRatioWithinBox.xyz=ratioWithinBox.xyz;
- if(insideStructure==1) {
- ratioWithinBox.x=0.5;
- }
- else if(insideStructure==2) {
- ratioWithinBox.y=0.5;
- }
- else if(insideStructure==3 && shapeGeom!=PATH) {
- ratioWithinBox.z=0.5;
- }
- switch(shapeGeom) {
+ //get fragment coordinates
+ float coordX = (gl_FragCoord.x-0.5)/viewportWidth;
+ float coordY = (gl_FragCoord.y-0.5)/viewportHeight;
+ ivec2 sliSize = textureSize(sliceTex, 0);
+
+ //retrieve pixel in slicing texture
+ vec4 sli = texelFetch(sliceTex, ivec2(coordX*float(sliSize.x), coordY*float(sliSize.y)), 0);
+ float pixZ=abs(gl_FragCoord.z);
+ float cutZ=abs(sli.z);
+ int depthID=int(sli.y)-1;
+
+ int outCols=imageSize(outputTex).x;
+ int outOffset=(int(shapeID-1)*depthOutNb+(depthID-1))*revSize;
+
+ int rendered=0;
+ vec3 finalColor = shapeColor;
+ float alpha=0;
+ vec3 pixelPosW;
+ vec3 pixelPos = vec3(0.0, 0.0, 1.0);
+ vec3 ratioWithinBox = vec3(0.0, 0.0, 0.0);
+ vec3 outRatioWithinBox = vec3(0.0, 0.0, 0.0);
+
+ //if there is a slicing pixel aligned with our coordinate
+ //and we are revealed by this depth module
+ if(cutZ>0 && (revealedBy & (1<<(1+depthID)))>0 ) {
+ //compute the slicing pixel world position
+ pixelPosW = vec3(viewMat[3][0], viewMat[3][1], viewMat[3][2]) + vec3(normalize(viewRay) * sli.w);
+ pixelPosW.x = pixelPosW.x*(-2.0*(1-mirrored)+1.0);
+ //compute the slicing pixel position in model coords
+ pixelPos = (invModelMat * vec4(pixelPosW,1.0)).xyz;
+
+ //depending on type, test if slicing pixel inside
+ //and retrieve distance to the surface on each axis
+ vec3 diffMin = vec3(1.0);
+ vec3 diffMax = vec3(1.0);
+
+ switch(shapeGeom) {
+ case PATH : {
+ //use min/max/size of current segment
+ pixelPos = (subShapeInvMat*vec4(pixelPos,1.0)).xyz;
+ if(length(vec2(pixelPos.x, pixelPos.y))<=0.5 && (pixelPos.z>-0.5 && pixelPos.z<0.5)) {
+ float xx = (pixelPos.x)*(pixelPos.x);
+ float yy = (pixelPos.y)*(pixelPos.y);
+ float ax = sqrt(0.25-yy);
+ diffMin.x = pixelPos.x+ax;
+ diffMax.x = ax-pixelPos.x;
+ float ay = sqrt(0.25-xx);
+ diffMin.y = pixelPos.y+ay;
+ diffMax.y = ay-pixelPos.y;
+ diffMin.z = pixelPos.z+0.5;
+ diffMax.z = 0.5-pixelPos.z;
+ rendered=1;
+ }
+ } break;
+ case CONE : {
+ if(pixelPos.y<0.5 && pixelPos.y>-0.5) {
+ float xx = (pixelPos.x)*(pixelPos.x);
+ float yy = (pixelPos.y-0.5)*(pixelPos.y-0.5);
+ float zz = (pixelPos.z)*(pixelPos.z);
+ if((xx+zz)/yy<0.25){
+ float ax = sqrt(0.25*yy-zz);
+ diffMin.x = pixelPos.x+ax;
+ diffMax.x = ax-pixelPos.x;
+ float ay = sqrt((yy+xx)/0.25);
+ diffMin.y = pixelPos.y+0.5;
+ diffMax.y = 0.5-pixelPos.y;
+ float az = sqrt(0.25*yy-xx);
+ diffMin.z = pixelPos.z+az;
+ diffMax.z = az-pixelPos.z;
+ rendered=1;
+ }
+ }
+ } break;
+ case TUBE : {
+ if(length(vec2(pixelPos.x, pixelPos.z))<=0.5 && (pixelPos.y>-0.5 && pixelPos.y<0.5)) {
+ float xx = (pixelPos.x)*(pixelPos.x);
+ float zz = (pixelPos.z)*(pixelPos.z);
+ float ax = sqrt(0.25-zz);
+ diffMin.x = pixelPos.x+ax;
+ diffMax.x = ax-pixelPos.x;
+ float az = sqrt(0.25-xx);
+ diffMin.z = pixelPos.z+az;
+ diffMax.z = az-pixelPos.z;
+ diffMin.y = pixelPos.y+0.5;
+ diffMax.y = 0.5-pixelPos.y;
+ rendered=1;
+ }
+ } break;
+ case SPHERE : {
+ if(length(pixelPos)<=0.5) {
+ float xx = (pixelPos.x)*(pixelPos.x);
+ float yy = (pixelPos.y)*(pixelPos.y);
+ float zz = (pixelPos.z)*(pixelPos.z);
+ float ax = sqrt(0.25-yy-zz);
+ diffMin.x = pixelPos.x+ax;
+ diffMax.x = ax-pixelPos.x;
+ float ay = sqrt(0.25-xx-zz);
+ diffMin.y = pixelPos.y+ay;
+ diffMax.y = ay-pixelPos.y;
+ float az = sqrt(0.25-xx-yy);
+ diffMin.z = pixelPos.z+az;
+ diffMax.z = az-pixelPos.z;
+ rendered=1;
+ }
+ } break;
+ case BOX : {
+ diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
+ diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
+ if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0 && diffMax.y>0
+ && diffMin.z>0 && diffMax.z>0){
+ rendered=1;
+ }
+ } break;
+ case FRAME : {
+ diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
+ diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
+ if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0 && diffMax.y>0
+ && diffMin.z>0 && diffMax.z>0){
+ rendered=1;
+ }
+ } break;
+ case MODEL : {
+ ivec2 selSize = textureSize(selectTex, 0);
+ vec4 sel = texelFetch(selectTex,
+ ivec2(coordX*float(selSize.x), coordY*float(selSize.y)), 0);
+ //get front surfaces before depth map
+ if(pixZ<=cutZ+thickness/1000.0) {
+ if(sel.z==0) {
+ if(sel.x==shapeID) {
+ rendered=1;
+ }
+ else if((int(shapeIDBit)&int(sel.w))>0) {
+ diffMin = pixelPos - vec3(-0.5, -0.5, -0.5);
+ diffMax = vec3(0.5, 0.5, 0.5) - pixelPos;
+ if(diffMin.x>0 && diffMax.x>0 && diffMin.y>0
+ && diffMax.y>0 && diffMin.z>0
+ && diffMax.z>0){
+ rendered=1;
+ }
+ }
+ }
+ if(surface>0
+ && (pixZ>cutZ || (sel.z>0
+ && (int(shapeIDBit)&int(sel.w))>0))) {
+ rendered=2;
+ }
+ }
+ } break;
+ }
+ if(rendered>0) {
+ ratioWithinBox = (pixelPos)+0.5;
+ //test if on the surface
+ if(diffMin.x*modelScale.x<thickness
+ || diffMax.x*modelScale.x<thickness
+ || diffMin.y*modelScale.y<thickness
+ || diffMax.y*modelScale.y<thickness
+ || diffMin.z*modelScale.z<thickness
+ || diffMax.z*modelScale.z<thickness) {
+ rendered=2;
+ }
+ //extend ratiowithinbox to multiplesubshapes
+ //and get gradient ratio according to type
+ float gradRatio = 0;
+ vec3 subAdd;
+ vec3 subDiv;
+ if(insideStructure==0) {
+ //from center
+ subAdd = vec3(subShapeID, subShapeID, subShapeID);
+ subDiv = vec3(subShapesNb, subShapesNb, subShapesNb);
+ ratioWithinBox.xyz=(ratioWithinBox.xyz+subAdd)/subDiv;
+ outRatioWithinBox.xyz=ratioWithinBox.xyz;
+ gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
+ }
+ else {
+ //from surface or along axes
+ subAdd = vec3(0,0, subShapeID);
+ subDiv = vec3(1,1, subShapesNb);
+ ratioWithinBox.xyz=(ratioWithinBox.xyz+subAdd)/subDiv;
+ outRatioWithinBox.xyz=ratioWithinBox.xyz;
+ if(insideStructure==1) {
+ ratioWithinBox.x=0.5;
+ }
+ else if(insideStructure==2) {
+ ratioWithinBox.y=0.5;
+ }
+ else if(insideStructure==3 && shapeGeom!=PATH) {
+ ratioWithinBox.z=0.5;
+ }
+ switch(shapeGeom) {
case BOX : {
- vec3 q = abs(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))*2.0 - vec3(1.0,1.0,1.0);
- gradRatio = 1.0-abs(length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0));
- } break;
- case SPHERE : {
- gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
- } break;
- case PATH : {
- vec2 d = abs(vec2(length((ratioWithinBox.xy-vec2(0.5, 0.5))*2.0), (ratioWithinBox.z-0.5)*2.0)) - vec2(1.0,1.0);
- gradRatio = 1.0 - abs(min(max(d.x,d.y),0.0) + length(max(d,0.0)));
-
- } break;
- case TUBE : {
- vec2 d = abs(vec2(length((ratioWithinBox.xz-vec2(0.5, 0.5))*2.0), (ratioWithinBox.y-0.5)*2.0)) - vec2(1.0,1.0);
- gradRatio = 1.0 - abs(min(max(d.x,d.y),0.0) + length(max(d,0.0)));
- } break;
- case CONE : {
- float q = length((ratioWithinBox.xz - vec2(0.5,0.5))*2.0);
- gradRatio = 1.0-abs(max(dot(vec2(0.5,0.5), vec2(q,(ratioWithinBox.y-1.0))), -1.0-(ratioWithinBox.y-1.0)));
- } break;
- case FRAME : {
- //FIXME compute frame SDF
- vec3 q = abs(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))*2.0 - vec3(1.0,1.0,1.0);
- gradRatio = 1.0-abs(length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0));
- } break;
- case MODEL : {
- gradRatio = texture(surfDistTex, ratioWithinBox).r * structureRatio;
- } break;
- default :{
- //defaults to sphere
- gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
- } break;
- }
- }
-
- //texture coordinates
- vec3 texCoords = vec3(1-ratioWithinBox.x, 1-ratioWithinBox.y, ratioWithinBox.z);
-
- //start with shapeColor
- finalColor = shapeColor;
- //test gradient
- if(gradientAlpha>0) {
- float gradColor = pow(gradientCurveRatio<0?1.0-gradRatio:gradRatio, abs(gradientCurveRatio));
- if(gradientSteps>1) {
- gradColor = floor(gradColor*gradientSteps) / gradientSteps;
- }
- gradColor*=(gradRatio<=1.0)?1.0:0.0;
- if(gradientType>0) {
- //gradient texture
- finalColor=finalColor*(1.0-gradientAlpha) + finalColor*gradientAlpha * texture(gradientTex, vec2(gradRatio, 0.0)).xyz;
- }
- else {
- finalColor=finalColor*(1.0-gradientAlpha) + finalColor*gradColor*gradientAlpha;
- }
- }
- //test density
- if(densityAlpha>0) {
- float densColor = pow(densityCurveRatio<0?1.0-gradRatio:gradRatio, abs(densityCurveRatio));
- if(densityType==0 && //layers
- length(mod(densColor*100.0, densitySize*100.0)) < densityRatio*densitySize*100.0) {
- densColor = 1.0;
- densColor*=(gradRatio<=1.0)?1.0:0.0;
- }
- else if(densityType==1 //grid
- && (length(mod(ratioWithinBox.x*100, densitySize*100.0)) < densitySize*densityRatio*100.0
- || length(mod(ratioWithinBox.y*100, densitySize*100.0)) < densitySize*densityRatio*100.0
- || length(mod(ratioWithinBox.z*100, densitySize*100.0)) < densitySize*densityRatio*100.0)) {
- densColor = 1.0;
- }
- else if(densityType==2 //pointcloud
- && floor(random(ratioWithinBox.xyz)*floor(100.0))>100.0*densColor) {
- densColor = 1.0;
- densColor*=(gradRatio<=1.0)?1.0:0.0;
- }
- else {
- densColor = 0.0;
- }
- finalColor=finalColor*(1.0-densityAlpha) + finalColor*densColor*densityAlpha;
- }
- //test texture
- if(texAlpha>0) {
- vec3 texColor = texture(insideTex, texOffset+texScale*texCoords).xyz;
- if(texGray>0) {
- texColor=vec3((texColor.r+texColor.g+texColor.b) / 3.0);
- }
- finalColor=finalColor*(1.0-texAlpha) + finalColor*texColor*texAlpha;
- }
-
- //if revealing something, output values
- if(sli.x>=1.0 && depthID<=depthOutNb) {
- //inside output
- if(revInside>0 && rendered==1) {
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revInside,outCols), floor((outOffset+revInside))/outCols), 1);
- }
- outRatioWithinBox.x=clamp(outRatioWithinBox.x, 0, 1);
- outRatioWithinBox.y=clamp(outRatioWithinBox.y, 0, 1);
- outRatioWithinBox.z=clamp(outRatioWithinBox.z, 0, 1);
- //compute min,max on the three axes
- int xk=int(outRatioWithinBox.x*1000.0);
- int yk=int(outRatioWithinBox.y*1000.0);
- int zk=int(outRatioWithinBox.z*1000.0);
- //output min/max ratios
- if(revCenter>0) {
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+0,outCols), floor((outOffset+revCenter+0)/outCols)), 1000-xk);
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+1,outCols), floor((outOffset+revCenter+1)/outCols)), xk);
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+2,outCols), floor((outOffset+revCenter+2)/outCols)), 1000-yk);
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+3,outCols), floor((outOffset+revCenter+3)/outCols)), yk);
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+4,outCols), floor((outOffset+revCenter+4)/outCols)), 1000-zk);
- imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+5,outCols), floor((outOffset+revCenter+5)/outCols)), zk);
- }
- //convert from rgb to hsv
- vec3 hsv = rgb2hsv(finalColor);
- //Sum color channels
- if(revColor>0) {
- //count nb revealed points
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+0,outCols), floor((outOffset+revColor+0)/outCols)), 1);
- //sum point h
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+1,outCols), floor((outOffset+revColor+1)/outCols)), clamp(int(hsv.x*1000.0),0,1000));
- //sum s
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+2,outCols), floor((outOffset+revColor+2)/outCols)), clamp(int(hsv.y*1000.0),0,1000));
- //sum v
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+3,outCols), floor((outOffset+revColor+3)/outCols)), clamp(int(hsv.z*1000.0),0,1000));
- }
- //histo : accumulate on luminance bins
- if(revHisto>0) {
- //count nb revealed points
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revHisto,outCols),
- floor((outOffset+revHisto)/outCols)), 1);
- int bin = int(hsv.z*float(histoOutSize-1));
- imageAtomicAdd(outputTex, ivec2(mod(outOffset+revHisto+1+bin,outCols), floor((outOffset+revHisto+1+bin)/outCols)), 1);
- }
-
- //2D grid of projected voxels (nbvox, 3D coords, lum)
- if(revVoxels>0) {
- //compute pixel ratio within 2D bounding rect
- vec2 pixRatio = (vec2(coordX, coordY) - boundingRect.xy) / (boundingRect.zw-boundingRect.xy);
- pixRatio.x = clamp(pixRatio.x, 0.0, 1.0);
- pixRatio.y = clamp(pixRatio.y, 0.0, 1.0);
- //compute offset in voxel output
- int voxOff = outOffset+revVoxels;
- voxOff+=5*(int(pixRatio.x*voxelOutSize)
- + int((1.0-pixRatio.y)*voxelOutSize)*voxelOutSize);
- //accumulate points
- imageAtomicAdd(outputTex, ivec2(mod(voxOff,outCols),
- floor((voxOff)/outCols)), 1);
- //accumulate coords
- imageAtomicAdd(outputTex, ivec2(mod(voxOff+1,outCols),
- floor((voxOff+1)/outCols)),
- clamp(int(outRatioWithinBox.x*1000.0),0,1000));
- imageAtomicAdd(outputTex, ivec2(mod(voxOff+2,outCols),
- floor((voxOff+2)/outCols)),
- clamp(int(outRatioWithinBox.y*1000.0),0,1000));
- imageAtomicAdd(outputTex, ivec2(mod(voxOff+3,outCols),
- floor((voxOff+3)/outCols)),
- clamp(int(outRatioWithinBox.z*1000.0),0,1000));
- //accumulate lum
- imageAtomicAdd(outputTex, ivec2(mod(voxOff+4,outCols),
- floor((voxOff+4)/outCols)),
- clamp(int(hsv.z*1000.0),0,1000));
- }
- }
- }
-
- //SURFACE test
- if(rendered>1) {
- finalColor = surfaceColor;
-
- if(revSurface>0 && sli.x>=1.0 && depthID<=depthOutNb) {
- imageAtomicMax(outputTex,
- ivec2(mod(outOffset+revSurface,outCols),
- floor((outOffset+revSurface)/outCols)), 1);
- }
- }
- }
- //final test, output if rendered or not, output final color
- //if(rendered>0 && length(finalColor)>0) {
- if(rendered>0) {
- if(revSize>0) {
- imageAtomicOr(outputTex, ivec2(mod(outOffset,outCols),
- floor((outOffset))/outCols), rendered);
- }
-
- if((insideVisible>0 && rendered==1) || (surface>0 && rendered==2)) {
- color = vec4(finalColor, 1.0);
- switch(processAudio) {
- case 1 : {
- additiveSynth(color);
- }break;
- case 2 : {
- pitchedAdditiveSynth(color);
- }break;
- default:break;
- }
- }
- else {
- color = vec4(0.0, 0.0, 0.0, 1.0);
- }
+ vec3 q = abs(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))*2.0 - vec3(1.0,1.0,1.0);
+ gradRatio = 1.0-abs(length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0));
+ } break;
+ case SPHERE : {
+ gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
+ } break;
+ case PATH : {
+ vec2 d = abs(vec2(length((ratioWithinBox.xy-vec2(0.5, 0.5))*2.0), (ratioWithinBox.z-0.5)*2.0)) - vec2(1.0,1.0);
+ gradRatio = 1.0 - abs(min(max(d.x,d.y),0.0) + length(max(d,0.0)));
+
+ } break;
+ case TUBE : {
+ vec2 d = abs(vec2(length((ratioWithinBox.xz-vec2(0.5, 0.5))*2.0), (ratioWithinBox.y-0.5)*2.0)) - vec2(1.0,1.0);
+ gradRatio = 1.0 - abs(min(max(d.x,d.y),0.0) + length(max(d,0.0)));
+ } break;
+ case CONE : {
+ float q = length((ratioWithinBox.xz - vec2(0.5,0.5))*2.0);
+ gradRatio = 1.0-abs(max(dot(vec2(0.5,0.5), vec2(q,(ratioWithinBox.y-1.0))), -1.0-(ratioWithinBox.y-1.0)));
+ } break;
+ case FRAME : {
+ //FIXME compute frame SDF
+ vec3 q = abs(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))*2.0 - vec3(1.0,1.0,1.0);
+ gradRatio = 1.0-abs(length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0));
+ } break;
+ case MODEL : {
+ gradRatio = texture(surfDistTex, ratioWithinBox).r * structureRatio;
+ } break;
+ default :{
+ //defaults to sphere
+ gradRatio = length(ratioWithinBox.xyz - vec3(0.5,0.5,0.5))/0.5;
+ } break;
+ }
+ }
+
+ //texture coordinates
+ vec3 texCoords = vec3(1-ratioWithinBox.x, 1-ratioWithinBox.y, ratioWithinBox.z);
+
+ //start with shapeColor
+ finalColor = shapeColor;
+ //test gradient
+ if(gradientAlpha>0) {
+ float gradColor = pow(gradientCurveRatio<0?1.0-gradRatio:gradRatio, abs(gradientCurveRatio));
+ if(gradientSteps>1) {
+ gradColor = floor(gradColor*gradientSteps) / gradientSteps;
+ }
+ gradColor*=(gradRatio<=1.0)?1.0:0.0;
+ if(gradientType>0) {
+ //gradient texture
+ finalColor=finalColor*(1.0-gradientAlpha) + finalColor*gradientAlpha * texture(gradientTex, vec2(gradRatio, 0.0)).xyz;
+ }
+ else {
+ finalColor=finalColor*(1.0-gradientAlpha) + finalColor*gradColor*gradientAlpha;
+ }
+ }
+ //test density
+ if(densityAlpha>0) {
+ float densColor = pow(densityCurveRatio<0?1.0-gradRatio:gradRatio, abs(densityCurveRatio));
+ if(densityType==0 && //layers
+ length(mod(densColor*100.0, densitySize*100.0)) < densityRatio*densitySize*100.0) {
+ densColor = 1.0;
+ densColor*=(gradRatio<=1.0)?1.0:0.0;
+ }
+ else if(densityType==1 //grid
+ && (length(mod(ratioWithinBox.x*100, densitySize*100.0)) < densitySize*densityRatio*100.0
+ || length(mod(ratioWithinBox.y*100, densitySize*100.0)) < densitySize*densityRatio*100.0
+ || length(mod(ratioWithinBox.z*100, densitySize*100.0)) < densitySize*densityRatio*100.0)) {
+ densColor = 1.0;
+ }
+ else if(densityType==2 //pointcloud
+ && floor(random(ratioWithinBox.xyz)*floor(100.0))>100.0*densColor) {
+ densColor = 1.0;
+ densColor*=(gradRatio<=1.0)?1.0:0.0;
+ }
+ else {
+ densColor = 0.0;
+ }
+ finalColor=finalColor*(1.0-densityAlpha) + finalColor*densColor*densityAlpha;
+ }
+ //test texture
+ if(texAlpha>0) {
+ vec3 texColor = texture(insideTex, texOffset+texScale*texCoords).xyz;
+ if(texGray>0) {
+ texColor=vec3((texColor.r+texColor.g+texColor.b) / 3.0);
+ }
+ finalColor=finalColor*(1.0-texAlpha) + finalColor*texColor*texAlpha;
+ }
+
+ //if revealing something, output values
+ if(sli.x>=1.0 && depthID<=depthOutNb) {
+ //inside output
+ if(revInside>0 && rendered==1) {
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revInside,outCols), floor((outOffset+revInside))/outCols), 1);
+ }
+ outRatioWithinBox.x=clamp(outRatioWithinBox.x, 0, 1);
+ outRatioWithinBox.y=clamp(outRatioWithinBox.y, 0, 1);
+ outRatioWithinBox.z=clamp(outRatioWithinBox.z, 0, 1);
+ //compute min,max on the three axes
+ int xk=int(outRatioWithinBox.x*1000.0);
+ int yk=int(outRatioWithinBox.y*1000.0);
+ int zk=int(outRatioWithinBox.z*1000.0);
+ //output min/max ratios
+ if(revCenter>0) {
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+0,outCols), floor((outOffset+revCenter+0)/outCols)), 1000-xk);
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+1,outCols), floor((outOffset+revCenter+1)/outCols)), xk);
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+2,outCols), floor((outOffset+revCenter+2)/outCols)), 1000-yk);
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+3,outCols), floor((outOffset+revCenter+3)/outCols)), yk);
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+4,outCols), floor((outOffset+revCenter+4)/outCols)), 1000-zk);
+ imageAtomicMax(outputTex, ivec2(mod(outOffset+revCenter+5,outCols), floor((outOffset+revCenter+5)/outCols)), zk);
+ }
+ //convert from rgb to hsv
+ vec3 hsv = rgb2hsv(finalColor);
+ //Sum color channels
+ if(revColor>0) {
+ //count nb revealed points
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+0,outCols), floor((outOffset+revColor+0)/outCols)), 1);
+ //sum point h
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+1,outCols), floor((outOffset+revColor+1)/outCols)), clamp(int(hsv.x*1000.0),0,1000));
+ //sum s
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+2,outCols), floor((outOffset+revColor+2)/outCols)), clamp(int(hsv.y*1000.0),0,1000));
+ //sum v
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revColor+3,outCols), floor((outOffset+revColor+3)/outCols)), clamp(int(hsv.z*1000.0),0,1000));
+ }
+ //histo : accumulate on luminance bins
+ if(revHisto>0) {
+ //count nb revealed points
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revHisto,outCols),
+ floor((outOffset+revHisto)/outCols)), 1);
+ int bin = int(hsv.z*float(histoOutSize-1));
+ imageAtomicAdd(outputTex, ivec2(mod(outOffset+revHisto+1+bin,outCols), floor((outOffset+revHisto+1+bin)/outCols)), 1);
+ }
+
+ //2D grid of projected voxels (nbvox, 3D coords, lum)
+ if(revVoxels>0) {
+ //compute pixel ratio within 2D bounding rect
+ vec2 pixRatio = (vec2(coordX, coordY) - boundingRect.xy) / (boundingRect.zw-boundingRect.xy);
+ pixRatio.x = clamp(pixRatio.x, 0.0, 1.0);
+ pixRatio.y = clamp(pixRatio.y, 0.0, 1.0);
+ //compute offset in voxel output
+ int voxOff = outOffset+revVoxels;
+ voxOff+=5*(int(pixRatio.x*voxelOutSize)
+ + int((1.0-pixRatio.y)*voxelOutSize)*voxelOutSize);
+ //accumulate points
+ imageAtomicAdd(outputTex, ivec2(mod(voxOff,outCols),
+ floor((voxOff)/outCols)), 1);
+ //accumulate coords
+ imageAtomicAdd(outputTex, ivec2(mod(voxOff+1,outCols),
+ floor((voxOff+1)/outCols)),
+ clamp(int(outRatioWithinBox.x*1000.0),0,1000));
+ imageAtomicAdd(outputTex, ivec2(mod(voxOff+2,outCols),
+ floor((voxOff+2)/outCols)),
+ clamp(int(outRatioWithinBox.y*1000.0),0,1000));
+ imageAtomicAdd(outputTex, ivec2(mod(voxOff+3,outCols),
+ floor((voxOff+3)/outCols)),
+ clamp(int(outRatioWithinBox.z*1000.0),0,1000));
+ //accumulate lum
+ imageAtomicAdd(outputTex, ivec2(mod(voxOff+4,outCols),
+ floor((voxOff+4)/outCols)),
+ clamp(int(hsv.z*1000.0),0,1000));
+ }
+ }
+ }
+
+ //SURFACE test
+ if(rendered>1) {
+ finalColor = surfaceColor;
+
+ if(revSurface>0 && sli.x>=1.0 && depthID<=depthOutNb) {
+ imageAtomicMax(outputTex,
+ ivec2(mod(outOffset+revSurface,outCols),
+ floor((outOffset+revSurface)/outCols)), 1);
+ }
+ }
+ }
+ //final test, output if rendered or not, output final color
+ //if(rendered>0 && length(finalColor)>0) {
+ if(rendered>0) {
+ if(revSize>0) {
+ imageAtomicOr(outputTex, ivec2(mod(outOffset,outCols),
+ floor((outOffset))/outCols), rendered);
+ }
+
+ if((insideVisible>0 && rendered==1) || (surface>0 && rendered==2)) {
+ color = vec4(finalColor, 1.0);
+ switch(processAudio) {
+ case 1 : {
+ additiveSynth(color);
+ }break;
+ case 2 : {
+ pitchedAdditiveSynth(color);
+ }break;
+ default:break;
+ }
+ }
+ else {
+ color = vec4(0.0, 0.0, 0.0, 1.0);
+ }
//color = vec4(0.0, 1.0, 0.0, 1.0);//for testing purposes
- }
- else { //DISCARD
- //color = vec4(1.0, 0.0, 0.0, 1.0);//for testing purposes
- discard;
- }
+ }
+ else { //DISCARD
+ //color = vec4(1.0, 0.0, 0.0, 1.0);//for testing purposes
+ discard;
+ }
};
--
GitLab