Skip to content

Commit 3af0abc

Browse files
wilsonCernWqwilsonCernWq
committed
upgrade api.cpp
1 parent a537b34 commit 3af0abc

File tree

5 files changed

+232
-63
lines changed

5 files changed

+232
-63
lines changed

‎api.cpp

+124-50
Original file line numberDiff line numberDiff line change
@@ -450,72 +450,109 @@ const vnr::range1f& vnrTransferFunctionGetValueRange(vnrTransferFunction tfn)
450450
return tfn->range;
451451
}
452452

453-
454453
// ------------------------------------------------------------------
455454
//
456455
// ------------------------------------------------------------------
457456

458457
vnrRenderer vnrCreateRenderer(vnrVolume v)
459458
{
460-
auto self = std::make_shared<RendererContext>();
459+
auto self = std::make_shared<RenderContext>();
461460
self->volume = v;
462461

463-
auto& renderer = self->renderer;
462+
// auto& renderer = self->renderer;
463+
464+
self->framebuffer.create();
465+
self->framebuffer_stream = self->framebuffer.current_stream();
466+
self->render.stream = self->framebuffer_stream;
467+
464468
if (self->volume->isNetwork()) {
465-
auto& neural = std::dynamic_pointer_cast<NeuralVolumeContext>(self->volume)->neural;
469+
auto& source = std::dynamic_pointer_cast<NeuralVolumeContext>(self->volume)->neural;
466470

467471
// std::cout << "INF MC " << neural.get_macrocell_value_range() << std::endl;
468-
renderer.set_scene(neural.texture(),
469-
neural.get_data_type(),
470-
neural.get_data_dims(),
471-
neural.get_data_value_range(),
472-
neural.get_data_transform(),
473-
neural.get_macrocell_dims(),
474-
neural.get_macrocell_spacings(),
475-
neural.get_macrocell_value_range(),
476-
neural.get_macrocell_max_opacity(),
477-
&neural);
472+
473+
self->render.init(
474+
source.get_data_transform(),
475+
source.get_data_type(),
476+
source.get_data_dims(),
477+
source.get_data_value_range(),
478+
source.get_macrocell_dims(),
479+
source.get_macrocell_spacings(),
480+
source.get_macrocell_value_range(),
481+
source.get_macrocell_max_opacity()
482+
);
483+
484+
// renderer.set_scene(neural.texture(),
485+
// neural.get_data_type(),
486+
// neural.get_data_dims(),
487+
// neural.get_data_value_range(),
488+
// neural.get_data_transform(),
489+
// neural.get_macrocell_dims(),
490+
// neural.get_macrocell_spacings(),
491+
// neural.get_macrocell_value_range(),
492+
// neural.get_macrocell_max_opacity(),
493+
// &neural);
478494
}
479495
else {
480496
auto& source = std::dynamic_pointer_cast<SimpleVolumeContext>(self->volume)->source;
481497

482498
// std::cout << "REF MC " << source.get_macrocell_value_range() << std::endl;
483-
renderer.set_scene(source.texture(),
484-
source.get_data_type(),
485-
source.get_data_dims(),
486-
source.get_data_value_range(),
487-
source.get_data_transform(),
488-
source.get_macrocell_dims(),
489-
source.get_macrocell_spacings(),
490-
source.get_macrocell_value_range(),
491-
source.get_macrocell_max_opacity());
492-
}
493-
494-
renderer.set_scene_clipbox(self->volume->clipbox);
495-
renderer.set_rendering_mode(5);
496-
// 1179636.polaris-pbs-01.hsn.cm.polaris.alcf.anl.gov (without init, OKAY (1.893421 - 1.891434)GB = 1.987 MB), problem in init)
497-
renderer.init();
499+
500+
self->render.init(
501+
source.get_data_transform(),
502+
source.get_data_type(),
503+
source.get_data_dims(),
504+
source.get_data_value_range(),
505+
source.get_macrocell_dims(),
506+
source.get_macrocell_spacings(),
507+
source.get_macrocell_value_range(),
508+
source.get_macrocell_max_opacity()
509+
);
510+
511+
// renderer.set_scene(source.texture(),
512+
// source.get_data_type(),
513+
// source.get_data_dims(),
514+
// source.get_data_value_range(),
515+
// source.get_data_transform(),
516+
// source.get_macrocell_dims(),
517+
// source.get_macrocell_spacings(),
518+
// source.get_macrocell_value_range(),
519+
// source.get_macrocell_max_opacity());
520+
}
521+
522+
// renderer.set_scene_clipbox(self->volume->clipbox);
523+
// renderer.set_rendering_mode(5);
524+
// // 1179636.polaris-pbs-01.hsn.cm.polaris.alcf.anl.gov (without init, OKAY (1.893421 - 1.891434)GB = 1.987 MB), problem in init)
525+
// renderer.init();
526+
527+
self->framebuffer_reset = true;
528+
498529
return self;
499530
}
500531

