What programming/technical projects have you been working on?

Warning, premature optimization ahead. Not trying to write this efficiently, just having fun. :P

So I started toying around with writing an Entity Component System (ECS) after reading through this series. Briefly, the ideas is to break game entity data into components and store each component data in contiguous blocks of memory to minimize cache misses when you want to iterate over every component for associated entities.

Right now I have a working sparse set to manage each block of components. Each set is composed of three containers: a large sparse vector to map entity IDs to component index, and two custom containers to pack components and entity IDs as tightly as possible, allowing for contiguous iteration over both.

I wrote a custom container for the components because I dislike how std::vector value initializes anything you can index, so a resize on a large component vector could be quite costly. I understand why they do this, if you let people arbitrarily construct objects anywhere in allocated memory there is no way to iterate through and destruct all of them but as we are already tracking indexes in the sparse array we can just use the sparse set safely as a destructor or to manage resizing anyways. This lets us use placement new to constuct on demand anywhere in allocated space. In practice, we construct contiguously anyways but at least a resize only costs us an allocation and some moves now.

(I suppose I could have pre-allocated everything on the stack but not sure if I want to limit the number of entities. I may end up writing a pool allocator in the future that pre-allocates, but it will include a method to get more blocks as required.)

Anyways, my container uses std::aligned_storage as a method for allocating uninitialized blocks of memory I can placement new into:

    std::unique_ptr<typename std::aligned_storage<sizeof(T), alignof(T)>::type[]> data_;

Which we can then emplace new objects into :

template<typename... Args>
void emplace (std::size_t index, Args&&... args)
{
    if (index >= capacity_)
    {
        std::size_t new_size = (capacity_) ? capacity_ * growth_factor : 8u;
        resize(new_size);
    }
		
	
	new (&data_.get()[index]) T(std::forward<Args>(args)...);
	size_++;
	
}

Erase objects:

void erase(std::size_t index)
{
    std::launder(reinterpret_cast<T*>(&data_.get()[index]))->~T();
	size_--;
}

And access them by index:

T& operator[](std::size_t index)
{
    return *std::launder(reinterpret_cast<T*>(&data_.get()[index]));
}

const T& operator[](std::size_t index) const
{
    return *std::launder(reinterpret_cast<const T*>(&data_.get()[index]));
}

Inserting and erasing from the sparse set is very simple:

template<typename... Args>
	void insert(const entity_id &val, Args&&... args)
	{
		if (!contains(val))
		{
			if (val >= capacity_)
				grow(val); // resize sparse vec to val+1

			sparse[val] = size_;
			packed_entities.emplace(size_, val);
			packed_components.emplace(size_, args...);
			++size_;
		}
	}

	void erase_entity(entity_id id)
	{
		if (contains(id))
		{
			sparse[packed_entities[size_ - 1]] = sparse[id];

			packed_entities.erase(sparse[id]);
            packed_entities[sparse[id]] = packed_entities[size_ - 1];

            packed_components.erase(sparse[id]);
            packed_components[sparse[id]] = packed_components[size_ - 1];

			--size_;
		}
	}

I'm sure some of this is a bad idea, but given the constraints of a sparse set I can't see how the foot gun will bite me yet.

I recently bought a macro pad on /r/mechmarket and have been teaching myself basic QMK and how to build and flash keyboard firmware. It's been going...OK...but I'm a total noob and all I've been able to do is take a keymap someone else built and slightly tweak it. I have no idea how to program the OLED that's on my macropad, nor do I know how to do more than 3 layers using QMK tap dance or whatever it is you call that. As long as I don't brick the damn thing it should be a fun experiment at least

I'm converting my old Maker Select v2 (Duplicator i3 clone) to a 32-bit mainboard, the SKR 1.4 turbo, and adding an auto-leveling probe. The stock melzi board died on me last weekend and a drop in replacement is much more expensive and much less functional than the upgrade. Using drv8825 stepper drivers for now since a 5 pack was just sitting on the shelf next to the board at micro center for $10, though I will eventually replace them with some TMC2226s (2209 successor) coming in a few months from china. The wiring is almost done, but I had to order a JST crimper and ends to wire in the extruder motor in a non-hacky way, and that's not here until Friday. Crossing my fingers that the firmware install will go smoothly, the web interface for customizing marlin seemed pretty straightforward, and I may even try it before wiring up the extruder.