Christian Rauch
a296b8f694
With libepoxy we can choose between EGL and GLX at runtime, as well as dynamically open EGL and GLX libraries without linking to them. This will make it possible to build with Wayland, EGL, GLVND support while still running on systems that only have X11, GLX and libGL. It also paves the way for headless rendering through EGL. libepoxy is a new library dependency, and is included in the precompiled libraries. GLEW is no longer a dependency, and WITH_SYSTEM_GLEW was removed. Includes contributions by Brecht Van Lommel, Ray Molenkamp, Campbell Barton and Sergey Sharybin. Ref T76428 Differential Revision: https://developer.blender.org/D15291
666 lines
25 KiB
C++
666 lines
25 KiB
C++
//
|
|
// Copyright 2015 Pixar
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "Apache License")
|
|
// with the following modification; you may not use this file except in
|
|
// compliance with the Apache License and the following modification to it:
|
|
// Section 6. Trademarks. is deleted and replaced with:
|
|
//
|
|
// 6. Trademarks. This License does not grant permission to use the trade
|
|
// names, trademarks, service marks, or product names of the Licensor
|
|
// and its affiliates, except as required to comply with Section 4(c) of
|
|
// the License and to reproduce the content of the NOTICE file.
|
|
//
|
|
// You may obtain a copy of the Apache License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the Apache License with the above modification is
|
|
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the Apache License for the specific
|
|
// language governing permissions and limitations under the Apache License.
|
|
//
|
|
|
|
#include <epoxy/gl.h>
|
|
|
|
/* There are few aspects here:
|
|
* - macOS is strict about including both gl.h and gl3.h
|
|
* - libepoxy only pretends to be a replacement for gl.h
|
|
* - OpenSubdiv internally uses `OpenGL/gl3.h` on macOS
|
|
*
|
|
* In order to silence the warning pretend that gl3 has been included, fully relying on symbols
|
|
* from the epoxy.
|
|
*
|
|
* This works differently from how OpenSubdiv internally will use `OpenGL/gl3.h` without epoxy.
|
|
* Sounds fragile, but so far things seems to work. */
|
|
#if defined(__APPLE__)
|
|
# define __gl3_h_
|
|
#endif
|
|
|
|
#include "gl_compute_evaluator.h"
|
|
|
|
#include <opensubdiv/far/error.h>
|
|
#include <opensubdiv/far/patchDescriptor.h>
|
|
#include <opensubdiv/far/stencilTable.h>
|
|
#include <opensubdiv/osd/glslPatchShaderSource.h>
|
|
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using OpenSubdiv::Far::LimitStencilTable;
|
|
using OpenSubdiv::Far::StencilTable;
|
|
using OpenSubdiv::Osd::BufferDescriptor;
|
|
using OpenSubdiv::Osd::PatchArray;
|
|
using OpenSubdiv::Osd::PatchArrayVector;
|
|
|
|
extern "C" char datatoc_glsl_compute_kernel_glsl[];
|
|
|
|
namespace blender {
|
|
namespace opensubdiv {
|
|
|
|
template<class T> GLuint createSSBO(std::vector<T> const &src)
|
|
{
|
|
if (src.empty()) {
|
|
return 0;
|
|
}
|
|
|
|
GLuint devicePtr = 0;
|
|
|
|
#if defined(GL_ARB_direct_state_access)
|
|
if (epoxy_has_gl_extension("GL_ARB_direct_state_access")) {
|
|
glCreateBuffers(1, &devicePtr);
|
|
glNamedBufferData(devicePtr, src.size() * sizeof(T), &src.at(0), GL_STATIC_DRAW);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
GLint prev = 0;
|
|
glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, &prev);
|
|
glGenBuffers(1, &devicePtr);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, devicePtr);
|
|
glBufferData(GL_SHADER_STORAGE_BUFFER, src.size() * sizeof(T), &src.at(0), GL_STATIC_DRAW);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, prev);
|
|
}
|
|
|
|
return devicePtr;
|
|
}
|
|
|
|
GLStencilTableSSBO::GLStencilTableSSBO(StencilTable const *stencilTable)
|
|
{
|
|
_numStencils = stencilTable->GetNumStencils();
|
|
if (_numStencils > 0) {
|
|
_sizes = createSSBO(stencilTable->GetSizes());
|
|
_offsets = createSSBO(stencilTable->GetOffsets());
|
|
_indices = createSSBO(stencilTable->GetControlIndices());
|
|
_weights = createSSBO(stencilTable->GetWeights());
|
|
_duWeights = _dvWeights = 0;
|
|
_duuWeights = _duvWeights = _dvvWeights = 0;
|
|
}
|
|
else {
|
|
_sizes = _offsets = _indices = _weights = 0;
|
|
_duWeights = _dvWeights = 0;
|
|
_duuWeights = _duvWeights = _dvvWeights = 0;
|
|
}
|
|
}
|
|
|
|
GLStencilTableSSBO::GLStencilTableSSBO(LimitStencilTable const *limitStencilTable)
|
|
{
|
|
_numStencils = limitStencilTable->GetNumStencils();
|
|
if (_numStencils > 0) {
|
|
_sizes = createSSBO(limitStencilTable->GetSizes());
|
|
_offsets = createSSBO(limitStencilTable->GetOffsets());
|
|
_indices = createSSBO(limitStencilTable->GetControlIndices());
|
|
_weights = createSSBO(limitStencilTable->GetWeights());
|
|
_duWeights = createSSBO(limitStencilTable->GetDuWeights());
|
|
_dvWeights = createSSBO(limitStencilTable->GetDvWeights());
|
|
_duuWeights = createSSBO(limitStencilTable->GetDuuWeights());
|
|
_duvWeights = createSSBO(limitStencilTable->GetDuvWeights());
|
|
_dvvWeights = createSSBO(limitStencilTable->GetDvvWeights());
|
|
}
|
|
else {
|
|
_sizes = _offsets = _indices = _weights = 0;
|
|
_duWeights = _dvWeights = 0;
|
|
_duuWeights = _duvWeights = _dvvWeights = 0;
|
|
}
|
|
}
|
|
|
|
GLStencilTableSSBO::~GLStencilTableSSBO()
|
|
{
|
|
if (_sizes)
|
|
glDeleteBuffers(1, &_sizes);
|
|
if (_offsets)
|
|
glDeleteBuffers(1, &_offsets);
|
|
if (_indices)
|
|
glDeleteBuffers(1, &_indices);
|
|
if (_weights)
|
|
glDeleteBuffers(1, &_weights);
|
|
if (_duWeights)
|
|
glDeleteBuffers(1, &_duWeights);
|
|
if (_dvWeights)
|
|
glDeleteBuffers(1, &_dvWeights);
|
|
if (_duuWeights)
|
|
glDeleteBuffers(1, &_duuWeights);
|
|
if (_duvWeights)
|
|
glDeleteBuffers(1, &_duvWeights);
|
|
if (_dvvWeights)
|
|
glDeleteBuffers(1, &_dvvWeights);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
GLComputeEvaluator::GLComputeEvaluator() : _workGroupSize(64), _patchArraysSSBO(0)
|
|
{
|
|
memset((void *)&_stencilKernel, 0, sizeof(_stencilKernel));
|
|
memset((void *)&_patchKernel, 0, sizeof(_patchKernel));
|
|
}
|
|
|
|
GLComputeEvaluator::~GLComputeEvaluator()
|
|
{
|
|
if (_patchArraysSSBO) {
|
|
glDeleteBuffers(1, &_patchArraysSSBO);
|
|
}
|
|
}
|
|
|
|
static GLuint compileKernel(BufferDescriptor const &srcDesc,
|
|
BufferDescriptor const &dstDesc,
|
|
BufferDescriptor const &duDesc,
|
|
BufferDescriptor const &dvDesc,
|
|
BufferDescriptor const &duuDesc,
|
|
BufferDescriptor const &duvDesc,
|
|
BufferDescriptor const &dvvDesc,
|
|
const char *kernelDefine,
|
|
int workGroupSize)
|
|
{
|
|
GLuint program = glCreateProgram();
|
|
|
|
GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
|
|
|
|
std::string patchBasisShaderSource =
|
|
OpenSubdiv::Osd::GLSLPatchShaderSource::GetPatchBasisShaderSource();
|
|
const char *patchBasisShaderSourceDefine = "#define OSD_PATCH_BASIS_GLSL\n";
|
|
|
|
std::ostringstream defines;
|
|
defines << "#define LENGTH " << srcDesc.length << "\n"
|
|
<< "#define SRC_STRIDE " << srcDesc.stride << "\n"
|
|
<< "#define DST_STRIDE " << dstDesc.stride << "\n"
|
|
<< "#define WORK_GROUP_SIZE " << workGroupSize << "\n"
|
|
<< kernelDefine << "\n"
|
|
<< patchBasisShaderSourceDefine << "\n";
|
|
|
|
bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
|
|
bool deriv2 = (duuDesc.length > 0 || duvDesc.length > 0 || dvvDesc.length > 0);
|
|
if (deriv1) {
|
|
defines << "#define OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES\n";
|
|
}
|
|
if (deriv2) {
|
|
defines << "#define OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES\n";
|
|
}
|
|
|
|
std::string defineStr = defines.str();
|
|
|
|
const char *shaderSources[4] = {"#version 430\n", 0, 0, 0};
|
|
|
|
shaderSources[1] = defineStr.c_str();
|
|
shaderSources[2] = patchBasisShaderSource.c_str();
|
|
shaderSources[3] = datatoc_glsl_compute_kernel_glsl;
|
|
glShaderSource(shader, 4, shaderSources, NULL);
|
|
glCompileShader(shader);
|
|
glAttachShader(program, shader);
|
|
|
|
GLint linked = 0;
|
|
glLinkProgram(program);
|
|
glGetProgramiv(program, GL_LINK_STATUS, &linked);
|
|
|
|
if (linked == GL_FALSE) {
|
|
char buffer[1024];
|
|
glGetShaderInfoLog(shader, 1024, NULL, buffer);
|
|
OpenSubdiv::Far::Error(OpenSubdiv::Far::FAR_RUNTIME_ERROR, buffer);
|
|
|
|
glGetProgramInfoLog(program, 1024, NULL, buffer);
|
|
OpenSubdiv::Far::Error(OpenSubdiv::Far::FAR_RUNTIME_ERROR, buffer);
|
|
|
|
glDeleteProgram(program);
|
|
return 0;
|
|
}
|
|
|
|
glDeleteShader(shader);
|
|
|
|
return program;
|
|
}
|
|
|
|
bool GLComputeEvaluator::Compile(BufferDescriptor const &srcDesc,
|
|
BufferDescriptor const &dstDesc,
|
|
BufferDescriptor const &duDesc,
|
|
BufferDescriptor const &dvDesc,
|
|
BufferDescriptor const &duuDesc,
|
|
BufferDescriptor const &duvDesc,
|
|
BufferDescriptor const &dvvDesc)
|
|
{
|
|
|
|
// create a stencil kernel
|
|
if (!_stencilKernel.Compile(
|
|
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, _workGroupSize)) {
|
|
return false;
|
|
}
|
|
|
|
// create a patch kernel
|
|
if (!_patchKernel.Compile(
|
|
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, _workGroupSize)) {
|
|
return false;
|
|
}
|
|
|
|
// create a patch arrays buffer
|
|
if (!_patchArraysSSBO) {
|
|
glGenBuffers(1, &_patchArraysSSBO);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* static */
|
|
void GLComputeEvaluator::Synchronize(void * /*kernel*/)
|
|
{
|
|
// XXX: this is currently just for the performance measuring purpose.
|
|
// need to be reimplemented by fence and sync.
|
|
glFinish();
|
|
}
|
|
|
|
int GLComputeEvaluator::GetDispatchSize(int count) const
|
|
{
|
|
return (count + _workGroupSize - 1) / _workGroupSize;
|
|
}
|
|
|
|
void GLComputeEvaluator::DispatchCompute(int totalDispatchSize) const
|
|
{
|
|
int maxWorkGroupCount[2] = {0, 0};
|
|
|
|
glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &maxWorkGroupCount[0]);
|
|
glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &maxWorkGroupCount[1]);
|
|
|
|
const GLuint maxResX = static_cast<GLuint>(maxWorkGroupCount[0]);
|
|
|
|
const int dispatchSize = GetDispatchSize(totalDispatchSize);
|
|
GLuint dispatchRX = static_cast<GLuint>(dispatchSize);
|
|
GLuint dispatchRY = 1u;
|
|
if (dispatchRX > maxResX) {
|
|
/* Since there are some limitations with regards to the maximum work group size (could be as
|
|
* low as 64k elements per call), we split the number elements into a "2d" number, with the
|
|
* final index being computed as `res_x + res_y * max_work_group_size`. Even with a maximum
|
|
* work group size of 64k, that still leaves us with roughly `64k * 64k = 4` billion elements
|
|
* total, which should be enough. If not, we could also use the 3rd dimension. */
|
|
/* TODO(fclem): We could dispatch fewer groups if we compute the prime factorization and
|
|
* get the smallest rect fitting the requirements. */
|
|
dispatchRX = dispatchRY = std::ceil(std::sqrt(dispatchSize));
|
|
/* Avoid a completely empty dispatch line caused by rounding. */
|
|
if ((dispatchRX * (dispatchRY - 1)) >= dispatchSize) {
|
|
dispatchRY -= 1;
|
|
}
|
|
}
|
|
|
|
/* X and Y dimensions may have different limits so the above computation may not be right, but
|
|
* even with the standard 64k minimum on all dimensions we still have a lot of room. Therefore,
|
|
* we presume it all fits. */
|
|
assert(dispatchRY < static_cast<GLuint>(maxWorkGroupCount[1]));
|
|
|
|
glDispatchCompute(dispatchRX, dispatchRY, 1);
|
|
}
|
|
|
|
bool GLComputeEvaluator::EvalStencils(GLuint srcBuffer,
|
|
BufferDescriptor const &srcDesc,
|
|
GLuint dstBuffer,
|
|
BufferDescriptor const &dstDesc,
|
|
GLuint duBuffer,
|
|
BufferDescriptor const &duDesc,
|
|
GLuint dvBuffer,
|
|
BufferDescriptor const &dvDesc,
|
|
GLuint sizesBuffer,
|
|
GLuint offsetsBuffer,
|
|
GLuint indicesBuffer,
|
|
GLuint weightsBuffer,
|
|
GLuint duWeightsBuffer,
|
|
GLuint dvWeightsBuffer,
|
|
int start,
|
|
int end) const
|
|
{
|
|
|
|
return EvalStencils(srcBuffer,
|
|
srcDesc,
|
|
dstBuffer,
|
|
dstDesc,
|
|
duBuffer,
|
|
duDesc,
|
|
dvBuffer,
|
|
dvDesc,
|
|
0,
|
|
BufferDescriptor(),
|
|
0,
|
|
BufferDescriptor(),
|
|
0,
|
|
BufferDescriptor(),
|
|
sizesBuffer,
|
|
offsetsBuffer,
|
|
indicesBuffer,
|
|
weightsBuffer,
|
|
duWeightsBuffer,
|
|
dvWeightsBuffer,
|
|
0,
|
|
0,
|
|
0,
|
|
start,
|
|
end);
|
|
}
|
|
|
|
bool GLComputeEvaluator::EvalStencils(GLuint srcBuffer,
|
|
BufferDescriptor const &srcDesc,
|
|
GLuint dstBuffer,
|
|
BufferDescriptor const &dstDesc,
|
|
GLuint duBuffer,
|
|
BufferDescriptor const &duDesc,
|
|
GLuint dvBuffer,
|
|
BufferDescriptor const &dvDesc,
|
|
GLuint duuBuffer,
|
|
BufferDescriptor const &duuDesc,
|
|
GLuint duvBuffer,
|
|
BufferDescriptor const &duvDesc,
|
|
GLuint dvvBuffer,
|
|
BufferDescriptor const &dvvDesc,
|
|
GLuint sizesBuffer,
|
|
GLuint offsetsBuffer,
|
|
GLuint indicesBuffer,
|
|
GLuint weightsBuffer,
|
|
GLuint duWeightsBuffer,
|
|
GLuint dvWeightsBuffer,
|
|
GLuint duuWeightsBuffer,
|
|
GLuint duvWeightsBuffer,
|
|
GLuint dvvWeightsBuffer,
|
|
int start,
|
|
int end) const
|
|
{
|
|
|
|
if (!_stencilKernel.program)
|
|
return false;
|
|
int count = end - start;
|
|
if (count <= 0) {
|
|
return true;
|
|
}
|
|
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, srcBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, dstBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, duBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, dvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 10, duuBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 11, duvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 12, dvvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, sizesBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, offsetsBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, indicesBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 7, weightsBuffer);
|
|
if (duWeightsBuffer)
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 8, duWeightsBuffer);
|
|
if (dvWeightsBuffer)
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 9, dvWeightsBuffer);
|
|
if (duuWeightsBuffer)
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 13, duuWeightsBuffer);
|
|
if (duvWeightsBuffer)
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 14, duvWeightsBuffer);
|
|
if (dvvWeightsBuffer)
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 15, dvvWeightsBuffer);
|
|
|
|
GLint activeProgram;
|
|
glGetIntegerv(GL_CURRENT_PROGRAM, &activeProgram);
|
|
glUseProgram(_stencilKernel.program);
|
|
|
|
glUniform1i(_stencilKernel.uniformStart, start);
|
|
glUniform1i(_stencilKernel.uniformEnd, end);
|
|
glUniform1i(_stencilKernel.uniformSrcOffset, srcDesc.offset);
|
|
glUniform1i(_stencilKernel.uniformDstOffset, dstDesc.offset);
|
|
if (_stencilKernel.uniformDuDesc > 0) {
|
|
glUniform3i(_stencilKernel.uniformDuDesc, duDesc.offset, duDesc.length, duDesc.stride);
|
|
}
|
|
if (_stencilKernel.uniformDvDesc > 0) {
|
|
glUniform3i(_stencilKernel.uniformDvDesc, dvDesc.offset, dvDesc.length, dvDesc.stride);
|
|
}
|
|
if (_stencilKernel.uniformDuuDesc > 0) {
|
|
glUniform3i(_stencilKernel.uniformDuuDesc, duuDesc.offset, duuDesc.length, duuDesc.stride);
|
|
}
|
|
if (_stencilKernel.uniformDuvDesc > 0) {
|
|
glUniform3i(_stencilKernel.uniformDuvDesc, duvDesc.offset, duvDesc.length, duvDesc.stride);
|
|
}
|
|
if (_stencilKernel.uniformDvvDesc > 0) {
|
|
glUniform3i(_stencilKernel.uniformDvvDesc, dvvDesc.offset, dvvDesc.length, dvvDesc.stride);
|
|
}
|
|
|
|
DispatchCompute(count);
|
|
|
|
glUseProgram(activeProgram);
|
|
|
|
glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
|
|
for (int i = 0; i < 16; ++i) {
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, i, 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GLComputeEvaluator::EvalPatches(GLuint srcBuffer,
|
|
BufferDescriptor const &srcDesc,
|
|
GLuint dstBuffer,
|
|
BufferDescriptor const &dstDesc,
|
|
GLuint duBuffer,
|
|
BufferDescriptor const &duDesc,
|
|
GLuint dvBuffer,
|
|
BufferDescriptor const &dvDesc,
|
|
int numPatchCoords,
|
|
GLuint patchCoordsBuffer,
|
|
const PatchArrayVector &patchArrays,
|
|
GLuint patchIndexBuffer,
|
|
GLuint patchParamsBuffer) const
|
|
{
|
|
|
|
return EvalPatches(srcBuffer,
|
|
srcDesc,
|
|
dstBuffer,
|
|
dstDesc,
|
|
duBuffer,
|
|
duDesc,
|
|
dvBuffer,
|
|
dvDesc,
|
|
0,
|
|
BufferDescriptor(),
|
|
0,
|
|
BufferDescriptor(),
|
|
0,
|
|
BufferDescriptor(),
|
|
numPatchCoords,
|
|
patchCoordsBuffer,
|
|
patchArrays,
|
|
patchIndexBuffer,
|
|
patchParamsBuffer);
|
|
}
|
|
|
|
bool GLComputeEvaluator::EvalPatches(GLuint srcBuffer,
|
|
BufferDescriptor const &srcDesc,
|
|
GLuint dstBuffer,
|
|
BufferDescriptor const &dstDesc,
|
|
GLuint duBuffer,
|
|
BufferDescriptor const &duDesc,
|
|
GLuint dvBuffer,
|
|
BufferDescriptor const &dvDesc,
|
|
GLuint duuBuffer,
|
|
BufferDescriptor const &duuDesc,
|
|
GLuint duvBuffer,
|
|
BufferDescriptor const &duvDesc,
|
|
GLuint dvvBuffer,
|
|
BufferDescriptor const &dvvDesc,
|
|
int numPatchCoords,
|
|
GLuint patchCoordsBuffer,
|
|
const PatchArrayVector &patchArrays,
|
|
GLuint patchIndexBuffer,
|
|
GLuint patchParamsBuffer) const
|
|
{
|
|
|
|
if (!_patchKernel.program)
|
|
return false;
|
|
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, srcBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, dstBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, duBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, dvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 10, duuBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 11, duvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 12, dvvBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, patchCoordsBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, patchIndexBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 7, patchParamsBuffer);
|
|
|
|
GLint activeProgram;
|
|
glGetIntegerv(GL_CURRENT_PROGRAM, &activeProgram);
|
|
glUseProgram(_patchKernel.program);
|
|
|
|
glUniform1i(_patchKernel.uniformSrcOffset, srcDesc.offset);
|
|
glUniform1i(_patchKernel.uniformDstOffset, dstDesc.offset);
|
|
|
|
int patchArraySize = sizeof(PatchArray);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, _patchArraysSSBO);
|
|
glBufferData(
|
|
GL_SHADER_STORAGE_BUFFER, patchArrays.size() * patchArraySize, NULL, GL_STATIC_DRAW);
|
|
for (int i = 0; i < (int)patchArrays.size(); ++i) {
|
|
glBufferSubData(
|
|
GL_SHADER_STORAGE_BUFFER, i * patchArraySize, sizeof(PatchArray), &patchArrays[i]);
|
|
}
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, _patchArraysSSBO);
|
|
|
|
if (_patchKernel.uniformDuDesc > 0) {
|
|
glUniform3i(_patchKernel.uniformDuDesc, duDesc.offset, duDesc.length, duDesc.stride);
|
|
}
|
|
if (_patchKernel.uniformDvDesc > 0) {
|
|
glUniform3i(_patchKernel.uniformDvDesc, dvDesc.offset, dvDesc.length, dvDesc.stride);
|
|
}
|
|
if (_patchKernel.uniformDuuDesc > 0) {
|
|
glUniform3i(_patchKernel.uniformDuuDesc, duuDesc.offset, duuDesc.length, duuDesc.stride);
|
|
}
|
|
if (_patchKernel.uniformDuvDesc > 0) {
|
|
glUniform3i(_patchKernel.uniformDuvDesc, duvDesc.offset, duvDesc.length, duvDesc.stride);
|
|
}
|
|
if (_patchKernel.uniformDvvDesc > 0) {
|
|
glUniform3i(_patchKernel.uniformDvvDesc, dvvDesc.offset, dvvDesc.length, dvvDesc.stride);
|
|
}
|
|
|
|
DispatchCompute(numPatchCoords);
|
|
|
|
glUseProgram(activeProgram);
|
|
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, 0);
|
|
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 10, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 11, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 12, 0);
|
|
|
|
return true;
|
|
}
|
|
// ---------------------------------------------------------------------------
|
|
|
|
GLComputeEvaluator::_StencilKernel::_StencilKernel() : program(0)
|
|
{
|
|
}
|
|
GLComputeEvaluator::_StencilKernel::~_StencilKernel()
|
|
{
|
|
if (program) {
|
|
glDeleteProgram(program);
|
|
}
|
|
}
|
|
|
|
bool GLComputeEvaluator::_StencilKernel::Compile(BufferDescriptor const &srcDesc,
|
|
BufferDescriptor const &dstDesc,
|
|
BufferDescriptor const &duDesc,
|
|
BufferDescriptor const &dvDesc,
|
|
BufferDescriptor const &duuDesc,
|
|
BufferDescriptor const &duvDesc,
|
|
BufferDescriptor const &dvvDesc,
|
|
int workGroupSize)
|
|
{
|
|
// create stencil kernel
|
|
if (program) {
|
|
glDeleteProgram(program);
|
|
}
|
|
|
|
const char *kernelDefine = "#define OPENSUBDIV_GLSL_COMPUTE_KERNEL_EVAL_STENCILS\n";
|
|
|
|
program = compileKernel(
|
|
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, kernelDefine, workGroupSize);
|
|
if (program == 0)
|
|
return false;
|
|
|
|
// cache uniform locations (TODO: use uniform block)
|
|
uniformStart = glGetUniformLocation(program, "batchStart");
|
|
uniformEnd = glGetUniformLocation(program, "batchEnd");
|
|
uniformSrcOffset = glGetUniformLocation(program, "srcOffset");
|
|
uniformDstOffset = glGetUniformLocation(program, "dstOffset");
|
|
uniformDuDesc = glGetUniformLocation(program, "duDesc");
|
|
uniformDvDesc = glGetUniformLocation(program, "dvDesc");
|
|
uniformDuuDesc = glGetUniformLocation(program, "duuDesc");
|
|
uniformDuvDesc = glGetUniformLocation(program, "duvDesc");
|
|
uniformDvvDesc = glGetUniformLocation(program, "dvvDesc");
|
|
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
GLComputeEvaluator::_PatchKernel::_PatchKernel() : program(0)
|
|
{
|
|
}
|
|
GLComputeEvaluator::_PatchKernel::~_PatchKernel()
|
|
{
|
|
if (program) {
|
|
glDeleteProgram(program);
|
|
}
|
|
}
|
|
|
|
bool GLComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
|
|
BufferDescriptor const &dstDesc,
|
|
BufferDescriptor const &duDesc,
|
|
BufferDescriptor const &dvDesc,
|
|
BufferDescriptor const &duuDesc,
|
|
BufferDescriptor const &duvDesc,
|
|
BufferDescriptor const &dvvDesc,
|
|
int workGroupSize)
|
|
{
|
|
// create stencil kernel
|
|
if (program) {
|
|
glDeleteProgram(program);
|
|
}
|
|
|
|
const char *kernelDefine = "#define OPENSUBDIV_GLSL_COMPUTE_KERNEL_EVAL_PATCHES\n";
|
|
|
|
program = compileKernel(
|
|
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, kernelDefine, workGroupSize);
|
|
if (program == 0)
|
|
return false;
|
|
|
|
// cache uniform locations
|
|
uniformSrcOffset = glGetUniformLocation(program, "srcOffset");
|
|
uniformDstOffset = glGetUniformLocation(program, "dstOffset");
|
|
uniformPatchArray = glGetUniformLocation(program, "patchArray");
|
|
uniformDuDesc = glGetUniformLocation(program, "duDesc");
|
|
uniformDvDesc = glGetUniformLocation(program, "dvDesc");
|
|
uniformDuuDesc = glGetUniformLocation(program, "duuDesc");
|
|
uniformDuvDesc = glGetUniformLocation(program, "duvDesc");
|
|
uniformDvvDesc = glGetUniformLocation(program, "dvvDesc");
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace opensubdiv
|
|
} // namespace blender
|