yeet/TSE-RTS
SHA256
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: yeet:DICOM_Viewer
Branches Tags
yeet:main yeet:DICOM_Viewer
..
compare: yeet:main
Branches Tags
yeet:main yeet:DICOM_Viewer

3 Commits
DICOM_View ... main

Author SHA256 Message Date
Mexpert_PRO
7198e32a7f updated TSE 2026-04-11 09:57:17 +02:00
yeet
2aa742532e README.md aktualisiert 2026-04-11 07:52:52 +00:00
yeet
d4d8f2d909 README.md aktualisiert 2026-04-11 07:41:16 +00:00
11 changed files with 463 additions and 1420 deletions
Expand all files Collapse all files

188
.gitignore vendored
View File

@@ -1,95 +1,93 @@
# ---> C++ # ---> C++
# Prerequisites # Prerequisites
*.d *.d
# Compiled Object files # Compiled Object files
*.slo *.slo
*.lo *.lo
*.o *.o
*.obj *.obj
# Precompiled Headers # Precompiled Headers
*.gch *.gch
*.pch *.pch
# Compiled Dynamic libraries # Compiled Dynamic libraries
*.so *.so
*.dylib *.dylib
*.dll *.dll
# Fortran module files # Fortran module files
*.mod *.mod
*.smod *.smod
# Executables # Executables
*.exe *.exe
*.out *.out
*.app *.app
# ---> C # ---> C
# Prerequisites # Prerequisites
*.d *.d
# Object files # Object files
*.o *.o
*.ko *.ko
*.obj *.obj
*.elf *.elf
# Linker output # Linker output
*.ilk *.ilk
*.map *.map
*.exp *.exp
# Precompiled Headers # Precompiled Headers
*.gch *.gch
*.pch *.pch
# Shared objects (inc. Windows DLLs) # Shared objects (inc. Windows DLLs)
*.dll *.dll
*.so *.so
*.so.* *.so.*
*.dylib *.dylib
# Executables # Executables
*.exe *.exe
*.out *.out
*.app *.app
*.i*86 *.i*86
*.x86_64 *.x86_64
*.hex *.hex
# Debug files # Debug files
*.dSYM/ *.dSYM/
*.su *.su
*.idb *.idb
*.pdb *.pdb
# Kernel Module Compile Results # Kernel Module Compile Results
*.mod* *.mod*
*.cmd *.cmd
.tmp_versions/ .tmp_versions/
modules.order modules.order
Module.symvers Module.symvers
Mkfile.old Mkfile.old
dkms.conf dkms.conf
# ---> CMake # ---> CMake
CMakeLists.txt.user CMakeLists.txt.user
CMakeCache.txt CMakeCache.txt
CMakeFiles CMakeFiles
CMakeScripts CMakeScripts
Testing Testing
Makefile Makefile
cmake_install.cmake cmake_install.cmake
install_manifest.txt install_manifest.txt
compile_commands.json compile_commands.json
CTestTestfile.cmake CTestTestfile.cmake
_deps _deps
CMakeUserPresets.json CMakeUserPresets.json
build build
bin bin
lib lib
DCM

6
README.md
View File

@@ -1,3 +1,7 @@
# TSE_Project_Template # TSE_Project_Template
this is a template for using TSE this is a template for using TSE
packages needed for building under linux:
build-essential llvm cmake ninja-build clang mesa-common-dev gdb

2
TSE

Submodule TSE updated: 8c0152c3b4...4fce05a927

132
TSE-RTS/Resources/DCMVizPresets/Preset1.json
View File

@@ -1,132 +0,0 @@
{
"transparencyCount": 9,
"transparency": [
{
"index": 0,
"transpValue": 0
},
{
"index": 0.485526,
"transpValue": 0
},
{
"index": 0.497948,
"transpValue": 0
},
{
"index": 0.499458,
"transpValue": 0
},
{
"index": 0.500618,
"transpValue": 0.0035
},
{
"index": 0.505180,
"transpValue": 0.459089
},
{
"index": 0.509820,
"transpValue": 0.970381
},
{
"index": 0.519570,
"transpValue": 0.966309
},
{
"index": 0.531805,
"transpValue": 0.833358
},
{
"index": 0.544899,
"transpValue": 0.821918
},
{
"index": 1.0,
"transpValue": 0.821918
}
],
"colorCount": 20,
"colors": [
{
"index": 0.000000,
"color": { "x": 1.000000, "y": 1.000000, "z": 1.000000 }
},
{
"index": 0.454520,
"color": { "x": 1.000000, "y": 1.000000, "z": 1.000000 }
},
{
"index": 0.466438,
"color": { "x": 0.000000, "y": 0.000000, "z": 0.000000 }
},
{
"index": 0.486854,
"color": { "x": 0.407843, "y": 0.388235, "z": 0.968627 }
},
{
"index": 0.487724,
"color": { "x": 0.980392, "y": 0.976471, "z": 0.980392 }
},
{
"index": 0.488182,
"color": { "x": 0.796078, "y": 0.682353, "z": 0.611765 }
},
{
"index": 0.495598,
"color": { "x": 0.980392, "y": 0.976471, "z": 0.980392 }
},
{
"index": 0.497215,
"color": { "x": 0.709804, "y": 0.505882, "z": 0.380392 }
},
{
"index": 0.498283,
"color": { "x": 0.874510, "y": 0.254902, "z": 0.000000 }
},
{
"index": 0.498833,
"color": { "x": 1.000000, "y": 0.800000, "z": 0.164706 }
},
{
"index": 0.500633,
"color": { "x": 0.835294, "y": 0.117647, "z": 0.000000 }
},
{
"index": 0.500755,
"color": { "x": 1.000000, "y": 0.478431, "z": 0.313725 }
},
{
"index": 0.502113,
"color": { "x": 1.000000, "y": 1.000000, "z": 1.000000 }
},
{
"index": 0.502846,
"color": { "x": 0.874510, "y": 0.254902, "z": 0.000000 }
},
{
"index": 0.503441,
"color": { "x": 1.000000, "y": 0.866667, "z": 0.400000 }
},
{
"index": 0.503670,
"color": { "x": 0.988235, "y": 0.988235, "z": 0.988235 }
},
{
"index": 0.527932,
"color": { "x": 0.972549, "y": 0.972549, "z": 0.976471 }
},
{
"index": 0.544366,
"color": { "x": 1.000000, "y": 0.819608, "z": 0.188235 }
},
{
"index": 0.549660,
"color": { "x": 1.000000, "y": 1.000000, "z": 1.000000 }
},
{
"index": 1.000000,
"color": { "x": 1.000000, "y": 1.000000, "z": 1.000000 }
}
]
}

283
TSE-RTS/src/elements/visualizationData.cpp
View File

