Renderer::Renderer(int width, int height)
{
renderer = ospNewRenderer("vis_renderer");
camera.setRenderer(renderer);
renderProperties.setRenderer(renderer);
float clips[12] =
{
1.0, 0.0, 0.0, -0.9,
1.0, -1.0, 0.0, 0.0,
-1.0, 0.0, 0.0, 0.1
};
ospSetData(renderer, "clips", ospNewData(sizeof(clips) / (4 * sizeof(float)), OSP_FLOAT4, clips));
float slice[4] = {5.0, 6.0, 7.0, 8.0};
ospSetData(renderer, "slices", ospNewData(1, OSP_FLOAT4, slice));
OSPModel dmodel = ospNewModel();
ospCommit(dmodel);
ospSetObject(renderer, "dynamic_model", dmodel);
window = new CinemaWindow(width, height);
camera.setAspect(((float)height) / width);
}
void VolumeViewer::setIsovalues(std::vector<float> isovalues)
{
OSPData isovaluesData = ospNewData(isovalues.size(), OSP_FLOAT, &isovalues[0]);
// Remove existing isosurface geometries from models.
for(size_t i=0; i<modelStates.size(); i++) {
for(size_t j=0; j<modelStates[i].isosurfaces.size(); j++)
ospRemoveGeometry(modelStates[i].model, modelStates[i].isosurfaces[j]);
modelStates[i].isosurfaces.clear();
}
// Add new isosurfaces for each volume of each model. Later we can do this only for the active model on time step change...
for(size_t i=0; i<modelStates.size(); i++) {
if(isovalues.size() > 0) {
for(size_t j=0; j<modelStates[i].volumes.size(); j++) {
OSPGeometry isosurfacesGeometry = ospNewGeometry("isosurfaces");
ospSetData(isosurfacesGeometry, "isovalues", isovaluesData);
ospSetObject(isosurfacesGeometry, "volume", modelStates[i].volumes[j]);
ospCommit(isosurfacesGeometry);
ospAddGeometry(modelStates[i].model, isosurfacesGeometry);
modelStates[i].isosurfaces.push_back(isosurfacesGeometry);
}
}
ospCommit(modelStates[i].model);
}
render();
}
void Geometry::postCommit(RenderContext &)
{
auto ospGeometry = valueAs<OSPGeometry>();
if (hasChild("material") && !hasChild("materialList")) {
// XXX FIXME never happens
ospSetMaterial(ospGeometry, child("material").valueAs<OSPMaterial>());
}
auto materialListNode = child("materialList").nodeAs<MaterialList>();
const auto &materialList = materialListNode->nodes;
if (!materialList.empty()) {
std::vector<OSPObject> mats;
for (auto mat : materialList) {
auto m = mat->valueAs<OSPObject>();
if (m)
mats.push_back(m);
}
auto ospMaterialList = ospNewData(mats.size(), OSP_OBJECT, mats.data());
ospCommit(ospMaterialList);
ospSetData(valueAs<OSPObject>(), "materialList", ospMaterialList);
ospRelease(ospMaterialList);
}
ospCommit(ospGeometry);
}
void VolumeViewer::initObjects(const std::string &renderer_type)
{
// Create an OSPRay renderer.
renderer = ospNewRenderer(renderer_type.c_str());
exitOnCondition(renderer == NULL, "could not create OSPRay renderer object");
// Set renderer defaults (if not using 'aoX' renderers)
if (renderer_type[0] != 'a' && renderer_type[1] != 'o')
{
ospSet1i(renderer, "aoSamples", 1);
ospSet1i(renderer, "shadowsEnabled", 1);
}
// Create OSPRay ambient and directional lights. GUI elements will modify their parameters.
ambientLight = ospNewLight(renderer, "AmbientLight");
exitOnCondition(ambientLight == NULL, "could not create ambient light");
ospCommit(ambientLight);
directionalLight = ospNewLight(renderer, "DirectionalLight");
exitOnCondition(directionalLight == NULL, "could not create directional light");
ospCommit(directionalLight);
// Set the light sources on the renderer.
std::vector<OSPLight> lights;
lights.push_back(ambientLight);
lights.push_back(directionalLight);
ospSetData(renderer, "lights", ospNewData(lights.size(), OSP_OBJECT, &lights[0]));
// Create an OSPRay transfer function.
transferFunction = ospNewTransferFunction("piecewise_linear");
exitOnCondition(transferFunction == NULL, "could not create OSPRay transfer function object");
ospCommit(transferFunction);
// Load OSPRay objects from files.
for (size_t i=0 ; i < objectFileFilenames.size() ; i++)
importObjectsFromFile(objectFileFilenames[i]);
// Get the bounding box of all volumes of the first model.
if(modelStates.size() > 0 && modelStates[0].volumes.size() > 0) {
ospGetVec3f(modelStates[0].volumes[0], "boundingBoxMin", (osp::vec3f*)&boundingBox.lower);
ospGetVec3f(modelStates[0].volumes[0], "boundingBoxMax", (osp::vec3f*)&boundingBox.upper);
for (size_t i=1; i<modelStates[0].volumes.size(); i++) {
ospcommon::box3f volumeBoundingBox;
ospGetVec3f(modelStates[0].volumes[i], "boundingBoxMin", (osp::vec3f*)&volumeBoundingBox.lower);
ospGetVec3f(modelStates[0].volumes[i], "boundingBoxMax", (osp::vec3f*)&volumeBoundingBox.upper);
boundingBox.extend(volumeBoundingBox);
}
}
}
void VolumeViewer::setSlices(std::vector<SliceParameters> sliceParameters)
{
// Provide the slices to OSPRay as the coefficients (a,b,c,d) of the plane equation ax + by + cz + d = 0.
std::vector<ospcommon::vec4f> planes;
for(size_t i=0; i<sliceParameters.size(); i++)
planes.push_back(ospcommon::vec4f(sliceParameters[i].normal.x,
sliceParameters[i].normal.y,
sliceParameters[i].normal.z,
-dot(sliceParameters[i].origin, sliceParameters[i].normal)));
OSPData planesData = ospNewData(planes.size(), OSP_FLOAT4, &planes[0].x);
// Remove existing slice geometries from models.
for(size_t i=0; i<modelStates.size(); i++) {
for(size_t j=0; j<modelStates[i].slices.size(); j++)
ospRemoveGeometry(modelStates[i].model, modelStates[i].slices[j]);
modelStates[i].slices.clear();
}
// Add new slices for each volume of each model. Later we can do this only for the active model on time step change...
for(size_t i=0; i<modelStates.size(); i++) {
if(planes.size() > 0) {
for(size_t j=0; j<modelStates[i].volumes.size(); j++) {
OSPGeometry slicesGeometry = ospNewGeometry("slices");
ospSetData(slicesGeometry, "planes", planesData);
ospSetObject(slicesGeometry, "volume", modelStates[i].volumes[j]);
ospCommit(slicesGeometry);
ospAddGeometry(modelStates[i].model, slicesGeometry);
modelStates[i].slices.push_back(slicesGeometry);
}
}
ospCommit(modelStates[i].model);
}
render();
}
OSPTexture OSPRayMaterial::_createOSPTexture2D(Texture2DPtr texture)
{
OSPTextureFormat type = OSP_TEXTURE_R8; // smallest valid type as default
if (texture->getDepth() == 1)
{
if (texture->getNbChannels() == 1)
type = OSP_TEXTURE_R8;
if (texture->getNbChannels() == 3)
type = OSP_TEXTURE_RGB8;
if (texture->getNbChannels() == 4)
type = OSP_TEXTURE_RGBA8;
}
else if (texture->getDepth() == 4)
{
if (texture->getNbChannels() == 1)
type = OSP_TEXTURE_R32F;
if (texture->getNbChannels() == 3)
type = OSP_TEXTURE_RGB32F;
if (texture->getNbChannels() == 4)
type = OSP_TEXTURE_RGBA32F;
}
BRAYNS_DEBUG << "Creating OSPRay texture from " << texture->getFilename()
<< ": " << texture->getWidth() << "x" << texture->getHeight()
<< "x" << (int)type << std::endl;
OSPTexture ospTexture = ospNewTexture("texture2d");
const Vector2i size{int(texture->getWidth()), int(texture->getHeight())};
osphelper::set(ospTexture, "type", static_cast<int>(type));
osphelper::set(ospTexture, "size", size);
auto textureData =
ospNewData(texture->getSizeInBytes(), OSP_RAW, texture->getRawData(),
OSP_DATA_SHARED_BUFFER);
ospSetObject(ospTexture, "data", textureData);
ospRelease(textureData);
ospCommit(ospTexture);
return ospTexture;
}
int main(int ac, const char **av) {
// image size
osp_vec2i imgSize;
imgSize.x = 1024; // width
imgSize.y = 768; // height
// camera
float cam_pos[] = {0.f, 0.f, 0.f};
float cam_up [] = {0.f, 1.f, 0.f};
float cam_view [] = {0.1f, 0.f, 1.f};
// triangle mesh data
float vertex[] = { -1.0f, -1.0f, 3.0f, 0.f,
-1.0f, 1.0f, 3.0f, 0.f,
1.0f, -1.0f, 3.0f, 0.f,
0.1f, 0.1f, 0.3f, 0.f };
float color[] = { 0.9f, 0.5f, 0.5f, 1.0f,
0.8f, 0.8f, 0.8f, 1.0f,
0.8f, 0.8f, 0.8f, 1.0f,
0.5f, 0.9f, 0.5f, 1.0f };
int32_t index[] = { 0, 1, 2,
1, 2, 3 };
// initialize OSPRay; OSPRay parses (and removes) its commandline parameters, e.g. "--osp:debug"
ospInit(&ac, av);
// create and setup camera
OSPCamera camera = ospNewCamera("perspective");
ospSetf(camera, "aspect", imgSize.x/(float)imgSize.y);
ospSet3fv(camera, "pos", cam_pos);
ospSet3fv(camera, "dir", cam_view);
ospSet3fv(camera, "up", cam_up);
ospCommit(camera); // commit each object to indicate modifications are done
// create and setup model and mesh
OSPGeometry mesh = ospNewGeometry("triangles");
OSPData data = ospNewData(4, OSP_FLOAT3A, vertex, 0); // OSP_FLOAT3 format is also supported for vertex positions (currently not on MIC)
ospCommit(data);
ospSetData(mesh, "vertex", data);
data = ospNewData(4, OSP_FLOAT4, color, 0);
ospCommit(data);
ospSetData(mesh, "vertex.color", data);
data = ospNewData(2, OSP_INT3, index, 0); // OSP_INT4 format is also supported for triangle indices
ospCommit(data);
ospSetData(mesh, "index", data);
ospCommit(mesh);
OSPModel world = ospNewModel();
ospAddGeometry(world, mesh);
ospCommit(world);
// create and setup renderer
OSPRenderer renderer = ospNewRenderer("scivis"); // choose Scientific Visualization renderer
ospSet1f(renderer, "aoWeight", 1.0f); // with full Ambient Occlusion
ospSet1i(renderer, "aoSamples", 1);
ospSetObject(renderer, "model", world);
ospSetObject(renderer, "camera", camera);
ospCommit(renderer);
// create and setup framebuffer
OSPFrameBuffer framebuffer = ospNewFrameBuffer(&imgSize, OSP_FB_SRGBA, OSP_FB_COLOR | /*OSP_FB_DEPTH |*/ OSP_FB_ACCUM);
ospFrameBufferClear(framebuffer, OSP_FB_COLOR | OSP_FB_ACCUM);
// render one frame
ospRenderFrame(framebuffer, renderer, OSP_FB_COLOR | OSP_FB_ACCUM);
// access framebuffer and write its content as PPM file
const uint32_t * fb = (uint32_t*)ospMapFrameBuffer(framebuffer, OSP_FB_COLOR);
writePPM("firstFrameC.ppm", &imgSize, fb);
ospUnmapFrameBuffer(fb, framebuffer);
// render 10 more frames, which are accumulated to result in a better converged image
for (int frames = 0; frames < 10; frames++)
ospRenderFrame(framebuffer, renderer, OSP_FB_COLOR | OSP_FB_ACCUM);
fb = (uint32_t*)ospMapFrameBuffer(framebuffer, OSP_FB_COLOR);
writePPM("accumulatedFrameC.ppm", &imgSize, fb);
ospUnmapFrameBuffer(fb, framebuffer);
return 0;
}
