00a8d006fe
This port is not so straightforward. This shader is used in different configurations and is available to python bindings. So we need to keep compatibility with different attributes configurations. This is why attributes are loaded per component and a uniform sets the length of the component. Since this shader can be used from both the imm and batch API, we need to inject some workarounds to bind the buffers correctly. The end result is still less versatile than the previous metal workaround (i.e.: more attribute fetch mode supported), but it is also way less code. ### Limitations: The new shader has some limitation: - Both `color` and `pos` attributes need to be `F32`. - Each attribute needs to be 4byte aligned. - Fetch type needs to be `GPU_FETCH_FLOAT`. - Primitive type needs to be `GPU_PRIM_LINES`, `GPU_PRIM_LINE_STRIP` or `GPU_PRIM_LINE_LOOP`. - If drawing using an index buffer, it must contain no primitive restart. Rel #127493 Co-authored-by: Jeroen Bakker <jeroen@blender.org> Pull Request: https://projects.blender.org/blender/blender/pulls/129315
130 lines
3.7 KiB
C++
130 lines
3.7 KiB
C++
/* SPDX-FileCopyrightText: 2016 by Mike Erwin. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup gpu
|
|
*
|
|
* This interface allow GPU to manage GL objects for multiple context and threads.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "GPU_batch.hh"
|
|
#include "GPU_context.hh"
|
|
|
|
#include "gpu_debug_private.hh"
|
|
#include "gpu_framebuffer_private.hh"
|
|
#include "gpu_immediate_private.hh"
|
|
#include "gpu_shader_private.hh"
|
|
#include "gpu_state_private.hh"
|
|
|
|
#include <pthread.h>
|
|
|
|
struct GPUMatrixState;
|
|
|
|
namespace blender::gpu {
|
|
|
|
class Context {
|
|
public:
|
|
/** State management */
|
|
Shader *shader = nullptr;
|
|
FrameBuffer *active_fb = nullptr;
|
|
GPUMatrixState *matrix_state = nullptr;
|
|
StateManager *state_manager = nullptr;
|
|
Immediate *imm = nullptr;
|
|
|
|
ShaderCompiler *compiler = nullptr;
|
|
|
|
/**
|
|
* All 4 window frame-buffers.
|
|
* None of them are valid in an off-screen context.
|
|
* Right frame-buffers are only available if using stereo rendering.
|
|
* Front frame-buffers contains (in principle, but not always) the last frame color.
|
|
* Default frame-buffer is back_left.
|
|
*/
|
|
FrameBuffer *back_left = nullptr;
|
|
FrameBuffer *front_left = nullptr;
|
|
FrameBuffer *back_right = nullptr;
|
|
FrameBuffer *front_right = nullptr;
|
|
|
|
DebugStack debug_stack;
|
|
bool debug_is_capturing = false;
|
|
|
|
/* GPUContext counter used to assign a unique ID to each GPUContext.
|
|
* NOTE(Metal): This is required by the Metal Backend, as a bug exists in the global OS shader
|
|
* cache wherein compilation of identical source from two distinct threads can result in an
|
|
* invalid cache collision, result in a broken shader object. Appending the unique context ID
|
|
* onto compiled sources ensures the source hashes are different. */
|
|
static int context_counter;
|
|
int context_id = 0;
|
|
|
|
/* Used as a stack. Each render_begin/end pair will push pop from the stack. */
|
|
Vector<GPUStorageBuf *> printf_buf;
|
|
|
|
/** Dummy triangle batch for polyline workaround. */
|
|
Batch *polyline_batch = nullptr;
|
|
|
|
protected:
|
|
/** Thread on which this context is active. */
|
|
pthread_t thread_;
|
|
bool is_active_;
|
|
/** Avoid including GHOST headers. Can be nullptr for off-screen contexts. */
|
|
void *ghost_window_;
|
|
|
|
public:
|
|
Context();
|
|
virtual ~Context();
|
|
|
|
static Context *get();
|
|
|
|
virtual void activate() = 0;
|
|
virtual void deactivate() = 0;
|
|
virtual void begin_frame() = 0;
|
|
virtual void end_frame() = 0;
|
|
|
|
/* Will push all pending commands to the GPU. */
|
|
virtual void flush() = 0;
|
|
/* Will wait until the GPU has finished executing all command. */
|
|
virtual void finish() = 0;
|
|
|
|
virtual void memory_statistics_get(int *r_total_mem, int *r_free_mem) = 0;
|
|
|
|
virtual void debug_group_begin(const char * /*name*/, int /*index*/){};
|
|
virtual void debug_group_end(){};
|
|
|
|
/* Returns true if capture successfully started. */
|
|
virtual bool debug_capture_begin(const char *title) = 0;
|
|
virtual void debug_capture_end() = 0;
|
|
virtual void *debug_capture_scope_create(const char *name) = 0;
|
|
virtual bool debug_capture_scope_begin(void *scope) = 0;
|
|
virtual void debug_capture_scope_end(void *scope) = 0;
|
|
|
|
/* Consider all buffers slot empty after these call for error checking.
|
|
* But doesn't really free them. */
|
|
virtual void debug_unbind_all_ubo() = 0;
|
|
virtual void debug_unbind_all_ssbo() = 0;
|
|
|
|
bool is_active_on_thread();
|
|
|
|
Batch *polyline_batch_get();
|
|
};
|
|
|
|
/* Syntactic sugar. */
|
|
static inline GPUContext *wrap(Context *ctx)
|
|
{
|
|
return reinterpret_cast<GPUContext *>(ctx);
|
|
}
|
|
static inline Context *unwrap(GPUContext *ctx)
|
|
{
|
|
return reinterpret_cast<Context *>(ctx);
|
|
}
|
|
static inline const Context *unwrap(const GPUContext *ctx)
|
|
{
|
|
return reinterpret_cast<const Context *>(ctx);
|
|
}
|
|
|
|
} // namespace blender::gpu
|