static int config_geom(Stream_t *Stream, struct device *dev,
struct device *orig_dev, int media,
struct bootsector *boot)
{
if(check_geom(dev, media, boot))
return 1;
set_geom(boot,dev);
return 0;
}
static void skin_init (State *s, value vertexa_v, value normala_v,
value uva_v, value skin_v, value colors_v)
{
char *p;
GLsizei sizevn, sizev, sizeu, sizec;
void *ptrs[COUNT];
s->num_vertices = Wosize_val (vertexa_v) / (Double_wosize * 3);
sizev = AL32 (3 * sizeof (GLfloat) * s->num_vertices);
sizeu = 2 * sizeof (GLfloat) * s->num_vertices;
sizec = 4 * s->num_vertices;
sizevn = sizev * 2;
p = simd_alloc (16, AL16 (sizevn) + s->num_vertices * sizeof (struct skin));
s->skin = (struct skin *) (p + AL16 (sizevn));
s->ptrs[0] = ptrs[V_IDX] = p;
ptrs[N_IDX] = p + sizev;
p = stat_alloc (sizec + sizeu);
s->ptrs[1] = ptrs[UV_IDX] = p;
ptrs[C_IDX] = p + sizeu;
set_geom (s, ptrs, vertexa_v, normala_v, uva_v, skin_v, colors_v);
if (use_vbo) {
glGenBuffers (2, s->bufid);
glBindBuffer (GL_ARRAY_BUFFER, s->bufid[0]);
glBufferData (GL_ARRAY_BUFFER, sizevn, s->ptrs[0], GL_DYNAMIC_DRAW);
glBindBuffer (GL_ARRAY_BUFFER, s->bufid[1]);
glBufferData (GL_ARRAY_BUFFER, sizeu+sizec, s->ptrs[1], GL_STATIC_DRAW);
glBindBuffer (GL_ARRAY_BUFFER, 0);
stat_free (s->ptrs[1]);
p = NULL;
s->bufs[V_IDX] = p;
s->bufs[N_IDX] = p + sizev;
s->bufs[UV_IDX] = p;
s->bufs[C_IDX] = p + sizeu;
}
else {
p = simd_alloc (DSTAL, sizevn);
s->bufs[V_IDX] = p;
s->bufs[N_IDX] = p + sizev;
s->bufs[UV_IDX] = ptrs[UV_IDX];
s->bufs[C_IDX] = ptrs[C_IDX];
memcpy (p, s->ptrs[0], sizevn);
}
s->num_vertices /= 1;
}
//===== Copy =====//
Af& Af::operator=(const Af& iaf) //jrg - look at this...
{
type = iaf.type;
curve_loaded_flag = iaf.curve_loaded_flag;
inverted_flag = iaf.inverted_flag;
camber = iaf.camber;
camber_loc = iaf.camber_loc;
thickness = iaf.thickness;
thickness_loc = iaf.thickness_loc;
radius_le = iaf.radius_le;
radius_te = iaf.radius_te;
delta_y_le = iaf.delta_y_le;
a = iaf.a;
ideal_cl = iaf.ideal_cl;
sixser = iaf.sixser;
name = iaf.name;
num_pnts = iaf.num_pnts;
orig_af_thickness = iaf.orig_af_thickness;
radius_le_correction_factor = iaf.radius_le_correction_factor;
radius_te_correction_factor = iaf.radius_te_correction_factor;
upper_curve = iaf.upper_curve;
lower_curve = iaf.lower_curve;
slat_flag = iaf.slat_flag;
slat_shear_flag = iaf.slat_shear_flag;
slat_chord = iaf.slat_chord;
slat_angle = iaf.slat_angle;
flap_flag = iaf.flap_flag;
flap_shear_flag = iaf.flap_shear_flag;
flap_chord = iaf.flap_chord;
flap_angle = iaf.flap_angle;
set_geom(geom_ptr );
load_name();
generate_airfoil();
return *this;
}
Stream_t *XdfOpen(struct device *dev, char *name,
int mode, char *errmsg, struct xdf_info *info)
{
Xdf_t *This;
off_t begin, end;
struct bootsector *boot;
int type;
if(dev && (!SHOULD_USE_XDF(dev) || check_geom(dev, 0, 0)))
return NULL;
This = New(Xdf_t);
if (!This)
return NULL;
This->Class = &XdfClass;
This->sector_size = 512;
This->stretch = 0;
precmd(dev);
This->fd = open(name, mode | dev->mode | O_EXCL | O_NDELAY);
if(This->fd < 0) {
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"xdf floppy: open: \"%s\"", strerror(errno));
#else
sprintf(errmsg,"xdf floppy: open: \"%s\"", strerror(errno));
#endif
goto exit_0;
}
closeExec(This->fd);
This->drive = GET_DRIVE(This->fd);
if(This->drive < 0)
goto exit_1;
/* allocate buffer */
This->buffer = (char *) malloc(96 * 512);
if (!This->buffer)
goto exit_1;
This->current_track = -1;
This->track_map = (TrackMap_t *)
calloc(96, sizeof(TrackMap_t));
if(!This->track_map)
goto exit_2;
/* lock the device on writes */
if (lock_dev(This->fd, mode == O_RDWR, dev)) {
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"xdf floppy: device \"%s\" busy:",
dev->name);
#else
sprintf(errmsg,"xdf floppy: device \"%s\" busy:",
dev->name);
#endif
goto exit_3;
}
/* Before reading the boot sector, assume dummy values suitable
* for reading at least the boot sector */
This->track_size = 11;
This->track0_size = 6;
This->rate = 0;
This->FatSize = 9;
This->RootDirSize = 1;
decompose(This, 0, 512, &begin, &end, 0);
if (load_data(This, 0, 1, 1) < 0 ) {
This->rate = 0x43;
if(load_data(This, 0, 1, 1) < 0)
goto exit_3;
}
boot = (struct bootsector *) This->buffer;
This->FatSize = WORD(fatlen);
This->RootDirSize = WORD(dirents)/16;
This->track_size = WORD(nsect);
for(type=0; type < NUMBER(xdf_table); type++) {
if(xdf_table[type].track_size == This->track_size) {
This->map = xdf_table[type].map;
This->track0_size = xdf_table[type].track0_size;
This->rootskip = xdf_table[type].rootskip;
break;
}
}
if(type == NUMBER(xdf_table))
goto exit_3;
if(info) {
info->RootDirSize = This->RootDirSize;
info->FatSize = This->FatSize;
info->BadSectors = 5;
}
decompose(This, 0, 512, &begin, &end, 1);
This->refs = 1;
This->Next = 0;
This->Buffer = 0;
if(dev)
set_geom(boot, dev);
return (Stream_t *) This;
exit_3:
Free(This->track_map);
exit_2:
Free(This->buffer);
exit_1:
close(This->fd);
exit_0:
Free(This);
return NULL;
}
