261 lines
10 KiB
C++
261 lines
10 KiB
C++
#include "Renderable.h"
|
|
#include <QDir>
|
|
#include "base/Plot.h"
|
|
#include "Axis/Abs_Axis.h"
|
|
#include "plottable/Hover_Info.h"
|
|
#include "psc_global_include/export.h"
|
|
#include "psc_global_include/Fail_Fast.h"
|
|
namespace YSG {
|
|
QDebug operator<<(QDebug debug, const Range& range) {
|
|
QDebugStateSaver saver(debug); // 保存当前的 qDebug 状态
|
|
debug.nospace() << "Range(" << range.lower << ", " << range.upper << ")";
|
|
return debug;
|
|
}
|
|
Renderable::Render_Pipeline::Render_Pipeline() {
|
|
colorControl.set_stats(&colorBufferStats);
|
|
colorControl.reset();
|
|
}
|
|
void Renderable::Render_Pipeline::mark_edit_state() {
|
|
editStateVersion.fetch_add(1, std::memory_order_release);
|
|
}
|
|
bool Renderable::Render_Pipeline::has_new_state() const {
|
|
return Renderable::version_newer(editStateVersion.load(std::memory_order_acquire), renderStateVersion);
|
|
}
|
|
Renderable::Color_Buffer* Renderable::Render_Pipeline::color_by_index(std::uint8_t index) {
|
|
return &colorBuffers[index];
|
|
}
|
|
Renderable::Color_Buffer* Renderable::Render_Pipeline::color_by_role(std::uint8_t role) {
|
|
return color_by_index(colorControl.read_view()[role]);
|
|
}
|
|
Renderable::Color_Buffer_Lease Renderable::Render_Pipeline::wait_render_color() {
|
|
auto lease = colorControl.wait_mark_use_role(Color_Render);
|
|
return {color_by_index(lease.index), lease};
|
|
}
|
|
Renderable::Color_Buffer_Lease Renderable::Render_Pipeline::wait_front_color() {
|
|
auto lease = colorControl.wait_mark_use_role(Color_Front);
|
|
return {color_by_index(lease.index), lease};
|
|
}
|
|
Renderable::Color_Buffer_Lease Renderable::Render_Pipeline::try_front_color() {
|
|
auto record = colorControl.try_mark_use_role(Color_Front);
|
|
if (record.result != Triple_Buffer_Result::Success) {
|
|
return {};
|
|
}
|
|
return {color_by_index(record.lease.index), record.lease};
|
|
}
|
|
void Renderable::Render_Pipeline::unmark_color(Color_Buffer_Lease lease) {
|
|
colorControl.unmark_use(lease.lease);
|
|
}
|
|
Plot_Buffer_Acquire_Mode Renderable::buffer_acquire_mode() const {
|
|
return dPtr->buffer_acquire_mode();
|
|
}
|
|
void Renderable::set_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode) {
|
|
dPtr->set_buffer_acquire_mode(mode);
|
|
}
|
|
RenderAble_Render_Schedule_Mode Renderable::render_schedule_mode() const {
|
|
return dPtr->render_schedule_mode();
|
|
}
|
|
void Renderable::set_render_schedule_mode(RenderAble_Render_Schedule_Mode mode) {
|
|
dPtr->set_render_schedule_mode(mode);
|
|
}
|
|
double Renderable::render_schedule_max_fps() const {
|
|
return dPtr->render_schedule_max_fps();
|
|
}
|
|
void Renderable::set_render_schedule_max_fps(double fps) {
|
|
dPtr->set_render_schedule_max_fps(fps);
|
|
}
|
|
bool Renderable::independent_pixel_cache() const {
|
|
return dPtr->independent_pixel_cache();
|
|
}
|
|
void Renderable::set_independent_pixel_cache(bool enabled) {
|
|
dPtr->set_independent_pixel_cache(enabled);
|
|
}
|
|
QRegion Renderable::Render_Pipeline::publish_render_color() {
|
|
colorControl.wait_swap_role(Color_Ready, Color_Render, [this](const Triple_Buffer_View& view) {
|
|
auto render = color_by_index(view[Color_Render]);
|
|
auto ready = color_by_index(view[Color_Ready]);
|
|
return Renderable::version_newer(render->version.load(std::memory_order_acquire), ready->version.load(std::memory_order_acquire));
|
|
});
|
|
auto view = colorControl.read_view();
|
|
auto ready = color_by_index(view[Color_Ready]);
|
|
auto front = color_by_index(view[Color_Front]);
|
|
if (Renderable::version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire)) && !paintRequestPending.exchange(true, std::memory_order_acq_rel)) {
|
|
return ready->dirtyRegion;
|
|
}
|
|
return {};
|
|
}
|
|
Renderable::Color_Buffer_Lease Renderable::Render_Pipeline::consume_ready_color(Triple_Buffer_Mode mode) {
|
|
auto canSwap = [this](const Triple_Buffer_View& view) {
|
|
auto ready = color_by_index(view[Color_Ready]);
|
|
auto front = color_by_index(view[Color_Front]);
|
|
return Renderable::version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire));
|
|
};
|
|
if (mode == Triple_Buffer_Mode::Wait) {
|
|
colorControl.wait_swap_role(Color_Front, Color_Ready, canSwap);
|
|
}
|
|
else {
|
|
colorControl.try_swap_role(Color_Front, Color_Ready, canSwap);
|
|
}
|
|
paintRequestPending.store(false, std::memory_order_release);
|
|
if (mode == Triple_Buffer_Mode::Wait) {
|
|
return wait_front_color();
|
|
}
|
|
return try_front_color();
|
|
}
|
|
Render_Edit_Guard::Render_Edit_Guard(Render_Data* data, Triple_Buffer_Lease lease) : mData(data), mLease(lease) {}
|
|
Render_Edit_Guard::~Render_Edit_Guard() {
|
|
if (!mData) return;
|
|
++mData->state_by_index(mLease.index)->version;
|
|
if (mData->qPtr) mData->qPtr->mark_render_dirty();
|
|
mData->unmark_state(mLease);
|
|
}
|
|
Render_Input_Guard::Render_Input_Guard(Render_Data* data, Triple_Buffer_Lease lease) : mData(data), mLease(lease) {}
|
|
Render_Input_Guard::~Render_Input_Guard() {
|
|
if (!mData) return;
|
|
mData->mark_input_dirty(mLease);
|
|
mData->mInputControl.unmark_use(mLease);
|
|
}
|
|
void Render_Data::mark_input_dirty(Triple_Buffer_Lease lease, bool notifyRender) {
|
|
Input_Buffer_Slot& slot = input_slot_by_index(lease.index);
|
|
slot.version = ++mInputVersion;
|
|
slot.pending = true;
|
|
if (notifyRender && qPtr) qPtr->mark_render_dirty();
|
|
}
|
|
void Renderable::init(Plot* plot, QString layerName) {
|
|
if (layerName.isEmpty()) {
|
|
layerName = plot->default_layer_name;
|
|
}
|
|
plot->mLayerMap[layerName]->renderable_list.append(this);
|
|
mPlot = plot;
|
|
if (!dPtr) dPtr = create_render_data();
|
|
dPtr->set_buffer_acquire_mode(plot->render_able_buffer_acquire_mode());
|
|
dPtr->clear_state_buffers();
|
|
dPtr->clear_input_buffers();
|
|
dPtr->mStateBuffers[State_Edit] = create_render_state();
|
|
dPtr->mStateBuffers[State_Ready] = create_render_state();
|
|
dPtr->mStateBuffers[State_Render] = create_render_state();
|
|
dPtr->mInputBuffers[Input_Edit].data = create_input_data();
|
|
dPtr->mInputBuffers[Input_Ready].data = create_input_data();
|
|
dPtr->mInputBuffers[Input_Render].data = create_input_data();
|
|
for (Render_State* state : dPtr->mStateBuffers) {
|
|
state->dPtr = dPtr;
|
|
}
|
|
dPtr->qPtr = this;
|
|
dPtr->mStateBuffers[State_Edit]->version = 1;
|
|
if (mPlot) mPlot->mark_render_state_dirty();
|
|
}
|
|
void Renderable::mark_state_dirty() {
|
|
if (dPtr) {
|
|
auto lease = dPtr->mStateControl.wait_mark_use_role(State_Edit);
|
|
++dPtr->state_by_index(lease.index)->version;
|
|
dPtr->mStateControl.unmark_use(lease);
|
|
}
|
|
mark_render_dirty();
|
|
}
|
|
void Renderable::mark_render_dirty() {
|
|
if (!mPlot) return;
|
|
if (dPtr&& dPtr->independent_pixel_cache())
|
|
{
|
|
dPtr->mark_pixel_dirty();
|
|
mPlot->mark_independent_render_dirty(this);
|
|
return;
|
|
}
|
|
mPlot->mark_render_state_dirty();
|
|
}
|
|
bool Renderable::ok() const {
|
|
return dPtr->mRenderStart && mPlot && !mPlot->first_resize && !mPlot->first_prepare_data;
|
|
}
|
|
Renderable::~Renderable() {}
|
|
bool Renderable::dect_cycle_rely() {
|
|
QQueue<Renderable*> queue;
|
|
queue.enqueue(this);
|
|
while (!queue.isEmpty()) {
|
|
Renderable* current = queue.dequeue();
|
|
QSet<Renderable*> visited;
|
|
QSet<Renderable*> recursionStack;
|
|
QVector<Renderable*> path;
|
|
bool has = has_cycle_rely(current, visited, recursionStack, path);
|
|
if (has) {
|
|
return true;
|
|
}
|
|
}
|
|
qDebug() << this << " 检测成功!";
|
|
return false;
|
|
}
|
|
bool Renderable::has_cycle_rely(Renderable* node, QSet<Renderable*>& visited, QSet<Renderable*>& recursionStack,
|
|
QVector<Renderable*>& currentPath) {
|
|
if (!node) return false;
|
|
if (recursionStack.contains(node)) {
|
|
// 节点已经在当前递归路径中，检测到循环
|
|
qDebug() << "Cycle detected in path:";
|
|
// 打印循环依赖链
|
|
for (Renderable* n : currentPath) {
|
|
qDebug() << n->mObjectName << "(" << n << ")->";
|
|
}
|
|
qDebug() << node; // 打印形成循环的节点
|
|
return true;
|
|
}
|
|
if (visited.contains(node)) {
|
|
// 节点已经被处理过，无需再次处理
|
|
return false;
|
|
}
|
|
// 标记当前节点为已访问
|
|
visited.insert(node);
|
|
// 将当前节点标记为递归路径中的节点
|
|
recursionStack.insert(node);
|
|
// 记录当前节点在路径中
|
|
currentPath.append(node);
|
|
// 递归检查所有子节点
|
|
for (Renderable* child : node->mBeRelyList) {
|
|
if (has_cycle_rely(child, visited, recursionStack, currentPath)) {
|
|
return true;
|
|
}
|
|
}
|
|
// 从递归路径中移除当前节点
|
|
recursionStack.remove(node);
|
|
// 从路径中移除当前节点
|
|
currentPath.removeLast();
|
|
return false;
|
|
}
|
|
QVector<QRgb> get_turbo_color_gradient() {
|
|
QVector<QRgb> colors;
|
|
// std::cout << "11111111111111111111111111111111111111" << std::endl;
|
|
// for (auto s : QDir(":/").entryList())
|
|
// {
|
|
// std::cout << "QDir=============" << s.toStdString() << std::endl;
|
|
// }
|
|
//
|
|
// std::cout << "11111111111111111111111111111111111111" << std::endl;
|
|
//
|
|
QFile file(":/turbo.colorMap");
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
std::ostringstream oss;
|
|
oss << file.errorString().toStdString() << " getTurboColorGradient2: Failed to open file" << LOG_POS_SIMPLE << std::endl;
|
|
Psc::fail_fast(oss.str());
|
|
return colors; // 返回一个空的 std::vector
|
|
}
|
|
QByteArray fileData = file.readAll();
|
|
file.close();
|
|
// 检查文件内容
|
|
if (fileData.size() != 768) {
|
|
qDebug() << "getTurboColorGradient2: File size is not as expected (768 bytes), got" << fileData.size();
|
|
return colors; // 返回一个空的 std::vector
|
|
}
|
|
// 确保每个颜色有 3 个字节 (RGB)，总共有 256 个颜色
|
|
colors.reserve(256);
|
|
for (int i = 0; i < 256; ++i) {
|
|
uchar r = fileData[i * 3];
|
|
uchar g = fileData[i * 3 + 1];
|
|
uchar b = fileData[i * 3 + 2];
|
|
colors.push_back(qRgb(r, g, b));
|
|
}
|
|
return colors;
|
|
}
|
|
SRC Render_State::src() {
|
|
auto view = dPtr->mStateControl.read_view();
|
|
for (std::uint8_t role = State_Edit; role <= State_Render; ++role) {
|
|
if (dPtr->mStateBuffers[view[role]] == this) return static_cast<SRC>(role);
|
|
}
|
|
return SRC::Edit;
|
|
}
|
|
}
|