@@ -1,283 +0,0 @@
#include "visualizationData.hpp"
#include "json.hpp"
#include "utils/JsonExports.hpp"
#include <algorithm>
#include <cmath>
#include <filesystem>
#include <fstream>
#include <vector>
namespace
{
constexpr int LUT_WIDTH = 256;
constexpr int LUT_HEIGHT = 256;
constexpr int LUT_PIXEL_COUNT = LUT_WIDTH * LUT_HEIGHT;
constexpr float LUT_INV_MAX_INDEX = 1.0f / static_cast<float>(LUT_PIXEL_COUNT - 1);
inline float Clamp01(const float value)
{
return std::min(1.0f, std::max(0.0f, value));
}
inline float Lerp(const float a, const float b, const float t)
{
return a + (b - a) * t;
}
}
VisualizationData VisualizationData::LoadVisualizationSetting(string path)
{
VisualizationData dataOut{};
namespace fs = std::filesystem;
const fs::path jsonPath = fs::absolute(path);
if(!fs::exists(jsonPath) || !fs::is_regular_file(jsonPath))
{
return dataOut;
}
std::ifstream in(jsonPath, std::ios::in | std::ios::binary);
if(!in.is_open())
{
return dataOut;
}
nlohmann::json json = nlohmann::json::parse(in, nullptr, false);
if(json.is_discarded() || !json.is_object())
{
return dataOut;
}
const auto transpIt = json.find("transparency");
const auto colorsIt = json.find("colors");
const std::size_t transpArrayCount = (transpIt != json.end() && transpIt->is_array()) ? transpIt->size() : 0;
const std::size_t colorArrayCount = (colorsIt != json.end() && colorsIt->is_array()) ? colorsIt->size() : 0;
const std::size_t transpCount = std::min(json.value("transparencyCount", transpArrayCount), transpArrayCount);
const std::size_t colorCount = std::min(json.value("colorCount", colorArrayCount), colorArrayCount);
dataOut.transparencyCount = transpCount;
dataOut.colorCount = colorCount;
if(transpCount > 0)
{
dataOut.transparency = new TransparencyData[transpCount]();
for(std::size_t i = 0; i < transpCount; ++i)
{
const nlohmann::json& point = (*transpIt)[i];
dataOut.transparency[i].index = point.value("index", 0.0f);
dataOut.transparency[i].transpValue = point.value("transpValue", 0.0f);
}
}
if(colorCount > 0)
{
dataOut.colors = new ColorData[colorCount]();
for(std::size_t i = 0; i < colorCount; ++i)
{
const nlohmann::json& point = (*colorsIt)[i];
dataOut.colors[i].index = point.value("index", 0.0f);
const auto colorIt = point.find("color");
if(colorIt != point.end() && colorIt->is_object() &&
colorIt->contains("x") && colorIt->contains("y") && colorIt->contains("z"))
{
dataOut.colors[i].color = TSE::ImportVector3(*colorIt);
}
}
}
return dataOut;
}
void VisualizationData::FillLUTTexture(Texture& texture) const
{
if(static_cast<int>(texture.Width()) != LUT_WIDTH || static_cast<int>(texture.Height()) != LUT_HEIGHT)
{
return;
}
std::vector<TransparencyData> transparencyPoints;
std::vector<ColorData> colorPoints;
if(transparency != nullptr && transparencyCount > 0)
{
transparencyPoints.assign(transparency, transparency + transparencyCount);
std::sort(transparencyPoints.begin(), transparencyPoints.end(), [](const TransparencyData& a, const TransparencyData& b)
{
return a.index < b.index;
});
}
if(colors != nullptr && colorCount > 0)
{
colorPoints.assign(colors, colors + colorCount);
std::sort(colorPoints.begin(), colorPoints.end(), [](const ColorData& a, const ColorData& b)
{
return a.index < b.index;
});
}
std::size_t transparencySegment = 0;
std::size_t colorSegment = 0;
if(texture.bpp() == 32)
{
byte* pixel = texture.GetImagePtr();
if(pixel == nullptr)
{
return;
}
for(int i = 0; i < LUT_PIXEL_COUNT; ++i)
{
const float value = static_cast<float>(i) * LUT_INV_MAX_INDEX;
float alpha = 1.0f;
if(!transparencyPoints.empty())
{
if(transparencyPoints.size() == 1 || value <= transparencyPoints.front().index)
{
alpha = transparencyPoints.front().transpValue;
}
else if(value >= transparencyPoints.back().index)
{
alpha = transparencyPoints.back().transpValue;
}
else
{
while(transparencySegment + 1 < transparencyPoints.size() &&
value > transparencyPoints[transparencySegment + 1].index)
{
++transparencySegment;
}
const TransparencyData& p0 = transparencyPoints[transparencySegment];
const TransparencyData& p1 = transparencyPoints[transparencySegment + 1];
const float range = p1.index - p0.index;
const float t = (std::abs(range) > 1e-7f) ? Clamp01((value - p0.index) / range) : 0.0f;
alpha = Lerp(p0.transpValue, p1.transpValue, t);
}
}
float r = 0.0f;
float g = 0.0f;
float b = 0.0f;
if(!colorPoints.empty())
{
if(colorPoints.size() == 1 || value <= colorPoints.front().index)
{
r = colorPoints.front().color.x;
g = colorPoints.front().color.y;
b = colorPoints.front().color.z;
}
else if(value >= colorPoints.back().index)
{
r = colorPoints.back().color.x;
g = colorPoints.back().color.y;
b = colorPoints.back().color.z;
}
else
{
while(colorSegment + 1 < colorPoints.size() &&
value > colorPoints[colorSegment + 1].index)
{
++colorSegment;
}
const ColorData& p0 = colorPoints[colorSegment];
const ColorData& p1 = colorPoints[colorSegment + 1];
const float range = p1.index - p0.index;
const float t = (std::abs(range) > 1e-7f) ? Clamp01((value - p0.index) / range) : 0.0f;
r = Lerp(p0.color.x, p1.color.x, t);
g = Lerp(p0.color.y, p1.color.y, t);
b = Lerp(p0.color.z, p1.color.z, t);
}
}
*pixel++ = static_cast<byte>(Clamp01(b) * 255.0f);
*pixel++ = static_cast<byte>(Clamp01(g) * 255.0f);
*pixel++ = static_cast<byte>(Clamp01(r) * 255.0f);
*pixel++ = static_cast<byte>(Clamp01(alpha) * 255.0f);
}
texture.Apply();
return;
}
for(int i = 0; i < LUT_PIXEL_COUNT; ++i)
{
const float value = static_cast<float>(i) * LUT_INV_MAX_INDEX;
float alpha = 1.0f;
if(!transparencyPoints.empty())
{
if(transparencyPoints.size() == 1 || value <= transparencyPoints.front().index)
{
alpha = transparencyPoints.front().transpValue;
}
else if(value >= transparencyPoints.back().index)
{
alpha = transparencyPoints.back().transpValue;
}
else
{
while(transparencySegment + 1 < transparencyPoints.size() &&
value > transparencyPoints[transparencySegment + 1].index)
{
++transparencySegment;
}
const TransparencyData& p0 = transparencyPoints[transparencySegment];
const TransparencyData& p1 = transparencyPoints[transparencySegment + 1];
const float range = p1.index - p0.index;
const float t = (std::abs(range) > 1e-7f) ? Clamp01((value - p0.index) / range) : 0.0f;
alpha = Lerp(p0.transpValue, p1.transpValue, t);
}
}
float r = 0.0f;
float g = 0.0f;
float b = 0.0f;
if(!colorPoints.empty())
{
if(colorPoints.size() == 1 || value <= colorPoints.front().index)
{
r = colorPoints.front().color.x;
g = colorPoints.front().color.y;
b = colorPoints.front().color.z;
}
else if(value >= colorPoints.back().index)
{
r = colorPoints.back().color.x;
g = colorPoints.back().color.y;
b = colorPoints.back().color.z;
}
else
{
while(colorSegment + 1 < colorPoints.size() &&
value > colorPoints[colorSegment + 1].index)
{
++colorSegment;
}
const ColorData& p0 = colorPoints[colorSegment];
const ColorData& p1 = colorPoints[colorSegment + 1];
const float range = p1.index - p0.index;
const float t = (std::abs(range) > 1e-7f) ? Clamp01((value - p0.index) / range) : 0.0f;
r = Lerp(p0.color.x, p1.color.x, t);
g = Lerp(p0.color.y, p1.color.y, t);
b = Lerp(p0.color.z, p1.color.z, t);
}
}
const int x = (i & 255);
const int y = (i >> 8);
texture.SetPixelNoApply(x, y, Color(Clamp01(r), Clamp01(g), Clamp01(b), Clamp01(alpha)));
}
texture.Apply();
}

33
TSE-RTS/src/elements/visualizationData.hpp
View File

@@ -1,33 +0,0 @@
#pragma once
#include "Types.hpp"
#include "Vector3.hpp"
#include "elements/Texture.hpp"
#include <cstddef>
using namespace TSE;
struct TransparencyData
{
float index;
float transpValue;
};
struct ColorData
{
Vector3 color;
float index;
};
struct VisualizationData
{
public:
TransparencyData* transparency = nullptr;
ColorData* colors = nullptr;
std::size_t transparencyCount = 0;
std::size_t colorCount = 0;
static VisualizationData LoadVisualizationSetting(string path);
void FillLUTTexture(Texture& texture) const;
};

