Addressing Rejection Feedback #2

1. Tooltip Descriptions

So basically the program was hard to use, and tbh, I kinda agree. So I added tooltips on known attribute names to help understand which attribute/value does what.

2. Rethinking the Tutorial

In addition, the tutorial was a bit hard to understand. To address that, I simplified the tutorial and made it easier to understand what’s going on. While the previous tutorial was changing a texture, that required the user to understand where the change texture button is, and then locate the texture itself, requiring some understanding of the program. This defeats the purpose of a tutorial.
My new and improved tutorial involves removing textures, a simplified process that can be done with a click of a button. This helps the user understand how removing the normal, for example, affects how lighting calculations are made.

Something I noticed reviewing feedback videos.

In addition, I noticed that ImGui windows are really small at first launch, requiring the user to adjust its size before doing anything. With this update, I bundled preconfigured imgui.ini files for ImGui to detect and automatically scale windows to an appropriate size.

Addressing Rejection Feedback: Fixed a minor issue related to display scaling on ImGui that may cause small interfaces on high-DPI screens, such as laptops and high-resolution displays.

Added a zelda-like heart sprite health indicator bar.

The Animations Update

What’s New?

• Lots of confirmation dialogs, etc for the editor. Polishing it up for now.
• Animations! Edit and view animations from the animation editor. currently supports changing sprites.
• Overall stability improvements.
• Cleaned up physics & ui API.

Next

I need to work on the actual story and make some assets.

The brush up update

• Changed up the style to feel more fun.
• Updated the tutorial
• Minor QoL features.

The User Friendly Update

New features

• Added scene loading/saving
• Added tutorial and documentations
• Added a output log
• Added Markdown/XML editors for both tutorial and documentation

The Templates Update

As a part of making Vibrant easier to use, I added templates.

The formatting update

Minor formatting stuff, nothing new in terms of features & performance.

The Bloom Update

What’s new?

• Added bloom support
• Added player log (quest log)
• Adopt ui:: API for menu
• Fix player movement to feel smoother and less jagged
• Added some more assets
• Redesign pause screen

Minor Update: Smart Pointers

Added smart pointers. They usually come in at mid-development because I normally don’t have any problems with raw pointers and don’t see much benefit in smart pointers other than RAII support. Not much changed feature-wise though, and performance has minimal impact.

Also added some assets.

The Unfinished Features update

New stuff

• FINALLY implemented the pause menu’s functions. Been holding back on that for a bit, but I wanted to make a completely new UI system based off of SwiftUI. You can see it in action in the third image. Still incomplete style wise, so I’ll have to work on that.
• Major tweaks for physics that make the game feel less floaty and arcade-y,
• Performance improvements all around, this time by using less dependencies everywhere.
• Added a exposure adjustment setting. The game looks more vibrant at higher exposure settings, and dimmer at lower exposure. My first implementation of a post processing effect.
• Deferred scene changes for overall program stability.
• Refined player controls for a overall smoother experience. Feels like a cross between Mario and Kirby.

The Progression update

What’s new?

• Added a progression system. Save data similar to how player positions and health is stored.
• A typewriter effect on the opening sentences, as seen below.
• Minor bugfixes

Next,

I’ll continue to work on game-related systems and updates. I need assets, but unfortunately I’ve been procrastinating that.

The Editor Update

Changes and new features

• Finished up deferred rendering system. Lighting is simple but effective enough. May consider expanding normals support for the sweet edge shine and indie 2d look.
• Add SceneManager that uses a scene stack to manage, initialize, quit, update, handle input and render scenes.
• Update Level editor to clean up the interface. Implemented a toolkit system to change behavior based on the current tool.
• Add a move tool to drag entities around.
• A spotlight system that lights up the area around the mouse, useful for dark scenes. (White light in the top right is where my mouse is placed)

Next steps and considerations…

• I might want to add a post-processing system based on render passes. Not sure how I’ll make that work, though.
• Severe asset insufficiency. I need more assets (sprites, music, etc.)
• Working on the game perspective a lot more. I’ve been working too much on the technical side.
• Ironing out alot of bugs.

The Editor Update

What’s new?

• Worked on improving the editor, which was left in a very messy and convoluted state. Cleaned up code, worked on fixing coordinate system mismatches, etc. It works pretty much flawlessly except for the PPU selection.
• The selected entity window allows the user to edit parameters of a component attached to an entity.

What’s next?

Working on overhauling the rendering system from a simple sprite renderer to one with full lighting. Test image below.

The Save Game Update

Updates

• Added a save game structure that contains info like player position, etc.
• Lots of microoptimizations, mostly involving caching projection/view matrices to reduce matrix computation. I didn’t know multiplying matrices can take up so much processing power. Got around a 10% bump in frames.
• Lots of refactoring, some improving performance and others improving code readability
• Added functions and structures that will become handy later on

The camera update

• Smoothed out camera movement. First video is before, second video is after. The implementation removed the awkward sub-pixel jitter created by extremely small amounts of difference.
• Implemented EnTT for ecs. First time using it, but I quickly got a hang of it.

Minor Update

• Updated README according to rejection reason
• Linux Support

The refactor update

Changes

