load density/temp with specified keys

common/configs/example_cbox.json

@@ -30,7 +30,7 @@
 			"enable": true,
 			"name": "ToneMappingPass",
 			"params": {
-				"exposure": 1,
+				"exposure": 5,
 				"operator": "aces"
 			}
 		}

src/core/device/scene.cpp

@@ -156,7 +156,10 @@ void RTScene::uploadSceneMediumData() {
 		} else if (auto m = std::dynamic_pointer_cast<VDBVolume>(medium)) {
 			float maxDensity{0};
 			mNanoVDBMedium.emplace_back(m->getNode()->getGlobalTransform(), m->sigma_a, m->sigma_s,
-										m->g, std::move(*m->densityGrid), KRR_DEFAULT_COLORSPACE);
+										m->g, std::move(*m->densityGrid),
+										m->temperatureGrid ? std::move(*m->temperatureGrid)
+														   : NanoVDBGrid{},
+										KRR_DEFAULT_COLORSPACE);
 			mNanoVDBMedium.back().initializeFromHost();
 		}
 	}

src/core/scenegraph.h

@@ -165,11 +165,6 @@ class VDBVolume : public Volume {
 public:
 	using SharedPtr = std::shared_ptr<VDBVolume>;
 
-	VDBVolume(RGB sigma_a, RGB sigma_s, float g, fs::path filepath) :
-		sigma_a(sigma_a), sigma_s(sigma_s), g(g) {
-		densityGrid = loadNanoVDB(filepath);
-	}
-
 	VDBVolume(RGB sigma_a, RGB sigma_s, float g, 
 		NanoVDBGrid::SharedPtr density, NanoVDBGrid::SharedPtr temperature = nullptr) :
 		sigma_a(sigma_a), sigma_s(sigma_s), g(g), densityGrid(density), temperatureGrid(temperature) {}

src/main/kiraray.cpp

@@ -14,7 +14,7 @@ extern "C" int main(int argc, char *argv[]) {
 			   "Switch to Release build for normal performance!");
 #endif
 
-	string configFile = "common/configs/example_volbox.json";
+	string configFile = "common/configs/example_cbox.json";
 	if (argc < 2){
 		Log(Warning, "No config file specified, using default config file: %s", configFile.c_str());
 	} else {

src/render/media.cpp

@@ -58,14 +58,6 @@ void initializeMajorantGrid(MajorantGrid& majorantGrid,
 		}, 0);
 }
 
-NanoVDBMedium::NanoVDBMedium(const Affine3f &transform, RGB sigma_a, RGB sigma_s, float g,
-							 NanoVDBGrid density, const RGBColorSpace *colorSpace) :
-	transform(transform), phase(g), sigma_a(sigma_a), sigma_s(sigma_s), densityGrid(std::move(density)), colorSpace(colorSpace) {
-	inverseTransform = transform.inverse();
-	const Vector3f majorantGridRes{64, 64, 64};
-	majorantGrid	 = MajorantGrid(densityGrid.getBounds(), majorantGridRes);
-}
-
 NanoVDBMedium::NanoVDBMedium(const Affine3f &transform, RGB sigma_a, RGB sigma_s, float g,
 							 NanoVDBGrid density, NanoVDBGrid temperature, const RGBColorSpace *colorSpace) :
 	transform(transform), phase(g), sigma_a(sigma_a), sigma_s(sigma_s), densityGrid(std::move(density)), 

src/render/media.h

