[{"content":"Novi is a structured data inspector and validation system. A core library built in Rust provides a unified interface for parsing many different data types into a unified structured format. Included with the core library is a validation system, allowing for user provided Lua scripts (or builtin ones) which are given the structured data and can perform arbitrary validations and tests on the data, producing a validation report highlighting any issues with the data. Several client applications are also included such as a CLI, Web, and Desktop interface, which all provide interactive interfaces for exploring the parsed structured data, and the validation reports.\nCore Parsing The core parsing library is the core of Novi handling the parsing of various formats, supporting ELF, PNG, JPEG, MP4, etc. Being a library it can be easily integrated into other applications or paired with other clients. Input data is first transformed, using a chain of transformers, which allows for handling compressed / encoded content seamlessly. The library provides a handler structure for decoding data (the Decoder), which provides a robust and flexible interface allowing for the decoding of complex data types, and the decoder encapsulates all of the complex logic for converting data types and storing data into the structured tree. The transformed data is passed to the data format specific parser, which leverages the decoder to read the raw data into a structured tree, while recording all of the metadata about each field that was read.\nThe core parsing is intended to be extremely forgiving and robust. There should be very few cases that cause a parser to fail and they are more intended for marshaling the raw data into the defined structure. The checking if it is valid data (e.g. has reasonable values, or the right magic numbers, etc.) is left up to the validators. This allows for greater flexibility and improved support for parsing malformed or corrupted data.\nValidation An addition to the core parsing is the validation. Using an embedded Lua runtime, the Novi library can support validating the parsed structured tree. Each supported data format includes builtin validation, but users are also able to define or override with their own validations, by simply writing some simple Lua scripts. The validation generates a report with different messages which reference locations in the structured tree, making it easy through the clients to annotate the corresponding tree nodes with the validation warnings or errors.\nClients The client applications are all designed to be agnostic to the data format being parsed. The core library and validation handles all of the particularities of each given format, and by the time the client interacts with the data it is a generic structured tree and validation report. This makes it very easy to add support for new formats, since nothing needs to change in any of the clients to support it.\nWeb The web client compiles the rust library into web assembly to be able to run all of the parsing and validation client side in the web browser directly. And uses react and typescript for the interface. It provides a clear interface for loading new files, and viewing the structured tree of the parsed data.\nThe frontend interface is written using typescript and react, and using shadcn/ui for the frontend theming. Extending the philosophy of the core library, the interface aims to be robust and resilient to any potential issues. The web interface is the main interface new users are expected to use, so it is careful to include clear descriptions and follow standard design patterns so that new users can quickly and effectively onboard to using the tooling with a minimal learning curve for getting started.\nCommand Line Interface The Command Line Interface (CLI) acts as a power user client. It provides all of the features of the other clients (without the interactivity that other clients can provide), while aiming to be a slim wrapper around the library. It includes some additional power user focused features that are not available in the web client such as dynamically streaming content from files rather than needing to read it all into memory. This allows the CLI to parse significantly larger files than the web interface can currently handle.\nBecause the CLI client is a thin wrapper around the core library, it is a useful reference when implementing other clients, for a starting point to see how to integrate and leverage the library features to the fullest. The CLI client also provides useful hooks for more programmatic interaction. It supports outputting into machine readable formats (such as JSON or XML) which can then have further post processing applied as needed by the end user.\nThe CLI includes several builtin formatters for rendering the raw data as well as the parsed data tree, making it a useful tool for any of the users needs for inspecting their data, even if parsing failed it can still provide clear hex view of the data for manual inspection. And being directly in the command line it can be used on hosts that may not have a graphical interface for the desktop or web clients.\n","permalink":"https://ardenrasmussen.com/projects/00pw/","summary":"\u003cp\u003eNovi is a structured data inspector and validation system. A core library built\nin Rust provides a unified interface for parsing many different data types into\na unified structured format. Included with the core library is a validation\nsystem, allowing for user provided Lua scripts (or builtin ones) which are given\nthe structured data and can perform arbitrary validations and tests on the data,\nproducing a validation report highlighting any issues with the data. Several\nclient applications are also included such as a CLI, Web, and Desktop interface,\nwhich all provide interactive interfaces for exploring the parsed structured\ndata, and the validation reports.\u003c/p\u003e","title":"Novi"},{"content":"Bookshelf is a focused self hosted e-book manager. It is primarily focused on the server side, providing a well organized e-book database, and exposing those through an Open Publication Distribution System (OPDS) API for third party clients to consume (such as e-readers like Kindle, or mobile or desktop applications).\nThe server is written in Go with a strictly defined OpenAPI schema making it easy for third party clients to integrate with the server backend. Bookshelf handles detecting new or modified files through file system watching, and automatically reads the metadata from the EPUB, MOBI, or PDF file (or if present a sidecar metadata file). Using that metadata it builds a database of all the books and series.\nBookshelf also includes support for third party metadata providers to supplement the embedded metadata, filling in any missing information such as series, or cover images. Currently it supports Hardcover, Goodreads, and RanobeDB. With a scoring mechanism to score the quality of metadata match with the embedded metadata to ensure that the best metadata is used for each book.\nThe server also tracks user reading progress, which can be synchronized from all clients to the server so that reading progress is automatically shared across all devices and platforms.\nWeb Reader In addition to the main OPDS API, Bookshelf also includes a built in web reader. This allows users to read their books directly in the browser without needing to install any additional applications. The web interface is designed following the Google Material Design system with dynamic theming that applies to both the library browser as well as the reader.\nLibrary Browser The library browser includes pages for a home dashboard showing in progress books to quickly pick up where you last finished, as well as recently added books and book series to the server. Each in progress or completed book also includes a progress indicator making it easy to see which books have been finished or where you are in the book.\nIt also includes a page for browsing all books or all books in a specific library. These pages use paginated queries and a virtualized renderer using Tanstack Virtual to improve performance for large libraries by only rendering the books within the viewport, while prefetching data so that it is a smooth scrolling experience with minimal need for buffering.\nThe series view shows a list of all book series in the library, which again includes a progress indicator this time for the overall series, indicating how many books the user has read and how many are in the series as a whole. And clicking on the series will open the reader for the next book in the series for the user to read, making it very easy to quickly jump back into a series that you have started.\nReader Clicking on any book or series in the library will open the reader for that book, continuing from the last reading position for that user. The reader supports all of file types supported by the server (EPUB, MOBI, PDF). The handling of the rendering of the e-books is provided by foliate-js.\nThe reader is aimed to be a clean and focused reading experience without getting in the users way, while still providing all of the necessary features for a good reading experience. The base layout includes a chapter indicator and a time remaining for the book. It includes support for advanced formatting options such as customizing the reader theme (separate from the rest of the web interface), adjusting the font family, size, and line spacing. As well as customization of the layout like the number of columns, the gap between columns, the justification of the text, etc.\nThese settings are all saved client side to remember the users preferences, and allow for detailed customization to allow users to tune the reading experience to be best suited for them.\nThe reader also includes a pop-up header and footer which include quick actions for navigating the series (jumping to the previous or next book in the series), as well as a progress bar for the current book, allowing to jump to specific chapters or sections of the book.\n","permalink":"https://ardenrasmussen.com/projects/71rq/","summary":"\u003cp\u003eBookshelf is a focused self hosted e-book manager. It is primarily focused on\nthe server side, providing a well organized e-book database, and exposing those\nthrough an Open Publication Distribution System (OPDS) API for third party\nclients to consume (such as e-readers like Kindle, or mobile or desktop\napplications).\u003c/p\u003e\n\u003cp\u003eThe server is written in Go with a strictly defined OpenAPI schema making it\neasy for third party clients to integrate with the server backend. Bookshelf\nhandles detecting new or modified files through file system watching, and\nautomatically reads the metadata from the EPUB, MOBI, or PDF file (or if present\na sidecar metadata file). Using that metadata it builds a database of all the\nbooks and series.\u003c/p\u003e","title":"Bookshelf"},{"content":"Nand to Tetris is a course from the book The Elements of Computing Systems: Building a Modern Computer from First Principles by Noam Nisan and Shimon Schocken. The course covers the design and implementation of a simplified computer model, starting from first principles of a single NAND gate, and using that to build up more complex logic gates. Gradually expanding on the previous chapters to introduce more complex structures ultimately culminating in the construction of a basic computer.\nThen going beyond the basic computer on the hardware side of the equation it also introduces and develops the core software stack for interacting with the computer. Building up an assembler, a virtual machine, and even a compiler for a higher-level Java like language.\nThis project is my following along of the course, implementing the hardware in the Nand2Tetris Hardware Definition Language (HDL), and the software stack in Rust from scratch using no dependencies for the lexing or parsing. After completing the entire course the repository provides a functional HDL definition for the computer, and a fully featured software stack providing everything needed to write Jack (the high-level Java like language) programs and compile them to run on the simulated hardware.\n","permalink":"https://ardenrasmussen.com/projects/zhfq/","summary":"\u003cp\u003eNand to Tetris is a course from the book \u003cem\u003eThe Elements of Computing Systems:\nBuilding a Modern Computer from First Principles\u003c/em\u003e by Noam Nisan and Shimon\nSchocken. The course covers the design and implementation of a simplified\ncomputer model, starting from first principles of a single NAND gate, and using\nthat to build up more complex logic gates. Gradually expanding on the previous\nchapters to introduce more complex structures ultimately culminating in the\nconstruction of a basic computer.\u003c/p\u003e","title":"Nand to Tetris"},{"content":"GD Snake is a fully featured implementation of the classic Snake game, built using the Godot game engine. The aim of the project was primarily a learning experience for game development and how to use the Godot game engine. So it implements all features of a full sized game, just applied to the smaller scope of Snake.\nThe main menu, includes a real-time game of snake running in the background using AI snakes, to provide visual interest while the user is in the menus. Along with a standard settings allowing for the adjusting audio levels (which is persisted) and dynamic rebinding controls. The game includes a palettes swap shader allowing for multiple themes and styles to be easily applied to the full game, and includes a selection a builtin color palettes the user can pick from.\nThe game itself supports arbitrary number of AI opponents and up to four players. The initial spawn points for the snakes are guaranteed to be spaced out in the selected map so that there isn\u0026rsquo;t immediate contention when the game starts. The map size can also be arbitrary large or small, when the map is too large to fit on a single screen then a camera follows the snake, the zoom of which can be controlled in the settings. When multiple players are in the game, then it supports split screen so each player has their own camera. The map can also include optional obstacles, which place walls throughout the map which breaks up the open space and requires more strategy to work around and plan ahead to avoid.\nAI is implemented using a simplified A* pathfinding algorithm, which allows the AI snakes to navigate the map and avoid obstacles while trying to get to the food. A* alone tends to be too good at navigating the map, so to make the AI more human like and less perfect, a random chance of making a suboptimal move is added to the AI. This allows for more interesting games where the AI can make mistakes and be beaten by the player, while still being good enough to provide a challenge.\nFinally the game also includes both background music tracks, and sound effects to provide more user feedback when actions occurs.\nAlthough simple, this implementation of snake covers user input (and accessibility through rebinding controls), graphics, AI, menus, persistent/save data, and music and sound effects. And through the development of this game I have gained a better understanding of these different pieces and how to fit them together into a larger project.\n","permalink":"https://ardenrasmussen.com/projects/75o4/","summary":"\u003cp\u003eGD Snake is a fully featured implementation of the classic Snake game, built\nusing the \u003ca href=\"https://godotengine.org/\"\u003eGodot\u003c/a\u003e game engine. The aim of the project\nwas primarily a learning experience for game development and how to use the\nGodot game engine. So it implements all features of a full sized game, just\napplied to the smaller scope of Snake.\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"Main Menu\" loading=\"lazy\" src=\"/projects/75o4/20260508_113950.png\"\u003e\u003c/p\u003e\n\u003cp\u003eThe main menu, includes a real-time game of snake running in the background\nusing AI snakes, to provide visual interest while the user is in the menus.\nAlong with a standard settings allowing for the adjusting audio levels (which is\npersisted) and dynamic rebinding controls. The game includes a palettes swap\nshader allowing for multiple themes and styles to be easily applied to the full\ngame, and includes a selection a builtin color palettes the user can pick from.\u003c/p\u003e","title":"GD Snake"},{"content":"Cerebri is a framework and setup for training, hosting, and exploring Large Language Models (LLMs). It was created by following the Neural Networks: Zero to Hero course by Andrej Karpathy. Building up a backpropagation algorithm in python, and then expanding that to build up to a deep neural networks and a GPT model.\nThe goal of Cerebri is primarily for learning about the inner workings of a large language model, and all the components of that, so a large focus was on the development and the different phases that were a part of that. Then it also extends that by training some custom tokenizers and a very basic GPT using the FineWeb2 dataset and local hardware.\nDevelopment The development of Cerebri closely follows Zero to Hero course, starting with a custom implementation of backpropagation in python, then extending to implementing a bigram character-level language model. Then we build up a multilayer perceptron (MLP) character-level language model.\nAfterwards, taking the MLP model developed and expanding that into a convolutional neural network. And then finally constructing a Generatively Pretrained Transformer (GPT) based on OpenAI\u0026rsquo;s GPT-2 / GPT-3 model. Along with our own custom Byte Pair Encoding tokenizer used for the GPT model training and evaluation.\nTraining For the final training we use the PyTorch python library. Although our custom backpropagation library supports all the necessary features, it is not anywhere optimized or flexible as PyTorch is, so for practical use cases we opt to use PyTorch directly. And the repository contains the python scripts for training both the tokenizers and the models.\nDue to limited resources, the training data is dynamically streamed and interleaved different data sets to reduce the necessary disk space. And the GPT training includes the common optimizations for leveraging hardware acceleration with CUDA if available.\nAll tokenizer and model training was done locally using an Nvidia GTX 1060 GPU for the model training. As such the model is focused on verification of the achitecture and implementation and not for real world use cases, as the hardware is not powerful enough to train a large model in a reasonable amount of time.\nInference The second part of Cerebri is to provide a web interface to interact with the tokenizer and the GPT models. The backend is implemented in rust leveraging the PyTorch C++ library for the model inference. The backend provides an API interface and an OpenAPI schema for interacting with the tokenizers and the models.\nThe frontend interface written in React, allows users to dynamically explore and interact with the tokenizers and the models. Providing dynamic tokenization to visualize how text input is broken up, and the importance of the tokenizer being trained on the language being used, so that it can break the text into useful tokens.\n","permalink":"https://ardenrasmussen.com/projects/nn07/","summary":"\u003cp\u003eCerebri is a framework and setup for training, hosting, and exploring Large\nLanguage Models (LLMs). It was created by following the \u003ca href=\"https://karpathy.ai/zero-to-hero.html\"\u003eNeural Networks: Zero\nto Hero\u003c/a\u003e course by Andrej Karpathy.\nBuilding up a backpropagation algorithm in python, and then expanding that to\nbuild up to a deep neural networks and a GPT model.\u003c/p\u003e\n\u003cp\u003eThe goal of Cerebri is primarily for learning about the inner workings of a\nlarge language model, and all the components of that, so a large focus was on\nthe development and the different phases that were a part of that. Then it also\nextends that by training some custom tokenizers and a \u003cem\u003every\u003c/em\u003e basic GPT using the\n\u003ca href=\"https://huggingface.co/datasets/HuggingFaceFW/fineweb-2\"\u003eFineWeb2\u003c/a\u003e dataset and\nlocal hardware.\u003c/p\u003e","title":"Cerebri"},{"content":"Astri is a satellite tracking and visualizer. It automatically pulls the list of all publicly tracked satellites from CelesTrak (as of writing $\\sim 15,000$ satellites). Then using the Simplified General Perturbations-4 (SGP4) model developed by the United States Department of Defense (DoD) for predicting satellite position and velocity for any given point in time.\nAstri also includes an interactive user interface, which renders simplified models for each of the satellites and visualizes their position relative to the earth and the other satellites. The user interface includes an explorer list for sorting and filtering the satellites and controlling which ones are displayed. And it automatically groups satellites into their constellations both in the explorer list and using the same colors to represent satellites from the same constellation.\nSatellite Prediction Model Some of the SGP4 publications provides an implementation of the algorithm in C. However the included source code is not cross platform (it depends on Windows specific headers) and doesn\u0026rsquo;t follow modern development standards. I have re-implemented the SGP4 algorithm in C++ while leveraging more modern practices. Modifying functions that took $\u003e80$ individual variables to grouping those variables into data structures or arrays where applicable. Renaming the mathematically oriented variable names into more descriptive identifiers (e.g. argpp to arg_of_periapsis) to make the code more readable.\nThis reimplementation of the SGP4 algorithm is available as a standalone library so that it can be reused in any context. And has minimal dependencies beyond the standard library and a logging library. It implements the required logic for parsing the TLE (Two-Line Element) sets, and initializing and calculating the satellite position and velocity for any given point in time.\nAstri Application The Astri application is also written in C++ using OpenGL for rendering the earth and satellites. ImGui is used for handling and rendering the user interface. To improve performance the satellites are handled using an Entity Component System (ECS) flecs, and is easily able to handle the ~50k satellites without dropping frames.\nThe application includes a basic camera for orbiting around the earth and zooming in and out. With keybindings the user can speed up or slow down the simulation, and increase or shrink the size of the satellite models to make them easier to see.\nAnd through the builtin explorer list the user can filter and sort the satellites by their name, or id, and enable or disable the rendering of specific satellites.\n","permalink":"https://ardenrasmussen.com/projects/u1pa/","summary":"\u003cp\u003eAstri is a satellite tracking and visualizer. It automatically pulls the list of\nall publicly tracked satellites from \u003ca href=\"https://celestrak.org/\"\u003eCelesTrak\u003c/a\u003e (as of\nwriting $\\sim 15,000$ satellites). Then using the Simplified General\nPerturbations-4 (SGP4) model developed by the United States Department of\nDefense (DoD) for predicting satellite position and velocity for any given point\nin time.\u003c/p\u003e\n\u003cp\u003eAstri also includes an interactive user interface, which renders simplified\nmodels for each of the satellites and visualizes their position relative to the\nearth and the other satellites. The user interface includes an explorer list for\nsorting and filtering the satellites and controlling which ones are displayed.\nAnd it automatically groups satellites into their constellations both in the\nexplorer list and using the same colors to represent satellites from the same\nconstellation.\u003c/p\u003e","title":"Astri"},{"content":"Tiny Ray March v2 is a reworking of the previous version of TRM v1, with an emphasis on data collection to analytically quantify the quality and performance improvements of different features. It is designed as a simple and lightweight ray marcher for educational purposes and as a test platform for understanding ray marching and the performance improvements that come from various features.\nTRM is written as a C++ library, and the scene definition is a C++ structure which can be either statically defined in a runtime, or dynamically created by a runtime. It implements a minimal set of features initially, and only supports a small set of material types (Emissive, Diffuse, Specular, Refractive, and Fresnel). And as more features are implemented, the performance and quality improvements of each feature are tested with the included example scenes, and the results are recorded in a spreadsheet for analysis.\nStatistical Analysis There are two main aspects that are being analyzed as part of this project. The first being the performance, the time it takes to render each scene with varying number of samples. More complex scenes will take longer to render per-sample and more samples tends to linearly increase the time to render a scene.\nThe second aspect is the convergence towards the global truth. Photorealistic rendering through ray tracing or ray marching attempts to simulate the path of photons through a scene. However, it is not possible to simulate all the photons, so through clever statistical sampling we attempt to capture the scene while only simulating a small fraction of the light. This statistical sampling means that with more samples we expect to eventually converge towards \u0026ldquo;reality\u0026rdquo; by sampling more and more rays of light. So the second measurement is how quickly we converge towards the accurate output, and how effectively are we sampling the most important rays of light.\nThis measurement of convergence is harder to quantify, we approximate it by rendering a final extremely high-quality image using a much higher number of samples ($\\sim1024$). Then re-rendering the same scene using a different seed and saving snapshots at fixed intervals. Then for each snapshot we compute the average $\\Delta E$ (CIE76) difference between the snapshot and the high-quality \u0026ldquo;final\u0026rdquo; image. That $\\Delta E$ value is the measure of perceptual difference between the two images, allowing for small differences that are not noticeable by humans. And by comparing the rate of decrease for the $\\Delta E$ we get an approximation for the rate at which the image is converging to the ground truth.\nNote For a single color a $\\Delta E \\leq 2$ is considered to be an imperceptible difference. Since this data is the average for each individual pixel this isn\u0026rsquo;t as accurate but it is a convinient baseline to understand when viewing the statistics.\nSample Scenes A basic empty room, with an emissive ceiling, a diffuse floor and walls. There are no objects in the scene, and no reflections or refractions. This is the most basic scene, and serves as a baseline for testing the best case performance.\nA basic scene extending the empty room. Now including three objects. A diffuse white sphere, a reflective metallic sphere, and a glass torus. This scene is still relatively simple, but include the main material types for testing the BSDFs and the ray marching features.\nExtending the empty room, this scene includes 20 randomized spheres. 11 spheres are diffuse, 3 are reflective, 3 are transmissive, and 3 are emissive. This scene includes the most objects and is intended for measuring improvements around many objects such as Bounding Volume Hierarchies (BVHs) with many reflections and refraction bounces.\nThe Menger sponge is a classic fractal object, and is a good test for ray marching specific features which cannot be easily implemented in a ray tracer. The recursive nature of the object means that it has a lot of small details, and requires many ray bounces to accurately capture the scene.\nThe infinite Menger sponge, leverages the ease of replicating objects in ray marching to create an infinite scene. This provides testing for ray marching specific features, as well as extending the Menger Sponge scene as a torture test with many details requiring many ray bounces to capture the scene.\n","permalink":"https://ardenrasmussen.com/projects/ymoy/","summary":"\u003cp\u003eTiny Ray March v2 is a reworking of the previous version of \u003ca href=\"../ztb4\"\u003eTRM v1\u003c/a\u003e,\nwith an emphasis on data collection to analytically quantify the quality and\nperformance improvements of different features. It is designed as a simple and\nlightweight ray marcher for educational purposes and as a test platform for\nunderstanding ray marching and the performance improvements that come from\nvarious features.\u003c/p\u003e\n\u003cp\u003eTRM is written as a C++ library, and the scene definition is a C++ structure\nwhich can be either statically defined in a runtime, or dynamically created by a\nruntime. It implements a minimal set of features initially, and only supports a\nsmall set of material types (Emissive, Diffuse, Specular, Refractive, and\nFresnel). And as more features are implemented, the performance and quality\nimprovements of each feature are tested with the included example scenes, and\nthe results are recorded in a spreadsheet for analysis.\u003c/p\u003e","title":"TRM v2"},{"content":"I tasked myself to make a new render using blender once a week. I decided to to this to help improve my skills with blender, and to produce some interesting images that.\nThe eventual goal of this project is to learn how to use Blender more fluently, so that I am able to integrate the Specula with Blender more effectively. Since Specula is not intended to be a modeling software, I intend to use blender to do the modeling, and then load the scenes into the Specula renderer. So the first step of that process is to learn how to use Blender effectively.\n","permalink":"https://ardenrasmussen.com/projects/rfs6/","summary":"\u003cp\u003eI tasked myself to make a new render using blender once a week. I decided to to\nthis to help improve my skills with blender, and to produce some interesting\nimages that.\u003c/p\u003e\n\u003cp\u003eThe eventual goal of this project is to learn how to use Blender more fluently,\nso that I am able to integrate the \u003ca href=\"../5djw\"\u003eSpecula\u003c/a\u003e with Blender\nmore effectively. Since Specula is not intended to be a modeling software, I\nintend to use blender to do the modeling, and then load the scenes into the\nSpecula renderer. So the first step of that process is to learn how to use\nBlender effectively.\u003c/p\u003e","title":"Weekly Blender Render"},{"content":"TRM (Tiny Ray Marcher) is a C++ project that implement a very small ray marching algorithm. The project implements the fundamental components of a path tracer, and even provides an easy to use scene definition file.\nEfficiency By changing specific key configuration values in a rendered image, it is possible to significantly alter the quality of the image, in direct relation to the runtime of the program. However some settings will produce a better output image, for less cost to runtime. The main two settings that we consider here, is the spp and the resolution. By doubling the spp it can be considered that we are rendering twice as many images, and combining the images after the fact. While doubling the resolution is equivalent to rendering four times the number of images, and connecting the images as the four quadrants of the output image.\nAfter collecting the data it is clear that doubling the resolution in both axis is indeed about equivalent to four times the samples per pixel. However, increasing the resolution produces a visually shaper images, even with very few samples.\nNote More quantitative data is still being determined.\nConfiguration The scene file is based upon JSON file format. The general file is formatted like so:\n{ \u0026#34;spp\u0026#34;: 128, \u0026#34;maxiumumDepth\u0026#34;: 64, \u0026#34;resolution\u0026#34;: [2000, 2000], \u0026#34;camera\u0026#34;: { \u0026#34;fov\u0026#34;: 1.5707, \u0026#34;center\u0026#34;: [0.0, 0.0, 0.0], \u0026#34;up\u0026#34;: [0.0, 1.0, 0.0], \u0026#34;pos\u0026#34;: [0.0, 0.0, -6.0] }, \u0026#34;materials\u0026#34;: { ... }, \u0026#34;objects\u0026#34;: { ... } } General These are general settings for the render, they control how the renderer will function, and the quality of the produced image. Changing these values will significantly impact the runtime of the renderer. The amount that each value effects the runtime is described in the section on Efficiency.\nValue Description spp The number of samples per pixel. Higher values will result in better looking images. maximumDepth The number of bounces that the simulation will simulate before rays begin to terminate. resolution The width and height of the output image. camera Information about the camera object in the scene. camera.fov The field of view for the camera given in radians. camera.center The point in the scene that the camera will be focused at. camera.up The direction that will be the up direction relative to the camera. camera.pos The position of the camera object in the scene. ","permalink":"https://ardenrasmussen.com/projects/ztb4/","summary":"\u003cp\u003eTRM (Tiny Ray Marcher) is a C++ project that implement a very small ray\nmarching algorithm. The project implements the fundamental components of a path\ntracer, and even provides an easy to use scene definition file.\u003c/p\u003e\n\u003ch4 id=\"efficiency\"\u003eEfficiency\u003c/h4\u003e\n\u003cp\u003eBy changing specific key configuration values in a rendered image, it is\npossible to significantly alter the quality of the image, in direct relation to\nthe runtime of the program. However some settings will produce a better output\nimage, for less cost to runtime. The main two settings that we consider here,\nis the \u003cstrong\u003espp\u003c/strong\u003e and the \u003cstrong\u003eresolution\u003c/strong\u003e. By doubling the spp it can be considered\nthat we are rendering twice as many images, and combining the images after the\nfact. While doubling the resolution is equivalent to rendering four times the\nnumber of images, and connecting the images as the four quadrants of the output\nimage.\u003c/p\u003e","title":"TRM v1"},{"content":"This ray tracer implements the basis of a ray tracing rendering engine in C++. It is possible to render still images, or sequences of images. Multi threading has also been implemented allowing for significantly faster render times.\nWarning A complete overhaul of the Specula rendering engine is currently in progress. This rewrite is focused on implementing path tracing into the renderer, and implementing PBR techniques.\nThe ability to create multiple object of sphere, triangle, plane, circle, or mesh types is currently available. Where a mesh is any collection of triangles specified by an .stl file. Thus allowing for the import of any arbitrary model. Using these five different supported objects, there is the possibility for the construction of all three dimensional models.\nThe implementation of different materials is such that the reflectively of the material, the specular index, and the diffuse and specular colors can be determined. Using these settings it is possible to demonstrate most opaque materials.\nThere are three formats of lights implemented in the system. Distant lights are lights that cast parallel rays across the entire space. They are useful for simulations of sunlight, or large sources of light that are very far away. Point lights approximate point sources. Area lights represent a light source from a rectangle. This is useful for most light sources, as very few sources of light are actual point sources, and can be better represented by this area light source. Every light can have have a specified intensity and color. And area light sources can specify the number of samples for calculating the lighting. Higher number of samples improves the quality of soft shadows produced in the final image.\nThe entire process is self enclosed, as the process of compilation also compiles and links libpng in order to output png files.\nThe multi threading is optimized by scattering the pixels that each thread renders, so that no single thread is solely rendering a simple set of pixels. This proves a significantly faster rendering time. Thus allowing for the rendering of significantly more complex systems.\n","permalink":"https://ardenrasmussen.com/projects/5djw/","summary":"\u003cp\u003eThis ray tracer implements the basis of a ray tracing rendering engine in C++.\nIt is possible to render still images, or sequences of images. Multi threading\nhas also been implemented allowing for significantly faster render times.\u003c/p\u003e\n\n            \u003clink rel=\"stylesheet\" href=\"/css/vendors/admonitions.2396c2e673dc85178788d034193059c6cc19b3481a40d07e3ef8564f52f0eeef.css\" integrity=\"sha256-I5bC5nPchReHiNA0GTBZxswZs0gaQNB\u0026#43;PvhWT1Lw7u8=\" crossorigin=\"anonymous\"\u003e\n    \u003cdiv class=\"admonition warning\"\u003e\n      \u003cdiv class=\"admonition-header\"\u003e\u003csvg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 512 512\"\u003e\u003cpath d=\"M256 32c14.2 0 27.3 7.5 34.5 19.8l216 368c7.3 12.4 7.3 27.7 .2 40.1S486.3 480 472 480L40 480c-14.3 0-27.6-7.7-34.7-20.1s-7-27.8 .2-40.1l216-368C228.7 39.5 241.8 32 256 32zm0 128c-13.3 0-24 10.7-24 24l0 112c0 13.3 10.7 24 24 24s24-10.7 24-24l0-112c0-13.3-10.7-24-24-24zm32 224a32 32 0 1 0 -64 0 32 32 0 1 0 64 0z\"/\u003e\u003c/svg\u003e\n        \u003cspan\u003eWarning\u003c/span\u003e\n      \u003c/div\u003e\n      \u003cdiv class=\"admonition-content\"\u003e\n        \u003cp\u003eA complete overhaul of the Specula rendering engine is currently in progress.\nThis rewrite is focused on implementing path tracing into the renderer, and\nimplementing PBR techniques.\u003c/p\u003e","title":"Specula V1"}]