mirror of
https://github.com/libretro/parallel-gx1.git
synced 2026-11-10 11:21:34 -10:00
132 lines
3.2 KiB
C++
132 lines
3.2 KiB
C++
// Copyright 2014 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "VideoCommon/BoundingBox.h"
|
|
|
|
#include "Common/Assert.h"
|
|
#include "Common/ChunkFile.h"
|
|
#include "Common/CommonTypes.h"
|
|
#include "VideoCommon/PixelShaderManager.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
BoundingBox* g_bounding_box = nullptr;
|
|
|
|
void BoundingBox::Enable(PixelShaderManager& pixel_shader_manager)
|
|
{
|
|
m_is_active = true;
|
|
pixel_shader_manager.SetBoundingBoxActive(m_is_active);
|
|
}
|
|
|
|
void BoundingBox::Disable(PixelShaderManager& pixel_shader_manager)
|
|
{
|
|
m_is_active = false;
|
|
pixel_shader_manager.SetBoundingBoxActive(m_is_active);
|
|
}
|
|
|
|
void BoundingBox::Flush()
|
|
{
|
|
if (!g_ActiveConfig.bBBoxEnable || !g_backend_info.bSupportsBBox)
|
|
return;
|
|
|
|
m_is_valid = false;
|
|
|
|
u32 dirty = 0;
|
|
for (u32 i = 0; i < NUM_BBOX_VALUES; ++i)
|
|
dirty |= m_dirty[i];
|
|
if (!dirty)
|
|
return;
|
|
|
|
// TODO: Does this make any difference over just writing all the values?
|
|
// Games only ever seem to write all 4 values at once anyways.
|
|
for (u32 start = 0; start < NUM_BBOX_VALUES; ++start)
|
|
{
|
|
if (!m_dirty[start])
|
|
continue;
|
|
|
|
u32 end = start + 1;
|
|
while (end < NUM_BBOX_VALUES && m_dirty[end])
|
|
++end;
|
|
|
|
for (u32 i = start; i < end; ++i)
|
|
m_dirty[i] = false;
|
|
|
|
Write(start, m_values.data() + start, end - start);
|
|
}
|
|
}
|
|
|
|
void BoundingBox::Readback()
|
|
{
|
|
if (!g_backend_info.bSupportsBBox)
|
|
return;
|
|
|
|
BBoxType read_values[NUM_BBOX_VALUES];
|
|
Read(0, NUM_BBOX_VALUES, read_values);
|
|
|
|
// Preserve dirty values, that way we don't need to sync.
|
|
for (u32 i = 0; i < NUM_BBOX_VALUES; i++)
|
|
{
|
|
if (!m_dirty[i])
|
|
m_values[i] = read_values[i];
|
|
}
|
|
|
|
m_is_valid = true;
|
|
}
|
|
|
|
u16 BoundingBox::Get(u32 index)
|
|
{
|
|
ASSERT(index < NUM_BBOX_VALUES);
|
|
|
|
if (!g_ActiveConfig.bBBoxEnable || !g_backend_info.bSupportsBBox)
|
|
return m_bounding_box_fallback[index];
|
|
|
|
if (!m_is_valid)
|
|
Readback();
|
|
|
|
return static_cast<u16>(m_values[index]);
|
|
}
|
|
|
|
void BoundingBox::Set(u32 index, u16 value)
|
|
{
|
|
ASSERT(index < NUM_BBOX_VALUES);
|
|
|
|
if (!g_ActiveConfig.bBBoxEnable || !g_backend_info.bSupportsBBox)
|
|
{
|
|
m_bounding_box_fallback[index] = value;
|
|
return;
|
|
}
|
|
|
|
if (m_is_valid && m_values[index] == value)
|
|
return;
|
|
|
|
m_values[index] = value;
|
|
m_dirty[index] = true;
|
|
}
|
|
|
|
// FIXME: This may not work correctly if we're in the middle of a draw.
|
|
// We should probably ensure that state saves only happen on frame boundaries.
|
|
// Nonetheless, it has been designed to be as safe as possible.
|
|
void BoundingBox::DoState(PointerWrap& p)
|
|
{
|
|
p.DoArray(m_bounding_box_fallback);
|
|
p.Do(m_is_active);
|
|
p.DoArray(m_values);
|
|
p.DoArray(m_dirty);
|
|
p.Do(m_is_valid);
|
|
|
|
// We handle saving the backend values specially rather than using Readback() and Flush() so that
|
|
// we don't mess up the current cache state. Stored as a counted array.
|
|
BBoxType backend_values[NUM_BBOX_VALUES] = {};
|
|
u32 count = NUM_BBOX_VALUES;
|
|
if (!p.IsReadMode() && g_backend_info.bSupportsBBox)
|
|
Read(0, NUM_BBOX_VALUES, backend_values);
|
|
p.Do(count);
|
|
if (count != NUM_BBOX_VALUES)
|
|
{
|
|
p.SetMeasureMode();
|
|
return;
|
|
}
|
|
p.DoArray(backend_values, NUM_BBOX_VALUES);
|
|
if (p.IsReadMode() && g_backend_info.bSupportsBBox)
|
|
Write(0, backend_values, NUM_BBOX_VALUES);
|
|
}
|