mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-06 03:29:44 -06:00
258e62caa2
- Added support for more keys in RenderableToggle - Switched to Fixed ABuffer (needs to be fixed) - Removed commented code
142 lines
5.0 KiB
Plaintext
142 lines
5.0 KiB
Plaintext
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include "abufferAddToBuffer.hglsl"
|
|
|
|
uniform float volumeStepFactor = 1.0f;
|
|
|
|
int build_local_fragments_list() {
|
|
|
|
#if ABUFFER_IMPLEMENTATION == ABUFFER_SINGLE_LINKED
|
|
uint current;
|
|
int frag_count = 0;
|
|
|
|
current = imageLoad(anchorPointerTexture, ivec2(gl_FragCoord.xy)).x;
|
|
|
|
while(current != 0 && frag_count < MAX_FRAGMENTS) {
|
|
ABufferStruct_t item = loadFromBuffer(current);
|
|
current = _next_(item);
|
|
|
|
fragments[frag_count] = item;
|
|
|
|
frag_count++;
|
|
}
|
|
|
|
return frag_count;
|
|
#endif
|
|
|
|
#if ABUFFER_IMPLEMENTATION == ABUFFER_FIXED
|
|
uint frag_count = imageLoad(anchorPointerTexture, ivec2(gl_FragCoord.xy)).x;
|
|
|
|
int i;
|
|
for(i = 0; i < frag_count && i < MAX_FRAGMENTS; ++i) {
|
|
fragments[i] = loadFromBuffer(i);
|
|
}
|
|
|
|
return int(frag_count);
|
|
#endif
|
|
|
|
}
|
|
|
|
float pscLength(vec4 v1, vec4 v2) {
|
|
const float k = 10.0;
|
|
float ds = v2.w - v1.w;
|
|
vec4 vector;
|
|
if(ds >= 0) {
|
|
float p = pow(k,-ds);
|
|
vector = vec4(v1.x*p - v2.x, v1.y*p - v2.y, v1.z*p - v2.z, v2.w);
|
|
} else {
|
|
float p = pow(k,ds);
|
|
vector = vec4(v1.x - v2.x*p, v1.y - v2.y*p, v1.z - v2.z*p, v1.w);
|
|
}
|
|
return length(vector.xyz)*pow(k,vector.w);
|
|
}
|
|
|
|
float permute(float i) {
|
|
return mod((62.0*i*i + i), 961.0); // permutation polynomial; 62=2*31; 961=31*31
|
|
}
|
|
|
|
void sort_fragments_list(uint frag_count) {
|
|
uint i,j;
|
|
ABufferStruct_t tmp;
|
|
|
|
// INSERTION SORT
|
|
for(i = 1; i < frag_count; ++i) {
|
|
tmp = fragments[i];
|
|
for(j = i; j > 0 && _z_(tmp) < _z_(fragments[j-1]); --j) {
|
|
fragments[j] = fragments[j-1];
|
|
}
|
|
fragments[j] = tmp;
|
|
}
|
|
|
|
#if MAX_VOLUMES > 0
|
|
int ii, jj;
|
|
for(ii = 0; ii < MAX_VOLUMES; ++ii) {
|
|
bool start = true;
|
|
vec3 startColor;
|
|
vec4 startPosition;
|
|
for(jj = 0; jj < frag_count; ++jj) {
|
|
int type = int(_type_(fragments[jj])) - 1;
|
|
if(type== ii) {
|
|
if(start) {
|
|
startColor = _col_(fragments[jj]).rgb;
|
|
startPosition = _pos_(fragments[jj]);
|
|
#if ZTYPE == ZDEPTH
|
|
volume_zlength[ii].x = _z_(fragments[jj]);
|
|
#endif
|
|
start = false;
|
|
} else {
|
|
volumes_in_fragment[volume_count++] = ii;
|
|
vec3 dir = _col_(fragments[jj]).rgb - startColor;
|
|
volume_position[ii] = startColor;
|
|
volume_length[ii] = length(dir);
|
|
volume_direction[ii] = normalize(dir);
|
|
volumeStepSize[ii] = 1.0/(volumeStepFactor * length(volume_direction[ii]*volume_dim[ii]));
|
|
volumeStepSizeOriginal[ii] = volumeStepSize[ii];
|
|
#if ZTYPE == ZDEPTH
|
|
volume_zlength[ii].y = _z_(fragments[jj]);
|
|
#elif ZTYPE == PSCDEPTH
|
|
volume_zlength[ii] = pscLength(_pos_(fragments[jj]), startPosition);
|
|
#endif
|
|
#ifdef USE_JITTERING
|
|
if(volumeStepSize[ii] < volume_length[ii]) {
|
|
// jittering
|
|
float x = gl_FragCoord.x;
|
|
float y = gl_FragCoord.y;
|
|
float jitterValue = float(permute(x + permute(y))) / 961.0;
|
|
vec3 frontPosNew = startColor + (jitterValue*volumeStepSize[ii])*volume_direction[ii];
|
|
volume_position[ii] = frontPosNew;
|
|
}
|
|
#endif
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
//volume_direction[0] = vec3(1.0,0.0,0.0);
|
|
//volume_direction[0] = _col_(fragments[0]).rgb;
|
|
}
|