Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

various UI and rt changes

Browse Source
This commit is contained in:
Dynamitos
2025-01-29 16:15:48 +01:00
parent 4e6eb02e74
commit e5ac354527
29 changed files with 314 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+12 -8
View File
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.7...3.23)
if(${CMAKE_VERSION} VERSION_LESS 3.12)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
endif()
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD 23)
# Handle superbuild first
option (USE_SUPERBUILD "Whether or not a superbuild should be invoked" ON)
@@ -46,6 +46,7 @@ find_package(assimp CONFIG REQUIRED)
find_package(Stb REQUIRED)
find_package(EnTT CONFIG REQUIRED)
find_package(FreeType CONFIG REQUIRED)
find_package(harfbuzz CONFIG REQUIRED)
find_package(glfw3 CONFIG REQUIRED)
find_package(glm CONFIG REQUIRED)
find_package(Ktx CONFIG REQUIRED)
@@ -66,11 +67,14 @@ add_library(Engine SHARED "")
target_compile_definitions(Engine PRIVATE GLFW_WINDOWS)
target_include_directories(Engine PRIVATE src/Engine)
target_include_directories(Engine PRIVATE ${VCPKG_INSTALLED_DIR}/x64-windows/include/)
target_link_libraries(Engine PUBLIC Vulkan::Vulkan)
target_link_libraries(Engine PUBLIC EnTT::EnTT)
target_link_libraries(Engine PUBLIC glfw)
target_link_libraries(Engine PUBLIC glm::glm)
target_link_libraries(Engine PUBLIC freetype)
target_link_libraries(Engine PUBLIC harfbuzz::harfbuzz)
target_link_libraries(Engine PUBLIC harfbuzz::harfbuzz-subset)
target_link_libraries(Engine PUBLIC assimp::assimp)
target_link_libraries(Engine PUBLIC KTX::ktx)
target_link_libraries(Engine PUBLIC nlohmann_json::nlohmann_json)
@@ -78,8 +82,8 @@ target_link_libraries(Engine PUBLIC crcpp)
target_link_libraries(Engine PUBLIC fmt::fmt)
target_link_libraries(Engine PUBLIC unofficial::lunasvg::lunasvg)
target_link_libraries(Engine PUBLIC GPUOpen::VulkanMemoryAllocator)
target_link_libraries(Engine PUBLIC ${VCPKG_INSTALLED_DIR}/x64-windows/lib/slang.lib)
target_link_libraries(Engine PUBLIC slang)
if(APPLE)
target_link_libraries(Engine PUBLIC metal)
SET(CMAKE_OSX_DEPLOYMENT_TARGET 14.3)
@@ -105,8 +109,8 @@ target_include_directories(Benchmark PRIVATE src/Benchmark)
if(MSVC)
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
target_compile_options(Engine PUBLIC /std:c++20 /Zi /MP14 /W4 /wd4505)
target_compile_options(Editor PUBLIC /std:c++20 /Zi /MP14 /W4)
target_compile_options(Engine PUBLIC /Zi /MP14 /W4 /wd4505)
target_compile_options(Editor PUBLIC /Zi /MP14 /W4)
target_sources(Engine INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/Seele.natvis>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/Seele/Seele.natvis>
@@ -115,8 +119,8 @@ if(MSVC)
Seele.natvis
DESTINATION Seele/)
else()
target_compile_options(Engine PUBLIC -g -Wall -Wextra -Wno-error -pedantic -std=c++20 -Wno-missing-field-initializers -Wno-unused-function)
target_compile_options(Editor PUBLIC -g -Wall -Wextra -Wno-error -pedantic -std=c++20)
target_compile_options(Engine PUBLIC -g -Wall -Wextra -Wno-error -pedantic -Wno-missing-field-initializers -Wno-unused-function)
target_compile_options(Editor PUBLIC -g -Wall -Wextra -Wno-error -pedantic)
endif()
if(APPLE)
#Metal lib throws that internally for some reason
@@ -132,8 +136,8 @@ add_subdirectory(src/)
if(WIN32)
add_custom_target(dll_copy ALL
COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:Engine> $<TARGET_FILE_DIR:Editor>
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang.dll $<TARGET_FILE_DIR:Editor>
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang-glslang.dll $<TARGET_FILE_DIR:Editor>
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${VCPKG_INSTALLED_DIR}/x64-windows/bin/slang.dll $<TARGET_FILE_DIR:Editor>
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${VCPKG_INSTALLED_DIR}/x64-windows/bin/slang-glslang.dll $<TARGET_FILE_DIR:Editor>
COMMAND_EXPAND_LISTS
DEPENDS Editor)
elseif(APPLE)
cmake/SuperBuild.cmake
-31
View File
@@ -1,36 +1,5 @@
include (ExternalProject)
#--------------SLang------------------------------
add_library(slang SHARED IMPORTED)
if(WIN32)
add_library(slang-glslang SHARED IMPORTED)
set(SLANG_ROOT ${PROJECT_SOURCE_DIR}/../slang/build/Release/)
set_target_properties(slang-glslang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang-glslang.dll)
set_target_properties(slang-glslang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}lib/slang.lib)
set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang.dll)
set_target_properties(slang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}lib/slang.lib)
target_link_libraries(slang INTERFACE slang-glslang)
install(FILES
${SLANG_ROOT}bin/slang-glslang.dll
${SLANG_ROOT}bin/slang.dll
DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
install(FILES
${SLANG_ROOT}lib/slang.lib
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
elseif(APPLE)
set(BINARY_ROOT ${PROJECT_SOURCE_DIR}/../slang/build/Debug)
set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${BINARY_ROOT}/lib/libslang.dylib)
install(FILES
${BINARY_ROOT}/lib/libslang.dylib
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
endif()
target_include_directories(slang INTERFACE
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/../slang/include>
$<INSTALL_INTERFACE:include>
)
#--------------CRC++------------------------------
add_library(crcpp INTERFACE)
external/vcpkg
Vendored
+1 -1
Submodule external/vcpkg updated: 509f71e53f...ab42fb3032
res/fonts/arial.ttf
BIN
View File
Binary file not shown.
res/fonts/arialbd.ttf
BIN
View File
Binary file not shown.
res/fonts/arialbi.ttf
BIN
View File
Binary file not shown.
res/fonts/ariali.ttf
BIN
View File
Binary file not shown.
res/fonts/ariblk.ttf
BIN
View File
Binary file not shown.
res/shaders/UIPass.slang
+1 -1
View File
@@ -59,5 +59,5 @@ float4 fragmentMain(
if(style.textureIndex == -1) {
return float4(style.color, style.opacity);
}
return float4(pParams.textures[style.textureIndex].Sample(pParams.sampler, texCoords.xy).xyz, style.opacity);
return pParams.textures[style.textureIndex].Sample(pParams.sampler, texCoords.xy);
}
res/shaders/lib/BRDF.slang
+10 -2
View File
@@ -16,6 +16,7 @@ struct Phong : IBRDF
float3 normal;
float3 ambient;
float shininess;
float3 emissive;
__init()
{
@@ -25,6 +26,7 @@ struct Phong : IBRDF
normal = float3(0, 0, 1);
ambient = float3(0, 0, 0);
shininess = 0;
emissive = float3(0, 0, 0);
}
float3 evaluate(float3x3 tangentToWorld, float3 viewDir_WS, float3 lightDir_WS, float3 lightColor)
@@ -59,6 +61,7 @@ struct BlinnPhong : IBRDF
float3 normal;
float shininess;
float3 ambient;
float3 emissive;
__init()
{
@@ -66,8 +69,9 @@ struct BlinnPhong : IBRDF
alpha = 1;
specularColor = float3(0, 0, 0);
normal = float3(0, 0, 1);
shininess = 0;
shininess = 4;
ambient = float3(0, 0, 0);
emissive = float3(0, 0, 0);
}
float3 evaluate(float3x3 tangentToWorld, float3 viewDir_WS, float3 lightDir_WS, float3 lightColor)
@@ -77,7 +81,7 @@ struct BlinnPhong : IBRDF
float3 h = normalize(lightDir_WS + viewDir_WS);
float specular = pow(saturate(dot(normal_WS, h)), shininess);
return (baseColor * diffuse * lightColor);// + (specularColor * specular);
return (baseColor * diffuse * lightColor) + (specularColor * specular);
}
float3 evaluateAmbient()
@@ -99,12 +103,14 @@ struct CelShading : IBRDF
float3 baseColor;
float alpha;
float3 normal;
float3 emissive;
__init()
{
baseColor = float3(0, 0, 0);
alpha = 1;
normal = float3(0, 0, 1);
emissive = float3(0, 0, 0);
}
float3 evaluate(float3x3 tangentToWorld, float3 viewDir_WS, float3 lightDir_WS, float3 lightColor)
@@ -146,6 +152,7 @@ struct CookTorrance : IBRDF
float roughness;
float metallic;
float ambientOcclusion;
float3 emissive;
__init()
{
@@ -155,6 +162,7 @@ struct CookTorrance : IBRDF
roughness = 0;
metallic = 0;
ambientOcclusion = 1;
emissive = float3(0, 0, 0);
}
float TrowbridgeReitzGGX(float3 normal, float3 halfway)
res/shaders/raytracing/ClosestHit.slang
+86 -24
View File
@@ -9,6 +9,69 @@ import MATERIAL_FILE_NAME;
// simplification: all BLAS only have 1 geometry
/*vec3 nextEventEstimation(vec3 accmat, vec3 w, vec3 x, vec3 nl, float kt, bool useAtt, vec3 rnd) {
uint triId = 0;
uint sphereId = 0;
ShadingParams paramsls;
Material matls;
vec3 result = vec3(0);
// Direct Illumination: Next Event Estimation over any present lights
for (int i = spheres.length(); i-->0;) {
Sphere ls = spheres[i];
if (all(equal(ls.e, vec3(0)))) continue; // skip non-emissive spheres
vec3 xc = ls.geo.xyz - x;
vec3 sw = normalize(xc), su = normalize(cross((abs(sw.x)>.1 ? vec3(0,1,0) : vec3(1,0,0)), sw)), sv = cross(sw,su);
float cos_a_max = sqrt(float(1 - ls.geo.w*ls.geo.w / dot(xc,xc)));
float cos_a = 1 - rnd.x + rnd.x*cos_a_max, sin_a = sqrt(1 - cos_a*cos_a);
float phi = 2 * pi * rnd.y;
vec3 l = normalize(su*cos(phi)*sin_a + sv*sin(phi)*sin_a + sw*cos_a); // sampled direction towards light
if (intersect(Ray(x,l), matls, paramsls, sphereId, triId) && sphereId == i) { // test if shadow ray hits this light source
float omega = 2 * pi * (1-cos_a_max);
if(useAtt) {
float tau = exp(-kt * length(x - paramsls.x));
result += max(dot(l,nl),0) * ls.e * omega * tau;
} else {
result += accmat / pi * max(dot(l,nl),0) * ls.e * omega; // brdf term obj.c.xyz already in accmat, 1/pi for brdf
}
}
}
for(int i = meshLights.length(); i-->0;) {
MeshDescriptor mesh = meshes[meshLights[i]];
for(int j = 0; j < mesh.numIndices; j+=3) {
vec3 A = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 0]]);
vec3 B = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 1]]);
vec3 C = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 2]]);
float b1 = 1 - sqrt(rnd.x);
float b2 = (1 - rnd.y) * sqrt(rnd.x);
float b3 = rnd.y * sqrt(rnd.x);
vec3 P = A * b1 + B * b2 + C * b3;
vec3 omega = P - x;
vec3 l = normalize(omega);
float v = 0.f;
if(intersect(Ray(x,l), matls, paramsls, sphereId, triId) && triId == j) {
v = 1.0f;
}
vec3 e1 = C - A;
vec3 e2 = B - A;
float area = length(cross(e1, e2)) / 2;
float rayLen = length(omega);
float cosTheta = dot(nl, l);
float cosThetaDash = dot(paramsls.n, -l);
float factor = area * (cosThetaDash / (rayLen * rayLen));
if(useAtt) {
float tau = phase(w, l) * exp(-kt * length(x - paramsls.x));
result += tau * matls.e * max(cosTheta, 0) * factor;
} else {
result += accmat * (matls.e * max(cosTheta, 0) * factor) / pi;
}
}
}
return result;
}
*/
const float eps = 1e-5;
[shader("closesthit")]
void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttributes attr)
{
@@ -46,12 +109,11 @@ void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttribu
let brdf = Material.prepare(materialParams);
float3 normal_WS = normalize(mul(params.getTangentToWorld(), brdf.normal));
float3 normalLight_WS = dot(normal_WS,WorldRayOrigin())<0 ? normal_WS : -normal_WS;
float3 intersection_WS = params.position_WS + normal_WS * 0.001f;
float3 normalLight_WS = dot(normal_WS,WorldRayDirection())<0 ? normal_WS : -normal_WS;
float3 intersection_WS = params.position_WS;
hitValue.depth++;
float3 localAccRad = float3(0);
float3 rnd = rand01(uint3(vertexIndex0, vertexIndex1, vertexIndex2));
float3 rnd = rand01(hitValue.rndSeed);
//float kt = ka + ks;
//float s = -log(rnd.z) / kt;
//float3 xs = r.o + s * r.d;
@@ -73,13 +135,13 @@ void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttribu
// continue;
//}
//float p = max(max(brdf.baseColor.x, brdf.baseColor.color.y), brdf.baseColor.color.z);
//float p = max(max(brdf.baseColor.x, brdf.baseColor.y), brdf.baseColor.z);
//if(hitValue.depth > 5) {
// if (rnd.z >= p) return;
// else hitValue.accmat /= p;
//}
hitValue.light += brdf.emissive * hitValue.emissive + brdf.evaluateAmbient();
//-- Ideal DIFFUSE reflection
//if(bool(useNEE)) {
// accrad += nextEventEstimation(accmat, r.d, params.x, params.nl, kt, false, rnd);
@@ -89,22 +151,25 @@ void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttribu
float3 l = -pLightEnv.directionalLights[i].direction.xyz;
RayDesc rayDesc;
rayDesc.TMax = 10000.0f;
rayDesc.TMin = 0.001f;
rayDesc.TMin = eps;
rayDesc.Origin = x;
rayDesc.Direction = l;
RayPayload payload;
payload.depth = hitValue.depth;
payload.emissive = 1;
payload.anyHit = true;
payload.hit = false;
payload.rndSeed = hitValue.rndSeed;
TraceRay(pRayTracingParams.scene, 0, 0xff, 0, 0, 0, rayDesc, payload);
// we have missed all geometry, so directional light is affecting us
if(!payload.hit) {
localAccRad += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
}
//if(!payload.hit) {
//hitValue.light += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
//}
}
for(uint i = 0; i < pLightEnv.numPointLights; ++i) {
RayPayload payload;
payload.rndSeed = hitValue.rndSeed;
float3 x = intersection_WS;
float3 l = pLightEnv.pointLights[i].position_WS.xyz - intersection_WS;
if(length(l) > pLightEnv.pointLights[i].colorRange.w) {
@@ -112,40 +177,37 @@ void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttribu
}
RayDesc rayDesc;
rayDesc.TMax = 1.0f;
rayDesc.TMin = 0.001f;
rayDesc.TMin = eps;
rayDesc.Origin = x;
rayDesc.Direction = l;
TraceRay(pRayTracingParams.scene, 0, 0xff, 0, 0, 0, rayDesc, payload);
// hitting only after the light
if(!payload.hit) {
localAccRad += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
hitValue.light += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
}
}
// Indirect Illumination: cosine-weighted importance sampling
if(hitValue.depth < 12) {
float r1 = 2 * PI * rnd.x, r2 = rnd.y, r2s = sqrt(r2);
float3 w = normalLight_WS;
float3 u = normalize((cross(abs(w.x)>0.1 ? float3(0,1,0) : float3(1,0,0), w)));
float3 u = normalize(cross(abs(w.x)>0.1 ? float3(0,1,0) : float3(1,0,0), w));
float3 v = cross(w,u);
RayDesc rayDesc;
rayDesc.TMax = 10000.0f;
rayDesc.TMin = 0.001f;
rayDesc.TMin = eps;
rayDesc.Origin = intersection_WS;
rayDesc.Direction = normalize(u*cos(r1)*r2s + v * sin(r1)*r2s + w * sqrt(1 - r2));
RayPayload payload;
payload.light = float3(0);
payload.emissive = 0; // in the next bounce, consider reflective part only!
payload.depth = hitValue.depth+1;
payload.emissive = 1;
payload.hit = false;
//payload.emissive = 0; // in the next bounce, consider reflective part only!
payload.depth = hitValue.depth;
payload.anyHit = false;
payload.rndSeed = hitValue.rndSeed + 1;
TraceRay(pRayTracingParams.scene, 0, 0xff, 0, 0, 0, rayDesc, payload);
if(payload.hit) {
DirectionalLight dir;
dir.color = float4(payload.light, 0);
dir.direction = float4(-rayDesc.Direction, 0);
localAccRad += dir.illuminate(lightingParams, brdf);
float bias = dot(normalLight_WS, rayDesc.Direction);
hitValue.light += brdf.evaluate(params.getTangentToWorld(), -WorldRayDirection(), rayDesc.Direction, payload.light / bias);
}
}
hitValue.light += localAccRad;
}
res/shaders/raytracing/RayGen.slang
+5 -2
View File
@@ -108,10 +108,13 @@ void raygen()
payload.light=float3(0);
payload.emissive = 1;
payload.depth = 1;
payload.rndSeed = rndSeed + 1;
payload.anyHit = false;
TraceRay(pRayTracingParams.scene, 0, 0xff, 0, 0, 0, rayDesc, payload);
if(pSamps.pass == 0) pRayTracingParams.radianceAccumulator[pix] = float4(0);
pRayTracingParams.radianceAccumulator[pix] += float4(payload.light / pSamps.samplesPerPixel, 0);
pRayTracingParams.image[pix] = float4(clamp(pRayTracingParams.radianceAccumulator[pix].xyz, 0, 1), 1);
float3 accumulatedRadiance = payload.light / pSamps.samplesPerPixel;
pRayTracingParams.radianceAccumulator[pix] += float4(accumulatedRadiance, 0);
float3 compensatedRadiance = pRayTracingParams.radianceAccumulator[pix].xyz * pSamps.samplesPerPixel / (pSamps.pass + 1);
pRayTracingParams.image[pix] = float4(clamp(compensatedRadiance, 0, 1), 1);
}
res/shaders/raytracing/RayTracingData.slang
+1
View File
@@ -25,6 +25,7 @@ struct RayPayload
uint depth;
bool hit;
bool anyHit;
uint3 rndSeed;
};
float3 rand01(uint3 x){ // pseudo-random number generator
src/Editor/Asset/FontLoader.cpp
+2 -2
View File
@@ -32,9 +32,9 @@ void FontLoader::importAsset(FontImportArgs args) {
// so we create a single pixel empty texture
void FontLoader::import(FontImportArgs args, PFontAsset asset) {
std::ifstream stream(args.filePath.c_str(), std::ios::binary | std::ios::ate);
Array<uint8> ttfFile(stream.tellg());
Array<char> ttfFile(stream.tellg());
stream.seekg(0);
stream.read((char*)ttfFile.data(), ttfFile.size());
stream.read(ttfFile.data(), ttfFile.size());
asset->ttfFile = std::move(ttfFile);
asset->graphics = graphics;
asset->loadFace();
src/Editor/Asset/MeshLoader.cpp
+20 -7
View File
@@ -92,6 +92,8 @@ constexpr const char* KEY_AMBIENT_COLOR = "k_a";
constexpr const char* KEY_SHININESS = "k_shiny";
constexpr const char* KEY_ROUGHNESS = "k_r";
constexpr const char* KEY_METALLIC = "k_m";
constexpr const char* KEY_EMISSIVE_COLOR = "k_e";
constexpr const char* KEY_EMISSIVE_INTENSITY = "k_ei";
constexpr const char* KEY_DIFFUSE_TEXTURE = "tex_d";
constexpr const char* KEY_SPECULAR_TEXTURE = "tex_s";
@@ -101,6 +103,7 @@ constexpr const char* KEY_SHININESS_TEXTURE = "tex_shiny";
constexpr const char* KEY_ROUGHNESS_TEXTURE = "tex_r";
constexpr const char* KEY_METALLIC_TEXTURE = "tex_m";
constexpr const char* KEY_AMBIENT_OCCLUSION_TEXTURE = "tex_ao";
constexpr const char* KEY_EMISSIVE_TEXTURE = "tex_emissive";
void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>& textures, const std::string& baseName,
const std::filesystem::path& meshDirectory, const std::string& importPath,
@@ -353,9 +356,19 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
addTextureParameter(KEY_AMBIENT_OCCLUSION_TEXTURE, aiTextureType_AMBIENT_OCCLUSION, i, outputAO, {0, -1, -1, -1});
}
// Emissive
//addScalarParameter(KEY_EMISSIVE_INTENSITY, AI_MATKEY_EMISSIVE_INTENSITY);
addVectorParameter(KEY_EMISSIVE_COLOR, AI_MATKEY_COLOR_EMISSIVE);
std::string outputEmissive = KEY_EMISSIVE_COLOR;
uint32 numEmissive = material->GetTextureCount(aiTextureType_EMISSION_COLOR);
for (uint32 i = 0; i < numEmissive; ++i) {
addTextureParameter(KEY_EMISSIVE_TEXTURE, aiTextureType_EMISSION_COLOR, i, outputEmissive);
}
MaterialNode brdf;
brdf.variables["baseColor"] = outputDiffuse;
brdf.variables["alpha"] = outputAlpha;
brdf.variables["emissive"] = outputEmissive;
if (!outputNormal.empty()) {
expressions.add(new MulExpression());
expressions.back()->key = "NormalMul";
@@ -381,6 +394,13 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
case aiShadingMode_Toon:
brdf.profile = "CelShading";
break;
case aiShadingMode_Blinn:
brdf.profile = "BlinnPhong";
brdf.variables["specularColor"] = outputSpecular;
brdf.variables["ambient"] = outputAmbient;
brdf.variables["shininess"] = outputShininess;
break;
default:
case aiShadingMode_CookTorrance:
brdf.profile = "CookTorrance";
brdf.variables["roughness"] = outputRoughness;
@@ -389,13 +409,6 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
brdf.variables["ambientOcclusion"] = outputAmbient;
}
break;
default:
case aiShadingMode_Blinn:
brdf.profile = "BlinnPhong";
brdf.variables["specularColor"] = outputSpecular;
brdf.variables["ambient"] = outputAmbient;
brdf.variables["shininess"] = outputShininess;
break;
};
uint32 twoSided = false;
float opacity = 1.0f;
src/Editor/Asset/TextureLoader.cpp
+1 -1
View File
@@ -111,7 +111,7 @@ void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset) {
ktxBasisParams basisParams = {
.structSize = sizeof(ktxBasisParams),
.uastc = true,
.threadCount = 14,
.threadCount = 1,
.uastcFlags = KTX_PACK_UASTC_LEVEL_FASTEST,
.uastcRDO = true,
};
src/Editor/Window/InspectorView.cpp
+1 -1
View File
@@ -17,7 +17,7 @@ InspectorView::InspectorView(Gfx::PGraphics graphics, PWindow window, const View
{
new UI::Text<Font_Arial, Text_9XL>("Other Test T"),
}),
new UI::Text<Font_Arial>("Test"),
new UI::Text<Font_Arial>("Test fasdf agll;sdfgkj ahsf"),
}))) {
renderGraph.addPass(new UIPass(graphics, uiSystem));
renderGraph.setViewport(viewport);
src/Editor/main.cpp
+29 -31
View File
@@ -54,6 +54,8 @@ Array<Halfedge> generateEdges() {
return edges;
}
Array<uint32> generateArray() { return Array<uint32>(); }
int main() {
std::string gameName = "MeshShadingDemo";
#ifdef WIN32
@@ -117,22 +119,18 @@ int main() {
// .filePath = sourcePath / "import/models/after-the-rain-vr-sound/source/Whitechapel.glb",
// .importPath = "Whitechapel",
//});
// AssetImporter::importMesh(MeshImportArgs{
// .filePath = sourcePath / "import/models/plane.obj",
// .importPath = "",
// });
// AssetImporter::importMesh(MeshImportArgs{
// .filePath = sourcePath / "import/models/city-suburbs/source/city-suburbs.obj",
// .importPath = "suburbs",
// });
// AssetImporter::importMesh(MeshImportArgs{
// .filePath = sourcePath / "import/models/minecraft-medieval-city.fbx",
// .importPath = "minecraft",
// });
// AssetImporter::importMesh(MeshImportArgs{
// .filePath = sourcePath / "import/models/Volvo/Volvo.fbx",
// .importPath = "Volvo",
// });
AssetImporter::importMesh(MeshImportArgs{
.filePath = sourcePath / "import/models/box.glb",
.importPath = "",
});
AssetImporter::importMesh(MeshImportArgs{
.filePath = sourcePath / "import/models/rttest.glb",
.importPath = "",
});
AssetImporter::importMesh(MeshImportArgs{
.filePath = sourcePath / "import/models/town_hall.glb",
.importPath = "",
});
getThreadPool().waitIdle();
vd->commitMeshes();
WindowCreateInfo mainWindowInfo = {
@@ -142,26 +140,26 @@ int main() {
.preferredFormat = Gfx::SE_FORMAT_B8G8R8A8_SRGB,
};
auto window = windowManager->addWindow(graphics, mainWindowInfo);
// ViewportCreateInfo sceneViewInfo = {
// .dimensions =
// {
// .size = {1920, 1080},
// .offset = {0, 0},
// },
// .numSamples = Gfx::SE_SAMPLE_COUNT_4_BIT,
// };
// OGameView sceneView = new Editor::PlayView(graphics, window, sceneViewInfo, binaryPath.generic_string());
// sceneView->setFocused();
OInspectorView inspectorView = new Editor::InspectorView(graphics, window,
ViewportCreateInfo{
ViewportCreateInfo sceneViewInfo = {
.dimensions =
{
.size = {1920, 1080},
.offset = {0, 0},
},
.fieldOfView = 0,
.numSamples = Gfx::SE_SAMPLE_COUNT_1_BIT,
});
.numSamples = Gfx::SE_SAMPLE_COUNT_4_BIT,
};
OGameView sceneView = new Editor::PlayView(graphics, window, sceneViewInfo, binaryPath.generic_string());
sceneView->setFocused();
//OInspectorView inspectorView = new Editor::InspectorView(graphics, window,
// ViewportCreateInfo{
// .dimensions =
// {
// .size = {1920, 1080},
// .offset = {0, 0},
// },
// .fieldOfView = 0,
// .numSamples = Gfx::SE_SAMPLE_COUNT_1_BIT,
// });
while (windowManager->isActive() && getGlobals().running) {
windowManager->render();
src/Engine/Asset/FontAsset.cpp
+53 -16
View File
@@ -12,8 +12,11 @@ FontAsset::FontAsset(std::string_view folderPath, std::string_view name) : Asset
}
FontAsset::~FontAsset() {
FT_Done_Face(face);
FT_Done_Face(ft_face);
FT_Done_FreeType(ft);
hb_font_destroy(hb_font);
hb_face_destroy(hb_face);
hb_blob_destroy(blob);
}
void FontAsset::save(ArchiveBuffer& buffer) const { Serialization::save(buffer, ttfFile); }
@@ -25,23 +28,57 @@ void FontAsset::load(ArchiveBuffer& buffer) {
}
void FontAsset::loadFace() {
FT_Error error = FT_New_Memory_Face(ft, ttfFile.data(), ttfFile.size(), 0, &face);
FT_Error error = FT_New_Memory_Face(ft, (unsigned char*)ttfFile.data(), ttfFile.size(), 0, &ft_face);
assert(!error);
blob = hb_blob_create(ttfFile.data(), ttfFile.size(), HB_MEMORY_MODE_DUPLICATE, nullptr, nullptr);
hb_face = hb_face_create(blob, 0);
hb_font = hb_font_create(hb_face);
}
UVector2 FontAsset::shapeText(std::string_view view, uint32 fontSize, Array<RenderGlyph>& render) {
loadGlyphs(fontSize);
hb_buffer_t* buf = hb_buffer_create();
hb_buffer_add_utf8(buf, view.data(), view.size(), 0, -1);
hb_buffer_set_language(buf, hb_language_from_string("en", -1));
hb_buffer_set_script(buf, HB_SCRIPT_LATIN);
hb_buffer_set_direction(buf, HB_DIRECTION_LTR);
hb_shape(hb_font, buf, nullptr, 0);
uint32 num_glyphs;
hb_glyph_info_t* glyphs = hb_buffer_get_glyph_infos(buf, &num_glyphs);
hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buf, &num_glyphs);
Vector2 min = Vector2(std::numeric_limits<float>::max());
Vector2 max = Vector2(std::numeric_limits<float>::lowest());
int32 xppem, yppem;
hb_font_get_scale(hb_font, &xppem, &yppem);
Vector2 cursor = Vector2(0);
for (uint32 i = 0; i < num_glyphs; ++i) {
hb_codepoint_t glyphid = glyphs[i].codepoint;
float xOffset = positions[i].x_offset * fontSize / xppem;
float yOffset = positions[i].y_offset * fontSize / yppem;
float xAdvance = positions[i].x_advance * fontSize / xppem;
float yAdvance = positions[i].y_advance * fontSize / yppem;
Vector2 position = cursor + Vector2(xOffset, yOffset);
Vector2 dimensions = fontSizes[fontSize].glyphs[glyphid].size;
render.add(RenderGlyph{
.texture = fontSizes[fontSize].glyphs[glyphid].texture,
.position = position,
.dimensions = dimensions,
});
cursor += Vector2(xAdvance, yAdvance);
min = Vector2(std::min(min.x, position.x), std::min(min.y, position.y));
max = Vector2(std::max(max.x, position.x + dimensions.x), std::max(min.y, position.y + dimensions.y));
}
hb_buffer_destroy(buf);
return UVector2(max - min);
}
void FontAsset::loadFontSize(uint32 fontSize) {
FT_Set_Pixel_Sizes(face, 0, fontSize);
fontSizes[fontSize].ascent = face->ascender;
fontSizes[fontSize].descent = face->descender;
fontSizes[fontSize].linegap = 0;
for (uint32 c = 0; c < 256; ++c) {
if (FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_COLOR)) {
continue;
}
FontAsset::Glyph& glyph = fontSizes[fontSize].glyphs[c];
glyph.size = IVector2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
glyph.bearing = IVector2(face->glyph->bitmap_left, face->glyph->bitmap_top);
glyph.advance = face->glyph->advance.x;
void FontAsset::loadGlyphs(uint32 fontSize) {
FT_Set_Pixel_Sizes(ft_face, 0, fontSize);
for (uint32 i = 0; i < ft_face->num_glyphs; ++i) {
assert(FT_Load_Glyph(ft_face, i, FT_LOAD_RENDER | FT_LOAD_COLOR) == 0);
FontAsset::Glyph& glyph = fontSizes[fontSize].glyphs[i];
glyph.size = IVector2(ft_face->glyph->bitmap.width, ft_face->glyph->bitmap.rows);
glyph.bearing = IVector2(ft_face->glyph->bitmap_left, ft_face->glyph->bitmap_top);
glyph.advance = ft_face->glyph->advance.x;
glyph.textureData.resize(glyph.size.x * glyph.size.y);
if (glyph.textureData.size() == 0) {
glyph.size.x = 1;
@@ -49,7 +86,7 @@ void FontAsset::loadFontSize(uint32 fontSize) {
glyph.textureData.add(0);
// load a single transparent pixel, so that we dont have to handle empty textures later
} else {
std::memcpy(glyph.textureData.data(), face->glyph->bitmap.buffer, glyph.textureData.size());
std::memcpy(glyph.textureData.data(), ft_face->glyph->bitmap.buffer, glyph.textureData.size());
}
glyph.texture = graphics->createTexture2D(TextureCreateInfo{
.sourceData =
src/Engine/Asset/FontAsset.h
+14 -12
View File
@@ -4,6 +4,7 @@
#include "Graphics/Texture.h"
#include "Math/Math.h"
#include <freetype/freetype.h>
#include <harfbuzz/hb.h>
namespace Seele {
class FontAsset : public Asset {
@@ -25,25 +26,26 @@ class FontAsset : public Asset {
void load(ArchiveBuffer& buffer);
};
struct FontData {
int32 ascent;
int32 descent;
int32 linegap;
Map<uint32, Glyph> glyphs;
};
const Glyph& getGlyphData(char c, uint32 fontSize) {
if (!fontSizes.contains(fontSize))
loadFontSize(fontSize);
return fontSizes[fontSize].glyphs[c];
}
const FontData& getFontData(uint32 fontSize) { return fontSizes[fontSize]; }
void loadFace();
struct RenderGlyph {
Gfx::PTexture2D texture;
UVector2 position;
UVector2 dimensions;
};
UVector2 shapeText(std::string_view view, uint32 fontSize, Array<RenderGlyph>& render);
private:
void loadFontSize(uint32 fontSize);
void loadGlyphs(uint32 fontSize);
Gfx::PGraphics graphics;
hb_blob_t* blob;
hb_face_t* hb_face;
hb_font_t* hb_font;
FT_Library ft;
FT_Face face;
Array<uint8> ttfFile;
FT_Face ft_face;
Array<char> ttfFile;
Map<uint32, FontData> fontSizes;
friend class FontLoader;
};
src/Engine/Component/Camera.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ void Camera::moveY(float amount) {
}
void Camera::buildViewMatrix() {
Vector eyePos = getTransform().getPosition() + Vector(0, 0, -5);
Vector eyePos = getTransform().getPosition();
Vector lookAt = eyePos + getTransform().getForward();
viewMatrix = glm::lookAt(eyePos, lookAt, Vector(0, 1, 0));
cameraPos = eyePos;
src/Engine/Concepts.h
+5
View File
@@ -1,7 +1,12 @@
#pragma once
#include <concepts>
#include <ranges>
namespace Seele {
template <typename Range, typename T>
concept container_compatible_range = (std::ranges::input_range<Range>) && std::convertible_to<std::ranges::range_reference_t<Range>, T>;
template <class F, class... Args>
concept invocable = std::invocable<F, Args...>;
src/Engine/Containers/Array.h
+15 -1
View File
@@ -1,5 +1,6 @@
#pragma once
#include "EngineTypes.h"
#include "Concepts.h"
#include <algorithm>
#include <assert.h>
#include <initializer_list>
@@ -117,7 +118,20 @@ template <typename T, typename Allocator = std::pmr::polymorphic_allocator<T>> s
assert(_data != nullptr);
std::uninitialized_copy(init.begin(), init.end(), begin());
}
template <container_compatible_range<T> Range>
constexpr Array(std::from_range_t, Range&& rg, const allocator_type& alloc = allocator_type())
: arraySize(0), allocated(0), allocator(alloc) {
if constexpr (std::ranges::sized_range<Range> || std::ranges::forward_range<Range>) {
arraySize = std::ranges::size(rg);
allocated = arraySize;
_data = allocateArray(allocated);
std::ranges::uninitialized_copy(rg.begin(), rg.end(), begin(), end());
} else {
for (auto it = std::ranges::begin(rg); it != std::ranges::end(rg); it++) {
add(*it);
}
}
}
constexpr Array(const Array& other)
: arraySize(other.arraySize), allocated(other.allocated),
allocator(std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.allocator)) {
src/Engine/Graphics/RenderPass/UIPass.cpp
+9 -25
View File
@@ -58,8 +58,12 @@ void UIPass::beginFrame(const Component::Camera& cam) {
for (auto& render : renderElements) {
float x = render.position.x;
float y = render.position.y;
if (render.text.empty()) {
//todo: convert using actual tree depth
uint32 textureIndex = -1ul;
if (render.backgroundTexture != nullptr) {
textureIndex = usedTextures.size();
usedTextures.add(render.backgroundTexture);
}
elements.add(RenderElementStyle{
.x = x,
.y = y,
@@ -67,31 +71,8 @@ void UIPass::beginFrame(const Component::Camera& cam) {
.h = render.dimensions.y,
.color = render.backgroundColor,
.z = render.level / 100.f,
.textureIndex = textureIndex,
});
} else {
y = y + render.baseline;
for (uint32 c : render.text) {
const FontAsset::Glyph& glyph = render.font->getGlyphData(c, render.fontSize);
Vector2 bearing = Vector2(glyph.bearing);
Vector2 size = Vector2(glyph.size);
float xpos = x + glyph.bearing.x;
float ypos = y - bearing.y;
float w = size.x;
float h = size.y;
glyphs.add(GlyphInstanceData{
.x = xpos,
.y = ypos,
.z = render.level / 100.0f,
.width = w,
.height = h,
.glyphIndex = (uint32)usedTextures.size(),
});
usedTextures.add(glyph.texture);
x += glyph.advance / 64.0f;
}
}
}
glyphInstanceBuffer->rotateBuffer(sizeof(GlyphInstanceData) * glyphs.size());
glyphInstanceBuffer->updateContents(0, sizeof(GlyphInstanceData) * glyphs.size(), glyphs.data());
@@ -115,6 +96,9 @@ void UIPass::beginFrame(const Component::Camera& cam) {
uiDescriptorSet = uiDescriptorLayout->allocateDescriptorSet();
uiDescriptorSet->updateBuffer(0, 0, elementBuffer);
uiDescriptorSet->updateSampler(1, 0, glyphSampler);
for (uint32 i = 0; i < usedTextures.size(); ++i) {
uiDescriptorSet->updateTexture(2, i, usedTextures[i]);
}
uiDescriptorSet->writeChanges();
}
src/Engine/Graphics/Vulkan/RayTracing.cpp
+1 -2
View File
@@ -122,7 +122,6 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
.flags = 0,
.size = buildSizesInfo.accelerationStructureSize,
.usage = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
@@ -156,7 +155,7 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
VkAccelerationStructureBuildGeometryInfoKHR buildGeometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
.pNext = nullptr,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
.mode = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR,
.dstAccelerationStructure = handle,
.geometryCount = 1,
src/Engine/UI/Element.h
+7 -11
View File
@@ -7,14 +7,10 @@
namespace Seele {
namespace UI {
struct UIRender {
std::string text;
PFontAsset font;
uint32 fontSize;
Vector textColor;
Gfx::PTexture2D backgroundTexture;
Vector backgroundColor;
Vector2 position;
Vector2 dimensions;
uint32 baseline;
uint32 z;
uint32 level;
};
@@ -45,15 +41,15 @@ class Element {
} else if (style.widthType == DimensionType::Percent) {
dimensions.x = parentSize.x * style.width / 100.0f;
}
for (auto& child : children) {
child->layout(maxDimensions - Vector2(style.marginLeft + style.marginRight, style.marginTop + style.marginBottom));
}
if (style.heightType == DimensionType::Pixel) {
dimensions.y = style.height;
} else if (style.heightType == DimensionType::Percent) {
dimensions.y = parentSize.y * style.height / 100.0f;
}
for (auto& child : children) {
child->layout(maxDimensions - Vector2(style.marginLeft + style.marginRight, style.marginTop + style.marginBottom));
}
switch (style.innerDisplay) {
case InnerDisplayType::Flow:
flowLayout();
@@ -73,7 +69,7 @@ class Element {
// create a new line in case the element doesnt fit on the current one anymore,
// but keep in current line in case we are still at the start, as a new line wouldnt help here
if (cursor.x + child->dimensions.x > maxDimensions.x - child->style.left && cursor.x != 0) {
cursor.x = 0;
cursor.x = style.paddingLeft;
cursor.y += lineHeight;
lineHeight = 0;
}
@@ -94,7 +90,7 @@ class Element {
if (child->style.position == PositionType::Static || child->style.position == PositionType::Relative) {
// create a new line in case we are not already at one
if (cursor.x != 0) {
cursor.x = 0;
cursor.x = style.paddingLeft;
cursor.y += lineHeight;
}
child->position.x = cursor.x + child->style.marginLeft;
src/Engine/UI/Element/Text.h
+10 -16
View File
@@ -1,6 +1,7 @@
#pragma once
#include "UI/Element.h"
#include "UI/Style/Class.h"
#include <ranges>
namespace Seele {
namespace UI {
@@ -13,31 +14,24 @@ template <StyleClass... classes> class Text : public Element {
(classes::apply(style), ...);
}
virtual void layout(UVector2 parentSize) override {
size_t cursor = 0;
for (uint32 i = 0; i < text.size() - 1; ++i) {
dimensions.x += style.fontFamily->getGlyphData(text[i], style.fontSize).advance / 64.0f;
}
dimensions.x += style.fontFamily->getGlyphData(text[text.size() - 1], style.fontSize).size.x;
dimensions.y = style.fontSize;
UVector2 cursor = UVector2(0);
dimensions = style.fontFamily->shapeText(text, style.fontSize, glyphRenders);
}
virtual Array<UIRender> render(Vector2 anchor, uint32 level) override {
return {
UIRender{
.text = text,
.font = style.fontFamily,
.fontSize = style.fontSize,
.position = position + anchor,
.dimensions = dimensions,
.baseline = style.fontSize * 3 / 4, // TODO: improve
.z = style.z,
return Array<UIRender>(std::from_range, glyphRenders | std::views::transform([=](const FontAsset::RenderGlyph& glyph) {
return UIRender{
.backgroundTexture = glyph.texture,
.position = Vector2(glyph.position) + anchor,
.dimensions = Vector2(glyph.dimensions),
.level = level,
},
};
}));
}
// height = fontsize * 1.12
private:
std::string text;
Array<FontAsset::RenderGlyph> glyphRenders;
};
} // namespace UI
} // namespace Seele
vcpkg.json
+3 -1
View File
@@ -12,6 +12,8 @@
"fmt",
"gtest",
"vulkan-memory-allocator",
"lunasvg"
"lunasvg",
"harfbuzz",
"shader-slang"
]
}