Implements GetComponents

component.go

@@ -34,6 +34,11 @@ type ComponentType[T any] struct {
 	query      *Query
 }
 
+// Typ returns the reflect.Type of the ComponentType.
+func (c *ComponentType[T]) Typ() reflect.Type {
+	return c.typ
+}
+
 // Get returns component data from the entry.
 func (c *ComponentType[T]) Get(entry *Entry) *T {
 	return (*T)(entry.Component(c))

component/component.go

@@ -1,6 +1,7 @@
 package component
 
 import (
+	"reflect"
 	"unsafe"
 )
 
@@ -11,5 +12,6 @@ type (
 type IComponentType interface {
 	Id() ComponentTypeId
 	New() unsafe.Pointer
+	Typ() reflect.Type
 	Name() string
 }

entry.go

@@ -3,6 +3,7 @@ package donburi
 import (
 	"bytes"
 	"fmt"
+	"reflect"
 	"unsafe"
 
 	"github.com/yohamta/donburi/component"
@@ -23,6 +24,23 @@ func Get[T any](e *Entry, ctype component.IComponentType) *T {
 	return (*T)(e.Component(ctype))
 }
 
+// GetComponents uses reflection to convert the unsafe.Pointers of an entry into its component data instances.
+// Note that this is likely to be slow and should not be used in hot paths or if not necessary.
+func GetComponents(e *Entry) []any {
+	archetypeIdx := e.loc.Archetype
+	s := e.World.StorageAccessor().Archetypes[archetypeIdx]
+	cs := s.ComponentTypes()
+	var instances []any
+	for _, ctyp := range cs {
+		instancePtr := e.Component(ctyp)
+		componentType := ctyp.Typ()
+		val := reflect.NewAt(componentType, instancePtr)
+		valInstance := reflect.Indirect(val).Interface()
+		instances = append(instances, valInstance)
+	}
+	return instances
+}
+
 // Add adds the component to the entry.
 func Add[T any](e *Entry, ctype component.IComponentType, component *T) {
 	e.AddComponent(ctype, unsafe.Pointer(component))

internal/storage/archetype.go

@@ -33,6 +33,11 @@ func (archetype *Archetype) Entities() []Entity {
 	return archetype.entities
 }
 
+// ComponentTypes returns a slice of all component types in the archetype.
+func (archetype *Archetype) ComponentTypes() []component.IComponentType {
+	return archetype.Layout().componentTypes
+}
+
 // SwapRemove removes an entity from the archetype and returns it.
 func (archetype *Archetype) SwapRemove(entity_index int) Entity {
 	removed := archetype.entities[entity_index]