Hi,
first, I guess I’ve to apologize in some way, because I was the OP last
week and you kindly, very quickly, posted a suggestion on pastebin and I
was completely ignorant. Actually, I was in limbo because I had so many
questions and didn’t know where to start.
Joel VanderWerf wrote:
Can you describe the nesting you are trying to do?
Currently, I’m writing a reader for the BSP file format, as described
here: Unofficial Quake 3 Map Specs
The week before, I was writing a MD3 model reader, which works already
thanks to bit-struct 
Back to the BSP format: since it uses some fixed arrays, and it was one
of your post which suggested binaryparse, I tried that one and succeeded
so far, except the following:
-
it was incredible hart to get into binaryparse as you basically
have to learn from the source, as there’s no real usable rdoc doc
-
probably due 1), I’ve no idea how to read float values with it. I
just don’t get it, I guess
It does not seem to have out of the box
support, however it seems to provide some kind of support via custom
packing/unpacking, but I can’t figure out how.
Due 2), I don’t support reading the lumps containing floats ATM. Right
now I don’t need them, but reading all data is the goal.
char :s, 5*8
unsigned :x, 5
unsigned :y, 3
char :s, 5*8
end
class Container < BitStruct
vector :n, MyEntry, “some entries”, :length => 2
end
Now, I wouldn’t mind going back to bit-struct for the BSP reading stuff,
as I find the documentation outstanding well! However, through
binaryparse I discovered one thing I’m really enjoying: it supports
direct reading from an IO-type object. So I can pass either a File IO or
an StringIO object directory, which is really comfortable.
Maybe bit-struct supports that in some way, but I couldn’t find
anything. Basically, with bit-struct I’ve to know how much to pass to a
BitStruct class. Binaryparse, in contrast, uses the given structure
information to know itself how much to consume.
class Header < BinaryBlocker::Blocker
has_one …
has_one …
end
class Datadir < BinaryBlocker::Blocker
…
…
end
io = File.new(“data”)
Header.new io
Datadir.new io
That’s really nice compared to
Header.new io.read(Header.round_byte_length)
Datadir.new io.read(Datadir.round_byte_length)
But I can see that there are different philosophies at work, given that
it’s named round_byte_length, because reading single bits wouldn’t be
really possible that way, therefore the “rest” reader …
About your upcoming addition and your example: how would a simple
integer array look like?
C-struct example:
typedef struct {
float normal[3];
float dist;
} dplane_t;
Ruby (?):
class MyFloat < BitStruct
float :value, 32
end
class Plane < BitStruct
vector :normal, MyFloat, :length => 3
float :dist, 32
end
This wold mean I need to access plane.normal[0].value I guess … having
not to need the additional .value would be nice, e.g.
class Plane < BitStruct
vector :normal, :length => 3 do
float 32
end
float :dist, 32
end
Would multiple dimension be supported, too? Like C-style float[2][2] ?
class Plane < BitStruct
vector :normal, :length => 3 do
vector :length => 3 od
float 32
end
end
float :dist, 32
end
Ok, I think it’s getting out of control now 
thanks