@@ -136,9 +136,6 @@ class HomogeneousMedium {
 
 class NanoVDBMedium {
 public:
-	NanoVDBMedium(const Affine3f &transform, RGB sigma_a, RGB sigma_s, float g,
-				  NanoVDBGrid density, const RGBColorSpace *colorSpace = KRR_DEFAULT_COLORSPACE);
-
 	NanoVDBMedium(const Affine3f &transform, RGB sigma_a, RGB sigma_s, float g, NanoVDBGrid density,
 				  NanoVDBGrid temperature, const RGBColorSpace *colorSpace = KRR_DEFAULT_COLORSPACE);
 

src/scene/krrscene.cpp

@@ -56,6 +56,7 @@ bool SceneImporter::loadMedium(Scene::SharedPtr pScene, SceneGraphNode::SharedPt
 		pScene->addMesh(mesh);
 		pScene->getSceneGraph()->attachLeaf(node, instance);
 		pScene->getSceneGraph()->attachLeaf(node, volume);
+		return true;
 	} else if (type == "heterogeneous") {
 		if (params.contains("file")) {
 			return OpenVDBImporter().import(params.at("file"), pScene, node, params);

src/scene/openvdb.cpp

@@ -16,14 +16,18 @@ bool OpenVDBImporter::import(const fs::path filepath, Scene::SharedPtr scene,
 		scene->getSceneGraph()->setRoot(node);
 	}
 
-	auto sigma_a = params.value<Array3f>("sigma_a", Array3f{1, 1, 1});
-	auto sigma_s = params.value<Array3f>("sigma_s", Array3f{0, 0, 0});
-	float g		 = params.value<float>("g", 0);
+	auto sigma_a		 = params.value<Array3f>("sigma_a", Array3f{1, 1, 1});
+	auto sigma_s		 = params.value<Array3f>("sigma_s", Array3f{0, 0, 0});
+	auto key_density	 = params.value<string>("key_density", "density");
+	auto key_temperature = params.value<string>("key_temperature", "temperature");
+	float g				 = params.value<float>("g", 0);
+
+	NanoVDBGrid::SharedPtr densityGrid	   = loadNanoVDB(filepath, key_density);
+	NanoVDBGrid::SharedPtr temperatureGrid = loadNanoVDB(filepath, key_temperature);
+	auto volume = std::make_shared<VDBVolume>(sigma_a, sigma_s, g, densityGrid, temperatureGrid);
 
 	auto mesh	  = std::make_shared<Mesh>();
 	auto instance = std::make_shared<MeshInstance>(mesh);
-	auto volume	  = std::make_shared<VDBVolume>(sigma_a, sigma_s, g, filepath);
-
 	/* initialize a intersection bounding box for this volume */
 	auto aabb	  = volume->densityGrid->getBounds();
 	mesh->indices = {{4, 2, 0}, {2, 7, 3}, {6, 5, 7}, {1, 7, 5}, {0, 3, 1}, {4, 1, 5}, 

src/util/volume.cpp

@@ -17,27 +17,25 @@
 
 KRR_NAMESPACE_BEGIN
 
-NanoVDBGrid::SharedPtr loadNanoVDB(std::filesystem::path path) {
+NanoVDBGrid::SharedPtr loadNanoVDB(std::filesystem::path path, std::string key) {
 	openvdb::initialize();
 	Log(Info, "Loading openvdb file from %s", path.string().c_str());
 	openvdb::io::File file(path.generic_string());
 	if (!file.open())
 		Log(Fatal, "Failed to open vdb file %s", path.string().c_str());
 
 	openvdb::GridBase::Ptr baseGrid;
-	if(file.hasGrid("density"))
-		baseGrid = file.readGrid("density");
+	if (file.hasGrid(key.c_str()))
+		baseGrid = file.readGrid(key.c_str());
 	else {
-		baseGrid = file.getGrids()->at(0);
-		Log(Warning, "VDB file do not pocess a density grid, loading the first grid [%s].", 
-			baseGrid->getName().c_str());
+		Log(Warning, "VDB file %s do not pocess a [%s] grid.", path.string().c_str(), key.c_str());
+		return nullptr;
 	}
 
 	auto grid							  = openvdb::gridPtrCast<openvdb::FloatGrid>(baseGrid);
 	auto transform						  = grid->transform();
 	auto handle							  = nanovdb::openToNanoVDB<nanovdb::CudaDeviceBuffer>(grid);
 	const nanovdb::GridMetaData *metadata = handle.gridMetaData();
-	Log(Info, "Find a vdb grid: %s", metadata->gridName());
 	if (metadata->gridType() != nanovdb::GridType::Float) Log(Fatal, "only support float grid!");
 	float minValue, maxValue;
 	grid->evalMinMax(minValue, maxValue);

src/util/volume.h

@@ -58,6 +58,6 @@ class NanoVDBGrid {
 	float maxDensity{0};
 };
 
-NanoVDBGrid::SharedPtr loadNanoVDB(std::filesystem::path path);
+NanoVDBGrid::SharedPtr loadNanoVDB(std::filesystem::path path, std::string key);
 
 KRR_NAMESPACE_END