• Refactored input into core::input::
• Refactored quad handling into core::quad::, managing quad creation and rendering over the entire lifetime
• Moved the menu input function over to menu::input:: and a differentfile

The Big Update

Forgot to add a devlog for a bit.

Updates

• Added a simple level editor (pic 3)
• Tweaked the camera position/player movement a bit more.
• Added the ability to make the player go out of the camera’s center. The camera chases the player when it is close to the border of the window.
• Added a paused screen. Not functional yet tho.
• Added ImGui implementation.
• Optimized asset loading. Using atlas systems to prevent duplicates of the same asset in memory.

What’s next?

The core rendering/physics systems are mostly complete. I’m going to work more on the level editor, fix more bugs, and start working on implementing the story.

The Game Update

Updates

• Added the game main loop
• Added box2D physics to move the player (smooth accel/decel)
• Added a fun create-box-on-mouse-click function (temp)

What’s next?

As you may see in the image, I’m really limited on the number of assets at hand. I’m going to work on making more assets and the world itself. I also need to polish/brush up the rendering system. It’s really simple and doesn’t even have a basic camera.

The Core Update

Updates

• Added wrappers for shaders, textures, text (basic opengl stuff)
• Improved the menu a bit more.

What’s next?

since I’ve finished what I need for core development on the menu/ui, I’m going to move onto making the game itself. That consists of making the physics systems, load/save systems, etc.

The Start

Stuff done

• Added project boilerplate
• Started again with OpenGL
• Made a banner
• Created a main loop based on states

What’s next?

A lot of stuff needs to be done, such as making art (which is my pain point in this entire project probably) and setting up systems, keeping DRY (don’t repeat yourself), etc.

The Prep Update

Updates

• Improved the onboarding experience to introduce the navigation
• Added a classes tab

The Grades Update

Updates

Worked on improving grades calculation.

• Added a Grade/GPA Breakdown by Class section in the grades page.
• Added a Grade Contribution by Assignment section to see which assignments are affecting grades.
• Added a setting that lets you configure which type of grade calculation should be used. For now, I only have averages and international baccalaureate calculation methods.
• Updated the initial setup section since it hadn’t been updated since the start of the project.

What’s Next?

• The ability to add custom calculation methods.
• The app might be hard to use, so I think I’ll update the onboarding experience a bit more and introduce more parts of the program.

The Lazy Update

• Added GitHub Actions build automation. (curses is only supported on Unix systems, so the program will be limited to Linux & macOS.)

• Added per-class GPA calculation and a “Remove Assignment” button in home.

Added a calendar view.

The Human Readable Code Update

• Added a unified “interface” structure that builds the interface and draws it at once, reducing the number of calls made and improving the performance and overall look of the program. By doing so, I was also able to add an interface setting that controls the behavior of the draw functions. The attachments show the difference the settings make.

The Clean Up Update

Updates

Clean up the interface a bit more. Made sure the horizontal space between levels of headings is always 2, added more space between elements/toggles, etc.

Dissatisfactions

The code looks pretty messy though, which is something that I am definitely not satisfied with.
In addition, the Assignments and Grades tab look really rushed. I think I’m going to focus on those two next.

The UI Update

• Cleaned up the interface. I didn’t want to use the move() functions at first, but I ended up needing them to make clean grids.
• Added a tab bar, and made some tabs that have some dummy info. Before I continue on with making the “assignment manager” part of the program, I think I’ll rewrite some more interface functions and clean up the code.

I added basic assignment management. Struggled a bit since it’s my first time using curses, but I think I got something pretty good here.

Added initial project boilerplate

Formatted stuff and reduced strings. Made the codebase easier to read.

I added a simple readme and a few QoL features such as history and initial setup. After a bit of polishing I think I’ll be ready to ship.

Added the ability to favorite excuses.

Added the ability to select the tone and purpose of an excuse.

Finished my attribute based object management. Fixed attributes by using high-level C++ objects such as std::variant. I also added tags to help determine which objects should be worked on by which system. I think I need to work on my game systems now, like physics and audio, then I’ll probably be finished with the engine phase. I might take this project and use it to make a full-blown game.

Added attribute based scenes. The program finds objects with a specified tag to work on (ex. sprite), then fetches data about the object based on the attribute’s name and data (void*). I’m not sure if it’s good or not to do so, but I guess I wanted to experiment with different ways of managing data.

Finished three modes: casual, formal, and AI. I’m a strong believer in that AI should be optional, not forced.

Fixed frame buffer scaling. It looks more retro now.

Added z component influence on normal maps to improve user customization. The attachment below is the difference the height of the light makes, with the light at 0 being influenced the most by normals, while a larger z component is less influenced by the normal map.

I added uniform buffer objects to optimize performance. It also served as a learning opportunity for me, since this is a realm I haven’t stepped in yet. Was interesting to learn.

Made create functions for vertex array, buffer and texture creation to reduce the number of API calls and keep the codebase D.R.Y. (Don’t Repeat Yourself)

I added 2D normal maps to my engine, and tweaked the shaders a bit to better mix them together. The UI is really jank and there’s a whole lot more to go until this thing can ship. Motivation is down a bit but will keep it going.

Added basic window creation, shader loading, vertex/indices, etc. Still very early stage stuff.

Added project boilerplate (CMake, vcpkg, main.cc)