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::setGradientShadingEnabled(bool value) { for(size_t i=0; i<modelStates.size(); i++) for(size_t j=0; j<modelStates[i].volumes.size(); j++) { ospSet1i(modelStates[i].volumes[j], "gradientShadingEnabled", value); ospCommit(modelStates[i].volumes[j]); } render(); }
void OSPObjectFile::importAttributeInteger(const tinyxml2::XMLNode *node, OSPObject parent) { // The attribute value is encoded in a string. const char *text = node->ToElement()->GetText(); int value = 0; char guard[8]; // Get the attribute value. exitOnCondition(sscanf(text, "%d %7s", &value, guard) != 1, "malformed XML element '" + std::string(node->ToElement()->Name()) + "'"); // Set the attribute on the parent object. ospSet1i(parent, node->ToElement()->Name(), value); }
void Material::render(RenderContext &ctx) { if (ospMaterial) return; ospMaterial = ospNewMaterial(ctx.integrator->getOSPHandle(), type.c_str()); //We failed to create a material of the given type, handle it if (!ospMaterial) { std::cerr << "Warning: Could not create material type '" << type << "'. Replacing with default material." << std::endl; //Replace with default static OSPMaterial defaultMaterial = NULL; if (defaultMaterial) { ospMaterial = defaultMaterial; return; } defaultMaterial = ospNewMaterial(ctx.integrator->getOSPHandle(), "OBJMaterial"); vec3f kd(.7f); vec3f ks(.3f); ospSet3fv(defaultMaterial, "Kd", &kd.x); ospSet3fv(defaultMaterial, "Ks", &ks.x); ospSet1f(defaultMaterial, "Ns", 99.f); ospCommit(defaultMaterial); return; } for(size_t i = 0; i < textures.size(); i++) { textures[i]->render(ctx); } //Forward all params on to the ospMaterial... for (ParamMap::const_iterator itr = param.begin(); itr != param.end(); ++itr) { switch(itr->second->getOSPDataType()) { case OSP_INT: case OSP_UINT: { ParamT<int> *p = (ParamT<int>*)itr->second.ptr; if(itr->second->getName().find("map_") != std::string::npos) { //Handle textures! assert(textures[p->value]->ospTexture != NULL && "Texture should not be null at this point."); ospSetObject(ospMaterial, itr->second->getName().c_str(), textures[p->value]->ospTexture); } else { ospSet1i(ospMaterial, itr->second->getName().c_str(), p->value); } } break; case OSP_INT3: case OSP_UINT3: { ParamT<vec3i> *p = (ParamT<vec3i>*)itr->second.ptr; ospSet3i(ospMaterial, itr->second->getName().c_str(), p->value.x, p->value.y, p->value.z); } break; case OSP_FLOAT: { ParamT<float> *p = (ParamT<float>*)itr->second.ptr; ospSet1f(ospMaterial, itr->second->getName().c_str(), p->value); } break; case OSP_FLOAT2: { ParamT<vec2f> *p = (ParamT<vec2f>*)itr->second.ptr; ospSet2fv(ospMaterial, itr->second->getName().c_str(), &p->value.x); } break; case OSP_FLOAT3: { ParamT<vec3f> *p = (ParamT<vec3f>*)itr->second.ptr; ospSet3fv(ospMaterial, itr->second->getName().c_str(), &p->value.x); } break; default: //Catch not yet implemented data types std::cerr << "Warning: parameter '" << itr->second->getName() << "' of material '" << name << "' had an invalid data type and will be ignored." << std::endl; } } ospCommit(ospMaterial); }
void VolumeViewer::setSubsamplingInteractionEnabled(bool value) { ospSet1i(renderer, "spp", value ? -1 : 1); if(rendererInitialized) ospCommit(renderer); }
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; }