intern/opensubdiv/internal/evaluator/eval_output_gpu.cc

   1 /* SPDX-FileCopyrightText: 2021 Blender Foundation
   2  *
   3  * SPDX-License-Identifier: GPL-2.0-or-later
   4  *
   5  * Author: Sergey Sharybin. */
   6
   7 #include "internal/evaluator/eval_output_gpu.h"
   8
   9 #include "opensubdiv_evaluator_capi.hh"
  10
  11 using OpenSubdiv::Osd::PatchArray;
  12 using OpenSubdiv::Osd::PatchArrayVector;
  13
  14 namespace blender::opensubdiv {
  15
  16 static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_arrays,
  17                                              OpenSubdiv_Buffer *patch_arrays_buffer)
  18 {
  19   const size_t patch_array_size = sizeof(PatchArray);
  20   const size_t patch_array_byte_site = patch_array_size * patch_arrays.size();
  21   patch_arrays_buffer->device_alloc(patch_arrays_buffer, patch_arrays.size());
  22   patch_arrays_buffer->bind_gpu(patch_arrays_buffer);
  23   patch_arrays_buffer->device_update(
  24       patch_arrays_buffer, 0, patch_array_byte_site, &patch_arrays[0]);
  25 }
  26
  27 GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils,
  28                              const StencilTable *varying_stencils,
  29                              const std::vector<const StencilTable *> &all_face_varying_stencils,
  30                              const int face_varying_width,
  31                              const PatchTable *patch_table,
  32                              VolatileEvalOutput::EvaluatorCache *evaluator_cache)
  33     : VolatileEvalOutput<GLVertexBuffer,
  34                          GLVertexBuffer,
  35                          GLStencilTableSSBO,
  36                          GLPatchTable,
  37                          GLComputeEvaluator>(vertex_stencils,
  38                                              varying_stencils,
  39                                              all_face_varying_stencils,
  40                                              face_varying_width,
  41                                              patch_table,
  42                                              evaluator_cache)
  43 {
  44 }
  45
  46 void GpuEvalOutput::fillPatchArraysBuffer(OpenSubdiv_Buffer *patch_arrays_buffer)
  47 {
  48   GLPatchTable *patch_table = getPatchTable();
  49   buildPatchArraysBufferFromVector(patch_table->GetPatchArrays(), patch_arrays_buffer);
  50 }
  51
  52 void GpuEvalOutput::wrapPatchIndexBuffer(OpenSubdiv_Buffer *patch_index_buffer)
  53 {
  54   GLPatchTable *patch_table = getPatchTable();
  55   patch_index_buffer->wrap_device_handle(patch_index_buffer, patch_table->GetPatchIndexBuffer());
  56 }
  57
  58 void GpuEvalOutput::wrapPatchParamBuffer(OpenSubdiv_Buffer *patch_param_buffer)
  59 {
  60   GLPatchTable *patch_table = getPatchTable();
  61   patch_param_buffer->wrap_device_handle(patch_param_buffer, patch_table->GetPatchParamBuffer());
  62 }
  63
  64 void GpuEvalOutput::wrapSrcBuffer(OpenSubdiv_Buffer *src_buffer)
  65 {
  66   GLVertexBuffer *vertex_buffer = getSrcBuffer();
  67   src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
  68 }
  69
  70 void GpuEvalOutput::wrapSrcVertexDataBuffer(OpenSubdiv_Buffer *src_buffer)
  71 {
  72   GLVertexBuffer *vertex_buffer = getSrcVertexDataBuffer();
  73   src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
  74 }
  75
  76 void GpuEvalOutput::fillFVarPatchArraysBuffer(const int face_varying_channel,
  77                                               OpenSubdiv_Buffer *patch_arrays_buffer)
  78 {
  79   GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
  80   buildPatchArraysBufferFromVector(patch_table->GetFVarPatchArrays(face_varying_channel),
  81                                    patch_arrays_buffer);
  82 }
  83
  84 void GpuEvalOutput::wrapFVarPatchIndexBuffer(const int face_varying_channel,
  85                                              OpenSubdiv_Buffer *patch_index_buffer)
  86 {
  87   GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
  88   patch_index_buffer->wrap_device_handle(
  89       patch_index_buffer, patch_table->GetFVarPatchIndexBuffer(face_varying_channel));
  90 }
  91
  92 void GpuEvalOutput::wrapFVarPatchParamBuffer(const int face_varying_channel,
  93                                              OpenSubdiv_Buffer *patch_param_buffer)
  94 {
  95   GLPatchTable *patch_table = getFVarPatchTable(face_varying_channel);
  96   patch_param_buffer->wrap_device_handle(
  97       patch_param_buffer, patch_table->GetFVarPatchParamBuffer(face_varying_channel));
  98 }
  99
 100 void GpuEvalOutput::wrapFVarSrcBuffer(const int face_varying_channel,
 101                                       OpenSubdiv_Buffer *src_buffer)
 102 {
 103   GLVertexBuffer *vertex_buffer = getFVarSrcBuffer(face_varying_channel);
 104   src_buffer->buffer_offset = getFVarSrcBufferOffset(face_varying_channel);
 105   src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
 106 }
 107
 108 }  // namespace blender::opensubdiv