HdStGLSLProgramSharedPtr
HdStGLSLProgram::GetComputeProgram(
TfToken const &shaderToken,
HdStResourceRegistry *resourceRegistry)
{
// Find the program from registry
HdInstance<HdStGLSLProgram::ID, HdStGLSLProgramSharedPtr> programInstance;
std::unique_lock<std::mutex> regLock =
resourceRegistry->RegisterGLSLProgram(
HdStGLSLProgram::ComputeHash(shaderToken), &programInstance);
if (programInstance.IsFirstInstance()) {
// if not exists, create new one
HdStGLSLProgramSharedPtr newProgram(
new HdStGLSLProgram(HdTokens->computeShader));
GlfGLSLFX glslfx(HdStPackageComputeShader());
std::string version = "#version 430\n";
if (!newProgram->CompileShader(
GL_COMPUTE_SHADER, version + glslfx.GetSource(shaderToken))) {
TF_CODING_ERROR("Fail to compile " + shaderToken.GetString());
return HdStGLSLProgramSharedPtr();
}
if (!newProgram->Link()) {
TF_CODING_ERROR("Fail to link " + shaderToken.GetString());
return HdStGLSLProgramSharedPtr();
}
programInstance.SetValue(newProgram);
}
return programInstance.GetValue();
}
bool
HdxColorCorrectionTask::_CreateShaderResources()
{
if (_shaderProgram) {
return true;
}
// Client can choose to use Hydra's build-in sRGB color correction or use
// OpenColorIO for color correction in which case we insert extra OCIO code.
#ifdef PXR_OCIO_PLUGIN_ENABLED
bool useOCIO =
_colorCorrectionMode == HdxColorCorrectionTokens->openColorIO;
#else
bool useOCIO = false;
#endif
_shaderProgram.reset(new HdStGLSLProgram(_tokens->colorCorrectionShader));
HioGlslfx glslfx(HdxPackageColorCorrectionShader());
std::string fragCode = "#version 120\n";
if (useOCIO) {
fragCode += "#define GLSLFX_USE_OCIO\n";
}
fragCode += glslfx.GetSource(_tokens->colorCorrectionFragment);
if (useOCIO) {
std::string ocioGpuShaderText = _CreateOpenColorIOResources();
fragCode += ocioGpuShaderText;
}
if (!_shaderProgram->CompileShader(GL_VERTEX_SHADER,
glslfx.GetSource(_tokens->colorCorrectionVertex)) ||
!_shaderProgram->CompileShader(GL_FRAGMENT_SHADER, fragCode) ||
!_shaderProgram->Link()) {
TF_CODING_ERROR("Failed to load color correction shader");
_shaderProgram.reset();
return false;
}
GLuint programId = _shaderProgram->GetProgram().GetId();
_locations[COLOR_IN] = glGetUniformLocation(programId, "colorIn");
_locations[POSITION] = glGetAttribLocation(programId, "position");
_locations[UV_IN] = glGetAttribLocation(programId, "uvIn");
if (useOCIO) {
_locations[LUT3D_IN] = glGetUniformLocation(programId, "LUT3dIn");
}
GLF_POST_PENDING_GL_ERRORS();
return true;
}
HdSprim *
HdStreamRenderDelegate::_CreateFallbackShaderPrim()
{
GlfGLSLFXSharedPtr glslfx(new GlfGLSLFX(HdPackageFallbackSurfaceShader()));
HdSurfaceShaderSharedPtr fallbackShaderCode(new HdGLSLFXShader(glslfx));
HdStShader *shader = new HdStShader(SdfPath::EmptyPath());
shader->SetSurfaceShader(fallbackShaderCode);
return shader;
}
void
HdxCompositor::_CreateShaderResources(bool useDepthProgram)
{
_compositorProgram.reset(new HdStGLSLProgram(_tokens->fullscreenShader));
GlfGLSLFX glslfx(HdxPackageFullscreenShader());
TfToken fsToken = useDepthProgram ? _tokens->compositeFragmentWithDepth
: _tokens->compositeFragmentNoDepth;
if (!_compositorProgram->CompileShader(GL_VERTEX_SHADER,
glslfx.GetSource(_tokens->fullscreenVertex)) ||
!_compositorProgram->CompileShader(GL_FRAGMENT_SHADER,
glslfx.GetSource(fsToken)) ||
!_compositorProgram->Link()) {
TF_CODING_ERROR("Failed to load compositing shader");
_compositorProgram.reset();
return;
}
GLuint programId = _compositorProgram->GetProgram().GetId();
_locations[colorIn] = glGetUniformLocation(programId, "colorIn");
_locations[depthIn] = glGetUniformLocation(programId, "depthIn");
_locations[position] = glGetAttribLocation(programId, "position");
_locations[uvIn] = glGetAttribLocation(programId, "uvIn");
_locations[remapDepthIn] = glGetUniformLocation(programId, "remapDepthIn");
}
