Blender  V3.3
eval_output_gpu.cc
Go to the documentation of this file.
1 // Copyright 2021 Blender Foundation. All rights reserved.
2 //
3 // This program is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU General Public License
5 // as published by the Free Software Foundation; either version 2
6 // of the License, or (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program; if not, write to the Free Software Foundation,
15 // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 //
17 // Author: Sergey Sharybin
18 
20 
22 
23 using OpenSubdiv::Osd::PatchArray;
24 using OpenSubdiv::Osd::PatchArrayVector;
25 
26 namespace blender {
27 namespace opensubdiv {
28 
29 namespace {
30 
31 static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_arrays,
32  OpenSubdiv_Buffer *patch_arrays_buffer)
33 {
34  const size_t patch_array_size = sizeof(PatchArray);
35  const size_t patch_array_byte_site = patch_array_size * patch_arrays.size();
36  patch_arrays_buffer->device_alloc(patch_arrays_buffer, patch_arrays.size());
37  patch_arrays_buffer->bind_gpu(patch_arrays_buffer);
38  patch_arrays_buffer->device_update(
39  patch_arrays_buffer, 0, patch_array_byte_site, &patch_arrays[0]);
40 }
41 
42 } // namespace
43 
44 GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils,
45  const StencilTable *varying_stencils,
46  const vector<const StencilTable *> &all_face_varying_stencils,
47  const int face_varying_width,
48  const PatchTable *patch_table,
49  VolatileEvalOutput::EvaluatorCache *evaluator_cache)
50  : VolatileEvalOutput<GLVertexBuffer,
51  GLVertexBuffer,
53  GLPatchTable,
54  GLComputeEvaluator>(vertex_stencils,
55  varying_stencils,
56  all_face_varying_stencils,
57  face_varying_width,
58  patch_table,
59  evaluator_cache)
60 {
61 }
62 
64 {
65  GLPatchTable *patch_table = getPatchTable();
66  buildPatchArraysBufferFromVector(patch_table->GetPatchArrays(), patch_arrays_buffer);
67 }
68 
70 {
71  GLPatchTable *patch_table = getPatchTable();
72  patch_index_buffer->wrap_device_handle(patch_index_buffer, patch_table->GetPatchIndexBuffer());
73 }
74 
76 {
77  GLPatchTable *patch_table = getPatchTable();
78  patch_param_buffer->wrap_device_handle(patch_param_buffer, patch_table->GetPatchParamBuffer());
79 }
80 
82 {
83  GLVertexBuffer *vertex_buffer = getSrcBuffer();
84  src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
85 }
86 
88 {
89  GLVertexBuffer *vertex_buffer = getSrcVertexDataBuffer();
90  src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
91 }
92 
93 void GpuEvalOutput::fillFVarPatchArraysBuffer(const int face_varying_channel,
94  OpenSubdiv_Buffer *patch_arrays_buffer)
95 {
96  GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
97  buildPatchArraysBufferFromVector(patch_table->GetFVarPatchArrays(face_varying_channel),
98  patch_arrays_buffer);
99 }
100 
101 void GpuEvalOutput::wrapFVarPatchIndexBuffer(const int face_varying_channel,
102  OpenSubdiv_Buffer *patch_index_buffer)
103 {
104  GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
105  patch_index_buffer->wrap_device_handle(
106  patch_index_buffer, patch_table->GetFVarPatchIndexBuffer(face_varying_channel));
107 }
108 
109 void GpuEvalOutput::wrapFVarPatchParamBuffer(const int face_varying_channel,
110  OpenSubdiv_Buffer *patch_param_buffer)
111 {
112  GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
113  patch_param_buffer->wrap_device_handle(
114  patch_param_buffer, patch_table->GetFVarPatchParamBuffer(face_varying_channel));
115 }
116 
117 void GpuEvalOutput::wrapFVarSrcBuffer(const int face_varying_channel,
118  OpenSubdiv_Buffer *src_buffer)
119 {
120  GLVertexBuffer *vertex_buffer = getFVarSrcBuffer(face_varying_channel);
121  src_buffer->buffer_offset = getFVarSrcBufferOffset(face_varying_channel);
122  src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
123 }
124 
125 } // namespace opensubdiv
126 } // namespace blender
GL stencil table (Shader Storage buffer)
void fillFVarPatchArraysBuffer(const int face_varying_channel, OpenSubdiv_Buffer *patch_arrays_buffer) override
void wrapPatchIndexBuffer(OpenSubdiv_Buffer *patch_index_buffer) override
void wrapSrcBuffer(OpenSubdiv_Buffer *src_buffer) override
void fillPatchArraysBuffer(OpenSubdiv_Buffer *patch_arrays_buffer) override
GpuEvalOutput(const StencilTable *vertex_stencils, const StencilTable *varying_stencils, const vector< const StencilTable * > &all_face_varying_stencils, const int face_varying_width, const PatchTable *patch_table, EvaluatorCache *evaluator_cache=NULL)
void wrapPatchParamBuffer(OpenSubdiv_Buffer *patch_param_buffer) override
void wrapFVarPatchIndexBuffer(const int face_varying_channel, OpenSubdiv_Buffer *patch_index_buffer) override
void wrapFVarPatchParamBuffer(const int face_varying_channel, OpenSubdiv_Buffer *patch_param_buffer) override
void wrapFVarSrcBuffer(const int face_varying_channel, OpenSubdiv_Buffer *src_buffer) override
void wrapSrcVertexDataBuffer(OpenSubdiv_Buffer *src_buffer) override
OpenSubdiv::Osd::EvaluatorCacheT< EVALUATOR > EvaluatorCache
Definition: eval_output.h:342
void(* wrap_device_handle)(const struct OpenSubdiv_Buffer *buffer, uint64_t device_ptr)
void(* bind_gpu)(const struct OpenSubdiv_Buffer *buffer)
void(* device_update)(const struct OpenSubdiv_Buffer *buffer, unsigned int start, unsigned int len, const void *data)
void(* device_alloc)(const struct OpenSubdiv_Buffer *buffer, const unsigned int size)