521
TSE-RTS/src/game.cpp
View File

@@ -1,291 +1,232 @@
#include "game.hpp" #include "game.hpp"
#include "elements/Transformable.hpp" #include "elements/Transformable.hpp"
#include "BehaviourScripts/TileMap.hpp" #include "BehaviourScripts/TileMap.hpp"
#include "BehaviourScripts/OrdererSpriteSet.hpp" #include "BehaviourScripts/OrdererSpriteSet.hpp"
#include "BehaviourScripts/Renderable.hpp" #include "BehaviourScripts/Renderable.hpp"
#include "elements/ShaderRegistry.hpp" #include "elements/ShaderRegistry.hpp"
#include "Vector2.hpp" #include "Vector2.hpp"
#include "Vector3.hpp" #include <cmath>
#include <cmath> #include "PerlinNoise.hpp"
#include "PerlinNoise.hpp" #include "BehaviourScripts/Camera.hpp"
#include "BehaviourScripts/Camera.hpp" #include "interfaces/IRenderTexture.hpp"
#include "interfaces/IRenderTexture.hpp" #include "BehaviourScripts/MeshContainer.hpp"
#include "BehaviourScripts/MeshContainer.hpp" #include "BehaviourScripts/CameraSizeChangeNotifyer.hpp"
#include "BehaviourScripts/CameraSizeChangeNotifyer.hpp" #include "BehaviourScripts/RenderTextureResizes.hpp"
#include "BehaviourScripts/RenderTextureResizes.hpp" #include "BehaviourScripts/CanvasScaler.hpp"
#include "BehaviourScripts/CanvasScaler.hpp" #include "Random.hpp"
#include "Random.hpp"
#include "elements/VolumeTexture3D.hpp" #define circleRadius 32
#include "elements/visualizationData.hpp" #define circleFallof 25
#define treeCircleRadius 27
#define circleRadius 32 #define treeCircleFallof 20
#define circleFallof 25
#define treeCircleRadius 27 void game::setup(TSE::Scene* s, TSE::IWindow* wnd)
#define treeCircleFallof 20 {
using namespace TSE;
void game::setup(TSE::Scene* s, TSE::IWindow* wnd) s->AddLayer(&gameLayer);
{ s->AddLayer(&propsLayer);
using namespace TSE;
//s->AddLayer(&gameLayer); TileMap* maps[4];
// s->AddLayer(&propsLayer); OrdererSpriteSet* props;
Material* tileMapMaterial = new Material("tileSetMat", ShaderRegistry::GetShader("TileMapShader v2"));
// TileMap* maps[4]; tileMapMaterial->SetValue("spritePivot", Vector2(0,0));
// OrdererSpriteSet* props; Texture* setTexture = new Texture("tiles.png");
// Material* tileMapMaterial = new Material("tileSetMat", ShaderRegistry::GetShader("TileMapShader v2")); TileSet* set = new TileSet(setTexture, 10, 10);
// tileMapMaterial->SetValue("spritePivot", Vector2(0,0));
// Texture* setTexture = new Texture("tiles.png"); for (int i = 0; i < 4; i++)
// TileSet* set = new TileSet(setTexture, 10, 10); {
Transformable* tileMap = new Transformable("tileMapL" + std::to_string(i));
// for (int i = 0; i < 4; i++) tileMap->position += {0,0.5f * i,0};
// { gameLayer.AddTransformable(tileMap);
// Transformable* tileMap = new Transformable("tileMapL" + std::to_string(i)); TileMap* map = new TileMap();
// tileMap->position += {0,0.5f * i,0}; map->chunkSize = 12;
// gameLayer.AddTransformable(tileMap); map->set = set;
// TileMap* map = new TileMap();
// map->chunkSize = 12; Renderable* rnd = new Renderable(tileMapMaterial);
// map->set = set;
tileMap->AddBehaviourScript(map);
// Renderable* rnd = new Renderable(tileMapMaterial); tileMap->AddBehaviourScript(rnd);
// tileMap->AddBehaviourScript(map); maps[i] = map;
// tileMap->AddBehaviourScript(rnd); }
// maps[i] = map; Material* objectsMaterial = new Material("objectsTileSetMat", ShaderRegistry::GetShader("Basic Ordered Sprite Set Shader"));
// } Texture* treeSetTexture = new Texture("trees.png");
TileSet* treeSet = new TileSet(treeSetTexture, 6, 2);
// Material* objectsMaterial = new Material("objectsTileSetMat", ShaderRegistry::GetShader("Basic Ordered Sprite Set Shader")); Transformable* tileMap = new Transformable("propMap");
// Texture* treeSetTexture = new Texture("trees.png"); propsLayer.AddTransformable(tileMap);
// TileSet* treeSet = new TileSet(treeSetTexture, 6, 2); OrdererSpriteSet* map = new OrdererSpriteSet();
// Transformable* tileMap = new Transformable("propMap"); map->chunkSize = 12;
// propsLayer.AddTransformable(tileMap); map->set = treeSet;
// OrdererSpriteSet* map = new OrdererSpriteSet(); //map->SpriteScale = Vector2(1,2);
// map->chunkSize = 12;
// map->set = treeSet; Renderable* rend = new Renderable(objectsMaterial);
// //map->SpriteScale = Vector2(1,2);
tileMap->AddBehaviourScript(map);
// Renderable* rend = new Renderable(objectsMaterial); tileMap->AddBehaviourScript(rend);
// tileMap->AddBehaviourScript(map); props = map;
// tileMap->AddBehaviourScript(rend);
// props = map; Random rnd = Random(12345u);
const siv::PerlinNoise perlin{ rnd.nextUInt() };
// Random rnd = Random(12345u); const siv::PerlinNoise perlin2{ rnd.nextUInt() };
// const siv::PerlinNoise perlin{ rnd.nextUInt() }; for (int x = circleRadius * -4; x < circleRadius * 4; x++)
// const siv::PerlinNoise perlin2{ rnd.nextUInt() }; {
for (int y = circleRadius * -4; y < circleRadius * 4; y++)
// for (int x = circleRadius * -4; x < circleRadius * 4; x++) {
// { float noise = (float)perlin.octave2D_01(x * 0.05f,y * 0.05f, 4);
// for (int y = circleRadius * -4; y < circleRadius * 4; y++) float treeNoise = (float)perlin2.octave2D_01(x * 0.05f,y * 0.05f, 2);
// { float noiseFallof = 1;
// float noise = (float)perlin.octave2D_01(x * 0.05f,y * 0.05f, 4); float treeNoiseFallof = 1;
// float treeNoise = (float)perlin2.octave2D_01(x * 0.05f,y * 0.05f, 2); Vector2 realpos = maps[0]->TileMapToRealPos(Vector2(x,y));
// float noiseFallof = 1; Vector2 realposprop = (maps[0]->TileMapToRealPos(Vector2(x,y)) + Vector2(0, 0.25f)) * Vector2(1,0.5f);
// float treeNoiseFallof = 1; realpos *= {1,1.5f};
// Vector2 realpos = maps[0]->TileMapToRealPos(Vector2(x,y)); float dist = realpos.Length();
// Vector2 realposprop = (maps[0]->TileMapToRealPos(Vector2(x,y)) + Vector2(0, 0.25f)) * Vector2(1,0.5f); if(dist <= circleRadius && dist >= circleFallof)
// realpos *= {1,1.5f}; {
// float dist = realpos.Length(); float reldist = dist - circleFallof;
// if(dist <= circleRadius && dist >= circleFallof) noiseFallof = (reldist / (circleRadius - circleFallof) - 1) * -1;
// { }
// float reldist = dist - circleFallof; if(dist <= treeCircleRadius && dist >= treeCircleFallof)
// noiseFallof = (reldist / (circleRadius - circleFallof) - 1) * -1; {
// } float reldist = dist - treeCircleFallof;
// if(dist <= treeCircleRadius && dist >= treeCircleFallof) treeNoiseFallof = (reldist / (treeCircleRadius - treeCircleFallof) - 1) * -1;
// { }
// float reldist = dist - treeCircleFallof; else if (dist > treeCircleRadius)
// treeNoiseFallof = (reldist / (treeCircleRadius - treeCircleFallof) - 1) * -1; treeNoiseFallof = 0;
// } noise *= noiseFallof;
// else if (dist > treeCircleRadius) treeNoise *= treeNoiseFallof;
// treeNoiseFallof = 0; if(dist <= circleRadius && noise >= 0.2f)
// noise *= noiseFallof; {
// treeNoise *= treeNoiseFallof; float treernd = rnd.nextFloat01();
// if(dist <= circleRadius && noise >= 0.2f) int treeid = 0;
// { if(noise >= 0.8f)
// float treernd = rnd.nextFloat01(); {
// int treeid = 0; if(treeNoise > 0.5f && treernd > 0.4f)
// if(noise >= 0.8f) {
// { treeid = rnd.nextInt(0,5);
// if(treeNoise > 0.5f && treernd > 0.4f) props->SetSprite(realposprop + Vector2(0, 0.75f), Vector2(treeid, 1), 4.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0));
// { }
// treeid = rnd.nextInt(0,5); maps[3]->SetTile(Vector2(x, y), {0,9}, {1,9});
// props->SetSprite(realposprop + Vector2(0, 0.75f), Vector2(treeid, 1), 4.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0)); }
// } else if(noise >= 0.6f)
// maps[3]->SetTile(Vector2(x, y), {0,9}, {1,9}); {
// } if(treeNoise > 0.5f && treernd > 0.4f)
// else if(noise >= 0.6f) {
// { treeid = rnd.nextInt(0,5);
// if(treeNoise > 0.5f && treernd > 0.4f) props->SetSprite(realposprop + Vector2(0, 0.5f), Vector2(treeid, 1), 3.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0));
// { }
// treeid = rnd.nextInt(0,5); maps[2]->SetTile(Vector2(x, y), {0,9}, {1,9});
// props->SetSprite(realposprop + Vector2(0, 0.5f), Vector2(treeid, 1), 3.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0)); }
// } else if(noise >= 0.4f)
// maps[2]->SetTile(Vector2(x, y), {0,9}, {1,9}); {
// } if(treeNoise > 0.5f && treernd > 0.4f)
// else if(noise >= 0.4f) {
// { treeid = rnd.nextInt(0,5);
// if(treeNoise > 0.5f && treernd > 0.4f) props->SetSprite(realposprop + Vector2(0, 0.25f), Vector2(treeid, 1), 2.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0));
// { }
// treeid = rnd.nextInt(0,5); maps[1]->SetTile(Vector2(x, y), {0,9}, {1,9});
// props->SetSprite(realposprop + Vector2(0, 0.25f), Vector2(treeid, 1), 2.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0)); }
// } else
// maps[1]->SetTile(Vector2(x, y), {0,9}, {1,9}); {
// } if(treeNoise > 0.5f && treernd > 0.4f)
// else {
// { treeid = rnd.nextInt(0,5);
// if(treeNoise > 0.5f && treernd > 0.4f) props->SetSprite(realposprop, Vector2(treeid, 1), 1.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0));
// { }
// treeid = rnd.nextInt(0,5); maps[0]->SetTile(Vector2(x, y), {0,9}, {1,9});
// props->SetSprite(realposprop, Vector2(treeid, 1), 1.5f / 10.0f, Vector2(1,2), Vector2(treeid, 0)); }
// } }
// maps[0]->SetTile(Vector2(x, y), {0,9}, {1,9}); }
// } }
// }
// } //RenderingLayer
// }
s->AddLayer(&renderingLayer);
//RenderingLayer s->AddLayer(&characterLayer);
s->AddLayer(&renderingLayer); Transformable* player = new Transformable("Player");
float smallDicomDevider = 16.0f; Transformable* lastPassCamera = new Transformable("lastPassCamera");
Camera* lpCam = new Camera();
Texture* lutTexture = new Texture(256, 256, 32); lpCam->SetRenderTarget(wnd);
VisualizationData data = VisualizationData::LoadVisualizationSetting("./DCMVizPresets/Preset1.json"); lpCam->SetRenderScale(1);
data.FillLUTTexture(*lutTexture); lpCam->layersNotToRender.push_back(gameLayer.GetID());
lpCam->layersNotToRender.push_back(propsLayer.GetID());
VolumeTexture3D* dicom = new VolumeTexture3D("./DCM"); lpCam->layersNotToRender.push_back(characterLayer.GetID());
Vector3 textureSize = {dicom->Width(), dicom->Height(), dicom->Depth()}; lastPassCamera->AddBehaviourScript(lpCam);
Vector3 smallTextureSize = { ceilf(textureSize.x / smallDicomDevider), ceilf(textureSize.y / smallDicomDevider), ceilf(textureSize.z / smallDicomDevider)}; CameraSizeChangeNotifyer* camNotifyer = new CameraSizeChangeNotifyer();
VolumeTexture3D* dicomSmall = new VolumeTexture3D(smallTextureSize, 32); camNotifyer->lastSize = {0,0};
camNotifyer->camToObserver = lpCam;
for(int x = 0; x < smallTextureSize.x; x++) lastPassCamera->AddBehaviourScript(camNotifyer);
{
for(int y = 0; y < smallTextureSize.y; y++) Vector2 canvasSize = wnd->GetSize() / 4.0f;
{
for(int z = 0; z < smallTextureSize.z; z++) IRenderTexture* rt = IRenderTexture::factory->CreateTextureHeap(canvasSize, 3);
{ Transformable* firstPassCamera = new Transformable("firstPassCamera");
float value = 0; Camera* fpCam = new Camera();
for(int sx = 0; sx < smallDicomDevider; sx++) fpCam->SetRenderScale(256);
{ fpCam->SetRenderTarget(rt);
for(int sy = 0; sy < smallDicomDevider; sy++) fpCam->layersNotToRender.push_back(renderingLayer.GetID());
{ fpCam->layersNotToRender.push_back(propsLayer.GetID());
for(int sz = 0; sz < smallDicomDevider; sz++) fpCam->layersNotToRender.push_back(characterLayer.GetID());
{ firstPassCamera->AddBehaviourScript(fpCam);
Color c; RenderTextureResizes* resizer = new RenderTextureResizes();
Vector3 pos = Vector3(x * smallDicomDevider + sx, y * smallDicomDevider + sy, z * smallDicomDevider + sz); resizer->rt = rt;
if(pos.x < dicom->Width() && pos.y < dicom->Height() && pos.z < dicom->Depth()) camNotifyer->Observe(resizer);
{ firstPassCamera->AddBehaviourScript(resizer);
dicom->GetPixel(pos, c); firstPassCamera->SetParent(player);
ushort index = (ushort)(c.r * 65536.0f);
int x = index & 0xFF; IRenderTexture* rtProps = IRenderTexture::factory->CreateTextureHeap(canvasSize, 3);
int y = index >> 8; Transformable* secondPassCamera = new Transformable("secondPassCamera");
Camera* spCam = new Camera();
lutTexture->GetPixel(x, y, c); spCam->SetRenderScale(256);
value = fmax(c.a, value); spCam->SetRenderTarget(rtProps);
} spCam->layersNotToRender.push_back(renderingLayer.GetID());
} spCam->layersNotToRender.push_back(gameLayer.GetID());
} spCam->layersNotToRender.push_back(characterLayer.GetID());
} secondPassCamera->AddBehaviourScript(spCam);
dicomSmall->SetPixelNoApply(x,y,z, Color(value, value, value, value)); RenderTextureResizes* resizerProps = new RenderTextureResizes();
} resizerProps->rt = rtProps;
} camNotifyer->Observe(resizerProps);
} secondPassCamera->AddBehaviourScript(resizerProps);
dicomSmall->Apply(); secondPassCamera->SetParent(player);
//s->AddLayer(&characterLayer); //Render pipeline setup
Transformable* player = new Transformable("Player"); characterLayer.AddTransformable(player);
renderingLayer.AddTransformable(lastPassCamera);
Transformable* lastPassCamera = new Transformable("lastPassCamera");
Camera* lpCam = new Camera(); //final
lpCam->SetRenderTarget(wnd);
lpCam->SetRenderScale(0.0025f); Mesh* canvasMesh = new Mesh(Mesh::GetQuadMesh());
lpCam->SetFarClippingPlane(1000); for(auto& vertex : canvasMesh->vertecies)
lpCam->layersNotToRender.push_back(gameLayer.GetID()); {
lpCam->layersNotToRender.push_back(propsLayer.GetID()); vertex *= wnd->GetSize();
lpCam->layersNotToRender.push_back(characterLayer.GetID()); }
lastPassCamera->AddBehaviourScript(lpCam); MeshContainer* canvasContainer = new MeshContainer(canvasMesh);
CameraSizeChangeNotifyer* camNotifyer = new CameraSizeChangeNotifyer();
camNotifyer->lastSize = {0,0}; Material* canvasMat = new Material("canvasMat", ShaderRegistry::GetShader("LastPassShader"));
camNotifyer->camToObserver = lpCam; canvasMat->SetValue<float>("threshold", 0.01f);
lastPassCamera->AddBehaviourScript(camNotifyer); canvasMat->SetValue<float>("darken", 0.15f);
lastPassCamera->position = Vector3(-0.7f, -0.1f, 0); canvasMat->SetValue<uint>("colorTextureID", rt->GetTextureId(0));
lastPassCamera->SetEuler(Vector3(-16.7f, 0.3f, -0.2f)); canvasMat->SetValue<uint>("heightTextureID", rt->GetTextureId(1));
canvasMat->SetValue<uint>("depthTextureID", rt->GetTextureId(2));
Vector2 canvasSize = wnd->GetSize() / 4.0f; canvasMat->SetValue<uint>("colorTexture2ID", rtProps->GetTextureId(0));
canvasMat->SetValue<uint>("heightTexture2ID", rtProps->GetTextureId(1));
// IRenderTexture* rt = IRenderTexture::factory->CreateTextureHeap(canvasSize, 3); canvasMat->SetValue<uint>("depthTexture2ID", rtProps->GetTextureId(2));
// Transformable* firstPassCamera = new Transformable("firstPassCamera"); Renderable* canvasRenderer = new Renderable(canvasMat);
// Camera* fpCam = new Camera();
// fpCam->SetRenderScale(256); CanvasScaler* canvasScaler = new CanvasScaler();
// fpCam->SetRenderTarget(rt); canvasScaler->mesh = canvasMesh;
// fpCam->layersNotToRender.push_back(renderingLayer.GetID()); camNotifyer->Observe(canvasScaler);
// fpCam->layersNotToRender.push_back(propsLayer.GetID());
// fpCam->layersNotToRender.push_back(characterLayer.GetID()); lastPassCamera->AddBehaviourScript(canvasContainer);
// firstPassCamera->AddBehaviourScript(fpCam); lastPassCamera->AddBehaviourScript(canvasRenderer);
// RenderTextureResizes* resizer = new RenderTextureResizes(); lastPassCamera->AddBehaviourScript(canvasScaler);
// resizer->rt = rt;
// camNotifyer->Observe(resizer); //propper resize stuff for prior passes, and canvas, and implement LastPassShader siehe dazu den chat: https://chatgpt.com/c/69985c47-6a50-838b-852d-45bb0b8454e5
// firstPassCamera->AddBehaviourScript(resizer);
// firstPassCamera->SetParent(player);
// IRenderTexture* rtProps = IRenderTexture::factory->CreateTextureHeap(canvasSize, 3);
// Transformable* secondPassCamera = new Transformable("secondPassCamera");
// Camera* spCam = new Camera();
// spCam->SetRenderScale(256);
// spCam->SetRenderTarget(rtProps);
// spCam->layersNotToRender.push_back(renderingLayer.GetID());
// spCam->layersNotToRender.push_back(gameLayer.GetID());
// spCam->layersNotToRender.push_back(characterLayer.GetID());
// secondPassCamera->AddBehaviourScript(spCam);
// RenderTextureResizes* resizerProps = new RenderTextureResizes();
// resizerProps->rt = rtProps;
// camNotifyer->Observe(resizerProps);
// secondPassCamera->AddBehaviourScript(resizerProps);
// secondPassCamera->SetParent(player);
//Render pipeline setup
// characterLayer.AddTransformable(player);
renderingLayer.AddTransformable(lastPassCamera);
//final
Mesh* canvasMesh = new Mesh(Mesh::GetQuadMesh());
for(auto& vertex : canvasMesh->vertecies)
{
vertex *= 2;
}
MeshContainer* canvasContainer = new MeshContainer(canvasMesh);
Material* canvasMat = new Material("canvasMat", ShaderRegistry::GetShader("DICOMShader"));
canvasMat->SetValue<float>("threshold", 0.4f);
canvasMat->SetValue<float>("stepSize", 0.01f);
canvasMat->SetValue<float>("brickSize", smallDicomDevider);
canvasMat->SetValue<Vector3>("texSize", textureSize);
canvasMat->SetValue<Vector3>("smallTexSize", smallTextureSize);
Vector3 objectScale = Vector3(1,1,1);
canvasMat->SetValue<Vector3>("ObjectScale", objectScale);
canvasMat->SetValue<ITexture*>("DICOM", dicom);
canvasMat->SetValue<ITexture*>("DICOMsmall", dicomSmall);
canvasMat->SetValue<ITexture*>("LUT", lutTexture);
// canvasMat->SetValue<uint>("heightTextureID", rt->GetTextureId(1));
// canvasMat->SetValue<uint>("depthTextureID", rt->GetTextureId(2));
// canvasMat->SetValue<uint>("colorTexture2ID", rtProps->GetTextureId(0));
// canvasMat->SetValue<uint>("heightTexture2ID", rtProps->GetTextureId(1));
// canvasMat->SetValue<uint>("depthTexture2ID", rtProps->GetTextureId(2));
Renderable* canvasRenderer = new Renderable(canvasMat);
CanvasScaler* canvasScaler = new CanvasScaler();
canvasScaler->mesh = canvasMesh;
camNotifyer->Observe(canvasScaler);
lastPassCamera->AddBehaviourScript(canvasContainer);
lastPassCamera->AddBehaviourScript(canvasRenderer);
lastPassCamera->AddBehaviourScript(canvasScaler);
//propper resize stuff for prior passes, and canvas, and implement LastPassShader siehe dazu den chat: https://chatgpt.com/c/69985c47-6a50-838b-852d-45bb0b8454e5
} }

