TextureMind Framework – Work in progress

What is it?

TextureMind framework is a framework written in C++ language to develop a wide range of cross-platform applications. The framework is composed by a set of classes to facilitate multi-threading, serialization, ipc, networking, graphics and computer vision. The framework is also composed by a complete set of applications to create images, animations, GUIs and videogames. I'm creating this framework to speed-up the production of software in general. It has been coded by me from scratch and it can be seen as a collection of all the knowledge that I have in the field of computer programming. The framework is currently closed source and it will be used just for my personal creations.

Backlog

23 March, 2021

  • Implement dynamic resources
  • Support FreeType library
  • Calculate fonts to render onscreen text
  • Convert on the fly text glyphs into Vulkan textures
  • Render text with different types of indentations (left, right, certer, justified)
  • Enable text rendering on the GUI with Vulkan renderer
  • Use bitmap text rendering to optimize also Cairo renderer

10 September, 2020

  • Add support for bones weights and bones indices to vertex attributes
  • Import weights, indices, bones, skeleton, animated nodes with AssImp library
  • Implement shader storage buffers
  • Optimize vertex and index buffers
  • Implement skinned mesh computing in vertex shader
  • Animate nodes with linear interpolation for position / scale and slerp for quaternions

28 August, 2020

  • Refactor material system and lighting stage, implement PBR principles
  • Optimize ambient, diffusion and specular rendering with multiple textures
  • Implement missing parts in the importer to support advanced materials

20 August, 2020

  • Import texture coords, tangent and bitangent vertex attributes with AssImp library
  • Improve material system with multiple layers of textures
  • Implement bump mapping with tangets, bitangents and normal maps

9 August, 2020

  • Import 3D nodes, vertices, indices and normals with AssImp library.
  • Improve material system and mesh rendering

6 August, 2020

  • Define format for 3D mesh with multiple vertex attributes and layout
  • Implement convertion from 3D mesh to Vulkan vertex and index buffers
  • Design and implement the 3D engine. Handle 3D assets, resources and materials
  • Add support for 3D rendering in vulkan graphics context
  • Write a simple test case with a material and a rotating torus

1 June, 2020

  • Translate material nodes into GLSL shader for Vulkan
  • Support textures with Vulkan, implement materials with textures

17 May, 2020

  • Improve abstract graphics context interface for modern graphics libraries like Vulkan
  • Create Vulkan device and implement a specialization of the graphics context
  • Adapt uniforms mechanims to Vulkan uniform buffers, write a simple shader
  • Add shaderc dependency and convert GLSL program shader into SPIRV shaders
  • Implement materials with graphics pipeline, layouts and descriptor sets
  • Optimize rendering layers with primary and secondary command buffers
  • Implement vertex buffers, draw rainbow rectangles without textures
  • Fix transform 2D, finally make 2D GUI work with Vulkan Graphics context

23 February, 2020

  • Design an abstract physics engine and implement 2D physics engine for collision detection
  • Implement a GUI engine on top of the 2D graphics engine and physics engine
  • Introduce the first set of widgets, like buttons, options, check boxes and window forms.

16 August, 2019

  • Implement an abstract architecture for 2D and 3D engine
  • Manage resources like textures, materials and assets and attach them to the engine
  • Implement 2D graphics engine to draw a scene composed by 2D shapes
  • Make the engine work and write a simple test case

8 May, 2019

  • Improve texture's architecture, adding linear, radial and program shader textures
  • Implement materials composed by expression nodes, similar to Unreal Engine 4
  • Improve the architecture for path rendering of 2D shapes with textures and materials
  • Make the Cairo test case work with the new architecture

20 August, 2018

  • Implement system component, open a window, handle events, draw a picture
  • Improve graphics context, add 2D shapes rendering on graphics abstraction layer
  • Implement cairo graphics context and draw 2D shapes
  • Add a simple test case that uses Cairo library for drawing a rotating 2D shape

18 April, 2018

  • Implement cross-platform dynamic libraries loader
  • Dynamically link all the external libraries, when required
  • Add skeleton architecture for additional modules:
    • Picture (Handle color formats, palette, images)
    • Geometrics (2D and 3D shapes, splines, nurbs)
    • Graphics (Abstract layer for rendering 2D and 3D graphics)
    • System (Set of classes to handle windows and OS functionality)
    • DevIL (Import and export popular image formats with DevIL library)
    • Cairo (Implementation of 2D rendering with Cairo library)
  • Implement image loader with DevIL
  • Add Skeleton architecture for Graphics context

31 December, 2017

  • Add math classes (Complex, Vector, Matrix) and functionality
  • Improve json and xml parser interface
  • Implement constant strings on human readable (like xml or json) serialization
  • Improve the log
  • Fix some memory leak

29 October, 2017

  • Custom set of classes to handle objects and containers (vector, list, map, multimap)
  • Serialization with 4 formats (xml, json, raw and formatted binary) optimized for speed
  • Threads, mutexes, semaphores, atomics
  • Integration with TinyC library to build and execute Just-In time code
  • Custom memory allocation methods to trace leaks and optimize fragmentation
  • Full set of methods to handle streams into files and block of memory

Background

The CJS Framework that I was developing in my spare time now has been changed into TextureMind (TMD) Framework. It happened for different kind of reasons. When I created the CJS framework, my first aim was to create an opensource project for multiple target languages, using a valid and interchangable method to serialize a full set of classes. Well, even if it could be a good idea, my actual job didn't leave me the time to develop a project that is so large, even with the help of ther people. So i decided to continue another shorter framework in my spare time just for hobby and to facilitate the creation of my applications, changing the title of the project to TextureMind Framework.

If you don't have time, why not open source?

I decided to create this framework for hobby and for personal usage. I will use this framework mainly to create applications without having to rewrite the same things every time. I know that there are already valid frameworks around but my dream is to use my own framework, also to have the freedom to write custom features by myself. I want to continue this project without external contributions until it will be stable. Maybe one of these days it will be open source, but not now.