还是一堆bug的状态

Core/primitive/Raster_Image.cpp

@@ -0,0 +1,131 @@
+#include "Raster_Image_p.h"
+#include "../Axis/Abs_Axis_p.h"
+#include "../base/Memory.h"
+#include "../render/Canvas.h"
+namespace renderive {
+struct Raster_Image_Input_Data : Latest_Input_Data {
+    Image image;
+    void push(const Image& value) {
+        image = value;
+        mark_latest_pushed();
+    }
+    template <typename Handler>
+    void read_all(Handler handler) {
+        if (pending)
+            handler(image);
+    }
+    void clear() override {
+        image = Image();
+        clear_latest();
+    }
+};
+struct Raster_Image_Render_State : Render_State, Raster_Image_Prop {};
+struct Raster_Image_Private : Typed_Render_Data<Raster_Image, Raster_Image_Render_State, Raster_Image_Input_Data> {
+    Image image;
+    void prepare_data(const Plot_Render_Snapshot&) override {
+        sync_state_pipeline();
+        Raster_Image_Input_Data* input = render_input_data();
+        input->read_all([this](const Image& value) {
+            image = value;
+        });
+        clear_render_input();
+    }
+    void draw(Canvas& canvas, const Plot_Render_Snapshot&) override {
+        Raster_Image_Render_State* s = render_state();
+        auto domain_axis = s->domain_axis.lock();
+        auto value_axis = s->value_axis.lock();
+        if (!domain_axis || !value_axis || image.empty())
+            return;
+        if (s->domain_range.length() == 0.0 || s->value_range.length() == 0.0)
+            return;
+        Axis_Mapping_2D mapping = Axis_Render_Access::mapping(domain_axis.get(), value_axis.get());
+        Axis_Basis_2D basis = Axis_Basis_2D::from_ranges(mapping, s->domain_range, s->value_range);
+        RectF source_rect = s->source_rect.empty() ? RectF{0.0, 0.0, (double)image.width(), (double)image.height()} : s->source_rect;
+        if (source_rect.width == 0.0 || source_rect.height == 0.0)
+            return;
+        canvas.save();
+        canvas.set_image_interpolation(s->interpolation_mode);
+        canvas.transform(
+            basis.domain_vector.x / source_rect.width,
+            basis.domain_vector.y / source_rect.width,
+            basis.value_vector.x / source_rect.height,
+            basis.value_vector.y / source_rect.height,
+            basis.origin.x,
+            basis.origin.y);
+        canvas.draw_image(RectF{0.0, 0.0, source_rect.width, source_rect.height}, image, source_rect);
+        canvas.restore();
+    }
+};
+RENDERIVE_DEFINE_RENDERABLE_BINDING(Raster_Image, Raster_Image_Private, Raster_Image_Render_State, Raster_Image_Input_Data, "RasterImage")
+void Raster_Image::give_image(const Image& image) {
+    if (!ok())
+        return;
+    Render_Input_Lease<Raster_Image_Private, Raster_Image_Input_Data> input(d());
+    input->push(image);
+}
+void Raster_Image::give_image_frame(const Image& image, Range domain_range, Range value_range, RectF source_rect, Image_Interpolation_Mode interpolation_mode) {
+    if (domain_range.length() == 0.0 || value_range.length() == 0.0)
+        return;
+    if (!ok())
+        return;
+    Raster_Image_Private* pd = d();
+    auto lease = pd->state_control.mark_use_role(State_Edit);
+    Raster_Image_Render_State* state = reinterpret_cast<Raster_Image_Render_State*>(pd->state_by_index(lease.index));
+    state->domain_range = domain_range;
+    state->value_range = value_range;
+    state->source_rect = source_rect;
+    state->interpolation_mode = interpolation_mode;
+    ++state->version;
+    pd->unmark_state(lease);
+    Render_Input_Lease<Raster_Image_Private, Raster_Image_Input_Data> input(pd);
+    input->push(image);
+}
+RENDERIVE_DEFINE_WEAK_STATE_PROP(Raster_Image, Raster_Image_Render_State, Abs_Axis, domain_axis)
+RENDERIVE_DEFINE_WEAK_STATE_PROP(Raster_Image, Raster_Image_Render_State, Abs_Axis, value_axis)
+Range Raster_Image::domain_range() {
+    return d()->edit_state_value(&Raster_Image_Render_State::domain_range);
+}
+void Raster_Image::set_domain_range(Range value) {
+    if (value.length() == 0.0)
+        return;
+    d()->set_state_value(&Raster_Image_Render_State::domain_range, value);
+}
+Range Raster_Image::value_range() {
+    return d()->edit_state_value(&Raster_Image_Render_State::value_range);
+}
+void Raster_Image::set_value_range(Range value) {
+    if (value.length() == 0.0)
+        return;
+    d()->set_state_value(&Raster_Image_Render_State::value_range, value);
+}
+RENDERIVE_DEFINE_STATE_PROP(Raster_Image, Raster_Image_Render_State, RectF, source_rect)
+RENDERIVE_DEFINE_STATE_PROP(Raster_Image, Raster_Image_Render_State, Image_Interpolation_Mode, interpolation_mode)
+Raster_Image::Builder::Builder(std::shared_ptr<Renderable> parent, std::shared_ptr<Abs_Axis> domain_axis, std::shared_ptr<Abs_Axis> value_axis) {
+    ASSERT(parent, "Raster_Image build error! parent == nullptr");
+    ASSERT(domain_axis && value_axis, "Raster_Image build error! axis == nullptr");
+    ASSERT(domain_axis->attached_to_plot(), "Raster_Image build error! domain_axis->plot == nullptr");
+    ASSERT(domain_axis->shares_plot_with(*value_axis), "Raster_Image build error! domain_axis->plot != value_axis->plot");
+    ASSERT(parent->shares_plot_with(*domain_axis), "Raster_Image build error! parent->plot != axis->plot");
+    ASSERT(domain_axis->orientation() != value_axis->orientation(), "Raster_Image build error! axes must be orthogonal");
+    this->parent = parent;
+    this->domain_axis = domain_axis;
+    this->value_axis = value_axis;
+}
+std::shared_ptr<Raster_Image> Raster_Image::Builder::build() {
+    auto ret = renderive::make_shared<Raster_Image>();
+    ret->init(parent);
+    Raster_Image_Private* pd = ret->d();
+    Raster_Image_Render_State* sc = reinterpret_cast<Raster_Image_Render_State*>(pd->state(State_Edit));
+    PROP_R(std::weak_ptr<Abs_Axis>, domain_axis)
+    PROP_R(std::weak_ptr<Abs_Axis>, value_axis)
+    PROP_R(Range, domain_range)
+    PROP_R(Range, value_range)
+    PROP_R(RectF, source_rect)
+    PROP_R(Image_Interpolation_Mode, interpolation_mode)
+    if (sc->domain_range.length() == 0.0)
+        sc->domain_range = {0.0, 1.0};
+    if (sc->value_range.length() == 0.0)
+        sc->value_range = {0.0, 1.0};
+    return ret;
+}
+} // namespace renderive