cgv
Loading...
Searching...
No Matches
attribute_array_manager.h
1#pragma once
2
3#include <cgv/render/context.h>
4#include <cgv/render/vertex_buffer.h>
5#include <cgv/render/attribute_array_binding.h>
6#include <cgv_gl/gl/gl_context.h>
7
8#include "gl/lib_begin.h"
9
10namespace cgv { // @<
11namespace render { // @<
12
14class CGV_API attribute_array_manager {
15protected:
17 VertexBufferUsage default_usage;
19 attribute_array_binding aab;
21 std::map<int, vertex_buffer*> vbos;
23 friend class renderer;
24public:
26 template <typename T>
27 bool set_indices(const context& ctx, const T& array) {
28 bool res;
29 vertex_buffer*& vbo_ptr = vbos[-1];
30 if(vbo_ptr) {
31 if(vbo_ptr->get_size_in_bytes() == array_descriptor_traits <T>::get_size(array))
32 res = vbo_ptr->replace(ctx, 0, array_descriptor_traits <T>::get_address(array), array_descriptor_traits < T>::get_nr_elements(array));
33 else {
34 vbo_ptr->destruct(ctx);
35 res = vbo_ptr->create(ctx, array);
36 }
37 } else {
38 vbo_ptr = new vertex_buffer(VBT_INDICES, default_usage);
39 res = vbo_ptr->create(ctx, array);
40 }
41 if(res)
42 res = ctx.set_element_array(&aab, vbo_ptr);
43 return res;
44 }
46 template <typename T>
47 bool set_indices(const context& ctx, const T* array, size_t count) {
48 bool res;
49 vertex_buffer*& vbo_ptr = vbos[-1];
50 if(vbo_ptr) {
51 if(vbo_ptr->get_size_in_bytes() == count * get_type_size(cgv::type::info::type_id<T>::get_id()))
52 res = vbo_ptr->replace(ctx, 0, array, count);
53 else {
54 vbo_ptr->destruct(ctx);
55 res = vbo_ptr->create(ctx, array, count);
56 }
57 } else {
58 vbo_ptr = new vertex_buffer(VBT_INDICES, default_usage);
59 res = vbo_ptr->create(ctx, array, count);
60 }
61 if(res)
62 res = ctx.set_element_array(&aab, vbo_ptr);
63 return res;
64 }
66 bool has_index_buffer() const;
68 void remove_indices(const context& ctx);
70 template <typename T>
71 bool set_attribute_array(const context& ctx, int loc, const T& array) {
72 bool res;
73 vertex_buffer*& vbo_ptr = vbos[loc];
74 if(vbo_ptr) {
75 if(vbo_ptr->get_size_in_bytes() == array_descriptor_traits <T>::get_size(array))
76 res = vbo_ptr->replace(ctx, 0, array_descriptor_traits <T>::get_address(array), array_descriptor_traits < T>::get_nr_elements(array));
77 else {
78 vbo_ptr->destruct(ctx);
79 res = vbo_ptr->create(ctx, array);
80 }
81 } else {
82 vbo_ptr = new vertex_buffer(VBT_VERTICES, default_usage);
83 res = vbo_ptr->create(ctx, array);
84 }
85 if(res)
86 res = ctx.set_attribute_array_void(&aab, loc, array_descriptor_traits <T>::get_type_descriptor(array), vbo_ptr, 0, array_descriptor_traits < T>::get_nr_elements(array));
87 return res;
88 }
90 template <typename T>
91 bool set_attribute_array(const context& ctx, int loc, const T* array_ptr, size_t nr_elements, unsigned stride) {
92 bool res;
93 vertex_buffer*& vbo_ptr = vbos[loc];
94 size_t buffer_size = nr_elements*std::max(sizeof(T), size_t(stride));
95 if(vbo_ptr) {
96 if(vbo_ptr->get_size_in_bytes() == buffer_size)
97 res = vbo_ptr->replace(ctx, 0, reinterpret_cast<const uint8_t*>(array_ptr), buffer_size);
98 else {
99 vbo_ptr->destruct(ctx);
100 res = vbo_ptr->create(ctx, reinterpret_cast<const uint8_t*>(array_ptr), buffer_size);
101 }
102 } else {
103 vbo_ptr = new vertex_buffer(VBT_VERTICES, default_usage);
104 res = vbo_ptr->create(ctx, reinterpret_cast<const uint8_t*>(array_ptr), buffer_size);
105 }
106 if (res)
107 res = ctx.set_attribute_array_void(&aab, loc, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(*array_ptr), true), vbo_ptr, 0, nr_elements, stride);
108 return res;
109 }
111 bool set_attribute_array(const context& ctx, int loc, type_descriptor element_type, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes);
112
113 template <typename C, typename T>
114 bool set_composed_attribute_array(const context& ctx, int loc, const C* array_ptr, size_t nr_elements, const T& elem) {
115 bool res;
116 vertex_buffer*& vbo_ptr = vbos[loc];
117 if(vbo_ptr) {
118 if(vbo_ptr->get_size_in_bytes() == nr_elements * sizeof(C))
119 res = vbo_ptr->replace(ctx, 0, array_ptr, nr_elements);
120 else {
121 vbo_ptr->destruct(ctx);
122 res = vbo_ptr->create(ctx, array_ptr, nr_elements);
123 }
124 } else {
125 vbo_ptr = new vertex_buffer(VBT_VERTICES, default_usage);
126 res = vbo_ptr->create(ctx, array_ptr, nr_elements);
127 }
128 if(res)
129 res = ctx.set_attribute_array_void(&aab, loc,
130 type_descriptor(element_descriptor_traits<T>::get_type_descriptor(elem), true),
131 vbo_ptr,
132 reinterpret_cast<const void*>(reinterpret_cast<const cgv::type::uint8_type*>(&elem) - reinterpret_cast<const cgv::type::uint8_type*>(array_ptr)),
133 nr_elements, sizeof(C));
134 return res;
135 }
136 template <typename C, typename T>
137 bool ref_composed_attribute_array(const context& ctx, int loc, int loc_ref, const C* array_ptr, size_t nr_elements, const T& elem) {
138 vertex_buffer*& vbo_ptr = vbos[loc_ref];
139 if(!vbo_ptr)
140 return false;
141 return ctx.set_attribute_array_void(&aab, loc,
142 type_descriptor(element_descriptor_traits<T>::get_type_descriptor(elem), true),
143 vbo_ptr,
144 reinterpret_cast<const void*>(reinterpret_cast<const cgv::type::uint8_type*>(&elem) - reinterpret_cast<const cgv::type::uint8_type*>(array_ptr)),
145 nr_elements, sizeof(C));
146 }
147 void remove_attribute_array(const context& ctx, int loc);
148public:
150 attribute_array_manager(VertexBufferUsage _default_usage = VBU_STREAM_DRAW);
152 ~attribute_array_manager();
154 bool has_attribute(const context& ctx, int loc) const;
156 const vertex_buffer* get_buffer_ptr(int loc) const {
157 auto it = vbos.find(loc);
158 if(it != vbos.end())
159 return it->second;
160 return nullptr;
161 }
163 bool is_created() const;
165 bool init(context& ctx);
167 bool enable(context& ctx);
169 bool disable(context& ctx);
171 void destruct(const context& ctx);
172};
173
174}
175}
176
177#include <cgv/config/lib_end.h>
cgv::base::single_method_action
complete implementation of method actions that only call one method when entering a node
Definition action.h:113
cgv::render::attribute_array_binding
the attribute_array_binding allows to define vertex attributes (i.e.
Definition attribute_array_binding.h:20
cgv::render::attribute_array_manager
attribute array manager used to upload arrays to gpu
Definition attribute_array_manager.h:14
cgv::render::attribute_array_manager::vbos
std::map< int, vertex_buffer * > vbos
store vertex buffers generated per attribute location
Definition attribute_array_manager.h:21
cgv::render::attribute_array_manager::get_buffer_ptr
const vertex_buffer * get_buffer_ptr(int loc) const
returns the pointer to the vertex buffer as managed by this attribute array manager if specified and ...
Definition attribute_array_manager.h:156
cgv::render::attribute_array_manager::aab
attribute_array_binding aab
attribue array binding used to store array pointers
Definition attribute_array_manager.h:19
cgv::render::attribute_array_manager::default_usage
VertexBufferUsage default_usage
store default buffer usage
Definition attribute_array_manager.h:17
cgv::render::context
base class for all drawables, which is independent of the used rendering API.
Definition context.h:670
cgv::render::renderer
Abstract base class for all renderers that manage a render data and the rendering process.
Definition renderer.h:75
cgv::render::vertex_buffer
a vertex buffer is an unstructured memory block on the GPU.
Definition vertex_buffer.h:13
cgv::render::vertex_buffer::get_size_in_bytes
size_t get_size_in_bytes() const
Retrieves the current size of the buffer in bytes.
Definition vertex_buffer.cxx:22
cgv::render::vertex_buffer::create
bool create(const context &ctx, size_t size_in_bytes)
create empty vertex buffer of size size given in bytes
Definition vertex_buffer.cxx:54
cgv::render::vertex_buffer::destruct
void destruct(const context &ctx)
destruct the render buffer
Definition vertex_buffer.cxx:84
cgv::render::vertex_buffer::replace
bool replace(const context &ctx, size_t buffer_offset_in_bytes, const T *array_ptr, size_t nr_elements)
replace part (starting at byte offset buffer_offset_in_bytes) or whole vertex buffer content from nr_...
Definition vertex_buffer.h:172
cgv::render::VertexBufferUsage
VertexBufferUsage
Provides vertex buffer usage hints as defined in OpenGL.
Definition context.h:487
cgv::type::info::get_type_size
unsigned int get_type_size(TypeId tid)
function that returns the size of a type specified through TypeId
Definition type_id.cxx:18
cgv
this header is dependency free
Definition print.h:11
cgv::type::info::type_id
template with a static member function get_id() of type TypeId returning the TypeId of the template a...
Definition type_id.h:86