josh/FractalInspector
1
0
Fork 0
Code Issues 13 Pull Requests Packages Projects 1 Releases 2 Wiki Activity
Files
d93e6b6b904a6e9a03c9c81e2a3ccf66094fab36
FractalInspector/main.cpp
dawsh d93e6b6b90 Yeet
2025-05-04 02:36:52 -05:00

505 lines
18 KiB
C++
Raw Blame History

/// Fractal Inspector Application
#include <iostream>
#include <JGL/logger/logger.h>
#include <ReWindow/types/Window.h>
#include <JUI/Widgets/Scene.hpp>
#include <JUI/Widgets/Slider.hpp>
#include <JUI/Widgets/Window.hpp>
#include "JUI/Widgets/CommandLine.hpp"
#include "JGL/types/Shader.h"
#include <ReWindow/Logger.h>
#include <Color4.hpp>
#include "JUI/Widgets/UtilityBar.hpp"
#include <JUI/Widgets/ColorPicker.hpp>
std::vector<std::string> string_expand(const std::string& input, char delimiter = ' ');
#pragma region OpenGL Introspection
inline std::string GetGLVendor() { return {(const char*)glGetString(GL_VENDOR)}; }
inline std::string GetGLRenderer() { return {(const char*)glGetString(GL_RENDERER)}; }
inline std::string GetGLVersion() { return {(const char*)glGetString(GL_VERSION)}; }
inline std::string GetGLSLVersion() { return {(const char*)glGetString(GL_SHADING_LANGUAGE_VERSION)}; }
inline std::string GetGLExtensions() { return {(const char*)glGetString(GL_EXTENSIONS)}; }
inline std::vector<std::string> GetGLExtensionList() { return string_expand({(const char*)glGetString(GL_EXTENSIONS)}); }
#pragma endregion
std::vector<std::string> string_expand(const std::string& input, char delimiter)
{
std::vector<std::string> result;
std::stringstream ss (input);
std::string item;
while (getline(ss, item, delimiter)) {
result.push_back(item);
}
return result;
}
using namespace JUI::UDimLiterals;
class ReShaderProgram : public ReWindow::OpenGLWindow {
public:
JUI::Scene *scene;
JUI::UtilityBar* toolbar;
JUI::CommandLine *console;
JUI::Window* info_dialog;
JUI::Window* mandelbrotset_dialog;
JGL::Shader shader;
JGL::RenderTarget *canvas;
float u_time;
float u_scale = 2.f;
Vector2 u_translation {0.4f, 0.f};
Color4 u_rgb_1 = Colors::Greens::Chartreuse;
Color4 u_rgb_2 = Colors::Reds::LightCoral;
Color4 u_rgb_3 = Colors::Yellow;
Color4 u_rgb_4 = Colors::Green;
std::string frag_name;
std::string vert_name;
ReShaderProgram();
static std::filesystem::path VertexShaderFilepathFromPrefixName(const std::string &name)
{
return "../shaders/" + name + ".vert.glsl";
}
static std::filesystem::path FragmentShaderFilepathFromPrefixName(const std::string &name)
{
return "../shaders/" + name + ".frag.glsl";
}
void LoadShader(const std::string& name)
{
frag_name = name;
vert_name = name;
shader = Shader(VertexShaderFilepathFromPrefixName(name), FragmentShaderFilepathFromPrefixName(name));
}
void LoadShader(const std::string& vertex_name, const std::string& fragment_name)
{
this->vert_name = vertex_name;
this->frag_name = fragment_name;
shader = Shader(VertexShaderFilepathFromPrefixName(vert_name), FragmentShaderFilepathFromPrefixName(frag_name));
}
void LoadShaderWithDefaultVertex(const std::string& name) {
this->frag_name = name;
shader = Shader(VertexShaderFilepathFromPrefixName(vert_name), FragmentShaderFilepathFromPrefixName(name));
}
void ReloadShader() {
LoadShader(vert_name, frag_name);
}
using CmdArgs = std::vector<std::string>;
void PositionCmd(const CmdArgs& args) {
if (args.empty()) { // Output position + scale
console->Log(std::format("Pos: {}, {}, Zoom: {}", u_translation.x, u_translation.y, u_scale));
return;
}
if (args.size() >= 2) { // Set Position
u_translation.x = std::stof(args[0]);
u_translation.y = std::stof(args[1]);
if (args.size() >= 3) { // Also set scale
u_scale = std::stof(args[2]);
}
}
console->Log(std::format("{}", args.size()));
}
void ParseCmdLineMessage(const std::string& message) {
auto tokens = string_expand(message);
if (tokens.size() == 0) {
console->Log("No command input!", Colors::Red);
return;
}
std::string cmd = tokens[0];
// Remove 0th element from tokens before passing to command delegates.
tokens.erase(tokens.begin());
if (cmd == "r" || cmd == "reload") {
ReloadShader();
} else if (cmd == "lf") {
if (tokens.size() > 1) {
std::string fragment = tokens[1];
// TODO: Check for file in question.
LoadShaderWithDefaultVertex(fragment);
return;
}
console->Log("Error: Command syntax is lf <fragment-shader-name>", Colors::Red);
} else if (cmd == "ls") {
if (tokens.size() > 1) {
std::string shader = tokens[1];
// TODO: Check for file in question.
LoadShader(shader);
return;
}
console->Log("Error: Command syntax is ls <shader-name>", Colors::Red);
} else if (cmd == "pos") {
return PositionCmd(tokens);
} else {
console->Log(std::format("No such command: {}", cmd), Colors::Red);
}
}
void CreateMenu() {
using namespace JUI::UDimLiterals;
toolbar = new JUI::UtilityBar(scene);
toolbar->AddSubmenu("File"); toolbar->AddSubmenu("Edit");
auto* btn_toggle_console = toolbar->AddButton("Console");
btn_toggle_console->OnClickEvent += [this] (auto a, auto b) mutable {
console->Toggle();
};
auto* btn_toggle_info_dialog = toolbar->AddButton("Info");
// TODO: Implement JUI structure that makes blocks of text easy to impelement.
info_dialog = new JUI::Window(scene);
info_dialog->SetTitle("FractalInspector - Read Me");
btn_toggle_info_dialog->OnClickEvent += [this] (auto a, auto b) mutable {
info_dialog->Toggle();
};
auto* layout = new JUI::VerticalListLayout(info_dialog->ViewportInstance());
layout->Padding(0_px);
// TODO: Code like this ends up being a common construct in JUI programs: Make a TextList widget.
auto line_item = [&] (const std::string& text, int size = 20, const Color4& color = Colors::White) {
auto* content = new JUI::TextRect(layout);
content->Size({100_percent, 25_px});
content->SetContent(text);
content->SetTextSize(size);
content->SetTextColor(color);
content->BGColor(Colors::Transparent);
content->AlignCenterHorizontally();
};
// TODO: Is this text useful and relevant, or does it come off as egotistic autofellatio?
line_item("FractalInspector V 1.0");
line_item("Developed & Maintained by Josh O'Leary");
line_item("(c) 2025 Redacted Software - redacted.cc");
line_item("This project is part of an independent research project to develop high-performance,", 18);
line_item("useful software that stands in contrast to all modern software trends.", 18);
line_item("This program is written in C++, from scratch.");
// TODO: Utilize for things later.
auto* wind = new JUI::Window(scene);
wind->SetTitle("Color-Pickers");
wind->MinSize({600, 150});
wind->Size({600_px, 150_px});
wind->Position({50_px, 50_px});
auto* col_layout = new JUI::HorizontalListLayout(wind->Content());
//wind->Close();
JUI::ColorPicker* pp = new JUI::ColorPicker(col_layout);
pp->Size({25_percent, 100_percent});
pp->OnColorValueChanged += [this] (const Color4& color) mutable {
u_rgb_1 = color;
};
/*auto* wind2 = new JUI::Window(scene);
wind2->SetTitle("Color-Picker B");
wind2->MinSize({200, 150});
wind2->Size({200_px, 150_px});
wind2->Position({50_px, 250_px});*/
JUI::ColorPicker* pp2 = new JUI::ColorPicker(col_layout);
pp2->Size({25_percent, 100_percent});
pp2->OnColorValueChanged += [this] (const Color4& color) mutable {
u_rgb_2 = color;
};
JUI::ColorPicker* pp3 = new JUI::ColorPicker(col_layout);
pp3->Size({25_percent, 100_percent});
pp3->OnColorValueChanged += [this] (const Color4& color) mutable {
u_rgb_3 = color;
};
JUI::ColorPicker* pp4 = new JUI::ColorPicker(col_layout);
pp4->Size({25_percent, 100_percent});
pp4->OnColorValueChanged += [this] (const Color4& color) mutable {
u_rgb_3 = color;
};
console = new JUI::CommandLine(scene);
console->MinSize(Vector2(200, 200));
console->MaxSize(Vector2(GetWidth()-10, GetHeight()-10));
console->Size({100_percent, 200_px});
console->Position({0_percent, JUI::UDim(-200, 1)});
console->OnInput += [this] (const std::string& message) {
ParseCmdLineMessage(message);
};
mandelbrotset_dialog = new JUI::Window(scene);
mandelbrotset_dialog->Position({20_px, 300_px});
auto* mandelbrotset_layout = new JUI::VerticalListLayout(mandelbrotset_dialog->ViewportInstance());
mandelbrotset_layout->LayoutOrder(JUI::LayoutOrder::V::TOP);
int idx = 999;
auto mb_line_item = [&] (const std::string& text, int size = 20, const Color4& color = Colors::White) {
auto* content = new JUI::TextRect(mandelbrotset_layout);
content->Size({100_percent, 25_px});
content->SetContent(text);
content->SetTextSize(size);
content->SetTextColor(color);
content->BGColor(Colors::Transparent);
content->AlignCenterHorizontally();
content->LayoutOrder(idx--);
};
mb_line_item("The Mandelbrot Set");
mb_line_item("Imagine a simple rule: ");
mb_line_item("Take a number, square it, and add back the original number.");
// TODO: Collapsible section: Evaluation of mandelbrot set with z = 0.
mb_line_item("If we start with zero, and keep repeating this rule, we always get zero. Boring, right?");
// TODO: Collapsible section: Evaluation of mandelbrot set with z = 1.
mb_line_item("But what if we start with a different number. Let's say 1.");
mb_line_item("1 squared is 1, plus 1 is 2.");
mb_line_item("2 squared is 4, plus 1 is 5.");
mb_line_item("5 squared is 25, plus 1 is 26.");
mb_line_item("The numbers keep getting bigger and bigger -- they 'escape' to infinity.");
// TODO: Collapsible section: Evaluation of mandelbrot set with z = -1.
mb_line_item("Now, let's try a number like -1.");
mb_line_item("-1 squared is 1, plus -1 is 0.");
mb_line_item("0 squared is 0, plus -1 is -1");
mb_line_item("-1 squared is 1, plus -1 is 0");
mb_line_item("The numbers get stuck in a loop between -1 and 0 -- they don't escape");
mb_line_item("The Mandelbrot set is a collection of all the starting numbers that don't escape to infinity when you repeat this simple rule.");
mb_line_item("These numbers, when plotted on a complex number plane, create this incredibly intricate and beautiful fractal shape.");
mb_line_item("Color-code the 'escape velocity' of the input numbers that do escape, and you get a result like the one you see.");
}
bool Open() override
{
if (!OpenGLWindow::Open())
return false;
auto size = GetSize();
auto vec_size = Vector2i(size.x, size.y);
if (!JGL::Init(vec_size, 0.f, 1.f))
return false;
JGL::Update(vec_size);
glClearColor(0.f, 0.f, 0.f, 0.f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);
// TODO: Delete when we update to the next release of JGL
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // NOTE: This MUST be called for text rendering to work properly!!!
scene = new JUI::Scene();
CreateMenu();
canvas = new RenderTarget(vec_size);
LoadShader("test", "mandelbrot");
console->Log(std::format("OpenGL Renderer: {}", GetGLRenderer()));
console->Log(std::format("OpenGL Vendor: {}", GetGLVendor()));
console->Log(std::format("OpenGL Version: {}", GetGLVersion()));
console->Log(std::format("GLSL Version: {}", GetGLSLVersion()));
/*auto ext_list = GetGLExtensionList();
// TODO: output 3 at a time.
console->Log("GL-Extensions: ");
std::string formatted_output = "";//"GL-Extensions: {}";
int iter = 0;
for (auto& str : ext_list) {
formatted_output += str + ", ";
iter++;
if (iter > 5) {
iter = 0;
console->Log(formatted_output);
formatted_output = "";
}
}*/
return true;
}
void PropagateWindowSize() {
auto size = GetSize();
Vector2i vSize = Vector2i(size.x, size.y);
JGL::Update(vSize);
scene->SetViewportSize(Vector2(vSize));
console->MaxSize(Vector2(GetWidth()-10, GetHeight()-10));
// TODO: Causes the shader canvas to not appear...?
//canvas->Resize(vSize);
}
void Update(float elapsed) {
scene->Update(elapsed);
if (IsKeyDown(Keys::F6)) {
u_scale = 2.f;
u_translation = {.4, 0};
}
// TODO: Vary the rate appropriately.
float rate = elapsed * 0.125f;
if (IsKeyDown(Keys::LeftShift))
rate *= 0.125f;
if (IsKeyDown(Keys::LeftControl))
rate *= 0.125f;
if (IsKeyDown(Keys::Minus))
u_scale += rate;
if (IsKeyDown(Keys::Equals))
u_scale -= rate;
if (IsKeyDown(Keys::DownArrow))
u_translation.y += rate;
if (IsKeyDown(Keys::UpArrow))
u_translation.y -= rate;
if (IsKeyDown(Keys::LeftArrow))
u_translation.x += rate;
if (IsKeyDown(Keys::RightArrow))
u_translation.x -= rate;
u_time += elapsed;
Vector2 u_res = Vector2(GetSize().x, GetSize().y);
// TODO: Why do we need to multiply X by 1.5 here?
Vector2 u_mouse = Vector2(GetMouseCoordinates().x*1.5f, GetSize().y-GetMouseCoordinates().y);
shader.SetVector2("u_resolution", u_res);
shader.SetFloat("u_time", u_time);
shader.SetVector2("u_mouse", u_mouse);
shader.SetVector3("u_rgb_1", Vector3(u_rgb_1.RN(), u_rgb_1.GN(), u_rgb_1.BN()));
shader.SetVector3("u_rgb_2", Vector3(u_rgb_2.RN(), u_rgb_2.GN(), u_rgb_2.BN()));
shader.SetVector3("u_rgb_3", Vector3(u_rgb_3.RN(), u_rgb_3.GN(), u_rgb_3.BN()));
shader.SetVector3("u_rgb_4", Vector3(u_rgb_4.RN(), u_rgb_4.GN(), u_rgb_4.BN()));
shader.SetFloat("u_scale", u_scale);
shader.SetVector2("u_translation", u_translation);
}
void Draw() {
Shader::UseDefault();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// TODO: Have to be particular about the order-of-operations in regards to shaders.
// Protip: Use RenderTarget to draw a quad with the shader in question. *After rendering the rest of the scene.*
J2D::Begin();
J2D::DrawRenderTarget(canvas, {0, 0});
J2D::End();
scene->Draw();
JGL::J2D::Begin(canvas, true);
shader.Use();
JGL::J2D::FillRect(Colors::Black, {0, 0}, Vector2(GetSize().x, GetSize().y));
JGL::J2D::End();
}
void OnRefresh(float elapsed) override {
PropagateWindowSize();
Update(elapsed);
Draw();
this->SwapBuffers();
}
void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent &e) override {
if (e.Button == MouseButtons::Left)
scene->ObserveMouseInput(JUI::MouseButton::Left, true);
if (e.Button == MouseButtons::Middle)
scene->ObserveMouseInput(JUI::MouseButton::Middle, true);
if (e.Button == MouseButtons::Right)
scene->ObserveMouseInput(JUI::MouseButton::Right, true);
}
void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override {
if (e.Button == MouseButtons::Left)
scene->ObserveMouseInput(JUI::MouseButton::Left, false);
if (e.Button == MouseButtons::Middle)
scene->ObserveMouseInput(JUI::MouseButton::Middle, false);
if (e.Button == MouseButtons::Right)
scene->ObserveMouseInput(JUI::MouseButton::Right, false);
}
void OnMouseMove(const ReWindow::MouseMoveEvent &e) override {
Vector2 nmp = Vector2(e.Position.x, e.Position.y);
scene->ObserveMouseMovement(nmp);
}
void OnKeyDown(const ReWindow::KeyDownEvent &e) override {
if (scene->ObserveKeyInput(e.key, true))
return;
if (e.key == Keys::R)
ReloadShader();
}
void OnKeyUp(const ReWindow::KeyUpEvent &e) override {
scene->ObserveKeyInput(e.key, false);
}
protected:
private:
};
ReShaderProgram::ReShaderProgram(): ReWindow::OpenGLWindow("ReShader", 1800, 1000, 2, 1) {
Shader::OnCompilationErrorMessage += [this](std::string type, std::string infoLog) {
auto log_lines = string_expand(infoLog, '\n');
console->Log(type, Colors::Red);
std::cerr << type << std::endl;
for (auto line: log_lines) {
console->Log(line, Colors::Red);
std::cerr << line << std::endl;
}
};
u_time = 0;
}
int main(int argc, char** argv) {
ReWindow::Logger::Debug.EnableConsole(false);
auto* program = new ReShaderProgram();
program->Open();
program->SetFullscreen(false);
program->SetVsyncEnabled(false);
program->SetResizable(true);
while (program->IsAlive())
program->ManagedRefresh();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink