godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-19 14:31:59 +00:00
Code Releases Wiki Activity

msdfgen: Update to 1.12

Browse Source
This commit is contained in:
Rémi Verschelde
2025-01-09 21:16:08 +01:00
parent 24d74510e5
commit c97c7b73e6
41 changed files with 1038 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
thirdparty/msdfgen/core/render-sdf.cpp vendored
View File

@@ -2,89 +2,175 @@
#include "render-sdf.h"
#include "arithmetics.hpp"
#include "DistanceMapping.h"
#include "pixel-conversion.hpp"
#include "bitmap-interpolation.hpp"
namespace msdfgen {
static float distVal(float dist, double pxRange, float midValue) {
if (!pxRange)
return (float) (dist > midValue);
return (float) clamp((dist-midValue)*pxRange+.5);
static float distVal(float dist, DistanceMapping mapping) {
return (float) clamp(mapping(dist)+.5);
}
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 1> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 1> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(sd, pxRange, midValue);
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = float(sd >= sdThreshold);
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(sd+sdBias, distanceMapping);
}
}
}
}
void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 1> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 1> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
float v = distVal(sd, pxRange, midValue);
output(x, y)[0] = v;
output(x, y)[1] = v;
output(x, y)[2] = v;
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
float v = float(sd >= sdThreshold);
output(x, y)[0] = v;
output(x, y)[1] = v;
output(x, y)[2] = v;
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd;
interpolate(&sd, sdf, scale*Point2(x+.5, y+.5));
float v = distVal(sd+sdBias, distanceMapping);
output(x, y)[0] = v;
output(x, y)[1] = v;
output(x, y)[2] = v;
}
}
}
}
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 3> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 3> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(median(sd[0], sd[1], sd[2]), pxRange, midValue);
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = float(median(sd[0], sd[1], sd[2]) >= sdThreshold);
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(median(sd[0], sd[1], sd[2])+sdBias, distanceMapping);
}
}
}
}
void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 3> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 3> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = distVal(sd[0], pxRange, midValue);
output(x, y)[1] = distVal(sd[1], pxRange, midValue);
output(x, y)[2] = distVal(sd[2], pxRange, midValue);
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = float(sd[0] >= sdThreshold);
output(x, y)[1] = float(sd[1] >= sdThreshold);
output(x, y)[2] = float(sd[2] >= sdThreshold);
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[3];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = distVal(sd[0]+sdBias, distanceMapping);
output(x, y)[1] = distVal(sd[1]+sdBias, distanceMapping);
output(x, y)[2] = distVal(sd[2]+sdBias, distanceMapping);
}
}
}
}
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 4> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 4> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(median(sd[0], sd[1], sd[2]), pxRange, midValue);
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = float(median(sd[0], sd[1], sd[2]) >= sdThreshold);
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
*output(x, y) = distVal(median(sd[0], sd[1], sd[2])+sdBias, distanceMapping);
}
}
}
}
void renderSDF(const BitmapRef<float, 4> &output, const BitmapConstRef<float, 4> &sdf, double pxRange, float midValue) {
void renderSDF(const BitmapRef<float, 4> &output, const BitmapConstRef<float, 4> &sdf, Range sdfPxRange, float sdThreshold) {
Vector2 scale((double) sdf.width/output.width, (double) sdf.height/output.height);
pxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
for (int y = 0; y < output.height; ++y)
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = distVal(sd[0], pxRange, midValue);
output(x, y)[1] = distVal(sd[1], pxRange, midValue);
output(x, y)[2] = distVal(sd[2], pxRange, midValue);
output(x, y)[3] = distVal(sd[3], pxRange, midValue);
if (sdfPxRange.lower == sdfPxRange.upper) {
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = float(sd[0] >= sdThreshold);
output(x, y)[1] = float(sd[1] >= sdThreshold);
output(x, y)[2] = float(sd[2] >= sdThreshold);
output(x, y)[3] = float(sd[3] >= sdThreshold);
}
}
} else {
sdfPxRange *= (double) (output.width+output.height)/(sdf.width+sdf.height);
DistanceMapping distanceMapping = DistanceMapping::inverse(sdfPxRange);
float sdBias = .5f-sdThreshold;
for (int y = 0; y < output.height; ++y) {
for (int x = 0; x < output.width; ++x) {
float sd[4];
interpolate(sd, sdf, scale*Point2(x+.5, y+.5));
output(x, y)[0] = distVal(sd[0]+sdBias, distanceMapping);
output(x, y)[1] = distVal(sd[1]+sdBias, distanceMapping);
output(x, y)[2] = distVal(sd[2]+sdBias, distanceMapping);
output(x, y)[3] = distVal(sd[3]+sdBias, distanceMapping);
}
}
}
}
void simulate8bit(const BitmapRef<float, 1> &bitmap) {