501532
void vnrRendererSetMode(vnrRenderer self, int mode)
502533
{
503-
self->renderer.set_rendering_mode(mode);
534+
// self->renderer.set_rendering_mode(mode);
535+
self->rendering_mode = mode;
536+
self->framebuffer_reset = true;
504537
}
505538

506539
void vnrRendererSetDenoiser(vnrRenderer self, bool flag)
507540
{
508-
self->renderer.set_denoiser(flag);
541+
// self->renderer.set_denoiser(flag);
509542
}
510543

511544
void vnrRendererSetVolumeSamplingRate(vnrRenderer self, float rate)
512545
{
513-
self->renderer.set_volume_sampling_rate(rate);
546+
// self->renderer.set_volume_sampling_rate(rate);
547+
self->sampling_rate = rate;
548+
self->framebuffer_reset = true;
514549
}
515550

516551
void vnrRendererSetVolumeDensityScale(vnrRenderer self, float value)
517552
{
518-
self->renderer.set_volume_density_scale(value);
553+
// self->renderer.set_volume_density_scale(value);
554+
self->density_scale = value;
555+
self->framebuffer_reset = true;
519556
}
520557

521558
// ------------------------------------------------------------------
@@ -524,44 +561,87 @@ void vnrRendererSetVolumeDensityScale(vnrRenderer self, float value)
524561

525562
void vnrRendererSetTransferFunction(vnrRenderer self, vnrTransferFunction _tfn)
526563
{
564+
range1f original_data_range;
527565
auto& tfn = *_tfn;
528566
if (self->volume->isNetwork()) {
529-
auto nv = std::dynamic_pointer_cast<NeuralVolumeContext>(self->volume);
530-
nv->neural.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
567+
auto& source = std::dynamic_pointer_cast<NeuralVolumeContext>(self->volume)->neural;
568+
source.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
569+
original_data_range = source.get_data_value_range();
531570
}
532571
else {
533-
auto sv = std::dynamic_pointer_cast<SimpleVolumeContext>(self->volume);
534-
sv->source.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
572+
auto& source = std::dynamic_pointer_cast<SimpleVolumeContext>(self->volume)->source;
573+
source.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
574+
original_data_range = source.get_data_value_range();
535575
}
536576

537-
self->renderer.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
577+
// self->renderer.set_transfer_function(tfn.color, tfn.alpha, tfn.range);
578+
self->tfn.update(tfn, original_data_range, self->framebuffer_stream);
579+
self->framebuffer_reset = true;
538580
}
539581

540582
void vnrRendererSetCamera(vnrRenderer self, vnrCamera cam)
541583
{
542-
self->renderer.set_camera(*cam);
584+
// self->renderer.set_camera(*cam);
585+
self->camera = *cam;
586+
self->framebuffer_reset = true;
543587
}
544588

545589
void vnrRendererSetFramebufferSize(vnrRenderer self, vec2i fbsize)
546590
{
547-
self->renderer.resize(fbsize);
591+
// self->renderer.resize(fbsize);
592+
self->framebuffer.resize(fbsize);
593+
self->framebuffer_size = fbsize;
594+
self->framebuffer_reset = true;
548595
}
549596

