ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修复builder 调用方式

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-18 08:49:09 +08:00
parent 24315448f4
commit 97d2d1574b
19 changed files with 525 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files
web_server/app/Web_Plot_Session.cpp
+4 -4
View File
@@ -12,10 +12,10 @@ struct Web_Plot_Session::Impl {
Impl() { rebuild(); }
void rebuild() {
Render_Scene_2D::State state;
state.viewport = viewport;
scene = Render_Scene_2D::Builder{state}.build(
std::make_shared<Low_Latency_Render_Scene_2D_Strategy>());
scene = Render_Scene_2D::Builder(
std::make_shared<Low_Latency_Render_Scene_2D_Strategy>())
.set<&Render_Scene_2D::Properties::viewport>(viewport)
.build();
scene->activate_view();
}
std::optional<Web_Response> handle(const Web_Event& event) {
web_server/app/render_2D/Gallery_Scene2D.cpp
+217 -207
View File
@@ -1,4 +1,5 @@
#include "Gallery_Scene2D.h"
#include "../Gallery_Capture_Json.h"
#include "../common/Observer_Json.h"
#include "../Pixel_Frame.h"
@@ -13,6 +14,7 @@
#include "render_2D/plottable/Sweep_Spectrum.h"
#include "render_2D/plottable/Waterfall.h"
#include "render_2D/scene/Render_Scene_2D.h"
#include <algorithm>
#include <chrono>
#include <cmath>
@@ -22,7 +24,7 @@
#include <span>
#include <string>
#include <vector>
#include <asio.hpp>
namespace renderive::web {
template <>
struct Observer_Pfr_Adapter<Render_Scene_2D::State> {
@@ -40,12 +42,16 @@ constexpr std::size_t sweep_block_count = 8;
std::shared_ptr<Frame_Control_Strategy_Base> make_strategy(
Gallery_Frame_Mode mode) {
switch (mode) {
case Gallery_Frame_Mode::Manual: return std::make_shared<Manual_Render_Scene_2D_Strategy>();
case Gallery_Frame_Mode::Low_Latency: return std::make_shared<Low_Latency_Render_Scene_2D_Strategy>();
case Gallery_Frame_Mode::Playback: return std::make_shared<Playback_Render_Scene_2D_Strategy>();
case Gallery_Frame_Mode::Manual:
return std::make_shared<Manual_Render_Scene_2D_Strategy>();
case Gallery_Frame_Mode::Low_Latency:
return std::make_shared<Low_Latency_Render_Scene_2D_Strategy>();
case Gallery_Frame_Mode::Playback:
return std::make_shared<Playback_Render_Scene_2D_Strategy>();
}
return {};
}
std::string_view mode_id(Gallery_Frame_Mode mode) {
switch (mode) {
case Gallery_Frame_Mode::Manual: return "manual";
@@ -54,54 +60,56 @@ std::string_view mode_id(Gallery_Frame_Mode mode) {
}
return "low_latency";
}
Gallery_Frame_Mode strategy_mode(const Frame_Control_Strategy_Base& strategy) {
if (dynamic_cast<const Manual_Render_Scene_2D_Strategy*>(&strategy)) return Gallery_Frame_Mode::Manual;
if (dynamic_cast<const Playback_Render_Scene_2D_Strategy*>(&strategy)) return Gallery_Frame_Mode::Playback;
if (dynamic_cast<const Manual_Render_Scene_2D_Strategy*>(&strategy))
return Gallery_Frame_Mode::Manual;
if (dynamic_cast<const Playback_Render_Scene_2D_Strategy*>(&strategy))
return Gallery_Frame_Mode::Playback;
return Gallery_Frame_Mode::Low_Latency;
}
Time_Of_Day current_time_of_day() {
constexpr std::int64_t day_ms = 24LL * 60LL * 60LL * 1000LL;
const auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count();
std::chrono::system_clock::now().time_since_epoch())
.count();
return {now % day_ms};
}
class Gallery_Scene2D final : public Gallery_Scene_Interface {
public:
Gallery_Scene2D(std::string case_id, Gallery_Frame_Mode mode) : case_id_(std::move(case_id)) {
Gallery_Scene2D(std::string case_id, Gallery_Frame_Mode mode)
: case_id_(std::move(case_id)) {
rebuild(mode);
}
~Gallery_Scene2D() override {
if (scene_) scene_->deactivate_view();
}
const std::string& case_id() const noexcept override {
return case_id_;
}
const std::string& case_id() const noexcept override { return case_id_; }
nlohmann::json controls() const override {
return {
{"resources", nlohmann::json::array()},
{"observers", nlohmann::json::array()},
{"render_plan", gallery_render_plan_json(*scene_)},
{
"performance_capture",
gallery_performance_capture_json(*scene_)
}
};
return {{"resources", nlohmann::json::array()},
{"observers", nlohmann::json::array()},
{"render_plan", gallery_render_plan_json(*scene_)},
{"performance_capture",
gallery_performance_capture_json(*scene_)}};
}
Gallery_Frame_Mode frame_mode() const noexcept override {
return strategy_mode(*scene_->frame_control_strategy());
}
void reset_monitoring() override {
render_count_ = 0;
}
void reset_monitoring() override { render_count_ = 0; }
void set_client_metrics(Gallery_Client_Performance metrics) noexcept override {
client_ = metrics;
constexpr double maximum_interval_ms =
static_cast<double>(std::numeric_limits<std::uint64_t>::max()) /
1'000'000.0;
static_cast<double>(std::numeric_limits<std::uint64_t>::max()) /
1'000'000.0;
if (metrics.display_interval_latest_ms <= 0.0 ||
metrics.display_interval_latest_ms > maximum_interval_ms)
return;
metrics.display_interval_latest_ms > maximum_interval_ms) return;
const auto observed_interval_ns = static_cast<std::uint64_t>(
metrics.display_interval_latest_ms * 1'000'000.0);
if (observed_interval_ns == 0) return;
@@ -112,10 +120,12 @@ public:
Frame_Consumer_Feedback{observed_interval_ns}));
}
}
adminive::Update_Result apply_patch(
std::string_view, const nlohmann::json&) override {
return {false, "no editable resource matches the requested target"};
}
void resize(int width, int height) override {
const Size requested{std::max(1, width), std::max(1, height)};
if (requested == viewport_) return;
@@ -123,23 +133,30 @@ public:
viewport_ = requested;
rebuild(mode);
}
void dispatch(const Gallery_Input_Event& event) override {
std::visit([this](const auto& value) {
using T = std::decay_t<decltype(value)>;
if constexpr (std::same_as<T, Gallery_View_Input>) {
if (value.type == Gallery_View_Input_Type::Show) scene_->activate_view();
else if (value.type == Gallery_View_Input_Type::Hide) scene_->deactivate_view();
if (value.type == Gallery_View_Input_Type::Show)
scene_->activate_view();
else if (value.type == Gallery_View_Input_Type::Hide)
scene_->deactivate_view();
}
}, event);
}
bool request_frame() override {
update_samples();
const auto result = scene_->render_frame();
if (!result || *result != Plot_Render_Status::rendered) return false;
if (scene_->wait_for_render() != Scene_Render_Result::none) return false;
if (!result || *result != Plot_Render_Status::rendered)
return false;
if (scene_->wait_for_render() != Scene_Render_Result::none)
return false;
++render_count_;
return true;
}
std::optional<std::string> encode_latest_pixels() override {
std::string result;
scene_->with_frame([&](Image_View image) {
@@ -148,10 +165,12 @@ public:
if (result.empty()) return std::nullopt;
return result;
}
void record_pixel_response(std::chrono::steady_clock::time_point,
std::chrono::steady_clock::time_point,
std::chrono::steady_clock::time_point,
std::size_t) override {}
std::string action(const Gallery_Action_Request& request,
bool& recognized) override {
recognized = true;
@@ -160,15 +179,16 @@ public:
request.id == "frame_strategy_playback") {
const auto next = request.id == "frame_strategy_manual"
? Gallery_Frame_Mode::Manual
: request.id == "frame_strategy_playback"
? Gallery_Frame_Mode::Playback
: Gallery_Frame_Mode::Low_Latency;
: request.id == "frame_strategy_playback"
? Gallery_Frame_Mode::Playback
: Gallery_Frame_Mode::Low_Latency;
const auto operation = scene_->edit_renderables(
[strategy = make_strategy(next)](
Scene_2D_Base::Renderable_Editor& editor) mutable {
editor.replace_frame_control_strategy(std::move(strategy));
});
if (operation.wait() != Scene_Edit_Error::none) return "frame strategy replacement rejected";
if (operation.wait() != Scene_Edit_Error::none)
return "frame strategy replacement rejected";
return "frame strategy replaced";
}
if (request.id == "capture_next_frame") {
@@ -186,7 +206,9 @@ public:
recognized = false;
return {};
}
void record_action_notice_if_empty(std::string_view) override {}
std::string telemetry_json() const override {
const auto observer = scene_->observer();
auto kernel_observer = observer_json(observer);
@@ -197,182 +219,168 @@ public:
{"kernel_observer", std::move(kernel_observer)},
{"performance", {{"successful_render_count", render_count_}}},
{"client_performance", {{"transport_fps", client_.transport_fps}}},
{"performance_capture", gallery_performance_capture_json(*scene_)}
}
.dump();
{"performance_capture", gallery_performance_capture_json(*scene_)}}
.dump();
}
private:
template <class Product, class... Arguments>
static renderive_Owner<Product> build(
typename Product::Builder& builder, Arguments&&... arguments) {
return static_cast<Renderable_Builder<Product, typename Product::State>&>(
builder)
.build(std::forward<Arguments>(arguments)...);
}
void rebuild(Gallery_Frame_Mode mode) {
Render_Scene_2D::State scene_state;
scene_state.viewport = viewport_;
scene_state.background = Color{3, 8, 14, 255};
scene_ = Render_Scene_2D::Builder{scene_state}.build(
make_strategy(mode));
{
auto attach = scene_->attach_builder();
const auto root = scene_->root_renderable();
const bool numeric_domain =
scene_ = Render_Scene_2D::Builder(make_strategy(mode))
.set<&Render_Scene_2D::Properties::viewport>(viewport_)
.set<&Render_Scene_2D::Properties::background>(Color{3, 8, 14, 255})
.build();
const auto root = scene_->root_renderable();
const bool numeric_domain =
case_id_ == "sweep_spectrum" || case_id_ == "constellation";
const bool time_domain = case_id_ == "frequency_trace";
const int left = 62;
const int top = 18;
const auto width = static_cast<std::size_t>(
std::max(1, viewport_.width - 86));
const auto height = static_cast<std::size_t>(
std::max(1, viewport_.height - 64));
if (time_domain || case_id_ == "waterfall" || case_id_ == "axis_lab") {
Time_Axis::State state;
state.orientation = time_domain || case_id_ == "axis_lab"
? Orientation::Horizontal
: Orientation::Vertical;
state.visible_count = 80;
state.x = left;
state.y = state.orientation == Orientation::Horizontal
? top + static_cast<int>(height)
: top;
state.pixel_length =
state.orientation == Orientation::Horizontal ? width : height;
state.color = Color{69, 221, 190, 255};
Time_Axis::Builder builder{state, &attach};
time_axis_ = build<Time_Axis>(builder, root);
time_axis_->set_object_name("Time Axis");
}
if (!time_domain && !numeric_domain) {
Frequency_Axis::State state;
state.orientation = Orientation::Horizontal;
state.coordinates = Range{88'000'000.0, 108'000'000.0};
state.x = left;
state.y = top + static_cast<int>(height);
state.pixel_length = width;
state.color = Color{118, 145, 184, 255};
state.wheel = true;
state.drag = true;
Frequency_Axis::Builder builder{state, &attach};
frequency_axis_ = build<Frequency_Axis>(builder, root);
frequency_axis_->set_object_name("Frequency Axis");
}
else if (numeric_domain) {
Axis::State state;
state.orientation = Orientation::Horizontal;
state.coordinates = case_id_ == "constellation"
? Range{-1.25, 1.25}
: Range{0.0, 300.0};
state.x = left;
state.y = top + static_cast<int>(height);
state.pixel_length = width;
state.color = Color{118, 145, 184, 255};
state.wheel = true;
state.drag = true;
Axis::Builder builder{state, &attach};
domain_axis_ = build<Axis>(builder, root);
domain_axis_->set_object_name("Domain Axis");
}
if (case_id_ != "waterfall") {
Axis::State state;
state.orientation = Orientation::Vertical;
state.coordinates = case_id_ == "constellation"
? Range{-1.25, 1.25}
: time_domain
? Range{-1.0, 1.0}
: Range{-120.0, -20.0};
state.x = left;
state.y = top;
state.pixel_length = height;
state.color = Color{118, 145, 184, 255};
Axis::Builder builder{state, &attach};
value_axis_ = build<Axis>(builder, root);
value_axis_->set_object_name("Value Axis");
}
if (case_id_ == "spectrum" || case_id_ == "selection_overlay") {
Spectrum::State state;
state.frequency_range = {88'000'000.0, 108'000'000.0};
state.frequency_point_size = 512;
state.center_frequency = 98'000'000.0;
state.max_hold_visible = true;
state.current_pen = {Color{53, 230, 178, 255}, 2.0};
state.max_pen = {Color{255, 209, 102, 255}, 1.2};
state.min_pen = {Color{122, 162, 255, 255}, 1.2};
Spectrum::Builder builder{state, &attach};
spectrum_ = build<Spectrum>(
builder, root, frequency_axis_, value_axis_);
spectrum_->set_object_name("Spectrum");
if (case_id_ == "selection_overlay") {
Selection_Rectangle_Overlay::State overlay_state;
overlay_state.selection_brush =
{Color{23, 59, 102, 90}, Brush_Style::Solid};
Selection_Rectangle_Overlay::Builder overlay_builder{
overlay_state, &attach
};
selection_ = build<Selection_Rectangle_Overlay>(
overlay_builder, root, frequency_axis_, value_axis_);
selection_->set_object_name("Selection Overlay");
}
}
else if (case_id_ == "waterfall") {
Waterfall::State state;
state.frequency_range = {88'000'000.0, 108'000'000.0};
state.power_range = {-120.0, -20.0};
state.frequency_bin_count = 256;
Waterfall::Builder builder{state, &attach};
waterfall_ = build<Waterfall>(
builder, root, frequency_axis_, time_axis_);
waterfall_->set_object_name("Waterfall");
}
else if (case_id_ == "afterglow") {
Afterglow::State state;
state.frequency_range = {88'000'000.0, 108'000'000.0};
state.power_range = {-120.0, -20.0};
state.frequency_point_size = 192;
state.power_point_size = 96;
state.attenuation_rate = 0.18;
Afterglow::Builder builder{state, &attach};
afterglow_ = build<Afterglow>(
builder, root, frequency_axis_, value_axis_);
// Afterglow::Builder(frequency_axis_, value_axis_).set_paint_rely({root}).set_render_rely({root}).build();
afterglow_->set_object_name("Afterglow");
}
else if (case_id_ == "sweep_spectrum") {
Sweep_Spectrum::State state;
state.frequency_range = {0.0, 300.0};
state.bins_per_block = static_cast<int>(sweep_bins_per_block);
state.block_count = static_cast<int>(sweep_block_count);
Sweep_Spectrum::Builder builder{state, &attach};
sweep_ = build<Sweep_Spectrum>(
builder, root, domain_axis_, value_axis_);
sweep_->set_object_name("Sweep Spectrum");
}
else if (case_id_ == "frequency_trace") {
Frequency_Trace::State state;
state.pen = {Color{53, 230, 178, 255}, 2.0};
Frequency_Trace::Builder builder{state, &attach};
trace_ = build<Frequency_Trace>(
builder, root, time_axis_, value_axis_);
trace_->set_object_name("Frequency Trace");
}
else if (case_id_ == "constellation") {
Constellation_Diagram::State state;
state.i_range = {-1.25, 1.25};
state.q_range = {-1.25, 1.25};
state.point_color = Color{73, 230, 195, 255};
state.anchor_color = Color{255, 209, 102, 255};
Constellation_Diagram::Builder builder{state, &attach};
constellation_ = build<Constellation_Diagram>(
builder, root, domain_axis_, value_axis_);
constellation_->set_object_name("Constellation Diagram");
const bool time_domain = case_id_ == "frequency_trace";
const int left = 62;
const int top = 18;
const auto width = static_cast<std::size_t>(
std::max(1, viewport_.width - 86));
const auto height = static_cast<std::size_t>(
std::max(1, viewport_.height - 64));
if (time_domain || case_id_ == "waterfall" || case_id_ == "axis_lab") {
const auto orientation = time_domain || case_id_ == "axis_lab"
? Orientation::Horizontal
: Orientation::Vertical;
time_axis_ = Time_Axis::Builder{}
.set<&Time_Axis::Properties::orientation>(orientation)
.set<&Time_Axis::Properties::visible_count>(80)
.set<&Time_Axis::Properties::x>(left)
.set<&Time_Axis::Properties::y>(
orientation == Orientation::Horizontal
? top + static_cast<int>(height)
: top)
.set<&Time_Axis::Properties::pixel_length>(
orientation == Orientation::Horizontal ? width : height)
.set<&Time_Axis::Properties::color>(Color{69, 221, 190, 255})
.set_paint_rely({root})
.set_render_rely({root})
.build();
time_axis_->set_object_name("Time Axis");
}
if (!time_domain && !numeric_domain) {
frequency_axis_ = Frequency_Axis::Builder{}
.set<&Frequency_Axis::Properties::orientation>(Orientation::Horizontal)
.set<&Frequency_Axis::Properties::coordinates>(Range{88'000'000.0, 108'000'000.0})
.set<&Frequency_Axis::Properties::x>(left)
.set<&Frequency_Axis::Properties::y>(top + static_cast<int>(height))
.set<&Frequency_Axis::Properties::pixel_length>(width)
.set<&Frequency_Axis::Properties::color>(Color{118, 145, 184, 255})
.set<&Frequency_Axis::Properties::wheel>(true)
.set<&Frequency_Axis::Properties::drag>(true)
.set_paint_rely({root})
.set_render_rely({root})
.build();
frequency_axis_->set_object_name("Frequency Axis");
} else if (numeric_domain) {
domain_axis_ = Axis::Builder{}
.set<&Axis::Properties::orientation>(Orientation::Horizontal)
.set<&Axis::Properties::coordinates>(
case_id_ == "constellation" ? Range{-1.25, 1.25} : Range{0.0, 300.0})
.set<&Axis::Properties::x>(left)
.set<&Axis::Properties::y>(top + static_cast<int>(height))
.set<&Axis::Properties::pixel_length>(width)
.set<&Axis::Properties::color>(Color{118, 145, 184, 255})
.set<&Axis::Properties::wheel>(true)
.set<&Axis::Properties::drag>(true)
.set_paint_rely({root})
.set_render_rely({root})
.build();
domain_axis_->set_object_name("Domain Axis");
}
if (case_id_ != "waterfall") {
value_axis_ = Axis::Builder{}
.set<&Axis::Properties::orientation>(Orientation::Vertical)
.set<&Axis::Properties::coordinates>(
case_id_ == "constellation"
? Range{-1.25, 1.25}
: time_domain ? Range{-1.0, 1.0} : Range{-120.0, -20.0})
.set<&Axis::Properties::x>(left)
.set<&Axis::Properties::y>(top)
.set<&Axis::Properties::pixel_length>(height)
.set<&Axis::Properties::color>(Color{118, 145, 184, 255})
.set_paint_rely({root})
.set_render_rely({root})
.build();
value_axis_->set_object_name("Value Axis");
}
if (case_id_ == "spectrum" || case_id_ == "selection_overlay") {
spectrum_ = Spectrum::Builder(frequency_axis_, value_axis_)
.set<&Spectrum::Properties::frequency_range>(Range{88'000'000.0, 108'000'000.0})
.set<&Spectrum::Properties::frequency_point_size>(512)
.set<&Spectrum::Properties::center_frequency>(98'000'000.0)
.set<&Spectrum::Properties::max_hold_visible>(true)
.set<&Spectrum::Properties::current_pen>(Pen{Color{53, 230, 178, 255}, 2.0})
.set<&Spectrum::Properties::max_pen>(Pen{Color{255, 209, 102, 255}, 1.2})
.set<&Spectrum::Properties::min_pen>(Pen{Color{122, 162, 255, 255}, 1.2})
.set_paint_rely({root})
.set_render_rely({root})
.build();
spectrum_->set_object_name("Spectrum");
if (case_id_ == "selection_overlay") {
selection_ = Selection_Rectangle_Overlay::Builder(frequency_axis_, value_axis_)
.set<&Selection_Rectangle_Overlay::Properties::selection_brush>(
Brush{Color{23, 59, 102, 90}, Brush_Style::Solid})
.set_paint_rely({root})
.set_render_rely({root})
.build();
selection_->set_object_name("Selection Overlay");
}
} else if (case_id_ == "waterfall") {
waterfall_ = Waterfall::Builder(frequency_axis_, time_axis_)
.set<&Waterfall::Properties::frequency_range>(Range{88'000'000.0, 108'000'000.0})
.set<&Waterfall::Properties::power_range>(Range{-120.0, -20.0})
.set<&Waterfall::Properties::frequency_bin_count>(256)
.set_paint_rely({root})
.set_render_rely({root})
.build();
waterfall_->set_object_name("Waterfall");
} else if (case_id_ == "afterglow") {
afterglow_ = Afterglow::Builder(frequency_axis_, value_axis_)
.set<&Afterglow::Properties::frequency_range>(Range{88'000'000.0, 108'000'000.0})
.set<&Afterglow::Properties::power_range>(Range{-120.0, -20.0})
.set<&Afterglow::Properties::frequency_point_size>(192)
.set<&Afterglow::Properties::power_point_size>(96)
.set<&Afterglow::Properties::attenuation_rate>(0.18)
.set_paint_rely({root})
.set_render_rely({root})
.build();
afterglow_->set_object_name("Afterglow");
} else if (case_id_ == "sweep_spectrum") {
sweep_ = Sweep_Spectrum::Builder(domain_axis_, value_axis_)
.set<&Sweep_Spectrum::Properties::frequency_range>(Range{0.0, 300.0})
.set<&Sweep_Spectrum::Properties::bins_per_block>(static_cast<int>(sweep_bins_per_block))
.set<&Sweep_Spectrum::Properties::block_count>(static_cast<int>(sweep_block_count))
.set_paint_rely({root})
.set_render_rely({root})
.build();
sweep_->set_object_name("Sweep Spectrum");
} else if (case_id_ == "frequency_trace") {
trace_ = Frequency_Trace::Builder(time_axis_, value_axis_)
.set<&Frequency_Trace::Properties::pen>(Pen{Color{53, 230, 178, 255}, 2.0})
.set_paint_rely({root})
.set_render_rely({root})
.build();
trace_->set_object_name("Frequency Trace");
} else if (case_id_ == "constellation") {
constellation_ = Constellation_Diagram::Builder(domain_axis_, value_axis_)
.set<&Constellation_Diagram::Properties::i_range>(Range{-1.25, 1.25})
.set<&Constellation_Diagram::Properties::q_range>(Range{-1.25, 1.25})
.set<&Constellation_Diagram::Properties::point_color>(Color{73, 230, 195, 255})
.set<&Constellation_Diagram::Properties::anchor_color>(Color{255, 209, 102, 255})
.set_paint_rely({root})
.set_render_rely({root})
.build();
constellation_->set_object_name("Constellation Diagram");
}
scene_->activate_view();
}
void update_samples() {
const std::size_t count =
waterfall_ ? 256U : afterglow_ ? 192U : sweep_ ? sweep_bins_per_block * sweep_block_count : 512U;
waterfall_ ? 256U :
afterglow_ ? 192U :
sweep_ ? sweep_bins_per_block * sweep_block_count : 512U;
std::vector<double> values(count);
const std::uint64_t sample_sequence = sample_sequence_++;
const std::uint64_t time_sequence = sweep_
@@ -405,19 +413,20 @@ private:
if (trace_) trace_->append_sample(current_time_of_day(), std::sin(time));
if (constellation_) {
constexpr std::size_t symbol_count =
static_cast<std::size_t>(Constellation_Diagram_Type::Psk8);
static_cast<std::size_t>(Constellation_Diagram_Type::Psk8);
const std::size_t symbol_index = sample_sequence % symbol_count;
const double phase = 2.0 * std::numbers::pi *
static_cast<double>(symbol_index) /
static_cast<double>(symbol_count);
static_cast<double>(symbol_index) /
static_cast<double>(symbol_count);
const double i_noise =
std::sin(time * 17.0 + static_cast<double>(symbol_index) * 0.73) * 0.04;
std::sin(time * 17.0 + static_cast<double>(symbol_index) * 0.73) * 0.04;
const double q_noise =
std::cos(time * 19.0 + static_cast<double>(symbol_index) * 1.11) * 0.04;
std::cos(time * 19.0 + static_cast<double>(symbol_index) * 1.11) * 0.04;
constellation_->append_point(
{std::cos(phase) + i_noise, std::sin(phase) + q_noise});
}
}
std::string case_id_;
Size viewport_{560, 320};
std::unique_ptr<Render_Scene_2D> scene_;
@@ -437,6 +446,7 @@ private:
std::uint64_t sample_sequence_{};
};
} // namespace
std::unique_ptr<Gallery_Scene_Interface> make_gallery_scene_2d(
std::uint64_t, std::string case_id, Gallery_Frame_Mode mode) {
return std::make_unique<Gallery_Scene2D>(std::move(case_id), mode);
web_server/app/render_3D/Gallery_Scene3D.cpp
+5 -6
View File
@@ -208,13 +208,12 @@ private:
{{-0.55F, -0.25F, 0.0F}, {255, 80, 80, 255}, 24.0F},
{{0.0F, 0.45F, 0.0F}, {80, 255, 120, 255}, 28.0F},
{{0.55F, -0.1F, 0.0F}, {80, 140, 255, 255}, 26.0F}};
visual_ = Point_Visual::Builder{}.build(std::move(points));
visual_ = Point_Visual::Builder(std::move(points)).build();
visual_->set_object_name(case_id_ + " Points");
Render_Scene_3D::State state;
state.viewport = extent_;
state.visual_family = visual_family(case_id_);
scene_ = Render_Scene_3D::Builder{state}.build(
visual_, make_strategy(mode));
scene_ = Render_Scene_3D::Builder(visual_, make_strategy(mode))
.set<&Render_Scene_3D::Properties::viewport>(extent_)
.set<&Render_Scene_3D::Properties::visual_family>(visual_family(case_id_))
.build();
}
std::string case_id_;