blob: 40253420a3ec2a63472bd8ac4743bc7c7506acf8 [file] [log] [blame] [edit]
// Copyright 2017 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "dawn/native/opengl/PipelineGL.h"
#include <algorithm>
#include <set>
#include <sstream>
#include <string>
#include "dawn/common/BitSetIterator.h"
#include "dawn/native/BindGroupLayoutInternal.h"
#include "dawn/native/Device.h"
#include "dawn/native/Pipeline.h"
#include "dawn/native/opengl/BufferGL.h"
#include "dawn/native/opengl/Forward.h"
#include "dawn/native/opengl/OpenGLFunctions.h"
#include "dawn/native/opengl/PipelineLayoutGL.h"
#include "dawn/native/opengl/SamplerGL.h"
#include "dawn/native/opengl/ShaderModuleGL.h"
#include "dawn/native/opengl/TextureGL.h"
namespace dawn::native::opengl {
PipelineGL::PipelineGL() : mProgram(0) {}
PipelineGL::~PipelineGL() = default;
MaybeError PipelineGL::InitializeBase(const OpenGLFunctions& gl,
const PipelineLayout* layout,
const PerStage<ProgrammableStage>& stages,
bool usesVertexIndex,
bool usesInstanceIndex,
bool usesFragDepth) {
mProgram = gl.CreateProgram();
// Compute the set of active stages.
wgpu::ShaderStage activeStages = wgpu::ShaderStage::None;
for (SingleShaderStage stage : IterateStages(kAllStages)) {
if (stages[stage].module != nullptr) {
activeStages |= StageBit(stage);
}
}
// Create an OpenGL shader for each stage and gather the list of combined samplers.
PerStage<CombinedSamplerInfo> combinedSamplers;
bool needsPlaceholderSampler = false;
std::vector<GLuint> glShaders;
for (SingleShaderStage stage : IterateStages(activeStages)) {
const ShaderModule* module = ToBackend(stages[stage].module.Get());
GLuint shader;
DAWN_TRY_ASSIGN(
shader, module->CompileShader(
gl, stages[stage], stage, usesVertexIndex, usesInstanceIndex, usesFragDepth,
&combinedSamplers[stage], layout, &needsPlaceholderSampler,
&mNeedsTextureBuiltinUniformBuffer, &mBindingPointEmulatedBuiltins));
gl.AttachShader(mProgram, shader);
glShaders.push_back(shader);
}
if (needsPlaceholderSampler) {
SamplerDescriptor desc = {};
DAWN_ASSERT(desc.minFilter == wgpu::FilterMode::Nearest);
DAWN_ASSERT(desc.magFilter == wgpu::FilterMode::Nearest);
DAWN_ASSERT(desc.mipmapFilter == wgpu::MipmapFilterMode::Nearest);
Ref<SamplerBase> sampler;
DAWN_TRY_ASSIGN(sampler, layout->GetDevice()->GetOrCreateSampler(&desc));
mPlaceholderSampler = ToBackend(std::move(sampler));
}
if (!mBindingPointEmulatedBuiltins.empty()) {
BufferDescriptor desc = {};
desc.size = mBindingPointEmulatedBuiltins.size() * sizeof(uint32_t);
desc.usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst;
Ref<BufferBase> buffer;
DAWN_TRY_ASSIGN(buffer, layout->GetDevice()->CreateBuffer(&desc));
mTextureBuiltinsBuffer = ToBackend(std::move(buffer));
}
// Link all the shaders together.
gl.LinkProgram(mProgram);
GLint linkStatus = GL_FALSE;
gl.GetProgramiv(mProgram, GL_LINK_STATUS, &linkStatus);
if (linkStatus == GL_FALSE) {
GLint infoLogLength = 0;
gl.GetProgramiv(mProgram, GL_INFO_LOG_LENGTH, &infoLogLength);
if (infoLogLength > 1) {
std::vector<char> buffer(infoLogLength);
gl.GetProgramInfoLog(mProgram, infoLogLength, nullptr, &buffer[0]);
return DAWN_VALIDATION_ERROR("Program link failed:\n%s", buffer.data());
}
}
// Compute links between stages for combined samplers, then bind them to texture units
gl.UseProgram(mProgram);
const auto& indices = layout->GetBindingIndexInfo();
std::set<CombinedSampler> combinedSamplersSet;
for (SingleShaderStage stage : IterateStages(activeStages)) {
for (const CombinedSampler& combined : combinedSamplers[stage]) {
combinedSamplersSet.insert(combined);
}
}
mUnitsForSamplers.resize(layout->GetNumSamplers());
mUnitsForTextures.resize(layout->GetNumSampledTextures());
GLuint textureUnit = layout->GetTextureUnitsUsed();
for (const auto& combined : combinedSamplersSet) {
const std::string& name = combined.GetName();
GLint location = gl.GetUniformLocation(mProgram, name.c_str());
if (location == -1) {
continue;
}
gl.Uniform1i(location, textureUnit);
bool shouldUseFiltering;
{
const BindGroupLayoutInternalBase* bgl =
layout->GetBindGroupLayout(combined.textureLocation.group);
BindingIndex bindingIndex = bgl->GetBindingIndex(combined.textureLocation.binding);
GLuint textureIndex = indices[combined.textureLocation.group][bindingIndex];
mUnitsForTextures[textureIndex].push_back(textureUnit);
const auto& bindingLayout = bgl->GetBindingInfo(bindingIndex).bindingLayout;
shouldUseFiltering = std::get<TextureBindingInfo>(bindingLayout).sampleType ==
wgpu::TextureSampleType::Float;
}
{
if (combined.usePlaceholderSampler) {
mPlaceholderSamplerUnits.push_back(textureUnit);
} else {
const BindGroupLayoutInternalBase* bgl =
layout->GetBindGroupLayout(combined.samplerLocation.group);
BindingIndex bindingIndex = bgl->GetBindingIndex(combined.samplerLocation.binding);
GLuint samplerIndex = indices[combined.samplerLocation.group][bindingIndex];
mUnitsForSamplers[samplerIndex].push_back({textureUnit, shouldUseFiltering});
}
}
textureUnit++;
}
for (GLuint glShader : glShaders) {
gl.DetachShader(mProgram, glShader);
gl.DeleteShader(glShader);
}
mInternalUniformBufferBinding = layout->GetInternalUniformBinding();
return {};
}
void PipelineGL::DeleteProgram(const OpenGLFunctions& gl) {
gl.DeleteProgram(mProgram);
}
const std::vector<PipelineGL::SamplerUnit>& PipelineGL::GetTextureUnitsForSampler(
GLuint index) const {
DAWN_ASSERT(index < mUnitsForSamplers.size());
return mUnitsForSamplers[index];
}
const std::vector<GLuint>& PipelineGL::GetTextureUnitsForTextureView(GLuint index) const {
DAWN_ASSERT(index < mUnitsForTextures.size());
return mUnitsForTextures[index];
}
GLuint PipelineGL::GetProgramHandle() const {
return mProgram;
}
void PipelineGL::ApplyNow(const OpenGLFunctions& gl) {
gl.UseProgram(mProgram);
for (GLuint unit : mPlaceholderSamplerUnits) {
DAWN_ASSERT(mPlaceholderSampler.Get() != nullptr);
gl.BindSampler(unit, mPlaceholderSampler->GetNonFilteringHandle());
}
if (mTextureBuiltinsBuffer.Get() != nullptr) {
gl.BindBufferBase(GL_UNIFORM_BUFFER, mInternalUniformBufferBinding,
mTextureBuiltinsBuffer->GetHandle());
}
}
const Buffer* PipelineGL::GetInternalUniformBuffer() const {
return mTextureBuiltinsBuffer.Get();
}
const BindingPointToFunctionAndOffset& PipelineGL::GetBindingPointBuiltinDataInfo() const {
return mBindingPointEmulatedBuiltins;
}
} // namespace dawn::native::opengl