550597
vnr::vec4f *vnrRendererMapFrame(vnrRenderer self)
551598
{
552-
vec4f *pixels = nullptr;
553-
self->renderer.mapframe(&pixels);
599+
// self->renderer.mapframe(&pixels);
600+
601+
CUDA_CHECK(cudaStreamSynchronize(self->framebuffer_stream));
602+
vec4f *pixels = self->framebuffer.host_pointer();
603+
604+
self->framebuffer.safe_swap();
605+
self->framebuffer_stream = self->framebuffer.current_stream();
606+
self->render.stream = self->framebuffer_stream;
607+
554608
return pixels;
555609
}
556610

557611
void vnrRendererResetAccumulation(vnrRenderer self)
558612
{
559-
self->renderer.reset_frame();
613+
// self->renderer.reset_frame();
614+
self->framebuffer_reset = true;
560615
}
561616

562617
void vnrRender(vnrRenderer self)
563618
{
564-
self->renderer.render();
619+
// self->renderer.render();
620+
621+
if (self->framebuffer_reset) {
622+
self->render.update(
623+
self->rendering_mode,
624+
self->tfn.tfn,
625+
self->sampling_rate,
626+
self->density_scale,
627+
self->volume->clipbox.lower,
628+
self->volume->clipbox.upper,
629+
self->camera,
630+
self->framebuffer_size
631+
);
632+
self->framebuffer_reset = false;
633+
}
634+
635+
if (self->volume->isNetwork()) {
636+
auto& source = std::dynamic_pointer_cast<NeuralVolumeContext>(self->volume)->neural;
637+
self->render.render(self->framebuffer.device_pointer(), &source, source.texture());
638+
}
639+
else {
640+
auto& source = std::dynamic_pointer_cast<SimpleVolumeContext>(self->volume)->source;
641+
self->render.render(self->framebuffer.device_pointer(), nullptr, source.texture());
642+
}
643+
644+
self->framebuffer.download_async();
565645
}
566646

567647

@@ -622,12 +702,6 @@ void vnrCompilationStatus(const char* str)
622702
printf(" fV-SRN: disabled\n");
623703
#endif
624704

625-
#ifdef ENABLE_OPTIX
626-
printf(" optix renderer: enabled\n");
627-
#else
628-
printf(" optix renderer: disabled\n");
629-
#endif
630-
631705
#ifdef ENABLE_IN_SHADER
632706
printf(" in-shader renderer: enabled\n");
633707
#else

‎api.h

+6-9
Original file line numberDiff line numberDiff line change
@@ -16,22 +16,19 @@
1616
#include <memory>
1717

1818
namespace vnr {
19-
2019
using json = nlohmann::json;
21-
struct VolumeContext;
22-
struct RendererContext;
23-
struct TransferFunction;
2420
struct Camera;
25-
21+
struct TransferFunction;
22+
struct VolumeContext;
23+
struct RenderContext;
2624
}
2725

28-
typedef std::shared_ptr<vnr::VolumeContext> vnrVolume;
29-
typedef std::shared_ptr<vnr::RendererContext> vnrRenderer;
30-
31-
typedef std::shared_ptr<vnr::TransferFunction> vnrTransferFunction;
3226
typedef std::shared_ptr<vnr::Camera> vnrCamera;
27+
typedef std::shared_ptr<vnr::TransferFunction> vnrTransferFunction;
3328

3429
typedef vnr::ValueType vnrType;
30+
typedef std::shared_ptr<vnr::VolumeContext> vnrVolume;
31+
typedef std::shared_ptr<vnr::RenderContext> vnrRenderer;
3532

3633
enum vnrRenderMode {
3734
// reference ray marcher implmented in optix

‎api_internal.h

+19-2
Original file line numberDiff line numberDiff line change
@@ -41,10 +41,27 @@ struct NeuralVolumeContext : VolumeContext
4141
bool isNetwork() const override { return true; };
4242
};
4343

