/*
====================
TFile_CleanupFailedSocket
====================
*/
void TFile_CleanupFailedSocket( const t_char *const error, const SOCKET socket, struct addrinfo *const info ) {
if ( info ) {
freeaddrinfo( info );
}
if ( error ) {
T_Error( error );
}
TFile_TryCloseSocket( socket );
}
/*
====================
TFile_TryCloseSocket
====================
*/
t_bool TFile_TryCloseSocket( const SOCKET socket ) {
if ( socket == INVALID_SOCKET )
return t_false;
if ( closesocket( socket ) == SOCKET_ERROR ) {
T_Error( "TFile_TryCloseSocket: Error trying to close valid socket.\n" );
return t_false;
}
return t_true;
}
void loadTIKI(const char *fname) {
int len;
char *txt;
char *p;
const char *fixedPath;
const char *token;
char path[MAX_TOOLPATH];
float scale;
len = F_LoadBuf(fname,(byte**)&txt);
if(len == -1) {
T_Error("loadTIKI: Cannot open %s\n",fname);
return;
}
path[0] = 0;
scale = 1.f;
// NOTE: this will not open the "fname" file!
COM_BeginParseSession(fname);
p = txt;
token = COM_ParseExt(&p, qtrue);
while(token[0]) {
if (!Q_stricmp(token, "path") || !Q_stricmp(token, "$path")) {
token = COM_ParseExt(&p, qtrue);
strcpy(path,token);
} else if (!Q_stricmp(token, "scale")) {
token = COM_ParseExt(&p, qtrue);
scale = atof(token);
} else if (!Q_stricmp(token, "skelmodel")) {
token = COM_ParseExt(&p, qtrue);
mainModel = readSKD(fixPath(token,path,fname),scale);
} else if(strstr(token,".skc")) {
tAnim_t *a;
fixedPath = fixPath(token,path,fname);
a = appendSKC(mainModel,fixedPath,scale);
if(a) {
strcpy(inAnimFNames[numAnims],fixedPath);
anims[numAnims] = a;
numAnims++;
}
}
token = COM_ParseExt(&p, qtrue);
}
F_FreeBuf(txt);
}
/*
====================
TFile_InitServer
====================
*/
t_bool TFile_InitServer( const t_int port ) {
if ( server_initialized ) {
T_FatalError( "TFile_InitServer: Server is already initialized" );
}
server_pipe = T_CreatePipe();
if ( !CreateServer( AF_INET, port, &server_socket ) || !CreateServer( AF_INET6, port, &server_socket6 ) ) {
TFile_CleanupFailedSocket( NULL, server_socket, NULL ); // Clean up IPv4 socket in case only the IPv6 socket failed.
T_Error( "TFile_InitServer: Unable to initialize server.\n" );
return t_false;
}
server_initialized = t_true;
T_Print( "File server initialized.\n" );
return t_true;
}
float *findRotChannel(skcHeader_t *h, const char *name, int frameNum, int parentIndex) {
#if 0
char channelName[32];
strcpy(channelName,name);
strcat(channelName," rot");
return getChannelValue(h,channelName,frameNum);
#else
static int i = 0;
static quat_t qs[1024];
float *q;
char channelName[32];
float *f;
float len;
i++;
i %= 1024;
q = qs[i];
strcpy(channelName,name);
strcat(channelName," rot");
f = getChannelValue(h,channelName,frameNum);
if(f == 0) {
//return quat_identity;
QuatSet(q,0,0,0,-1);
} else {
QuatCopy(f,q);
}
//QuatInverse(q);
////if(parentIndex == -1)
// QuatInverse(q);
len = QuatNormalize(q);
if(abs(len-1.f) > 0.1) {
T_Error("Non-normalized quat in skc file (%f)\n",len);
}
#if 1
FixQuatForMD5_P(q);
#endif
return q;
#endif
}
/*
====================
TryReceive
====================
*/
static void TryReceive( const int timeout ) {
SOCKET sockets[MAX_SOCKETS] = { ZERO_SOCKET };
SOCKET reads[MAX_SOCKETS] = { ZERO_SOCKET };
t_int i;
// Set up IPv4 and IPv6 sockets.
sockets[0] = server;
sockets[1] = server6;
for ( i = 2; i < MAX_SOCKETS; ++i ) {
sockets[i] = connections[i - 2];
}
// Synchronous event demultiplexer.
// It's ok that we are using select as its portable.
// It may not be the fastest, but it's definitely quick enough for what we are trying to accomplish.
if ( T_Select( sockets, MAX_SOCKETS, timeout, reads ) == SOCKET_ERROR ) {
T_Error( "TryReceive: Select error.\n" );
}
for( i = 0; i < MAX_SOCKETS; ++i ) {
if ( reads[i] == ZERO_SOCKET )
continue;
// Accept connections on IPv4 and IPv6.
if ( reads[i] == server ) {
AcceptConnection( server );
} else if ( reads[i] == server6 ) {
AcceptConnection( server6 );
} else {
static t_byte buffer[MAX_PACKET_SIZE];
// Handle packets from the accepted connections.
t_int bytes = recv( reads[i], ( char * )buffer, MAX_PACKET_SIZE, 0 );
HandlePacket( i - 2, buffer, bytes );
}
}
}
tModel_t *readSKD(const char *fname, float scale) {
int len;
skdHeader_t *h;
skdSurface_t *sf;
skdBone_t *b;
tBone_t *ob;
tModel_t *out;
tSurf_t *os;
int i, j, k;
T_Printf("Loading MoHAA skd model file %s...\n",fname);
len = F_LoadBuf(fname,(byte**)&h);
if(len == -1) {
T_Printf("readSKD: Cannot open %s\n",fname);
return 0;
}
out = T_Malloc(sizeof(tModel_t));
strcpy(out->fname,fname);
out->numSurfaces = h->numSurfaces;
out->numBones = h->numBones;
out->surfs = T_Malloc(sizeof(tSurf_t)*out->numSurfaces);
out->bones = T_Malloc(sizeof(tBone_t)*out->numBones);
// load bones
b = (skdBone_t *) ( (byte *)h + h->ofsBones );
ob = out->bones;
for ( i = 0; i < h->numBones; i++, ob++) {
strcpy(ob->name,b->name);
if(b->jointType != 1) {
T_Error("readSKD: joints types other than 1 are not supported yet (skd file %s)\n",fname);
}
b = (skdBone_t *)( (byte *)b + b->ofsEnd );
}
b = (skdBone_t *) ( (byte *)h + h->ofsBones );
ob = out->bones;
for ( i = 0; i < h->numBones; i++, ob++) {
ob->parent = getBoneIndex(out,b->parent);
b = (skdBone_t *)( (byte *)b + b->ofsEnd );
}
// load surfaces
sf = (skdSurface_t *) ( (byte *)h + h->ofsSurfaces );
os = out->surfs;
for ( i = 0; i < h->numSurfaces; i++,os++) {
skdVertex_t *v;
skdTriangle_t *t;
tVert_t *ov;
strcpy(os->name,sf->name);
os->numTris = sf->numTriangles;
os->numVerts = sf->numVerts;
os->tris = T_Malloc(sizeof(tTri_t)*sf->numTriangles);
os->verts = T_Malloc(sizeof(tVert_t)*sf->numVerts);
// copy triangles
t = (skdTriangle_t *) ( (byte *)sf + sf->ofsTriangles );
assert(sizeof(skdTriangle_t) == sizeof(tTri_t));
memcpy(os->tris,t,sizeof(skdTriangle_t)*sf->numTriangles);
// copy and scale vertices data
v = (skdVertex_t *) ( (byte *)sf + sf->ofsVerts );
ov = os->verts;
for ( j = 0; j < sf->numVerts; j++,ov++) {
skdWeight_t *w;
tWeight_t *ow;
ov->numWeights = v->numWeights;
VectorCopy(v->normal,ov->normal);
ov->texCoords[0] = v->texCoords[0];
ov->texCoords[1] = v->texCoords[1];
ov->weights = T_Malloc(sizeof(tWeight_t)*ov->numWeights);
w = (skdWeight_t *) ( (byte *)v + sizeof(skdVertex_t)+(sizeof(skdMorph_t)*v->numMorphs));
ow = ov->weights;
for ( k = 0; k < v->numWeights; k++,ow++) {
VectorScale(w->offset,scale,ow->offset);
if(w->boneWeight<0 || w->boneWeight>1) {
T_Error("invalid bone weight %f in %s \n",w->boneWeight,out->fname);
}
ow->boneWeight = w->boneWeight;
ow->boneNum = w->boneIndex;
w = (skdWeight_t *) ( (byte *)w + sizeof(skdWeight_t));
}
v = (skdVertex_t *) ( (byte *)v + sizeof(skdVertex_t) + v->numWeights*sizeof(skdWeight_t) + v->numMorphs*sizeof(skdMorph_t) );
}
sf = (skdSurface_t *)( (byte *)sf + sf->ofsEnd );
}
F_FreeBuf((byte*)h);
T_Printf("Succesfully loaded MoHAA model %s\n",fname);
return out;
}
