improve structs again

Author: codex128

jme3-core/src/main/java/com/jme3/util/struct/FieldDesc.java

@@ -0,0 +1,13 @@
+package com.jme3.util.struct;
+
+public interface FieldDesc<T> {
+
+    int getSize(StructLayout layout, T value);
+
+    int getAlignment(StructLayout layout, T value);
+
+    void write(StructLayout layout, long address, T value);
+
+    T read(StructLayout layout, long address, T store);
+
+}

jme3-core/src/main/java/com/jme3/util/struct/Struct.java

@@ -0,0 +1,112 @@
+package com.jme3.util.struct;
+
+import com.jme3.math.FastMath;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+public abstract class Struct {
+
+    private final List<Field> fields = new LinkedList<>();
+    private StructLayout layout;
+    private int size, alignment;
+
+    public Struct() {}
+
+    public Struct(StructLayout layout, long address) {
+        read(layout, address);
+    }
+
+    public void write(StructLayout layout, long address) {
+        setLayout(layout);
+        for (Field f : fields) {
+            f.write(layout, address);
+        }
+    }
+
+    public void read(StructLayout layout, long address) {
+        setLayout(layout);
+        for (Field f : fields) {
+            f.read(layout, address);
+        }
+    }
+
+    protected void addFields(Field... fields) {
+        this.fields.addAll(Arrays.asList(fields));
+    }
+
+    public void setLayout(StructLayout layout) {
+        if (this.layout == layout) {
+            return;
+        }
+        this.layout = layout;
+        size = 0;
+        alignment = Float.BYTES * 4;
+        for (Field f : fields) {
+            FieldDesc d = layout.getFieldDescription(f.get().getClass());
+            int align = d.getAlignment(layout, f.get());
+            f.bind(d, size = FastMath.toMultipleOf(size, align));
+            size += d.getSize(layout, f.get());
+            alignment = Math.max(alignment, align);
+        }
+        size = FastMath.toMultipleOf(size, alignment);
+    }
+
+    public StructLayout getLayout() {
+        return layout;
+    }
+
+    public int getSize(StructLayout layout) {
+        setLayout(layout);
+        return size;
+    }
+
+    public int getAlignment(StructLayout layout) {
+        setLayout(layout);
+        return alignment;
+    }
+
+    public static class Field <T> {
+
+        private T value;
+        private FieldDesc<T> description;
+        private int offset;
+
+        public Field(T value) {
+            assert value != null : "Struct value cannot be null.";
+            this.value = value;
+        }
+
+        protected void bind(FieldDesc<T> description, int offset) {
+            this.description = description;
+            this.offset = offset;
+        }
+
+        protected void write(StructLayout layout, long structAddress) {
+            description.write(layout, structAddress + offset, value);
+        }
+
+        protected void read(StructLayout layout, long structAddress) {
+            value = description.read(layout, structAddress + offset, value);
+        }
+
+        public void set(T value) {
+            this.value = value;
+        }
+
+        public T get() {
+            return value;
+        }
+
+        public FieldDesc<T> getDescription() {
+            return description;
+        }
+
+        public int getOffset() {
+            return offset;
+        }
+
+    }
+
+}

jme3-core/src/main/java/com/jme3/util/struct/StructBuffer.java

@@ -0,0 +1,69 @@
+package com.jme3.util.struct;
+
+import com.jme3.vulkan.buffers.BufferMapping;
+import com.jme3.vulkan.buffers.MappableBuffer;
+import com.jme3.vulkan.memory.MemorySize;
+
+import java.util.Iterator;
+import java.util.function.Function;
+
+public class StructBuffer <T extends Struct> implements MappableBuffer, Iterable<T> {
+
+    private final StructLayout layout;
+    private final T[] structs;
+    private final MappableBuffer buffer;
+
+    public StructBuffer(StructLayout layout, T[] structs, Function<MemorySize, MappableBuffer> buffer) {
+        assert structs.length > 0 : "Struct buffer must contain at least one struct.";
+        this.layout = layout;
+        this.structs = structs;
+        this.buffer = buffer.apply(MemorySize.bytes(structs[0].getSize(layout)));
+    }
+
+    @Override
+    public BufferMapping map(long offset, long size) {
+        return buffer.map(offset, size);
+    }
+
+    @Override
+    public void stage(long offset, long size) {
+        buffer.stage(offset, size);
+    }
+
+    @Override
+    public ResizeResult resize(MemorySize size) {
+        return buffer.resize(size);
+    }
+
+    @Override
+    public MemorySize size() {
+        return buffer.size();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return new IteratorImpl<>(structs);
+    }
+
+    private static class IteratorImpl <T extends Struct> implements Iterator<T> {
+
+        private final T[] array;
+        private int index = 0;
+
+        public IteratorImpl(T[] array) {
+            this.array = array;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return index < array.length;
+        }
+
+        @Override
+        public T next() {
+            return array[index++];
+        }
+
+    }
+
+}