44-
struct RendererContext
44+
struct RenderContext
4545
{
46-
MainRenderer renderer;
46+
// MainRenderer renderer;
47+
4748
vnrVolume volume;
49+
Camera camera;
50+
51+
TransferFunctionAPI tfn;
52+
RenderAPI render;
53+
54+
int rendering_mode{ VNR_INVALID };
55+
56+
// volume states
57+
float sampling_rate{ 1.f };
58+
float density_scale{ 1.f };
59+
60+
// framebuffer states
61+
FrameBuffer framebuffer;
62+
cudaStream_t framebuffer_stream{};
63+
vec2i framebuffer_size;
64+
bool framebuffer_reset{ true };
4865
};
4966

5067
}

‎renderer.cpp

+72
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,78 @@ static std::ostream null_output_stream(0);
3434

3535
namespace vnr {
3636

37+
TransferFunctionAPI::~TransferFunctionAPI() {
38+
if (tfn_color_array_handler) {
39+
CUDA_CHECK_NOEXCEPT(cudaTrackedFreeArray(tfn_color_array_handler));
40+
tfn_color_array_handler = NULL;
41+
}
42+
if (tfn.colors.data) {
43+
CUDA_CHECK_NOEXCEPT(cudaDestroyTextureObject(tfn.colors.data));
44+
tfn.colors.data = { 0 };
45+
}
46+
if (tfn.colors.rawptr) {
47+
CUDA_CHECK_NOEXCEPT(cudaTrackedFree(tfn.colors.rawptr, tfn.colors.length * sizeof(float4)));
48+
tfn.colors.rawptr = nullptr;
49+
}
50+
tfn.colors.length = 0;
51+
52+
if (tfn_alpha_array_handler) {
53+
CUDA_CHECK_NOEXCEPT(cudaTrackedFreeArray(tfn_alpha_array_handler));
54+
tfn_color_array_handler = NULL;
55+
}
56+
if (tfn.alphas.data) {
57+
CUDA_CHECK_NOEXCEPT(cudaDestroyTextureObject(tfn.alphas.data));
58+
tfn.alphas.data = { 0 };
59+
}
60+
if (tfn.alphas.rawptr) {
61+
CUDA_CHECK_NOEXCEPT(cudaTrackedFree(tfn.alphas.rawptr, tfn.alphas.length * sizeof(float)));
62+
tfn.alphas.rawptr = nullptr;
63+
}
64+
tfn.alphas.length = 0;
65+
}
66+
67+
void TransferFunctionAPI::update(const TransferFunction& input, const range1f original_data_range, cudaStream_t framebuffer_stream) {
68+
const std::vector<vec3f>& c = input.color;
69+
const std::vector<vec2f>& o = input.alpha;
70+
const range1f& r = input.range;
71+
72+
std::vector<vec4f> colors_data;
73+
std::vector<float> alphas_data;
74+
colors_data.resize(c.size());
75+
for (int i = 0; i < colors_data.size(); ++i) {
76+
colors_data[i].x = c[i].x;
77+
colors_data[i].y = c[i].y;
78+
colors_data[i].z = c[i].z;
79+
colors_data[i].w = 1.f;
80+
}
81+
alphas_data.resize(o.size());
82+
for (int i = 0; i < alphas_data.size(); ++i) {
83+
alphas_data[i] = o[i].y;
84+
}
85+
if (!colors_data.empty()) {
86+
CreateArray1DFloat4(framebuffer_stream, colors_data, tfn_color_array_handler, tfn.colors);
87+
}
88+
if (!alphas_data.empty()) {
89+
CreateArray1DScalar(framebuffer_stream, alphas_data, tfn_alpha_array_handler, tfn.alphas);
90+
}
91+
if (!r.is_empty()) {
92+
tfn.range.upper = min(original_data_range.upper, r.upper);
93+
tfn.range.lower = max(original_data_range.lower, r.lower);
94+
}
95+
tfn.range_rcp_norm = 1.f / tfn.range.span();
96+
}
97+
98+
99+
100+
101+
102+
103+
104+
105+
106+
107+
108+
37109
static void
38110
context_log_cb(unsigned int level, const char* tag, const char* message, void*)
39111
{

0 commit comments

Comments
 (0)