Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
C++ 3d3d-sculptingcppdear-imguidigital-sculptingfbxgame-developmentgaussian-splattinggltfimage-to-3dmcpopenglopenusdsculptingtext-to-3dunreal-engine
// SculptForge - open source digital sculpting
// SPDX-License-Identifier: GPL-3.0-or-later
#include "render/UvView.h"
#include <glm/gtc/type_ptr.hpp>
#include <algorithm>
namespace sf {
namespace {
constexpr GLenum kViewport = 0x0BA2; // GL_VIEWPORT
constexpr GLenum kFramebufferBinding = 0x8CA6; // GL_FRAMEBUFFER_BINDING
constexpr GLenum kRepeat = 0x2901; // GL_REPEAT
// A full-view quad: the tile grid, the checker or the texture.
const char* kBgVS = R"(#version 330 core
uniform vec2 uMin, uMax;
out vec2 vUv;
void main() {
vec2 p = vec2(float(gl_VertexID & 1), float(gl_VertexID >> 1));
vUv = mix(uMin, uMax, p);
gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
}
)";
const char* kBgFS = R"(#version 330 core
in vec2 vUv;
out vec4 fragColor;
uniform int uMode; // 0 nothing, 1 checker, 2 texture
uniform sampler2D uImage; // sRGB: samples come back linear
uniform float uOpacity;
uniform float uChecker; // squares per UV unit
uniform vec2 uPixel; // UV units per pixel
uniform ivec2 uTiles; // UDIM tiles in use (columns, rows)
// Distance in pixels to the nearest line of a grid with `step` UV units.
float gridDist(vec2 uv, float step) {
vec2 d = abs(fract(uv / step + 0.5) - 0.5) * step / uPixel;
return min(d.x, d.y);
}
void main() {
vec2 tile = floor(vUv);
bool used = tile.x >= 0.0 && tile.y >= 0.0 && tile.x < float(uTiles.x) && tile.y < float(uTiles.y);
bool home = tile.x == 0.0 && tile.y == 0.0;
vec3 c = vec3(0.098, 0.098, 0.106);
if (used) c = vec3(0.137, 0.137, 0.149);
if (home) c = vec3(0.157, 0.157, 0.172);
if (uMode == 1 && used) {
vec2 cell = floor(vUv * uChecker);
float odd = mod(cell.x + cell.y, 2.0);
c = mix(c, mix(vec3(0.62), vec3(0.30), odd), uOpacity);
} else if (uMode == 2 && home) {
c = mix(c, pow(texture(uImage, vUv).rgb, vec3(1.0 / 2.2)), uOpacity);
}
// Tenths inside tiles (fading out when they get too close), tile borders on top.
float tenthsPx = 0.1 / max(uPixel.x, 1e-9);
float fine = (1.0 - smoothstep(0.0, 1.0, gridDist(vUv, 0.1))) * smoothstep(6.0, 18.0, tenthsPx);
float border = 1.0 - smoothstep(0.5, 1.5, gridDist(vUv, 1.0));
c = mix(c, vec3(0.30, 0.30, 0.34), fine * (used ? 0.55 : 0.25));
c = mix(c, used ? vec3(0.50, 0.50, 0.56) : vec3(0.26, 0.26, 0.29), border);
fragColor = vec4(c, 1.0);
}
)";
// Triangles (fill) and lines (edges) of the UV layout.
const char* kMeshVS = R"(#version 330 core
layout(location = 0) in vec2 aUv;
layout(location = 1) in vec4 aFace;
layout(location = 2) in vec4 aEdge;
layout(location = 3) in float aMove;
uniform vec2 uMin, uMax;
uniform mat3 uMove;
uniform int uLines;
flat out vec4 vColor;
void main() {
vec2 p = aUv;
if (aMove > 0.5) p = (uMove * vec3(p, 1.0)).xy;
gl_Position = vec4((p - uMin) / (uMax - uMin) * 2.0 - 1.0, 0.0, 1.0);
vColor = uLines == 1 ? aEdge : aFace;
}
)";
const char* kMeshFS = R"(#version 330 core
flat in vec4 vColor;
out vec4 fragColor;
void main() { fragColor = vColor; }
)";
GLuint compileShader(GLenum type, const char* src, std::string& error) {
GLuint s = gl::CreateShader(type);
gl::ShaderSource(s, 1, &src, nullptr);
gl::CompileShader(s);
GLint ok = 0;
gl::GetShaderiv(s, GL_COMPILE_STATUS, &ok);
if (!ok) {
char log[1024];
gl::GetShaderInfoLog(s, sizeof log, nullptr, log);
error = std::string("UV view shader: ") + log;
gl::DeleteShader(s);
return 0;
}
return s;
}
GLuint linkProgram(const char* vs, const char* fs, std::string& error) {
const GLuint v = compileShader(GL_VERTEX_SHADER, vs, error);
if (!v) return 0;
const GLuint f = compileShader(GL_FRAGMENT_SHADER, fs, error);
if (!f) {
gl::DeleteShader(v);
return 0;
}
GLuint p = gl::CreateProgram();
gl::AttachShader(p, v);
gl::AttachShader(p, f);
gl::LinkProgram(p);
gl::DeleteShader(v);
gl::DeleteShader(f);
GLint ok = 0;
gl::GetProgramiv(p, GL_LINK_STATUS, &ok);
if (!ok) {
error = "UV view shader: link failed";
gl::DeleteProgram(p);
return 0;
}
return p;
}
} // namespace
bool UvViewRenderer::init(std::string& error) {
if (meshProgram_) return true;
bgProgram_ = linkProgram(kBgVS, kBgFS, error);
meshProgram_ = bgProgram_ ? linkProgram(kMeshVS, kMeshFS, error) : 0;
if (!meshProgram_) return false;
auto at = [](GLuint p, const char* n) { return gl::GetUniformLocation(p, n); };
bgMin_ = at(bgProgram_, "uMin"), bgMax_ = at(bgProgram_, "uMax"), bgMode_ = at(bgProgram_, "uMode");
bgImage_ = at(bgProgram_, "uImage"), bgOpacity_ = at(bgProgram_, "uOpacity"), bgChecker_ = at(bgProgram_, "uChecker");
bgPixel_ = at(bgProgram_, "uPixel"), bgTiles_ = at(bgProgram_, "uTiles");
mMin_ = at(meshProgram_, "uMin"), mMax_ = at(meshProgram_, "uMax"), mMove_ = at(meshProgram_, "uMove");
mLines_ = at(meshProgram_, "uLines");
gl::GenVertexArrays(1, &vao_);
gl::GenVertexArrays(1, &emptyVao_);
GLuint buffers[5];
gl::GenBuffers(5, buffers);
uvBuffer_ = buffers[0], faceBuffer_ = buffers[1], edgeBuffer_ = buffers[2], moveBuffer_ = buffers[3], indexBuffer_ = buffers[4];
gl::BindVertexArray(vao_);
gl::BindBuffer(GL_ARRAY_BUFFER, uvBuffer_);
gl::EnableVertexAttribArray(0);
gl::VertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
gl::BindBuffer(GL_ARRAY_BUFFER, faceBuffer_);
gl::EnableVertexAttribArray(1);
gl::VertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
gl::BindBuffer(GL_ARRAY_BUFFER, edgeBuffer_);
gl::EnableVertexAttribArray(2);
gl::VertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
gl::BindBuffer(GL_ARRAY_BUFFER, moveBuffer_);
gl::EnableVertexAttribArray(3);
gl::VertexAttribPointer(3, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, nullptr);
gl::BindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer_);
gl::BindVertexArray(0);
gl::BindBuffer(GL_ARRAY_BUFFER, 0);
return true;
}
void UvViewRenderer::shutdown() {
if (!meshProgram_) return;
gl::DeleteProgram(bgProgram_);
gl::DeleteProgram(meshProgram_);
const GLuint buffers[5] = {uvBuffer_, faceBuffer_, edgeBuffer_, moveBuffer_, indexBuffer_};
gl::DeleteBuffers(5, buffers);
gl::DeleteVertexArrays(1, &vao_);
gl::DeleteVertexArrays(1, &emptyVao_);
if (fbo_) gl::DeleteFramebuffers(1, &fbo_);
if (msFbo_) gl::DeleteFramebuffers(1, &msFbo_);
if (msColor_) gl::DeleteRenderbuffers(1, &msColor_);
if (texture_) gl::DeleteTextures(1, &texture_);
*this = UvViewRenderer();
}
void UvViewRenderer::setUvs(const std::vector<glm::vec2>& uvs) {
if (!meshProgram_) return;
if (uvs.size() != corners_) colorsValid_ = false;
corners_ = uvs.size();
gl::BindBuffer(GL_ARRAY_BUFFER, uvBuffer_);
gl::BufferData(GL_ARRAY_BUFFER, GLsizeiptr(uvs.size() * sizeof(glm::vec2)), uvs.empty() ? nullptr : uvs.data(), GL_DYNAMIC_DRAW);
gl::BindBuffer(GL_ARRAY_BUFFER, 0);
}
void UvViewRenderer::setColors(const std::vector<uint32_t>& face, const std::vector<uint32_t>& edge, const std::vector<uint8_t>& moving) {
if (!meshProgram_) return;
colorsValid_ = face.size() == corners_ && edge.size() == corners_ && moving.size() == corners_;
if (!colorsValid_) return;
gl::BindBuffer(GL_ARRAY_BUFFER, faceBuffer_);
gl::BufferData(GL_ARRAY_BUFFER, GLsizeiptr(face.size() * 4), face.data(), GL_DYNAMIC_DRAW);
gl::BindBuffer(GL_ARRAY_BUFFER, edgeBuffer_);
gl::BufferData(GL_ARRAY_BUFFER, GLsizeiptr(edge.size() * 4), edge.data(), GL_DYNAMIC_DRAW);
gl::BindBuffer(GL_ARRAY_BUFFER, moveBuffer_);
gl::BufferData(GL_ARRAY_BUFFER, GLsizeiptr(moving.size()), moving.data(), GL_DYNAMIC_DRAW);
gl::BindBuffer(GL_ARRAY_BUFFER, 0);
}
void UvViewRenderer::setEdges(const std::vector<uint32_t>& corners) {
if (!meshProgram_) return;
// Each line as (next corner, corner): the last vertex is the provoking one, so the edge takes the colour of
// the corner it starts at.
std::vector<uint32_t> idx(corners.size() * 2);
for (size_t i = 0; i < corners.size(); ++i) {
const uint32_t c = corners[i];
idx[i * 2] = c - c % 3 + (c % 3 + 1) % 3;
idx[i * 2 + 1] = c;
}
edgeCount_ = corners.size();
gl::BindVertexArray(vao_);
gl::BufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(idx.size() * sizeof(uint32_t)), idx.empty() ? nullptr : idx.data(), GL_DYNAMIC_DRAW);
gl::BindVertexArray(0);
}
bool UvViewRenderer::ensureTarget(int w, int h) {
if (w == width_ && h == height_ && fbo_) return true;
if (!fbo_) {
gl::GenFramebuffers(1, &fbo_);
gl::GenFramebuffers(1, &msFbo_);
gl::GenRenderbuffers(1, &msColor_);
gl::GenTextures(1, &texture_);
}
GLint maxSamples = 0;
gl::GetIntegerv(GL_MAX_SAMPLES, &maxSamples);
samples_ = std::clamp(maxSamples, 1, 4);
gl::BindRenderbuffer(GL_RENDERBUFFER, msColor_);
gl::RenderbufferStorageMultisample(GL_RENDERBUFFER, samples_, GL_RGBA8, w, h);
gl::BindRenderbuffer(GL_RENDERBUFFER, 0);
gl::BindFramebuffer(GL_FRAMEBUFFER, msFbo_);
gl::FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, msColor_);
const bool msOk = gl::CheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
gl::BindTexture(GL_TEXTURE_2D, texture_);
gl::TexImage2D(GL_TEXTURE_2D, 0, GLint(GL_RGBA8), w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl::BindTexture(GL_TEXTURE_2D, 0);
gl::BindFramebuffer(GL_FRAMEBUFFER, fbo_);
gl::FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_, 0);
const bool ok = gl::CheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
if (!msOk) samples_ = 0; // draw straight into the texture
width_ = w, height_ = h;
return ok;
}
GLuint UvViewRenderer::draw(int w, int h, const View& v) {
if (!meshProgram_ || w <= 0 || h <= 0) return 0;
GLint oldFbo = 0, oldViewport[4] = {0, 0, 0, 0};
gl::GetIntegerv(kFramebufferBinding, &oldFbo);
gl::GetIntegerv(kViewport, oldViewport);
if (!ensureTarget(w, h)) {
gl::BindFramebuffer(GL_FRAMEBUFFER, GLuint(oldFbo));
return 0;
}
gl::BindFramebuffer(GL_FRAMEBUFFER, samples_ > 0 ? msFbo_ : fbo_);
gl::Viewport(0, 0, w, h);
gl::Disable(GL_DEPTH_TEST);
gl::Disable(GL_CULL_FACE);
gl::Disable(GL_SCISSOR_TEST);
gl::ClearColor(0.098f, 0.098f, 0.106f, 1.0f);
gl::Clear(GL_COLOR_BUFFER_BIT);
// Background.
gl::UseProgram(bgProgram_);
gl::Uniform2f(bgMin_, v.min.x, v.min.y);
gl::Uniform2f(bgMax_, v.max.x, v.max.y);
gl::Uniform1i(bgMode_, v.imageMode == 2 && !v.image ? 0 : v.imageMode);
gl::Uniform1f(bgOpacity_, v.imageOpacity);
gl::Uniform1f(bgChecker_, v.checkerScale);
gl::Uniform2f(bgPixel_, (v.max.x - v.min.x) / float(w), (v.max.y - v.min.y) / float(h));
gl::Uniform2i(bgTiles_, std::max(v.tiles.x, 1), std::max(v.tiles.y, 1));
gl::Uniform1i(bgImage_, 0);
gl::ActiveTexture(GL_TEXTURE0);
gl::BindTexture(GL_TEXTURE_2D, v.image);
if (v.image) {
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GLint(kRepeat));
gl::TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GLint(kRepeat));
}
gl::BindVertexArray(emptyVao_);
gl::DrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl::BindTexture(GL_TEXTURE_2D, 0);
// The layout.
if (corners_ && colorsValid_) {
gl::Enable(GL_BLEND);
gl::BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
gl::UseProgram(meshProgram_);
gl::Uniform2f(mMin_, v.min.x, v.min.y);
gl::Uniform2f(mMax_, v.max.x, v.max.y);
gl::UniformMatrix3fv(mMove_, 1, GL_FALSE, glm::value_ptr(v.move));
gl::BindVertexArray(vao_);
if (v.fill) {
gl::Uniform1i(mLines_, 0);
gl::DrawArrays(GL_TRIANGLES, 0, GLsizei(corners_));
}
if (v.edges && edgeCount_) {
gl::Uniform1i(mLines_, 1);
gl::DrawElements(GL_LINES, GLsizei(edgeCount_ * 2), GL_UNSIGNED_INT, nullptr);
}
gl::BindVertexArray(0);
gl::Disable(GL_BLEND);
}
gl::UseProgram(0);
if (samples_ > 0) {
gl::BindFramebuffer(GL_READ_FRAMEBUFFER, msFbo_);
gl::BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_);
gl::BlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
gl::BindFramebuffer(GL_FRAMEBUFFER, GLuint(oldFbo));
gl::Viewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
return texture_;
}
} // namespace sf