void LinearTransferFunction::commit() { // Create the equivalent ISPC transfer function. if (ispcEquivalent == NULL) createEquivalentISPC(); // Retrieve the color and opacity values. colorValues = getParamData("colors", NULL); opacityValues = getParamData("opacities", NULL); // Set the color values. if (colorValues) ispc::LinearTransferFunction_setColorValues(ispcEquivalent, colorValues->numItems, (ispc::vec3f *) colorValues->data); // Set the opacity values. if (opacityValues) { float *alpha = (float *)opacityValues->data; ispc::LinearTransferFunction_setOpacityValues(ispcEquivalent, opacityValues->numItems, (float *)opacityValues->data); } // Set the value range that the transfer function covers. vec2f valueRange = getParam2f("valueRange", vec2f(0.0f, 1.0f)); ispc::TransferFunction_setValueRange(ispcEquivalent, (const ispc::vec2f &) valueRange); // Notify listeners that the transfer function has changed. notifyListenersThatObjectGotChanged(); }
void StreamLines::finalize(Model *model) { radius = getParam1f("radius",0.01f); vertexData = getParamData("vertex",NULL); indexData = getParamData("index",NULL); colorData = getParamData("vertex.color",getParamData("color")); Assert(radius > 0.f); Assert(vertexData); Assert(indexData); index = (const uint32*)indexData->data; numSegments = indexData->numItems; vertex = (const vec3fa*)vertexData->data; numVertices = vertexData->numItems; color = colorData ? (const vec4f*)colorData->data : NULL; std::cout << "#osp: creating streamlines geometry, " << "#verts=" << numVertices << ", " << "#segments=" << numSegments << ", " << "radius=" << radius << std::endl; ispc::StreamLineGeometry_set(getIE(),model->getIE(),radius, (ispc::vec3fa*)vertex,numVertices, (uint32_t*)index,numSegments, (ispc::vec4f*)color); }
void SimulationRenderer::commit( ) { Renderer::commit(); lightData = ( ospray::Data* )getParamData( "lights" ); lightArray.clear( ); if( lightData ) for( size_t i=0; i < lightData->size( ); ++i ) lightArray.push_back( ( ( ospray::Light** )lightData->data )[ i ]->getIE( )); void **lightPtr = lightArray.empty() ? nullptr : &lightArray[0]; ospray::vec3f bgColor = getParam3f( "bgColor", ospray::vec3f( 1.f )); shadowsEnabled = bool( getParam1i( "shadowsEnabled", 1 )); softShadowsEnabled = bool(getParam1i( "softShadowsEnabled", 1 )); ambientOcclusionStrength = getParam1f( "ambientOcclusionStrength", 0.f ); shadingEnabled = bool( getParam1i( "shadingEnabled", 1 )); randomNumber = getParam1i( "randomNumber", 0 ); moving = bool( getParam1i( "moving", 0 )); timestamp = getParam1f( "timestamp", 0.f ); spp = getParam1i("spp", 1); electronShadingEnabled = bool( getParam1i( "electronShading", 0 )); ospray::vec3f scale = getParam3f( "scale", ospray::vec3f( 1.f )); simulationNbOffsets = getParam1i( "simulationNbOffsets", 0 ); simulationNbFrames = getParam1i( "simulationNbFrames", 0 ); // Those materials are used for simulation mapping only materialData = ( ospray::Data* )getParamData( "materials" ); materialArray.clear( ); if( materialData ) for( size_t i = 0; i < materialData->size( ); ++i ) materialArray.push_back( ( ( ospray::Material** )materialData->data )[i]->getIE( )); void **materialPtr = materialArray.empty( ) ? nullptr : &materialArray[0]; ispc::SimulationRenderer_set( getIE( ), ( ispc::vec3f& )bgColor, ( ispc::vec3f& )scale, shadowsEnabled, softShadowsEnabled, ambientOcclusionStrength, shadingEnabled, randomNumber, moving, timestamp, spp, electronShadingEnabled, simulationNbOffsets, simulationNbFrames, lightPtr, lightArray.size( ), materialPtr, materialArray.size( )); }
void ProximityRenderer::commit( ) { Renderer::commit( ); lightData = ( ospray::Data* )getParamData( "lights" ); lightArray.clear( ); if( lightData ) for( size_t i = 0; i < lightData->size( ); ++i ) lightArray.push_back(((Light**)lightData->data)[i]->getIE()); void **lightPtr = lightArray.empty( ) ? NULL : &lightArray[0]; vec3f bgColor = getParam3f( "bgColor", vec3f( 0.f )); vec3f nearColor = getParam3f( "detectionNearColor", vec3f( 0.f, 1.f, 0.f )); vec3f farColor = getParam3f( "detectionFarColor", vec3f( 1.f, 0.f, 0.f )); detectionDistance = getParam1f( "detectionDistance", 1.f ); detectionOnDifferentMaterial = bool( getParam1i( "detectionOnDifferentMaterial", 0 )); randomNumber = getParam1i( "randomNumber", 0 ); timestamp = getParam1f( "timestamp", 0.f ); spp = getParam1i( "spp", 1 ); electronShadingEnabled = bool( getParam1i( "electronShading", 1 )); // Those materials are used for skybox mapping only materialData = ( ospray::Data* )getParamData( "materials" ); materialArray.clear( ); if( materialData ) for( size_t i = 0; i < materialData->size( ); ++i ) materialArray.push_back( ( ( ospray::Material** )materialData->data )[i]->getIE( )); void **materialArrayPtr = materialArray.empty( ) ? nullptr : &materialArray[0]; ispc::ProximityRenderer_set( getIE( ), ( ispc::vec3f& )bgColor, ( ispc::vec3f& )nearColor, ( ispc::vec3f& )farColor, detectionDistance, detectionOnDifferentMaterial, randomNumber, timestamp, spp, electronShadingEnabled, lightPtr, lightArray.size( ), materialArrayPtr, materialArray.size( )); }
void SciVisRenderer::commit() { Renderer::commit(); lightData = (Data*)getParamData("lights"); lightArray.clear(); if (lightData) { for (int i = 0; i < lightData->size(); i++) lightArray.push_back(((Light**)lightData->data)[i]->getIE()); } void **lightPtr = lightArray.empty() ? NULL : &lightArray[0]; const bool shadowsEnabled = getParam1i("shadowsEnabled", 0); const int32 maxDepth = getParam1i("maxDepth", 10); int numAOSamples = getParam1i("aoSamples", 0); float rayLength = getParam1f("aoOcclusionDistance", 1e20f); float aoWeight = getParam1f("aoWeight", 0.25f); ispc::SciVisRenderer_set(getIE(), shadowsEnabled, maxDepth, numAOSamples, rayLength, aoWeight, lightPtr, lightArray.size()); }
void ExtendedCylinders::finalize(ospray::Model *model) { radius = getParam1f("radius",0.01f); materialID = getParam1i("materialID",0); bytesPerCylinder = getParam1i("bytes_per_cylinder",9*sizeof(float)); offset_v0 = getParam1i("offset_v0",0); offset_v1 = getParam1i("offset_v1",3*sizeof(float)); offset_radius = getParam1i("offset_radius",6*sizeof(float)); offset_timestamp = getParam1i("offset_timestamp",7*sizeof(float)); offset_value = getParam1i("offset_value",8*sizeof(float)); offset_materialID = getParam1i("offset_materialID",-1); data = getParamData("extendedcylinders",nullptr); if (data.ptr == nullptr || bytesPerCylinder == 0) throw std::runtime_error("#ospray:geometry/extendedcylinders: " \ "no 'extendedcylinders' data specified"); numExtendedCylinders = data->numBytes / bytesPerCylinder; ispc::ExtendedCylindersGeometry_set( getIE(), model->getIE(), data->data, numExtendedCylinders, bytesPerCylinder, radius, materialID, offset_v0, offset_v1, offset_radius, offset_timestamp, offset_value, offset_materialID); }
void StructuredVolume::getVolumeFromMemory() { //! Create the equivalent ISPC volume container and allocate memory for voxel data. createEquivalentISPC(); //! Get a pointer to the source voxel data. const Data *voxelData = getParamData("voxelData", NULL); exitOnCondition(voxelData == NULL, "no voxel data specified"); const uint8 *data = (const uint8 *) voxelData->data; //! The dimensions of the source voxel data and target volume must match. exitOnCondition(size_t(volumeDimensions.x) * volumeDimensions.y * volumeDimensions.z != voxelData->numItems, "unexpected source voxel data dimensions"); //! The source and target voxel types must match. exitOnCondition(getVoxelType() != voxelData->type, "unexpected source voxel type"); //! Size of a volume slice in bytes. size_t sliceSizeInBytes = volumeDimensions.x * volumeDimensions.y * getVoxelSizeInBytes(); //! Copy voxel data into the volume in slices to avoid overflow in ISPC offset calculations. for (size_t z=0 ; z < volumeDimensions.z ; z++) setRegion(&data[z * sliceSizeInBytes], vec3i(0, 0, z), vec3i(volumeDimensions.x, volumeDimensions.y, 1)); }
void ParameterItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) { setColor(Qt::red); getParamData(); setColor(Qt::darkCyan); event->setAccepted(true); }
void Cylinders::finalize(Model *model) { radius = getParam1f("radius",0.01f); materialID = getParam1i("materialID",0); bytesPerCylinder = getParam1i("bytes_per_cylinder",6*sizeof(float)); offset_v0 = getParam1i("offset_v0",0); offset_v1 = getParam1i("offset_v1",3*sizeof(float)); offset_radius = getParam1i("offset_radius",-1); offset_materialID = getParam1i("offset_materialID",-1); offset_colorID = getParam1i("offset_colorID",-1); cylinderData = getParamData("cylinders"); materialList = getParamData("materialList"); colorData = getParamData("color"); if (cylinderData.ptr == NULL || bytesPerCylinder == 0) throw std::runtime_error("#ospray:geometry/cylinders: no 'cylinders' data specified"); numCylinders = cylinderData->numBytes / bytesPerCylinder; std::cout << "#osp: creating 'cylinders' geometry, #cylinders = " << numCylinders << std::endl; if (_materialList) { free(_materialList); _materialList = NULL; } if (materialList) { void **ispcMaterials = (void**) malloc(sizeof(void*) * materialList->numItems); for (int i=0;i<materialList->numItems;i++) { Material *m = ((Material**)materialList->data)[i]; ispcMaterials[i] = m?m->getIE():NULL; } _materialList = (void*)ispcMaterials; } ispc::CylindersGeometry_set(getIE(),model->getIE(), cylinderData->data,_materialList, colorData?(ispc::vec4f*)colorData->data:NULL, numCylinders,bytesPerCylinder, radius,materialID, offset_v0,offset_v1, offset_radius, offset_materialID,offset_colorID); }
void Slices::finalize(Model *model) { planesData = getParamData("planes", NULL); volume = (Volume *)getParamObject("volume", NULL); Assert(planesData); Assert(volume); numPlanes = planesData->numItems; planes = (const vec4f*)planesData->data; ispc::Slices_set(getIE(), model->getIE(), numPlanes, (ispc::vec4f*)planes, volume->getIE()); }
void SciVisRenderer::commit() { Renderer::commit(); lightData = (Data*)getParamData("lights"); lightArray.clear(); vec3f aoColor = vec3f(0.f); bool ambientLights = false; if (lightData) { for (uint32_t i = 0; i < lightData->size(); i++) { const Light* const light = ((Light**)lightData->data)[i]; // extract color from ambient lights and remove them const AmbientLight* const ambient = dynamic_cast<const AmbientLight*>(light); if (ambient) { ambientLights = true; aoColor += ambient->getRadiance(); } else lightArray.push_back(light->getIE()); } } void **lightPtr = lightArray.empty() ? nullptr : &lightArray[0]; const bool shadowsEnabled = getParam1i("shadowsEnabled", 0); int aoSamples = getParam1i("aoSamples", 0); float aoDistance = getParam1f("aoDistance", getParam1f("aoOcclusionDistance"/*old name*/, 1e20f)); // "aoWeight" is deprecated, use an ambient light instead if (!ambientLights) aoColor = vec3f(getParam1f("aoWeight", 0.f)); const bool aoTransparencyEnabled = getParam1i("aoTransparencyEnabled", 0); const bool oneSidedLighting = getParam1i("oneSidedLighting", 1); ispc::SciVisRenderer_set(getIE(), shadowsEnabled, aoSamples, aoDistance, (ispc::vec3f&)aoColor, aoTransparencyEnabled, lightPtr, lightArray.size(), oneSidedLighting); }
void RaycastVolumeRenderer::commit() { // Create the equivalent ISPC RaycastVolumeRenderer object. if (ispcEquivalent == NULL) ispcEquivalent = ispc::RaycastVolumeRenderer_createInstance(); // Get the background color. vec3f bgColor = getParam3f("bgColor", vec3f(1.f)); // Set the background color. ispc::RaycastVolumeRenderer_setBackgroundColor(ispcEquivalent, (const ispc::vec3f&) bgColor); // Set the lights if any. ispc::RaycastVolumeRenderer_setLights(ispcEquivalent, getLightsFromData(getParamData("lights", NULL))); // Initialize state in the parent class, must be called after the ISPC object is created. Renderer::commit(); }
void PathTracer::commit() { Renderer::commit(); destroyGeometryLights(); lightArray.clear(); geometryLights = 0; const bool useGeometryLights = getParam1i("useGeometryLights", true); if (model && useGeometryLights) { areaPDF.resize(model->geometry.size()); generateGeometryLights(model, affine3f(one), &areaPDF[0]); geometryLights = lightArray.size(); } lightData = (Data*)getParamData("lights"); if (lightData) { for (uint32_t i = 0; i < lightData->size(); i++) lightArray.push_back(((Light**)lightData->data)[i]->getIE()); } void **lightPtr = lightArray.empty() ? nullptr : &lightArray[0]; const int32 rouletteDepth = getParam1i("rouletteDepth", 5); const float maxRadiance = getParam1f("maxContribution", getParam1f("maxRadiance", inf)); Texture2D *backplate = (Texture2D*)getParamObject("backplate", nullptr); vec4f shadowCatcherPlane = getParam4f("shadowCatcherPlane", vec4f(0.f)); ispc::PathTracer_set(getIE() , rouletteDepth , maxRadiance , backplate ? backplate->getIE() : nullptr , (ispc::vec4f&)shadowCatcherPlane , lightPtr , lightArray.size() , geometryLights , &areaPDF[0] ); }
void DistributedModel::commit() { othersRegions.clear(); // TODO: We may need to override the ISPC calls made // to the Model or customize the model struct on the ISPC // side. In which case we need some ISPC side inheritence // for the model type. Currently the code is actually identical. Model::commit(); // Send my bounding boxes to other nodes, recieve theirs for a // "full picture" of what geometries live on what nodes Data *regionData = getParamData("regions"); Data *ghostRegionData = getParamData("ghostRegions"); // The box3f data is sent as data of FLOAT3 items // TODO: It's a little awkward to copy the boxes again like this, maybe // can re-thinkg the send side of the bcast call? One that takes // a ptr and a size since we know we won't be writing out to it? // TODO: For now it doesn't matter that we don't know who owns the // other boxes, just that we know they exist and their bounds, and that // they aren't ours. if (regionData) { box3f *boxes = reinterpret_cast<box3f*>(regionData->data); myRegions = std::vector<box3f>(boxes, boxes + regionData->numItems / 2); } // If the user hasn't set any regions, there's an implicit infinitely // large region box we can place around the entire world. if (myRegions.empty()) { postStatusMsg("No regions found, making implicit " "infinitely large region", 1); myRegions.push_back(box3f(vec3f(neg_inf), vec3f(pos_inf))); } // Check if we've got ghost regions set, otherwise just use the regions if (ghostRegionData) { box3f *boxes = reinterpret_cast<box3f*>(ghostRegionData->data); ghostRegions = std::vector<box3f>(boxes, boxes + ghostRegionData->numItems / 2); } else { ghostRegions = myRegions; } for (int i = 0; i < mpicommon::numGlobalRanks(); ++i) { if (i == mpicommon::globalRank()) { messaging::bcast(i, myRegions); } else { std::vector<box3f> recv; messaging::bcast(i, recv); std::copy(recv.begin(), recv.end(), std::back_inserter(othersRegions)); } } if (logLevel() >= 1) { for (int i = 0; i < mpicommon::numGlobalRanks(); ++i) { if (i == mpicommon::globalRank()) { postStatusMsg(1) << "Rank " << mpicommon::globalRank() << ": Got regions from others {"; for (const auto &b : othersRegions) { postStatusMsg(1) << "\t" << b << ","; } postStatusMsg(1) << "}"; } } } }
//! Allocate storage and populate the volume. void AMRVolume::commit() { updateEditableParameters(); // Make the voxel value range visible to the application. if (findParam("voxelRange") == nullptr) setParam("voxelRange", voxelRange); else voxelRange = getParam2f("voxelRange", voxelRange); auto methodStringFromEnv = utility::getEnvVar<std::string>("OSPRAY_AMR_METHOD"); std::string methodString = methodStringFromEnv.value_or(getParamString("amrMethod","current")); if (methodString == "finest" || methodString == "finestLevel") ispc::AMR_install_finest(getIE()); else if (methodString == "current" || methodString == "currentLevel") ispc::AMR_install_current(getIE()); else if (methodString == "octant") ispc::AMR_install_octant(getIE()); if (data != nullptr) //TODO: support data updates return; brickInfoData = getParamData("brickInfo"); assert(brickInfoData); assert(brickInfoData->data); brickDataData = getParamData("brickData"); assert(brickDataData); assert(brickDataData->data); data = make_unique<amr::AMRData>(*brickInfoData,*brickDataData); accel = make_unique<amr::AMRAccel>(*data); // finding coarset cell size + finest level cell width float coarsestCellWidth = 0.f; float finestLevelCellWidth = data->brick[0].cellWidth; box3i rootLevelBox = empty; for (auto &b : data->brick) { if (b.level == 0) rootLevelBox.extend(b.box); finestLevelCellWidth = min(finestLevelCellWidth, b.cellWidth); coarsestCellWidth = max(coarsestCellWidth, b.cellWidth); } vec3i rootGridDims = rootLevelBox.size() + vec3i(1); ospLogF(1) << "found root level dimensions of " << rootGridDims; ospLogF(1) << "coarsest cell width is " << coarsestCellWidth << std::endl; auto rateFromEnv = utility::getEnvVar<float>("OSPRAY_AMR_SAMPLING_STEP"); float samplingStep = rateFromEnv.value_or(0.1f * coarsestCellWidth); box3f worldBounds = accel->worldBounds; const vec3f gridSpacing = getParam3f("gridSpacing", vec3f(1.f)); const vec3f gridOrigin = getParam3f("gridOrigin", vec3f(0.f)); voxelType = getParamString("voxelType", "unspecified"); auto voxelTypeID = getVoxelType(); switch (voxelTypeID) { case OSP_UCHAR: break; case OSP_SHORT: break; case OSP_USHORT: break; case OSP_FLOAT: break; case OSP_DOUBLE: break; default: throw std::runtime_error("amrVolume unsupported voxel type '" + voxelType + "'"); } ispc::AMRVolume_set(getIE(), (ispc::box3f&)worldBounds, samplingStep, (const ispc::vec3f&)gridOrigin, (const ispc::vec3f&)gridSpacing); ispc::AMRVolume_setAMR(getIE(), accel->node.size(), &accel->node[0], accel->leaf.size(), &accel->leaf[0], accel->level.size(), &accel->level[0], voxelTypeID, (ispc::box3f &)worldBounds); tasking::parallel_for(accel->leaf.size(),[&](size_t leafID) { ispc::AMRVolume_computeValueRangeOfLeaf(getIE(), leafID); }); }