273
TSE-RTS/src/main.cpp
View File

@@ -1,141 +1,134 @@
#include <iostream> #include <iostream>
#include "GL/gl3w.h" #include "GL/gl3w.h"
#include "globalVars.hpp" #include "globalVars.hpp"
#include "WindowManager.hpp" #include "WindowManager.hpp"
#if defined(TSE_GLFW) #if defined(TSE_GLFW)
#include "WindowGlfw.hpp" #include "WindowGlfw.hpp"
#elif defined(TSE_SDL3) #elif defined(TSE_SDL3)
#include "WindowSdl3.hpp" #include "WindowSdl3.hpp"
#endif #endif
#include "OpenGLRenderingBackend.hpp" #include "OpenGLRenderingBackend.hpp"
#include "imgui/imgui.h" #include "imgui/imgui.h"
#include "shader/defaultShaderHandler.cpp" #include "shader/defaultShaderHandler.cpp"
#include "DefaultRendererOpenGL.hpp" #include "DefaultRendererOpenGL.hpp"
#include "BehaviourScripts/RectBase.hpp" #include "BehaviourScripts/RectBase.hpp"
#include "BehaviourScripts/Renderable.hpp" #include "BehaviourScripts/Renderable.hpp"
#include "BehaviourScripts/Camera.hpp" #include "BehaviourScripts/Camera.hpp"
#include "elements/Sprite.hpp" #include "elements/Sprite.hpp"
#include "elements/Texture.hpp" #include "elements/Texture.hpp"
#include "elements/Layer.hpp" #include "elements/Layer.hpp"
#include "elements/Scene.hpp" #include "elements/Scene.hpp"
#include "EditorSubsystem.hpp" #include "EditorSubsystem.hpp"
#include "game.hpp" #include "game.hpp"
#include "shaders/TileMapShader.hpp" #include "shaders/TileMapShader.hpp"
#include "shaders/LastPassShader.hpp" #include "shaders/LastPassShader.hpp"
#include "shaders/DICOMShader.hpp"
#define USE_EDITOR
#define USE_EDITOR
using namespace TSE;
using namespace TSE; #if defined(TSE_GLFW)
#if defined(TSE_GLFW) using namespace TSE::GLFW;
using namespace TSE::GLFW; #elif defined(TSE_SDL3)
#elif defined(TSE_SDL3) using namespace TSE::SDL3;
using namespace TSE::SDL3; #endif
#endif using namespace TSE::OpenGL;
using namespace TSE::OpenGL; using namespace TSE::EDITOR;
using namespace TSE::EDITOR;
IWindow* wnd = nullptr;
IWindow* wnd = nullptr; DefaultRendererOpenGL* rend = nullptr;
DefaultRendererOpenGL* rend = nullptr; Scene* currentScene = nullptr;
Scene* currentScene = nullptr; Layer* planeteryLayer = nullptr;
Layer* planeteryLayer = nullptr; EditorSubsystem* editor;
EditorSubsystem* editor;
void SetupWindow()
void SetupWindow() {
{ Color backColor(0.0f, 0.0f, 0.0f, 0.0f);
Color backColor(0.0f, 0.0f, 0.0f, 0.0f); #if defined(TSE_GLFW)
#if defined(TSE_GLFW) #ifdef USE_EDITOR
#ifdef USE_EDITOR wnd = new WindowGlfw(PROJECT_NAME, 800, 600, new OpenGLRenderingBackend(backColor, false, 8, true), WindowType::Maximized);
wnd = new WindowGlfw(PROJECT_NAME, 800, 600, new OpenGLRenderingBackend(backColor, false, 8, true), WindowType::Maximized); editor = new EditorSubsystem();
editor = new EditorSubsystem(); #else
#else wnd = new WindowGlfw(PROJECT_NAME, 1920, 1080, new OpenGLRenderingBackend(backColor, false, 8, false), WindowType::Fullscreen);
wnd = new WindowGlfw(PROJECT_NAME, 1920, 1080, new OpenGLRenderingBackend(backColor, false, 8, false), WindowType::Fullscreen); #endif
#endif #elif defined(TSE_SDL3)
#elif defined(TSE_SDL3) #ifdef USE_EDITOR
#ifdef USE_EDITOR wnd = new WindowSdl3(PROJECT_NAME, 800, 600, new OpenGLRenderingBackend(backColor, false, 8, true), WindowType::Maximized);
wnd = new WindowSdl3(PROJECT_NAME, 800, 600, new OpenGLRenderingBackend(backColor, false, 8, true), WindowType::Maximized); editor = new EditorSubsystem();
editor = new EditorSubsystem(); #else
#else wnd = new WindowSdl3(PROJECT_NAME, 1920, 1080, new OpenGLRenderingBackend(backColor, false, 8, false), WindowType::Fullscreen);
wnd = new WindowSdl3(PROJECT_NAME, 1920, 1080, new OpenGLRenderingBackend(backColor, false, 8, false), WindowType::Fullscreen); #endif
#endif #endif
#endif
LoadBasicShaders(wnd->GetSize().x, wnd->GetSize().y);
LoadBasicShaders(wnd->GetSize().x, wnd->GetSize().y); TileMapShader::Init(wnd->GetSize().x, wnd->GetSize().y);
TileMapShader::Init(wnd->GetSize().x, wnd->GetSize().y); LastPassShader::Init(wnd->GetSize().x, wnd->GetSize().y);
LastPassShader::Init(wnd->GetSize().x, wnd->GetSize().y); ShaderRegistry::SetShader("TileMapShader v2", TileMapShader::Instance());
DICOMShader::Init(wnd->GetSize().x, wnd->GetSize().y); ShaderRegistry::SetShader("LastPassShader", LastPassShader::Instance());
ShaderRegistry::SetShader("TileMapShader v2", TileMapShader::Instance());
ShaderRegistry::SetShader("LastPassShader", LastPassShader::Instance()); rend = new DefaultRendererOpenGL(*BasicShader::Instance());
ShaderRegistry::SetShader("DICOMShader", DICOMShader::Instance()); currentScene = new Scene();
rend = new DefaultRendererOpenGL(*BasicShader::Instance()); #ifdef USE_EDITOR
currentScene = new Scene(); ((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->layersNotToRender.push_back(game::renderingLayer.GetID());
((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->SetRenderScale(128);
#ifdef USE_EDITOR currentScene->AddLayer(&editor->editorLayer);
//((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->layersNotToRender.push_back(game::renderingLayer.GetID()); editor->hv.SetScene(currentScene);
((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->SetRenderScale(0.002f); #endif
((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->SetFarClippingPlane(1000);
((Camera*)Transformable::Find(".EditorCamera")->GetBehaviourScript(CAMERA))->SetNearClippingPlane(0.1f);
Transformable::Find(".EditorCamera")->position = Vector3(-30.678f, 618.352f, 139.872f); game::setup(currentScene, wnd);
Transformable::Find(".EditorCamera")->rotation = Quaternion::FromEulerAngles(Vector3(86.348f, -0.450f, 9.699f));
currentScene->AddLayer(&editor->editorLayer); wnd->DoneSetup();
editor->hv.SetScene(currentScene); }
#endif
void CleanUp()
{
game::setup(currentScene, wnd); #ifdef USE_EDITOR
delete(editor);
wnd->DoneSetup(); #endif
}
UnLoadBasicShaders();
void CleanUp() }
{
#ifdef USE_EDITOR void GameLoop()
delete(editor); {
#endif while(!wnd->ShouldClose())
{
UnLoadBasicShaders(); wnd->Clear();
} rend->Begin();
void GameLoop() if(currentScene != nullptr)
{ currentScene->Render(*rend, *wnd);
while(!wnd->ShouldClose())
{ rend->End();
wnd->Clear(); rend->Flush();
rend->Begin();
if(currentScene != nullptr)
if(currentScene != nullptr) currentScene->DoneRender();
currentScene->Render(*rend, *wnd);
#ifdef USE_EDITOR
rend->End(); editor->controller.Update();
rend->Flush(); #endif
wnd->Update();
if(currentScene != nullptr) if(currentScene != nullptr)
currentScene->DoneRender(); currentScene->Update();
}
#ifdef USE_EDITOR }
editor->controller.Update();
#endif
wnd->Update(); int main(int argc, char** argv)
if(currentScene != nullptr) {
currentScene->Update(); SetupWindow();
}
} GameLoop();
CleanUp();
int main(int argc, char** argv) return 0;
{ }
SetupWindow();
#if defined(_WIN32)
GameLoop(); extern "C" {
__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001; // NVIDIA
CleanUp(); __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; // AMD
return 0; }
}
#if defined(_WIN32)
extern "C" {
__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001; // NVIDIA
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; // AMD
}
#endif #endif

131
TSE-RTS/src/shaders/DICOMShader.cpp
View File

@@ -1,131 +0,0 @@
#include "DICOMShader.hpp"
#include "DICOMShaderGLSL.hpp"
#include "BehaviourScripts/Renderable.hpp"
#include "Color.hpp"
using namespace TSE;
using namespace TSE::OpenGL;
#define SHADER_VERTEX_INDEX 0
#define SHADER_UV_INDEX 1
#define SHADER_PACKAGE_SIZE (sizeof(float) * (3 + 2))
DICOMShader* DICOMShader::instance = nullptr;
DICOMShader *DICOMShader::Instance()
{
return instance;
}
void DICOMShader::Destroy()
{
if(instance != nullptr)
delete instance;
instance = nullptr;
}
void DICOMShader::Init(float width, float height)
{
std::vector<std::unique_ptr<ShaderPart>> parts;
parts.push_back(ShaderPart::LoadFromString(vertDICOM, GL_VERTEX_SHADER));
parts.push_back(ShaderPart::LoadFromString(fragDICOM, GL_FRAGMENT_SHADER));
instance = new DICOMShader(std::move(parts));
instance->Enable();
instance->SetUniform("DICOMTexture", 0);
instance->SetUniform("SmallDICOMTexture", 1);
instance->SetUniform("LUTTexture", 2);
instance->SetUniform("Threshold", 0.5f);
instance->SetUniform("TexSize", &Vector3::zero);
instance->SetUniform("SmallTexSize", &Vector3::zero);
instance->SetUniform("StepSize", 0.5f);
instance->Disable();
}
DICOMShader::DICOMShader(std::vector<std::unique_ptr<TSE::OpenGL::ShaderPart>> &&parts) : Shader(parts)
{
PackageSize = SHADER_PACKAGE_SIZE;
}
void DICOMShader::OnEnable() const
{
glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)0);
glEnableVertexAttribArray(SHADER_UV_INDEX);
glVertexAttribPointer(SHADER_UV_INDEX, 2, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 3));
}
void DICOMShader::OnDisable() const
{
glDisableVertexAttribArray(SHADER_VERTEX_INDEX);
glDisableVertexAttribArray(SHADER_UV_INDEX);
}
void DICOMShader::OnFlush()
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_3D, DICOM->GetTextureId());
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_3D, SmallDICOM->GetTextureId());
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, LUT->GetTextureId());
SetUniform("Threshold", Threshold);
if(stepSize < 0.001f) stepSize = 0.001f;
SetUniform("StepSize", stepSize);
SetUniform("TexSize", &size);
SetUniform("SmallTexSize", &smallSize);
SetUniform("ObjectScale", &scale);
SetUniform("BrickScale", brickSize);
}
void DICOMShader::OnDrawCall(int indexCount)
{
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, NULL);
}
void DICOMShader::OnSubmit(const TSE::Transformable &t, float *&target, TSE::TransformationStack &stack, void (*restartDrawcall)(TSE::IRenderer &), TSE::IRenderer &rnd)
{
auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
if (!r) return;
if(!r->GetMaterial()->HasValue("threshold")) return;
if(!r->GetMaterial()->HasValue("texSize")) return;
if(!r->GetMaterial()->HasValue("smallTexSize")) return;
if(!r->GetMaterial()->HasValue("DICOM")) return;
if(!r->GetMaterial()->HasValue("DICOMsmall")) return;
if(!r->GetMaterial()->HasValue("stepSize")) return;
if(!r->GetMaterial()->HasValue("ObjectScale")) return;
if(!r->GetMaterial()->HasValue("LUT")) return;
if(!r->GetMaterial()->HasValue("brickSize")) return;
Threshold = r->GetMaterial()->GetValue<float>("threshold");
stepSize = r->GetMaterial()->GetValue<float>("stepSize");
brickSize = r->GetMaterial()->GetValue<float>("brickSize");
size = r->GetMaterial()->GetValue<Vector3>("texSize");
smallSize = r->GetMaterial()->GetValue<Vector3>("smallTexSize");
scale = r->GetMaterial()->GetValue<Vector3>("ObjectScale");
DICOM = r->GetMaterial()->GetValue<ITexture*>("DICOM");
LUT = r->GetMaterial()->GetValue<ITexture*>("LUT");
SmallDICOM = r->GetMaterial()->GetValue<ITexture*>("DICOMsmall");
const Vector3* verts = r->GetVertices();
const Vector2* uvs = r->GetUVs();
ushort vCount = r->GetVertexCount();
Matrix4x4 matr = t.GetLocalMatrix();
stack.Push(matr);
const Matrix4x4& top = stack.Top();
for (ushort i = 0; i < vCount; i++) {
Vector3 p = top * verts[i];
Vector2 uv = uvs[i];
*target++ = p.x;
*target++ = p.y;
*target++ = p.z;
*target++ = uv.x;
*target++ = uv.y;
}
stack.Pop();
}

35
TSE-RTS/src/shaders/DICOMShader.hpp
View File

@@ -1,35 +0,0 @@
#pragma once
#include "GL/gl3w.h"
#include "GL/gl.h"
#include "shader/Shader.hpp"
#include "Types.hpp"
#include "interfaces/ITexture.hpp"
class DICOMShader : public TSE::OpenGL::Shader
{
private:
static DICOMShader* instance;
TSE::ITexture* DICOM;
TSE::ITexture* SmallDICOM;
TSE::ITexture* LUT;
TSE::Vector3 size;
TSE::Vector3 smallSize;
TSE::Vector3 scale;
float Threshold;
float stepSize;
float brickSize;
public:
static DICOMShader* Instance();
static void Destroy();
static void Init(float width, float height);
DICOMShader(std::vector<std::unique_ptr<TSE::OpenGL::ShaderPart>>&& parts);
protected:
void OnEnable() const override;
void OnDisable() const override;
void OnFlush() override;
void OnDrawCall(int indexCount) override;
void OnSubmit(const TSE::Transformable& t, float*& target, TSE::TransformationStack& stack, void (*restartDrawcall)(TSE::IRenderer&), TSE::IRenderer& rnd) override;
};

279
TSE-RTS/src/shaders/DICOMShaderGLSL.hpp
View File

@@ -1,279 +0,0 @@
#pragma once
inline const char* vertDICOM = R"(
#version 330 core
layout (location = 0) in vec3 position;
layout (location = 1) in vec2 uv;
uniform mat4 prMatrix;
uniform mat4 camMatrix;
out DATA
{
vec2 uv_out;
} vs_out;
void main()
{
gl_Position = vec4(position.x, position.y, 0.0, 1.0);
vs_out.uv_out = uv;
}
)";
inline const char* fragDICOM = R"(
#version 330 core
layout (location = 0) out vec4 color;
uniform sampler3D DICOMTexture;
uniform sampler3D SmallDICOMTexture;
uniform sampler2D LUTTexture;
uniform vec3 CamPos;
uniform vec3 CamRight;
uniform vec3 CamUp;
uniform vec3 CamForward;
uniform float OrthoLeft;
uniform float OrthoRight;
uniform float OrthoBottom;
uniform float OrthoTop;
uniform float NearPlane;
uniform float FarPlane;
uniform float Threshold;
uniform float StepSize;
uniform vec3 TexSize;
uniform vec3 SmallTexSize;
uniform vec3 ObjectScale;
uniform float BrickScale;
const float EPSILON = 1e-6;
in DATA
{
vec2 uv_out;
} fs_in;
bool IntersectAABB(vec3 rayOrigin, vec3 rayDir, vec3 boxMin, vec3 boxMax, out float tEnter, out float tExit)
{
vec3 invDir = 1.0 / rayDir;
vec3 t0 = (boxMin - rayOrigin) * invDir;
vec3 t1 = (boxMax - rayOrigin) * invDir;
vec3 tMin3 = min(t0, t1);
vec3 tMax3 = max(t0, t1);
tEnter = max(max(tMin3.x, tMin3.y), tMin3.z);
tExit = min(min(tMax3.x, tMax3.y), tMax3.z);
return tExit >= max(tEnter, 0.0);
}
void BuildOrthoRay(out vec3 rayOrigin, out vec3 rayDir)
{
vec2 uv = fs_in.uv_out;
float xView = mix(OrthoLeft, OrthoRight, uv.x);
float yView = mix(OrthoBottom, OrthoTop, uv.y);
rayOrigin = CamPos
+ CamRight * xView
+ CamUp * yView
+ CamForward * NearPlane;
rayDir = CamForward;
}
vec4 TraverseFineBlock(vec3 rayOrigin, vec3 rayDir, float blockTEnter, float blockTExit, ivec3 brickCoord, float brickScaleF, ivec3 gridSize, vec4 currColor)
{
int brickSize = int(brickScaleF);
ivec3 blockVoxelMin = brickCoord * brickSize;
ivec3 blockVoxelMax = min(blockVoxelMin + ivec3(brickSize - 1), gridSize - ivec3(1));
float t = blockTEnter + 1e-4;
vec3 pos = rayOrigin + rayDir * t;
ivec3 voxel = ivec3(floor(pos / ObjectScale));
voxel = clamp(voxel, blockVoxelMin, blockVoxelMax);
ivec3 step;
step.x = (rayDir.x > 0.0) ? 1 : ((rayDir.x < 0.0) ? -1 : 0);
step.y = (rayDir.y > 0.0) ? 1 : ((rayDir.y < 0.0) ? -1 : 0);
step.z = (rayDir.z > 0.0) ? 1 : ((rayDir.z < 0.0) ? -1 : 0);
vec3 tDelta;
tDelta.x = (step.x != 0) ? abs(ObjectScale.x / rayDir.x) : 1e30;
tDelta.y = (step.y != 0) ? abs(ObjectScale.y / rayDir.y) : 1e30;
tDelta.z = (step.z != 0) ? abs(ObjectScale.z / rayDir.z) : 1e30;
vec3 nextBoundary;
nextBoundary.x = (step.x > 0) ? (float(voxel.x) + 1.0) * ObjectScale.x : float(voxel.x) * ObjectScale.x;
nextBoundary.y = (step.y > 0) ? (float(voxel.y) + 1.0) * ObjectScale.y : float(voxel.y) * ObjectScale.y;
nextBoundary.z = (step.z > 0) ? (float(voxel.z) + 1.0) * ObjectScale.z : float(voxel.z) * ObjectScale.z;
vec3 tMax;
tMax.x = (step.x != 0) ? ((nextBoundary.x - rayOrigin.x) / rayDir.x) : 1e30;
tMax.y = (step.y != 0) ? ((nextBoundary.y - rayOrigin.y) / rayDir.y) : 1e30;
tMax.z = (step.z != 0) ? ((nextBoundary.z - rayOrigin.z) / rayDir.z) : 1e30;
int maxIters = brickSize * 3 + 8;
for (int i = 0; i < maxIters; ++i)
{
if (t > blockTExit)
break;
float density = texelFetch(DICOMTexture, voxel, 0).r;
uint v = uint(density * 65535.0 + 0.5);
uint x = v & 0xFFu;
uint y = v >> 8u;
vec4 lutValue = texelFetch(LUTTexture, ivec2(x, y), 0);
if (lutValue.a > EPSILON)
{
currColor.xyz += (1.0 - currColor.w) * lutValue.rgb * lutValue.a;
currColor.w += (1.0 - currColor.w) * lutValue.a;
if (currColor.w > 0.98)
break;
}
if (tMax.x <= tMax.y && tMax.x <= tMax.z)
{
voxel.x += step.x;
if (voxel.x < blockVoxelMin.x || voxel.x > blockVoxelMax.x) break;
t = tMax.x;
tMax.x += tDelta.x;
}
else if (tMax.y <= tMax.z)
{
voxel.y += step.y;
if (voxel.y < blockVoxelMin.y || voxel.y > blockVoxelMax.y) break;
t = tMax.y;
tMax.y += tDelta.y;
}
else
{
voxel.z += step.z;
if (voxel.z < blockVoxelMin.z || voxel.z > blockVoxelMax.z) break;
t = tMax.z;
tMax.z += tDelta.z;
}
}
return currColor;
}
vec4 RenderVoxelDDA(vec3 rayOrigin, vec3 rayDir)
{
ivec3 gridSize = ivec3(TexSize);
ivec3 smallGridSize = ivec3(SmallTexSize);
float brickScaleF = max(BrickScale, 1.0);
int brickSize = int(brickScaleF);
vec3 scaledSize = TexSize * ObjectScale;
vec3 boxMin = vec3(0.0);
vec3 boxMax = scaledSize;
float tEnter, tExit;
if (!IntersectAABB(rayOrigin, rayDir, boxMin, boxMax, tEnter, tExit))
return vec4(0.0, 0.0, 0.0, 1.0);
tEnter = max(tEnter, 0.0);
tExit = min(tExit, FarPlane - NearPlane);
vec3 brickWorldSize = ObjectScale * brickScaleF;
float t = tEnter + 1e-4;
vec3 pos = rayOrigin + rayDir * t;
ivec3 brick = ivec3(floor(pos / brickWorldSize));
ivec3 brickMax = smallGridSize - ivec3(1);
brick = clamp(brick, ivec3(0), brickMax);
ivec3 step;
step.x = (rayDir.x > 0.0) ? 1 : ((rayDir.x < 0.0) ? -1 : 0);
step.y = (rayDir.y > 0.0) ? 1 : ((rayDir.y < 0.0) ? -1 : 0);
step.z = (rayDir.z > 0.0) ? 1 : ((rayDir.z < 0.0) ? -1 : 0);
vec3 tDelta;
tDelta.x = (step.x != 0) ? abs(brickWorldSize.x / rayDir.x) : 1e30;
tDelta.y = (step.y != 0) ? abs(brickWorldSize.y / rayDir.y) : 1e30;
tDelta.z = (step.z != 0) ? abs(brickWorldSize.z / rayDir.z) : 1e30;
vec3 nextBoundary;
nextBoundary.x = (step.x > 0) ? (float(brick.x) + 1.0) * brickWorldSize.x : float(brick.x) * brickWorldSize.x;
nextBoundary.y = (step.y > 0) ? (float(brick.y) + 1.0) * brickWorldSize.y : float(brick.y) * brickWorldSize.y;
nextBoundary.z = (step.z > 0) ? (float(brick.z) + 1.0) * brickWorldSize.z : float(brick.z) * brickWorldSize.z;
vec3 tMax;
tMax.x = (step.x != 0) ? ((nextBoundary.x - rayOrigin.x) / rayDir.x) : 1e30;
tMax.y = (step.y != 0) ? ((nextBoundary.y - rayOrigin.y) / rayDir.y) : 1e30;
tMax.z = (step.z != 0) ? ((nextBoundary.z - rayOrigin.z) / rayDir.z) : 1e30;
int maxIters = smallGridSize.x + smallGridSize.y + smallGridSize.z + 8;
float count = 0;
float increment = StepSize;
vec4 colorAcum = vec4(0.0);
for (int i = 0; i < maxIters; ++i)
{
if (t > tExit)
break;
float brickDensity = texelFetch(SmallDICOMTexture, brick, 0).r;
float cellTExit = min(min(tMax.x, tMax.y), tMax.z);
cellTExit = min(cellTExit, tExit);
if (brickDensity >= EPSILON)
{
colorAcum = TraverseFineBlock(rayOrigin, rayDir, t, cellTExit, brick, brickScaleF, gridSize, colorAcum);
if (colorAcum.w > 0.98)
break;
}
if (tMax.x <= tMax.y && tMax.x <= tMax.z)
{
brick.x += step.x;
if (brick.x < 0 || brick.x > brickMax.x) break;
t = tMax.x;
tMax.x += tDelta.x;
}
else if (tMax.y <= tMax.z)
{
brick.y += step.y;
if (brick.y < 0 || brick.y > brickMax.y) break;
t = tMax.y;
tMax.y += tDelta.y;
}
else
{
brick.z += step.z;
if (brick.z < 0 || brick.z > brickMax.z) break;
t = tMax.z;
tMax.z += tDelta.z;
}
}
//return vec4(colorAcum.w, colorAcum.w, colorAcum.w, 1.0);
return vec4(colorAcum.x, colorAcum.y, colorAcum.z, 1.0);
}
void main()
{
vec3 rayOrigin, rayDir;
BuildOrthoRay(rayOrigin, rayDir);
color = RenderVoxelDDA(rayOrigin, rayDir);
}
)";