well if/when we switch over the geometry to a new system, I think we should go full bore, write a converter for the old system, and just totaly ditch it, otherwise I guess all we can realy do is add another type of polygon to the exsisting BSP structure.
as for how it would actualy be packaged in the chunck, we probly will need either a new version of the defpoints chunck, or modify the exsisting one seveirly. I'm thinking it would be easier to simply make a new one, it'd be fairly simple, what you'd have is:
defpointchunk{
int n_defpoints;
vertex *points;
}
I'm trying to use struct notation to describe what it'd look like in the file, wich isn't exactly perfict

points is a vertex array of size n_defpoints, the vertex defenition shall be modifyed to include a normal, wich it realy should already have, if you look our vertex class is _realy_ ugly, thinking about it more, we should probly make up a new vertex class for this specific situation, wich would basicly be what you posted
struct defpoint{
vector pos;
uv_pair uv;
vector norm;
};
and use that as the array of size n_defpoints.
ok, that could basicly be read from directly by the polys (this would only be done during colision ditection, we'd set pointer to a defpoint to the points array from the defpoint chunk and read directly from it as it's already in memory)
the polygon structure, I guess we could call them "tmap_htl"s would consist primaraly of an int array, there would though be things like a bounding box or center point and radius, poly normal, one thing I would realy like to have is offsets to all neboring polys, this would spead decal creation up __massively__
/*goes off on decal system tangent*/ as currently I basicly have to rework the entier colision ditection on a per poly basis, though I am useing the exsisting BSP tree to (I beleive) it's fullest potential, part of the culling proces involves finding the closest point on a polygon to the decal (wich is extreemly procesor intinsive as you find a point on the polys plane thin if it isn't on the poly you have to go on an edge by edge basis and find the point closest to that) and seeing if it's in the decal (wich involves rotateing it into the decals space), the actual creation of the decal polys is very quick, I just set the UV's acording to there distance from two of the clipping planes and copy them to the decal.
/*back on topic*/
struct tmap_htl{
vector center; // center of poly
vector norm; //the normal of the poly
float rad; //radius of the poly (distance of the furthest point from the center)
int tmap; wich texture/material of the model's textures/materials is this poly useing (I still want that material system)
... //anything else we come up with :)
int n_points; //number of points in this poly
int *points; //points[n_points], these are indecies into the defpoints chunck
int *neighbor;//neighbor[n_points], neighbor[N] == the offset to the polygon shareing edge defined by points (N,(N+1)%n_points)
}
I think it would be ok to have these organised by a sort of octant system, rather than a full BSP, as the only thing the BSP (the real BSP with the sortnorms and crap) was used for was in the now obsoleate rendering code, colision ditection only uses the bounding boxes