CELL make_vector_uninited(size_t len)
{
CELL cell = gc_alloc_extra(VECTOR, len * sizeof(CELL));
VECTOR* p = GET_VECTOR(cell);
p->len = len;
return cell;
}
CELL make_vector_inited(size_t len, CELL init)
{
gc_root_1("make_vector_inited", init);
CELL cell = gc_alloc_extra(VECTOR, len * sizeof(CELL));
VECTOR* p = GET_VECTOR(cell);
p->len = len;
int i;
for(i = 0; i < len; ++i) {
p->data[i] = init;
}
gc_unroot();
return cell;
}
/*****************************************
* Read nappe characterization in a file *
*****************************************/
GEO *
file_geo_nappe (BYTE Type, FILE *File)
{
GEO_NAPPE *Geo;
PNT *Pnt, *PntA, *PntB, *PntC, *PntD;
FCT *Fct;
VECTOR U, V;
REAL Real;
INDEX Index;
INIT_MEM (Geo, 1, GEO_NAPPE);
Geo->Type = Type;
GET_INDEX (Geo->NbrPnt);
INIT_MEM (Geo->TabPnt, Geo->NbrPnt, PNT);
GET_INDEX (Geo->NbrFct);
INIT_MEM (Geo->TabFct, Geo->NbrFct, FCT);
Geo->Min.x = Geo->Min.y = Geo->Min.z = INFINITY;
Geo->Max.x = Geo->Max.y = Geo->Max.z = -INFINITY;
for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++) {
GET_VECTOR (Pnt->Point);
VEC_MIN (Geo->Min, Pnt->Point);
VEC_MAX (Geo->Max, Pnt->Point);
}
for (Index = 0, Fct = Geo->TabFct; Index < Geo->NbrFct; Index++, Fct++) {
if (fscanf (File, " ( %d %d %d %d )", &Fct->i, &Fct->j, &Fct->k, &Fct->l) < 4)
return (FALSE);
Fct->NumFct = Index;
PntA = Geo->TabPnt + Fct->i;
PntB = Geo->TabPnt + Fct->j;
PntC = Geo->TabPnt + Fct->k;
PntD = Geo->TabPnt + Fct->l;
VEC_SUB (U, PntC->Point, PntA->Point);
VEC_SUB (V, PntD->Point, PntB->Point);
VEC_CROSS (Fct->Normal, U, V);
VEC_UNIT (Fct->Normal, Real);
VEC_INC (PntA->Normal, Fct->Normal);
VEC_INC (PntB->Normal, Fct->Normal);
VEC_INC (PntC->Normal, Fct->Normal);
VEC_INC (PntD->Normal, Fct->Normal);
}
for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++)
VEC_UNIT (Pnt->Normal, Real);
return ((GEO *) Geo);
}
GEO *
file_geo_sphere (BYTE Type, FILE *File)
{
GEO_SPHERE *Geo;
VECTOR Vector;
INIT_MEM (Geo, 1, GEO_SPHERE);
Geo->Type = Type;
GET_VECTOR (Geo->Point);
GET_REAL (Geo->Radius);
Vector.x = Vector.y = Vector.z = Geo->Radius;
VEC_SUB (Geo->Min, Geo->Point, Vector);
VEC_ADD (Geo->Max, Geo->Point, Vector);
return ((GEO *) Geo);
}
int internal_equalp(CELL obj1, CELL obj2)
{
while(1) {
if (AS_LITERAL(obj1) == AS_LITERAL(obj2)) {
return 1;
}
if (! (IS_POINTER(obj1) && IS_POINTER(obj2)) ) {
return 0;
}
if (GET_POINTER_TYPE(obj1) != GET_POINTER_TYPE(obj2)) {
return 0;
}
switch(GET_POINTER_TYPE(obj1)) {
case T_CONS:
// FIXME - unbounded recursion!
if (!internal_equalp(CAR(obj1), CAR(obj2))) {
return 0;
}
obj1 = CDR(obj1);
obj2 = CDR(obj2);
break;
case T_VECTOR:
case T_RECORD:
{
VECTOR * const vec1 = GET_VECTOR(obj1);
VECTOR * const vec2 = GET_VECTOR(obj2);
if (vec1->len != vec2->len) {
return 0;
}
int i;
for(i = 0; i < vec1->len; ++i) {
// FIXME - unbounded recursion!
if (!internal_equalp(vec1->data[i], vec2->data[i])) {
return 0;
}
}
return 1;
}
case T_STRING:
{
STRING * const p1 = GET_STRING(obj1);
STRING * const p2 = GET_STRING(obj2);
return p1->len == p2->len && 0 == memcmp(p1->data, p2->data, p1->len);
}
case T_FLOAT:
return GET_FLOAT(obj1) == GET_FLOAT(obj2);
case T_BIGINT:
return GET_BIGINT(obj1) == GET_BIGINT(obj2);
default:
return 0;
}
}
}
bool CameraDeserializer::DeserializeToFrame(FramePtr frame, const TypeInfo& info, std::ostream& log)
{
if (info.TypeName != "camera")
{
log << "[ERROR] Camera deserializer passed a type of type: "
<< info.TypeName.c_str() << "." << std::endl;
return false;
}
Camera cam;
bool errorbit = false;
if (!GetReferenceFrame(cam.RefFrame, info, log))
errorbit = true;
if (!GetPosition(cam.Position, cam.RefFrame.Velocity == ReferenceFrame::Default.Velocity, info, log))
errorbit = true;
auto end = info.Values.end();
auto forward = info.Values.find("forward");
auto up = info.Values.find("up");
auto right = info.Values.find("right");
auto fovx = info.Values.find("fovx");
auto fovy = info.Values.find("fovy");
auto aspect = info.Values.find("aspect");
if (forward == end)
{
CHECK_PRESENT(forward, up);
CHECK_PRESENT(forward, right);
if (!errorbit)
{
GET_VECTOR(cam.Up, up);
GET_VECTOR(cam.Right, right);
if (!errorbit)
{
cam.Forward = cross(cam.Up, cam.Right);
}
}
}
else if (up == end)
{
CHECK_PRESENT(up, right);
if (!errorbit)
{
GET_VECTOR(cam.Forward, forward);
GET_VECTOR(cam.Right, right);
if (!errorbit)
{
cam.Up = cross(cam.Forward, cam.Right);
}
}
}
else if (right == end)
{
GET_VECTOR(cam.Forward, forward);
GET_VECTOR(cam.Up, up);
if (!errorbit)
{
cam.Right = cross(cam.Forward, cam.Up);
}
}
else
{
GET_VECTOR(cam.Forward, forward);
GET_VECTOR(cam.Up, up);
GET_VECTOR(cam.Right, right);
}
if (aspect == end)
{
if (fovx == end)
{
log << NOT_PRESENT(aspect, fovx, camera) << std::endl;
errorbit = true;
}
else if (fovy == end)
{
log << NOT_PRESENT(aspect, fovy, camera) << std::endl;
errorbit = true;
}
else
{
GET_NUMBER(cam.FovX, fovx);
GET_NUMBER(cam.FovY, fovy);
}
}
else if (fovx == end)
{
if (fovy == end)
{
log << NOT_PRESENT(fovx, fovy, camera) << std::endl;
errorbit = true;
}
else
{
double aspect_;
GET_NUMBER(aspect_, aspect);
GET_NUMBER(cam.FovY, fovy);
if (!errorbit)
{
cam.FovX = cam.FovY * aspect_;
}
}
}
else if (fovy == end)
{
double aspect_;
GET_NUMBER(aspect_, aspect);
GET_NUMBER(cam.FovX, fovx);
if (!errorbit)
{
cam.FovY = cam.FovX / aspect_;
}
}
else
{
GET_NUMBER(cam.FovX, fovx);
GET_NUMBER(cam.FovY, fovy);
}
if (!errorbit)
frame->Viewpoint = cam;
return !errorbit;
}
// process an incoming respawn info packet
void multi_respawn_process_packet(ubyte *data, header *hinfo)
{
ubyte code,cur_link_status;
char cur_primary_bank,cur_secondary_bank;
ushort net_sig,ship_ets;
short player_id;
int player_index;
vec3d v;
char parse_name[1024] = "";
int offset = HEADER_LENGTH;
// determine who send the packet
player_index = find_player_id(hinfo->id);
if(player_index == -1){
nprintf(("Network","Couldn't find player for processing respawn packet!\n"));
}
// get the opcode
GET_DATA(code);
// do something based upon the opcode
switch((int)code){
case AI_RESPAWN_NOTICE:
p_object *pobjp;
GET_USHORT( net_sig );
pobjp = mission_parse_get_arrival_ship( net_sig );
Assert( pobjp != NULL );
multi_respawn_ai( pobjp );
break;
case RESPAWN_BROADCAST:
// get the respawn data
GET_USHORT(net_sig);
GET_VECTOR(v);
GET_SHORT(player_id);
GET_DATA(cur_primary_bank);
GET_DATA(cur_secondary_bank);
GET_DATA(cur_link_status);
GET_USHORT(ship_ets);
GET_STRING(parse_name);
player_index = find_player_id(player_id);
if(player_index == -1){
nprintf(("Network","Couldn't find player to respawn!\n"));
break;
}
// create the ship and assign its position, net_signature, and class
// respawn the player
multi_respawn_player(&Net_players[player_index], cur_primary_bank, cur_secondary_bank, cur_link_status, ship_ets, net_sig, parse_name, &v);
// if this is for me, I should jump back into gameplay
if(&Net_players[player_index] == Net_player){
gameseq_post_event(GS_EVENT_ENTER_GAME);
}
break;
case RESPAWN_REQUEST:
// determine whether he wants to respawn as an observer or not
GET_DATA(code);
if(player_index == -1){
nprintf(("Network","Received respawn request from unknown player!\n"));
break;
}
nprintf(("Network","Received respawn request for player %s\n", Net_players[player_index].m_player->callsign));
// make sure he's not making an invalid request
if((code == 0) && !(Net_players[player_index].flags & NETINFO_FLAG_RESPAWNING)){
nprintf(("Network","This player shouldn't be respawning!\n"));
Int3();
break;
} else if((code == 1) && !(Net_players[player_index].flags & NETINFO_FLAG_LIMBO)){
nprintf(("Network","This is a respawn observer request from a player who shouldn't be respawning as an observer!\n"));
Int3();
break;
}
// otherwise perform the operation
// respawn the guy as an observer
if(code){
multi_respawn_make_observer(&Net_players[player_index]);
}
// respawn him as normal
else {
// create his new ship, and change him from respawning to respawned
Assert(Net_players[player_index].p_info.p_objp != NULL);
if(Net_players[player_index].p_info.p_objp != NULL){
multi_respawn_player(&Net_players[player_index], Net_players[player_index].s_info.cur_primary_bank, Net_players[player_index].s_info.cur_secondary_bank,Net_players[player_index].s_info.cur_link_status, Net_players[player_index].s_info.ship_ets, 0, Net_players[player_index].p_info.p_objp->name);
}
}
break;
}
PACKET_SET_SIZE();
}
void internal_generic_output(FILE* fp, CELL cell, int strict, int tab)
{
switch(GET_TYPE(cell)) {
case T_VOID:
fputs("#<void>", fp);
break;
case T_NULL:
fputs("()", fp);
break;
case T_UNDEFINED:
fputs("#<undefined>", fp);
break;
case T_EMPTY:
fputs("#<empty>", fp);
break;
case T_BOOL:
fputs(GET_BOOL(cell) ? "#t" : "#f", fp);
break;
case T_CHAR:
{
CHAR ch = GET_CHAR(cell);
if (strict) {
switch(ch) {
case ' ': fputs("#\\space", fp); break;
case 0: fputs("#\\nul", fp); break;
case 27: fputs("#\\escape", fp); break;
case 127: fputs("#\\rubout", fp); break;
case '\a': fputs("#\\alarm", fp); break;
case '\b': fputs("#\\backspace", fp); break;
case '\f': fputs("#\\page", fp); break;
case '\n': fputs("#\\newline", fp); break;
case '\r': fputs("#\\return", fp); break;
case '\t': fputs("#\\tab", fp); break;
case '\v': fputs("#\\vtab", fp); break;
default: fprintf(fp, "#\\%c", ch); break;
}
}
else {
fputc(ch, fp);
}
}
break;
case T_INT:
fprintf(fp, "%d", GET_INT(cell));
break;
case T_BIGINT:
fprintf(fp, "%lld", GET_BIGINT(cell));
break;
case T_FLOAT:
fprintf(fp, "%f", GET_FLOAT(cell));
break;
case T_STRING:
{
STRING* p = GET_STRING(cell);
size_t len = p->len;
char* data = p->data;
if (strict) {
// FIXME -- make this more efficient, and escape other special chars?
fputc('"', fp);
while(len--) {
char ch = *data++;
if (ch == '"' || ch == '\\') {
fputc('\\', fp);
}
fputc(ch, fp);
}
fputc('"', fp);
}
else {
fwrite(data, 1, len, fp);
}
}
break;
case T_NAME:
{
NAME* p = GET_NAME(cell);
if (p->gensym) {
fprintf(fp, "#_%d", p->gensym);
}
else {
fwrite(GET_NAME(cell)->data, 1, GET_NAME(cell)->len, fp);
}
}
break;
case T_KEYWORD:
{
KEYWORD* p = GET_KEYWORD(cell);
fwrite(p->data, 1, p->len, fp);
fputc(':', fp);
}
break;
case T_SLOT:
fprintf(fp, "#<slot:%d>", GET_SLOT(cell));
break;
// FIXME - arbitrary recursion
case T_CONS:
fputc('(', fp);
if (tab) ++tab;
int did = 0;
while(1) {
int pair = CONSP(CAR(cell));
if (!did && tab && pair && !CONSP(CAR(CAR(cell)))) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
internal_generic_output(fp, CAR(cell), strict, tab);
cell = CDR(cell);
if (NULLP(cell)) {
break;
}
did = (tab && pair);
if (did) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
else fputc(' ', fp);
if (!CONSP(cell)) {
fputs(". ", fp);
internal_generic_output(fp, cell, strict, tab);
break;
}
}
fputc(')', fp);
break;
// FIXME - arbitrary recursion
case T_VECTOR:
{
VECTOR *vec = GET_VECTOR(cell);
fputs("#(", fp);
if (vec->len > 0) {
int i = 0;
internal_generic_output(fp, vec->data[i++], strict, tab);
while(i < vec->len) {
fputc(' ', fp);
internal_generic_output(fp, vec->data[i++], strict, tab);
}
}
fputc(')', fp);
break;
}
case T_FUNC:
fprintf(fp, "#<primitive:%s>", GET_FUNC(cell)->name);
break;
case T_COMPILED_LAMBDA:
fprintf(fp, "#<compiled-lambda:0x%08x>", AS_LITERAL(cell));
break;
{
if (tab) ++tab;
COMPILED_LAMBDA *l = GET_COMPILED_LAMBDA(cell);
fprintf(fp, "#<%s %d%s:%d/%d",
l->is_macro ? "macro" : "lambda",
l->argc, l->rest ? "+" : "",
l->depth,
l->max_slot);
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
else { fputc(' ', fp); }
internal_generic_output(fp, l->body, strict, tab);
fputc('>', fp);
}
break;
case T_CLOSURE:
fprintf(fp, "#<closure:0x%08x>", AS_LITERAL(cell));
break;
{
if (tab) ++tab;
CLOSURE *c = GET_CLOSURE(cell);
fprintf(fp, "#<closure ");
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
internal_print_env(fp, c->env);
if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); }
fputc(' ', fp);
internal_generic_output(fp, c->compiled_lambda, strict, tab);
fputc('>', fp);
}
break;
case T_EXCEPTION:
fputs("#<exception:", fp);
fwrite(GET_EXCEPTION(cell)->data, 1, GET_EXCEPTION(cell)->len, fp);
fputc('>', fp);
break;
case T_REIFIED_CONTINUATION:
fprintf(fp, "#<continuation:0x%08x>", (int)GET_REIFIED_CONTINUATION(cell)->cont);
break;
case T_STACK_FRAME:
{
STACK_FRAME* p = GET_STACK_FRAME(cell);
fputs("#<stack-frame [", fp);
int i;
for(i = 0; i < p->len; ++i) {
if (i) fputc(' ', fp);
fprintf(fp, "0x%08x", (int)p->cells[i]);
}
fputs("]>", fp);
}
break;
case T_ENV:
fprintf(fp, "#<env:count=%d>", GET_ENV(cell)->count);
break;
case T_RELOC:
fprintf(fp, "#<reloc:0x%08x>", (int)GET_RELOC(cell));
break;
case T_PORT:
fprintf(fp, "#<port:%s>", GET_PORT(cell)->data);
break;
case T_DB_CONNECTION:
fprintf(fp, "#<db-connection>");
break;
case T_DB_RESULT:
fprintf(fp, "#<db-result>");
break;
case T_RECORD:
fprintf(fp, "#<record>");
break;
default:
fprintf(fp, "#<%s-%02x:%08x>",
IS_LITERAL(cell) ? "literal" : "pointer",
GET_TYPE(cell),
AS_LITERAL(cell)
);
break;
}
}
