void OGL3DBase::PerspectiveSetup(double eyeSepMult)
{
Coord3D zeroOffset(0.0, 0.0, 0.0);
Coord3D minCoord = plotBase.GetNormalizedCoord(currView.viewLimits.minLim, zeroOffset);
Coord3D maxCoord = plotBase.GetNormalizedCoord(currView.viewLimits.maxLim, zeroOffset);;
double maxSceneWidth = minCoord.Distance(maxCoord);
double sceneWidth = maxSceneWidth / currView.scale;
double fovRadians = Radians(plot3Dbase.fieldOfView);
double focalLength = sceneWidth / 2.0 / tan(fovRadians / 2.0);
double nearDist = focalLength / 5.0;
double farDist = focalLength + maxSceneWidth * 4.0;
double wd2 = nearDist * tan(fovRadians);
double ndfl = nearDist / focalLength;
double eyeSep = focalLength * eyeSepMult;
int width, height;
plotBase.CalcAvailablePixels(width, height);
double aspect = double(width)/ double(height);
double left = -aspect * wd2 + eyeSep * ndfl;
double right = aspect * wd2 + eyeSep * ndfl;
double top = wd2;
double bottom = - wd2;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(left, right, bottom, top, nearDist, farDist);
Coord3D spanOffset((1.0 - xOrthoSpan)/ 2.0 , (1.0 - yOrthoSpan)/ 2.0 , (1.0 - zOrthoSpan)/ 2.0 );
Coord3D translation = currView.translation + spanOffset;
translation *= (maxCoord - minCoord);
Coord3D lookAtPoint = (minCoord + maxCoord) / 2.0;
lookAtPoint -= translation;
double elevAngle = Radians(currView.elevation);
double rotAngle = Radians(currView.azimuth);
double dz = focalLength * sin(elevAngle);
double xylen = focalLength * cos(elevAngle);
double dx = - xylen * sin(rotAngle);
double dy = - xylen * cos(rotAngle);
Coord3D eyeCoord = lookAtPoint;
eyeCoord.cX += dx;
eyeCoord.cY += dy;
eyeCoord.cZ += dz;
Coord3D upVec(0.0, 0.0, 1.0);
if (fabs(sin(elevAngle)) > 0.95)
{
upVec = Coord3D(sin(rotAngle), cos(rotAngle), 0.0);
upVec.Normalize();
}
if (eyeSep > stdEps)
{
Coord3D rsep = CrossProduct(eyeCoord, upVec);
rsep.Normalize();
rsep *= eyeSep;
eyeCoord += rsep;
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(eyeCoord.cX, eyeCoord.cY, eyeCoord.cZ,
lookAtPoint.cX, lookAtPoint.cY, lookAtPoint.cZ,
upVec.cX, upVec.cY, upVec.cZ);
// denormalize
// scale for normalizations
glScaled(xOrthoSpan / normSpan.cX, yOrthoSpan / normSpan.cY, zOrthoSpan / normSpan.cZ);
// translate again for normalizations
glTranslated(-normMin.cX, -normMin.cY, -normMin.cZ);
}
//--------------------------------------------------------------
void SnapshotRamses::setup(const std::string& folder, int frameIndex)
{
clear();
// Load the HDF5 data.
std::vector<float> posX;
std::vector<float> posY;
std::vector<float> posZ;
std::vector<float> cellSize;
std::vector<float> density;
load(folder + "x/seq_" + ofToString(frameIndex) + "_x.h5", posX);
load(folder + "y/seq_" + ofToString(frameIndex) + "_y.h5", posY);
load(folder + "z/seq_" + ofToString(frameIndex) + "_z.h5", posZ);
load(folder + "dx/seq_" + ofToString(frameIndex) + "_dx.h5", cellSize);
load(folder + "density/seq_" + ofToString(frameIndex) + "_density.h5", density);
m_numCells = posX.size();
// Set the ranges for all data.
for (int i = 0; i < posX.size(); ++i)
{
m_coordRange.add(glm::vec3(posX[i], posY[i], posZ[i]));
m_sizeRange.add(cellSize[i]);
m_densityRange.add(density[i]);
}
// Expand coord range taking cell size into account.
m_coordRange.add(m_coordRange.getMin() - m_sizeRange.getMax());
m_coordRange.add(m_coordRange.getMax() + m_sizeRange.getMax());
// Find the dimension with the max span, and set all spans to be the same (since we're rendering a cube).
glm::vec3 coordSpan = m_coordRange.getSpan();
float maxSpan = MAX(coordSpan.x, MAX(coordSpan.y, coordSpan.z));
glm::vec3 spanOffset(maxSpan * 0.5);
glm::vec3 coordMid = m_coordRange.getCenter();
m_coordRange.add(coordMid - spanOffset);
m_coordRange.add(coordMid + spanOffset);
// Set up the VBO.
m_vboMesh = ofMesh::box(1, 1, 1, 1, 1, 1);
m_vboMesh.setUsage(GL_STATIC_DRAW);
// Upload per-instance data to the VBO.
m_vboMesh.getVbo().setAttributeData(DENSITY_ATTRIBUTE, density.data(), 1, density.size(), GL_STATIC_DRAW, 0);
m_vboMesh.getVbo().setAttributeDivisor(DENSITY_ATTRIBUTE, 1);
// Upload per-instance transform data to the TBO.
std::vector<ofVec4f> transforms;
transforms.resize(posX.size());
for (size_t i = 0; i < transforms.size(); ++i)
{
transforms[i] = ofVec4f(posX[i], posY[i], posZ[i], cellSize[i]);
}
m_bufferObject.allocate();
m_bufferObject.bind(GL_TEXTURE_BUFFER);
m_bufferObject.setData(transforms, GL_STREAM_DRAW);
m_bufferTexture.allocateAsBufferTexture(m_bufferObject, GL_RGBA32F);
m_bLoaded = true;
}
