void drv_rd_Request(CPU_EXT_HD_REQUEST * pstRequest_inout)
{
CPU_INT08U * pbyDisk = 0;
if ((0 == drv_rd_stCtl.pbyStart) || (0 == drv_rd_stCtl.uiSize)) {
CPUExt_CorePanic("[drv_rd_Request][Ramdisk invalid]");
}
if ((0 == pstRequest_inout)
|| (0 == pstRequest_inout->in.pbyData)
|| (DRV_RD_DEVICE != (DRV_RD_DEVICE & pstRequest_inout->in.iDev))) {
CPUExt_CorePanic("[drv_rd_Request][Parameter invalid]");
}
pbyDisk = drv_rd_stCtl.pbyStart + ((pstRequest_inout->in.uiBlkIdx) * CPU_EXT_HD_BLOCK_SIZE);
if ((pbyDisk + CPU_EXT_HD_BLOCK_SIZE) > (drv_rd_stCtl.pbyStart + drv_rd_stCtl.uiSize)) {
CPUExt_CorePanic("[drv_rd_Request][Reading failed]");
//pstRequest_inout->out.iResult = CPU_EXT_HD_RESULT_IO;
//drv_blk_NotifyRWEnd((DRV_BLK_BUFFER *)pstRequest_inout);
//return;
}
if (CPU_EXT_HD_CMD_READ == pstRequest_inout->in.iCmd) {
Mem_Copy(pstRequest_inout->in.pbyData, pbyDisk, CPU_EXT_HD_BLOCK_SIZE);
} else if (CPU_EXT_HD_CMD_WRITE == pstRequest_inout->in.iCmd) {
Mem_Copy(pbyDisk, pstRequest_inout->in.pbyData, CPU_EXT_HD_BLOCK_SIZE);
} else {
CPUExt_CorePanic("[drv_rd_Request][Reading failed]");
}
pstRequest_inout->out.iResult = CPU_EXT_HD_RESULT_OK;
drv_blk_NotifyRWEnd((DRV_BLK_BUFFER *)pstRequest_inout);
}
////////////////////////////////////////////////////////////////////
// 函数名称：
// 函数功能：
// 入口参数：
//
//
// 出口参数：无
////////////////////////////////////////////////////////////////////
uint8 Check_UDP_Paket(void *pdata, uint16 lg)
{
uint8 *p;
struct COMM_XCOM *pxcom;
struct tagIC2CMD_Header cmd;
struct BASE_MSG *pmsg;
p = (uint8 *)pdata;
pxcom = (struct COMM_XCOM *)Get_XCOM_Port(DEV_XCOM_UDP);
Mem_Copy((uint8 *)&cmd, p, sizeof( struct tagIC2CMD_Header));
if (cmd.dwSyncHead != CMD_ABLE_ICII) return 0;
if ((cmd.byteProtocolType & CMD_SENDER_ACK) == CMD_SENDER_ACK)
{
if ((pxcom->Rflag & XCOM_READ_FLAG_WAIT_ACK) && (pxcom->flag != NULL))
OSSemPost(pxcom->flag);
}
else
{
if ((pxcom->Rflag & XCOM_READ_FLAG_WAIT_DATA) != XCOM_READ_FLAG_WAIT_DATA) return 0;
if (pxcom->flag == NULL) return 0;
pmsg = (struct BASE_MSG *)((uint8 *)pdata + sizeof(struct XCOM_REV_TYPE) + sizeof(struct tagIC2CMD_Header));
if (pmsg->option != pxcom->RCMDNo) return 0;
pxcom->Rdata_lg = lg - sizeof(struct tagIC2CMD_Header);
Mem_Copy(pxcom->pbuf, p + sizeof(struct tagIC2CMD_Header), pxcom->Rdata_lg);
OSSemPost(pxcom->flag);
UDP_Send_ACK(pdata);
return TRUE;
}
return FALSE;
}
bool ZIP_StatFile (unzFile archive, const char *filename, struct stat *stats)
{
gpointer file_entry;
int pos;
int err;
unz_s* s;
char *lowerfilename;
unz_s unz_backup;
struct tm newdate;
tm_unz tmu_date;
if (archive==NULL)
return UNZ_PARAMERROR;
s=(unz_s*)archive;
lowerfilename = g_ascii_strdown(filename, -1);
file_entry = g_hash_table_lookup(s->filenameHash, lowerfilename);
g_free(lowerfilename);
if (file_entry)
{
Mem_Copy(&unz_backup, s, sizeof(unz_s));
pos = GPOINTER_TO_UINT(file_entry);
s->pos_in_central_dir = pos;
err = unzlocal_GetCurrentFileInfoInternal(archive,&s->cur_file_info,
&s->cur_file_info_internal,
NULL,0,NULL,0,NULL,0);
if (err != UNZ_OK)
{
Mem_Copy(s, &unz_backup, sizeof(unz_s));
return false;
}
memset(stats, 0, sizeof(struct stat));
stats->st_size = s->cur_file_info.uncompressed_size;
tmu_date = s->cur_file_info.tmu_date;
newdate.tm_sec = tmu_date.tm_sec;
newdate.tm_min = tmu_date.tm_min;
newdate.tm_hour = tmu_date.tm_hour;
newdate.tm_mday = tmu_date.tm_mday;
newdate.tm_mon = tmu_date.tm_mon;
if (tmu_date.tm_year > 1900)
newdate.tm_year = tmu_date.tm_year - 1900;
else
newdate.tm_year = tmu_date.tm_year ;
newdate.tm_isdst=-1;
stats->st_mtime = mktime(&newdate);
stats->st_ctime = stats->st_mtime;
Mem_Copy(s, &unz_backup, sizeof(unz_s));
return true;
}
return false;
}
void WSock_Init()
{
int n;
struct hostent *phe;
int bestip = 0;
Console_DPrintf("WSock_Init\n");
if (strcmp(net_forceIP.string, "0.0.0.0") != 0)
{
unsigned long tmp;
tmp = inet_addr(net_forceIP.string);
Mem_Copy(&net_localip, (void *)&tmp, sizeof(struct in_addr));
strcpy(net_localaddr, inet_ntoa(net_localip));
}
else
{
if (WSAStartup(0x202, &ws.wsaData) == SOCKET_ERROR)
{
WSACleanup();
Console_Errorf("WSAStartup failed (%s)\n", WSAGetLastError());
return;
}
if (gethostname(net_localaddr, 256) == SOCKET_ERROR)
{
WSACleanup();
Console_Errorf("gethostname() failed (%s)\n", WSAGetLastError());
return;
}
phe = gethostbyname(net_localaddr);
for (n = 0; phe->h_addr_list[n] != 0; n++)
{
char *ipstring;
Mem_Copy(&net_localip, phe->h_addr_list[n], sizeof(struct in_addr));
ipstring = inet_ntoa(net_localip);
Console_DPrintf("Local IP #%i: %s\n", n+1, ipstring);
//fixme: this is a hack in case we're shared off the connection
//to the internet. this won't work all the time so find a better way
if (strncmp(ipstring, "192.168.", 8)!=0)
bestip = n;
}
Mem_Copy(&net_localip, phe->h_addr_list[bestip], sizeof(struct in_addr));
strcpy(net_localaddr, inet_ntoa(net_localip));
}
// ncLocalClient.driverData = WSock_AllocateDriverData();
ws.nonblock = 1;
}
void Scene_AddFxPoly (int nverts, scenefacevert_t *verts, residx_t shader, int flags)
{
scenefacelist_t *newface;
newface = (scenefacelist_t*)Scene_FramePool_Alloc(sizeof(scenefacelist_t));
if (!newface)
return;
newface->verts = (scenefacevert_t*)Scene_FramePool_Alloc(nverts * sizeof(scenefacevert_t));
if (!newface->verts)
return;
Mem_Copy(newface->verts, verts, nverts * sizeof(scenefacevert_t));
newface->nverts = nverts;
newface->shader = shader;
newface->flags = flags;
if (flags & POLY_IS_TERRAIN_DECAL)
{
newface->next = scenefxfacelist_decals;
scenefxfacelist_decals = newface;
}
else
{
newface->next = scenefxfacelist;
scenefxfacelist = newface;
}
}
void Scene_AddSkyObj (sceneobj_t *skyobj)
{
scenelist_t *newobj;
newobj = (scenelist_t*)Scene_FramePool_Alloc(sizeof(scenelist_t));
if (!newobj)
return;
// Case: if the is a uniform scale, we will use that instead. (to maintain compatibility)
if (skyobj->scale != 1.f)
M_SetVec3(skyobj->scaleVec, skyobj->scale, skyobj->scale, skyobj->scale);
Mem_Copy(newobj, skyobj, sizeof(sceneobj_t));
newobj->next = skylist;
newobj->obj.flags |= SCENEOBJ_SKYBOX;
//Vid_NormalizeColor(skyobj->color, newobj->obj.color);
if (!(skyobj->flags & SCENEOBJ_USE_AXIS))
{
//fill in axis
M_GetAxis(skyobj->angle[0], skyobj->angle[1], skyobj->angle[2], newobj->obj.axis);
}
skylist = newobj;
}
int WSock_ReceivePacket(netconnection_t *nc)
{
int ret;
socklen_t fromlen;
netaddr_t from;
fromlen = sizeof(struct sockaddr);
ret = recvfrom(nc->sock, (char*)nc->recv.__buf, MAX_PACKET_SIZE + HEADER_SIZE, 0, (struct sockaddr *)&from, &fromlen);
if (ret < 0)
{
int err = WSAGetLastError();
if (err != WSAEWOULDBLOCK)
{
NET_PRINTF("recvfrom() failed: error %s from %s\n", WSock_GetErrorString(err), inet_ntoa(from.sin_addr));
}
}
else if (ret > 0)
{
#ifdef ANAL_NETWORK_DEBUGGING
NET_PRINTF("Net: receiving %i bytes with seq %u from port %i - flags %s %s\n", nc->recv.length, seq,
ntohs(from->sin_port),
flags & PACKET_RELIABLE ? "RELIABLE" : "",
flags & PACKET_ACK ? "ACK" : "");
#endif
Mem_Copy(&nc->recvAddr, &from, sizeof(struct sockaddr_in));
strncpy(nc->recvAddrName, inet_ntoa(from.sin_addr), MAX_ADDRESS_LENGTH);
nc->recv.length = ret - HEADER_SIZE;
nc->recv.curpos = 0;
}
return ret;
}
bool WSock_PreProcessPacket(netconnection_t *nc)
{
byte flags;
unsigned int seq;
//extract sequence number and flags from the packet header
Mem_Copy(&seq, nc->recv.__buf, sizeof(unsigned int));
seq = LittleInt(seq);
flags = nc->recv.__buf[HEADER_FLAG_LOC];
if (flags & PACKET_RELIABLE)
{
if (WSock_ProcessReliablePacket(nc, nc->recv.__buf, &nc->recvAddr))
return true;
else
return false;
}
//okay, it's not a reliable packet, so the sequence should match the generic nonreliable sequence number
// if not, it's probably a fragmented packet and we should throw it out
if (seq != NONRELIABLE_SEQUENCE)
{
NET_PRINTF("Got invalid packet data - sequence %u\n", seq);
return false;
}
if (flags & PACKET_ACK)
{
WSock_ProcessPacketAck(nc);
return false;
}
return true;
}
bool WSock_ProcessReliablePacket(netconnection_t *nc, unsigned char *buf, struct sockaddr_in *from)
{
packet_t ackpacket;
//static char ackbuf[HEADER_SIZE + sizeof(unsigned int)];
unsigned int buf_seq;
bool process = true;
Mem_Copy(&buf_seq, buf, sizeof(unsigned int));
buf_seq = LittleInt(buf_seq);
NET_PRINTF("got reliable packet with sequence %u, waiting for %u\n", buf_seq, nc->reliableRecv_lastseq+1);
if (buf_seq > nc->reliableRecv_lastseq+1)
{
//drop it, out of order - wait for the next packet before jumping ahead, to maintain transfer order
// don't even ACK it, so they think we never got it and resend it after resending the earlier one(s) we missed
NET_PRINTF("Received out of order sequence %u, waiting for %u\n", buf_seq, nc->reliableRecv_lastseq+1);
return false;
}
else if (buf_seq == nc->reliableRecv_lastseq+1)
{
//this is a new reliable packet that we've waiting for. Increment the incoming sequence, and use the packet
nc->reliableRecv_lastseq++;
NET_PRINTF("reliable packet with sequence %u is valid, incrementing our lastseq to %u\n", buf_seq, nc->reliableRecv_lastseq);
}
else //buf_seq < nc->reliableRecv_lastseq+1
{
//this is a resend for a packet we've gotten already. ACK it, but don't process it again
NET_PRINTF("Received resend of reliable packet sequence %u, not using it\n", buf_seq);
process = false;
}
//send an ACK for this reliable packet
//HACK: write the client ID if we're a client
memset(&ackpacket, 0, sizeof(packet_t));
if (nc == &ncLocalClient)
{
Pkt_WriteShort(&ackpacket, (short)client_id);
Pkt_WriteInt(&ackpacket, buf_seq);
}
else
{
Pkt_WriteInt(&ackpacket, buf_seq);
}
//hack to stress-test the reliable packet code
if (!net_forcedPacketDrop.value || M_Randnum(0,1) <= 0.5)
{
NET_PRINTF("Sending ack for reliable packet sequence %u\n", buf_seq);
_WSock_SendPacket(nc->sock, (struct sockaddr *)(&nc->sendAddr), ackpacket.__buf, ackpacket.length + HEADER_SIZE, NONRELIABLE_SEQUENCE, PACKET_NORMAL | PACKET_ACK);
}
return process;
}
/*
============
Cbuf_Execute
============
*/
void Cbuf_Execute( void )
{
int i;
char *text;
char line[MAX_CMD_LINE];
int quotes;
while( cmd_text.cursize )
{
if( cmd_wait )
{
// skip out while text still remains in buffer, leaving it for next frame
cmd_wait--;
break;
}
// find a \n or ; line break
text = (char *)cmd_text.data;
quotes = 0;
for( i = 0; i < cmd_text.cursize; i++ )
{
if( text[i] == '"') quotes++;
if(!( quotes & 1 ) && text[i] == ';' )
break; // don't break if inside a quoted string
if( text[i] == '\n' || text[i] == '\r' ) break;
}
if( i >= MAX_CMD_LINE - 1 )
Sys_Error( "Cbuf_Execute: command string owerflow\n" );
Mem_Copy( line, text, i );
line[i] = 0;
// delete the text from the command buffer and move remaining commands down
// this is necessary because commands (exec) can insert data at the
// beginning of the text buffer
if( i == cmd_text.cursize )
{
cmd_text.cursize = 0;
}
else
{
i++;
cmd_text.cursize -= i;
memmove( text, text + i, cmd_text.cursize );
}
// execute the command line
Cmd_ExecuteString( line );
}
}
/*
=================
AllocSurfaceExtra
allocates a new extra storage
=================
*/
static surfaceExtra_t *AllocSurfaceExtra( void )
{
surfaceExtra_t *se;
if( numSurfaceExtras >= maxSurfaceExtras )
{
maxSurfaceExtras += GROW_SURFACE_EXTRAS;
se = Malloc( maxSurfaceExtras * sizeof( surfaceExtra_t ));
if( surfaceExtras != NULL )
{
Mem_Copy( se, surfaceExtras, numSurfaceExtras * sizeof( surfaceExtra_t ));
Mem_Free( surfaceExtras );
}
surfaceExtras = se;
}
se = &surfaceExtras[numSurfaceExtras];
numSurfaceExtras++;
Mem_Copy( se, &seDefault, sizeof( surfaceExtra_t ));
return se;
}
/*
============
Cbuf_AddText
Adds command text at the end of the buffer
============
*/
void Cbuf_AddText( const char *text )
{
int l;
l = com.strlen( text );
if( cmd_text.cursize + l >= cmd_text.maxsize )
{
MsgDev( D_WARN, "Cbuf_AddText: overflow\n" );
return;
}
Mem_Copy( &cmd_text.data[cmd_text.cursize], text, l );
cmd_text.cursize += l;
}
void Scene_AddOccluder (occluder_t *occluder)
{
occluderlist_t *newoccluder;
newoccluder = (occluderlist_t*)Scene_FramePool_Alloc(sizeof(occluder_t));
if (!newoccluder)
return;
Mem_Copy(newoccluder, occluder, sizeof(occluder_t));
newoccluder->next = occluderlist;
newoccluder->cull = false;
occluderlist = newoccluder;
}
void Scene_AddLight (scenelight_t *light)
{
scenelightlist_t *newlight;
newlight = (scenelightlist_t*)Scene_FramePool_Alloc(sizeof(scenelightlist_t));
if (!newlight)
return;
Mem_Copy(newlight, light, sizeof(scenelight_t));
newlight->next = scenelightlist;
newlight->cull = true;
scenelightlist = newlight;
}
int Scene_ClipPoly(scenefacevert_t *verts, int numVerts, plane_t *clipPlanes, int numClipPlanes, scenefacevert_t *outpoly, int maxVerts)
{
int plane;
int n = 0;
scenefacevert_t workingVerts[32];
int numWorkingVerts = numVerts;
OVERHEAD_INIT;
Mem_Copy(workingVerts, verts, sizeof(scenefacevert_t) * numVerts);
for (plane = 0; plane<numClipPlanes; plane++)
{
n = Scene_ClipPolyToPlane(workingVerts, numWorkingVerts, &clipPlanes[plane], outpoly, maxVerts);
numWorkingVerts = n;
Mem_Copy(workingVerts, outpoly, sizeof(scenefacevert_t) * n);
}
Mem_Copy(outpoly, workingVerts, sizeof(scenefacevert_t) * n);
return n;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
bool
MLRLookUpLight::LoadMap()
{
Check_Object(this);
Stuff::FileStream element_stream(mapName);
unsigned char *map = new unsigned char [mapZoneCountX*mapZoneCountZ*256*256];
Check_Pointer(map);
element_stream.ReadBytes(map, mapZoneCountX*mapZoneCountZ*256*256);
Verify(maps==NULL);
maps = new unsigned char * [mapZoneCountX * mapZoneCountZ];
Check_Pointer(maps);
int i, j, k;
for(j=0;j<mapZoneCountZ;j++)
{
for(i=0;i<mapZoneCountX;i++)
{
maps[j*mapZoneCountX+i] = new unsigned char [256*256];
Check_Pointer(maps[j*mapZoneCountX+i]);
}
}
unsigned char *uptr = map;
for(j=0;j<mapZoneCountZ;j++)
{
for(k=0;k<256;k++)
{
for(i=0;i<mapZoneCountX;i++)
{
Mem_Copy(&maps[j*mapZoneCountX+i][k*256], uptr, 256, (256-k)*256);
uptr += 256;
// &map[(256*j+k)*(mapZoneCountX*256) + i*256]
}
}
}
Check_Pointer(map);
delete map;
return false;
}
/*
============
Cbuf_InsertText
Adds command text immediately after the current command
Adds a \n to the text
FIXME: actually change the command buffer to do less copying
============
*/
void Cbuf_InsertText (const char *text)
{
int i, len;
len = com.strlen( text ) + 1;
if( len + cmd_text.cursize > cmd_text.maxsize )
{
MsgDev( D_WARN, "Cbuf_InsertText overflowed\n" );
return;
}
// move the existing command text
for( i = cmd_text.cursize - 1; i >= 0; i-- )
{
cmd_text.data[i + len] = cmd_text.data[i];
}
// copy the new text in
Mem_Copy( cmd_text.data, (char *)text, len - 1 );
cmd_text.data[len - 1] = '\n'; // add a \n
cmd_text.cursize += len;
}
void drv_rd_Setup(void)
{
CPU_INT32U uiBlkIdx = CPU_EXT_RAM_DISK_START;
CPU_INT32U uiBlkCnt = CPU_EXT_RAM_DISK_SIZE / CPU_EXT_HD_BLOCK_SIZE;
DRV_BLK_BUFFER * pstBuf = 0;
CPU_INT08U * pbyDst = drv_rd_stCtl.pbyStart;
CPU_INT32U uiCpSize = 0;
if ((0 == drv_rd_stCtl.pbyStart) || (0 == drv_rd_stCtl.uiSize)) {
return;
}
drv_disp_Printf("[RamDisk ][Loading...] \r\n");
while (uiBlkCnt > 0) {
if ((uiCpSize + CPU_EXT_HD_BLOCK_SIZE) > drv_rd_stCtl.uiSize) {
\
CPUExt_CorePanic("[drv_rd_Setup][buffer overflow]");
}
if (uiBlkCnt > 2) {
pstBuf = drv_blk_ReadAhead(0x300, uiBlkIdx, uiBlkIdx + 1, uiBlkIdx + 2, -1);
} else {
pstBuf = drv_blk_Read(0x300, uiBlkIdx);
}
if (0 == pstBuf) {
CPUExt_CorePanic("[drv_rd_Setup][reading block failed]");
}
Mem_Copy(pbyDst, pstBuf->pbyData, CPU_EXT_HD_BLOCK_SIZE);
drv_blk_Release(pstBuf);
uiCpSize += CPU_EXT_HD_BLOCK_SIZE;
pbyDst += CPU_EXT_HD_BLOCK_SIZE;
uiBlkIdx++;
uiBlkCnt--;
}
}
void ZIP_SystemDir(void *archive, char *_directory, char *wildcard, bool recurse,
void(*dirCallback)(const char *dir, void *userdata),
void(*fileCallback)(const char *filename, void *userdata),
void *userdata)
{
GPatternSpec* pattern;
unz_s* s;
unz_s unz_backup;
int err, numFiles;
char *slash, *fname;
char filename[384] = {0};
char directory[256] = {0};
char enumdir[256] = {0};
if (archive==NULL)
return;
s=(unz_s*)archive;
if (!_directory || strlen(_directory) == 0)
BPrintf(directory, 1024, "");
else
BPrintf(directory, 1024, "%s%s", (_directory[0] == '/') ? &_directory[1] : _directory, (_directory[strlen(_directory)-1] == '/') ? "" : "/");
BPrintf(filename, 1024, "%s%s", directory, wildcard);
pattern = g_pattern_spec_new(filename);
Console_DPrintf("Doing a System_Dir in a ZIP file matching %s\n", filename);
err = unzGoToFirstFile((unzFile)s);
numFiles = 0;
while (err == UNZ_OK)
{
unzGetCurrentFileInfo((unzFile)s,NULL,
filename,1023,
NULL,0,NULL,0);
filename[1023] = 0;
//Console_DPrintf("...%s\n", filename);
if (strcmp(filename, directory) != 0 && strstr(filename, "CVS/") == 0) //don't call a callback for the directory itself
{
if (g_pattern_match_string(pattern, filename))
{
bool goAhead;
slash = strchr(&filename[strlen(directory)], '/');
goAhead = (!slash || (slash == filename + strlen(filename) - 1) || recurse) != 0;
// UTTAR: Hack: NOTE: Dircallbacks could be activated several times with this method now! :(
//if (goAhead)
{
if (filename[strlen(filename)-1] != '/' && goAhead)
{
if (fileCallback)
{
goAhead = 0;
slash = strrchr(filename, '/');
if (!slash)
{
fname = filename;
BPrintf(enumdir, 1, "");
}
else
{
fname = slash+1;
BPrintf(enumdir, slash - filename + 1, "%s", filename);
}
Cvar_SetVar(&sys_enumdir, enumdir);
//Console_DPrintf("calling fileCallback for %s (in %s)\n", fname, sys_enumdir.string);
Mem_Copy(&unz_backup, s, sizeof(unz_s));
fileCallback(fname, userdata);
Mem_Copy(s, &unz_backup, sizeof(unz_s));
}
}
if(dirCallback && goAhead)
{
if(slash)
*slash = 0;
if (dirCallback)
{
//Console_DPrintf("calling dirCallback for %s\n", filename);
dirCallback(filename, userdata);
}
}
}
}
}
numFiles++;
err = unzGoToNextFile((unzFile)s);
}
Console_DPrintf("Done reading zip file contents - %i files\n", numFiles);
if (err != UNZ_END_OF_LIST_OF_FILE)
Console_DPrintf("ZIP error: err was %i\n", err);
Cvar_SetVar(&sys_enumdir, "");
g_pattern_spec_free(pattern);
}
void ts_recv_isr(void *recv_buff_0, void *recv_nbr_0)
{
OS_ERR err;
uint32_t i;
uint32_t start_pos;
uint8_t *recv_buff = (uint8_t *)recv_buff_0;
uint32_t *recv_nbr = (uint32_t *)recv_nbr_0;
uint32_t len;
if (*recv_nbr >= TS_RECV_BUFF_LEN)
{
*recv_nbr = 0;
}
*recv_nbr += UART_Receive(LPC_UART0, recv_buff + *recv_nbr, \
TS_RECV_BUFF_LEN - *recv_nbr);
start_pos = *recv_nbr - 1;
if (*recv_nbr > MIN_RECV_LEN)
{
for (i = 0; i < *recv_nbr-1; i++)
{
//if (recv_buff[i] == 0xa5 && recv_buff[i+1] == 0x5a)
//if (recv_buff[i] == 0xa5 && recv_buff[i+1] == 0x5a)
if (recv_buff[i] == START_CHAR)
{
start_pos = i;
break;
}
}
}
else
return;
if (start_pos < *recv_nbr - 1 )
{
if (start_pos != 0)
{
for (i = 0; i < *recv_nbr - start_pos ; i++)
{
recv_buff[i] = recv_buff[i + start_pos];
}
*recv_nbr -= start_pos;
}
if (*recv_nbr > MIN_RECV_LEN)
{
//if (*recv_nbr == recv_buff[2] + 3)
if (recv_buff[*recv_nbr - 2] == END_CHAR_1 && recv_buff[*recv_nbr - 1] == END_CHAR_2)
{
len = *recv_nbr;
recv_buff[len] = recv_buff[4];
recv_buff[len + 1] = recv_buff[5];
recv_buff[len + 2] = recv_buff[6];
Mem_Copy(recv_buff_copy, recv_buff, len + 3);
*recv_nbr = 0;
OSTaskQPost(&ts_serv_task_tcb,
(uint8_t *)recv_buff_copy,
len + 3,
OS_OPT_POST_FIFO,
&err);
}
}
else
return;
}
else
{
*recv_nbr = 1;
recv_buff[0] = recv_buff[start_pos];
}
}
void Simu_Send_Data(void* ps)
{
INT32S re=0,i,j,k,l,m,nKeyNo;
INT32S nChDataSize=sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S);
float fSign=0;
char inf[256]={0};
float fv[50];
//void* p;
INT8S p[sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+_DEFAULT_DATA_LTH-1)*sizeof(INT32S)];
INT8S* pData=(INT8S *)g_pOutChData;
struct tagChData2060* pchData=0;
INT32S nCurSit[_MAX_JKEY_CHANNEL_CNT]={0};
INT32S nSpeed[_MAX_JKEY_CHANNEL_CNT];
INT32S nLth[_MAX_JKEY_CHANNEL_CNT];
PAlertNode pAlert=g_AlertNode;
struct tagChValue *pAv=g_pSimuAlertMeasureValue;
PTranNode pTran=g_TranNode;
struct tagChValue chValue;
INT32S nRpmFlag=0;
//p=malloc(sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S));
Mem_Clr(p, sizeof(p));
pchData=(struct tagChData2060*)p;
chValue.nTrigerTime=0;
chValue.nChNo=0;
chValue.nRPM=g_nBasicRPM;
chValue.nAlertFlag=0;
chValue.nAllMeasureValue=g_fNormalAlp;
chValue.nAllPhase=0;
chValue.n1xV=g_fLevel*g_fCof1x;
chValue.n1xP=0;
chValue.n2xV=g_fLevel*g_fCof2x;
chValue.n2xP=0;
chValue.n05xV=g_fLevel*g_fCofP5x;
chValue.n05xP=0;
chValue.nRpmFlag=0;
i=0;
do{
// _log("Start Send SimuData\n");
for(m=0;;m++)
{
INT32S nChIndex=0;
CheckSimuData();
// OSTimeDly(5);
if(g_nChValueFlag!=3||g_nChDataFlag!=3)
{
//OSTimeDly(g_SendTimeInterval/(1000/OS_TICKS_PER_SEC));
//OSTimeDly(1);
OSTimeDly(1 );
continue;
}
OSSchedLock( );//禁止任务切换
g_nChValueFlag=0;
g_nChDataFlag=0;
if(i==50)
i=i;
for(j=0;j<g_nChcnt;j++)
{
// nSign=20*sin(6.2832*(m/100.+nSit[j]/71.));
fSign=(g_nSit[j]*48.0/g_nChcnt-24.0)*(1+0.3*sin(6.2832*(m/10.)));
if(g_nChKeyNo[g_nSit[j]]>=_START_KEY_CH)
{
nKeyNo=g_nChKeyNo[g_nSit[j]]-_START_KEY_CH;
nSpeed[nKeyNo]=*g_nKeySpeed[nKeyNo][i];
g_nCaltKeySpeed[nKeyNo]=nSpeed[nKeyNo];
}
else
nSpeed[nKeyNo]=-1;
// if(nSpeed[nKeyNo]>3000)
// nSpeed[nKeyNo]=nSpeed[nKeyNo];
nRpmFlag=0;
for(k=0;k<g_TranNode[nKeyNo].nEventcnt;k++)
{
if(i>= g_TranNode[nKeyNo].nTigerTime[2*k]&&i<= g_TranNode[nKeyNo].nTigerTime[2*k+1])
{
nRpmFlag=1;
break;
}
}
// CheckSimuData();
if(i==0)
i=i;
if(i==pAlert->nTigerTime)//报警时间
{
pAv->nRPM=nSpeed[nKeyNo];
pAv->nRpmFlag=nRpmFlag;
//////输出报警通道测量值pAv
//g_pOutChValue=pAv;
Mem_Copy(g_pOutChValue+g_nSit[j],pAv,sizeof(struct tagChValue));
pAv++;
}
else//非报警通道
{
chValue.nTrigerTime=i;
chValue.nChNo=g_nSit[j];
chValue.nRPM=nSpeed[nKeyNo];
chValue.nRpmFlag=nRpmFlag;
//g_pOutChValue=&chValue;
Mem_Copy(g_pOutChValue+g_nSit[j],&chValue,sizeof(struct tagChValue));
g_pOutChValue[g_nSit[j]].nAllMeasureValue*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n1xV*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n2xV*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n05xV*=(100+fSign)/100.;
fv[g_nSit[j]]=g_pOutChValue[g_nSit[j]].nAllMeasureValue;
g_nChValueFlag=1;
///////输出正常通道测量值chValue
}
// CheckSimuData();
//读取转速为nSpeed[nKeyNo]下的通道原始数据
if(i==680)
i=i;
memcpy(pchData,((INT8S*)g_pSimuTranPiece)+nSpeed[nKeyNo]*nChDataSize,nChDataSize);
//Mem_Copy(pchData,((INT8S*)g_pSimuTranPiece)+nSpeed[nKeyNo]*nChDataSize,nChDataSize);
// CheckSimuData();
nLth[nKeyNo]=nChDataSize-(_MAX_KEY_PT_CNT-pchData->nKeycnt)*sizeof(INT32S);
pchData->nTrigerTime=i;
pchData->nChNo=g_nSit[j];
if(i==pAlert->nTigerTime&&g_nSit[j]==pAlert->nChNo[nChIndex])//报警通道
{
INT32S step;
INT32S* p32s=&pchData->nKeycnt+1;
p32s+=pchData->nKeycnt;
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
// p32s[step]=p32s[step]*pAlert->fCof[nChIndex]*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]=p32s[step]*pAlert->fCof[nChIndex];
}
nChIndex++;
}
else
{
INT32S step;
INT32S* p32s=(&pchData->nKeycnt)+1;
p32s+=pchData->nKeycnt;
if(i>600)
i=i;
if(g_nSit[j]/2*2==g_nSit[j])
{
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
//p32s[step]*=(100+fSign)/100.*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]*=(100+fSign)/100.;
}
}else
{
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
//p32s[step]*=(100-fSign)/100.*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]*=(100-fSign)/100.;
}
}
nChIndex++;
}
if(i==350)
i=i;
//g_pOutChData=pchData;
Mem_Clr(inf, 256);
// sprintf(inf,"Ouput %d Sit\n",g_nCurWriteSit);
// _log(inf);
Mem_Copy(g_pOutChDataArray[g_nSit[j]],pchData,nChDataSize);
}
if(i==50)
i=i;
//输出所有通道数据头
OutputChValue();//
//输出所有通道原始数据
Simu_Write_ChData(g_nLength,g_nChNo,_MAX_SIGNAL_CHANNEL_CNT,
g_nFpgaDynamicChDataOffset,g_nFpgaDynamicKeyDataOffset,g_nFpgaDynamicChDataSampleStep,
g_nFpgaTranDataOffset,g_nFpgaTranKeyDataOffset,g_nFpgaTranDataSampleStep);
for(l=0;l<_MAX_SIGNAL_CHANNEL_CNT/_FPGA_GROUP_CHANNEL_CNT;l++)
receive_channel_data();
g_nChValueFlag=3;
g_nChDataFlag=3;
//OSTimeDly(g_SendTimeInterval/(1000/OS_TICKS_PER_SEC)/(_MAX_SIGNAL_CHANNEL_CNT/_FPGA_GROUP_CHANNEL_CNT));
if(i>=pAlert->nTigerTime)
pAlert++;
// _log("Deal Speed Too Slow,Data Will lose\n");
g_bDataValid=1;
for(l=0;l<_MAX_JKEY_CHANNEL_CNT;l++)
{
if(i==g_nTigerTime[l][nCurSit[l]])
{
nCurSit[l]++;
}
}
i++;
if(i==g_nAllcnt)
{
i=0;
// break;
}
OSSchedUnlock( );//允许任务切换
CheckSimuData();
sleep_ms(100);
}
//_log("End Send SimuData\n");
}while(1);
//free(p);
}
INT32S Simu_Write_ChData(INT32S nLength[],INT32S nChNo[],INT32S nCnt,
INT32U nDynamicChDataOffset[],INT32U nDynamicKeyOffset[],INT32U nDynamicStep[],
INT32U nTranChDataOffset[],INT32U nTranKeyOffset[],INT32U nTranStep[])
{
INT32S re=0;
INT32S i=0,j,nLth,nSit;
INT8S* pData=(INT8S *)g_pOutChData;
INT32S nChDataSize=sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S);
INT32S noKey[]={0,0,0,0};
for(i=0;i<_MAX_SIGNAL_CHANNEL_CNT;i++)
{
if(nChNo[re]==i)
{
INT8S* p=(INT8S *)g_pOutChDataArray[i];
INT32S* pChData=(INT32S *)(p+sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT-1)*sizeof(INT32S));
Mem_Clr(g_nDynamicResult, sizeof(g_nDynamicResult));
nLth=(g_nDynamicStart[i]+_DEFAULT_DATA_LTH)/nDynamicStep[i];
g_nDynamicResult[0]=nLth;
nSit=g_nDynamicStart[i];
for(j=1;j<nLth+1;j++)
{
g_nDynamicResult[j]=pChData[nSit];
nSit+=nDynamicStep[i];
}
WriteRamDisk(nDynamicChDataOffset[i],g_nDynamicResult,nLth+1);
g_nDynamicStart[i]=(g_nDynamicStart[i]+_DEFAULT_DATA_LTH)%nDynamicStep[i];
Mem_Clr(g_nTranResult, sizeof(g_nTranResult));
nLth=(g_nTranStart[i]+_DEFAULT_DATA_LTH)/nTranStep[i];
g_nTranResult[0]=nLth;
nSit=g_nTranStart[i];
for(j=1;j<nLth+1;j++)
{
g_nTranResult[j]=pChData[nSit];
nSit+=nTranStep[i];
}
WriteRamDisk(nTranChDataOffset[i],g_nTranResult,nLth+1);
g_nTranStart[i]=(g_nTranStart[i]+_DEFAULT_DATA_LTH)%nTranStep[i];
re++;
if(re==nCnt)
break;
}
}
for(i=0;i<_MAX_JKEY_CHANNEL_CNT;i++)
{
if(g_pOutChDataArray[g_nKeyChannSit[i]]->nKeycnt)
{
nLth=g_pOutChDataArray[g_nKeyChannSit[i]]->nKeycnt;
g_nKeyResult[0]=nLth;
nSit=g_nDynamicStart[i];
Mem_Copy(g_nKeyResult+1,g_pOutChDataArray[g_nKeyChannSit[i]]->pData,nLth*sizeof(INT32S));
for(j=1;j<nLth+1;j++)
{
g_nKeyResult[j]/=nDynamicStep[i];
}
WriteRamDisk(nDynamicKeyOffset[i],g_nKeyResult,nLth+1);
Mem_Copy(g_nKeyResult+1,g_pOutChDataArray[g_nKeyChannSit[i]]->pData,nLth*sizeof(INT32S));
for(j=1;j<nLth+1;j++)
{
g_nKeyResult[j]/=nTranStep[i];
}
WriteRamDisk(nTranKeyOffset[i],g_nKeyResult,nLth+1);
}else
{
WriteRamDisk(nDynamicKeyOffset[i],noKey,sizeof(noKey)/sizeof(INT32S));
WriteRamDisk(nTranKeyOffset[i],noKey,sizeof(noKey)/sizeof(INT32S));
}
}
return re;
}
INT32S WriteRamDisk(INT32U nOffset,INT32S pData[],INT32S nLength)
{
INT32S re=0;
Mem_Copy(g_pChData+nOffset,pData,nLength*sizeof(INT32S));
return re;
}
CPU_SIZE_T SerialBuf_Rd (SERIAL_BUF *pbuf,
CPU_INT08U *pdest,
CPU_SIZE_T len)
{
CPU_SIZE_T buf_avail;
CPU_SIZE_T buf_copy_start;
CPU_SIZE_T buf_copy_end;
CPU_SIZE_T buf_copy_tot;
CPU_SIZE_T ix_rd;
CPU_SIZE_T ix_rd_new;
CPU_SIZE_T buf_len;
CPU_INT08U *pdest_08;
CPU_SR_ALLOC();
CPU_CRITICAL_ENTER();
buf_len = pbuf->Len;
buf_avail = buf_len - pbuf->EmptyCnt; /* Calc nbr data octets in buf. */
pdest_08 = (CPU_INT08U *)pdest;
if (buf_avail == 0) { /* ------------------ HANDLE EMPTY BUF ---------------- */
CPU_CRITICAL_EXIT();
return ((CPU_SIZE_T)0);
}
/* ------------- CALC BUF IX & LEN TO COPY ------------ */
ix_rd = pbuf->IxRd;
buf_copy_tot = DEF_MIN(buf_avail, len); /* Calc nbr data octets tot to copy. */
buf_copy_end = DEF_MIN(buf_copy_tot, buf_len - ix_rd); /* Calc nbr data octets to copy from buf end. */
buf_copy_start = buf_copy_tot - buf_copy_end; /* Calc nbr data octets to copy from buf start. */
if (buf_copy_start > 0) { /* Update buf ix rd. */
pbuf->IxRd = buf_copy_start;
} else {
ix_rd_new = ix_rd + buf_copy_tot;
if (ix_rd_new == buf_len) {
pbuf->IxRd = 0;
} else {
pbuf->IxRd = ix_rd_new;
}
}
CPU_CRITICAL_EXIT();
/* --------------- COPY DATA AT BUF END --------------- */
/* Copy data. */
Mem_Copy((void *)pdest_08, (void *)&pbuf->DataPtr[ix_rd], buf_copy_end);
/* -------------- COPY DATA AT BUF START -------------- */
pdest_08 += buf_copy_end; /* Adj buf ptr. */
/* Copy data. */
Mem_Copy((void *)pdest_08, (void *)&pbuf->DataPtr[0], buf_copy_start);
CPU_CRITICAL_ENTER();
pbuf->EmptyCnt += buf_copy_tot; /* Update buf empty octets rem. */
CPU_CRITICAL_EXIT();
return (buf_copy_tot);
}
/*
==================
CM_SurfaceCollideFromTriangleSoup
==================
*/
static void CM_SurfaceCollideFromTriangleSoup( cTriangleSoup_t *triSoup, cSurfaceCollide_t *sc )
{
float *p1, *p2, *p3;
int i, i1, i2, i3;
cfacet_t *facet;
numPlanes = 0;
numFacets = 0;
#ifdef USE_HASHING
// initialize hash table
Mem_Set( planeHashTable, 0, sizeof( planeHashTable ));
#endif
// find the planes for each triangle of the grid
for( i = 0; i < triSoup->numTriangles; i++ )
{
p1 = triSoup->points[i][0];
p2 = triSoup->points[i][1];
p3 = triSoup->points[i][2];
triSoup->trianglePlanes[i] = CM_FindPlane( p1, p2, p3 );
}
// create the borders for each triangle
for( i = 0; i < triSoup->numTriangles; i++ )
{
facet = &facets[numFacets];
Mem_Set( facet, 0, sizeof( *facet ));
i1 = triSoup->indexes[i*3+0];
i2 = triSoup->indexes[i*3+1];
i3 = triSoup->indexes[i*3+2];
p1 = triSoup->points[i][0];
p2 = triSoup->points[i][1];
p3 = triSoup->points[i][2];
facet->surfacePlane = triSoup->trianglePlanes[i];
// try and make a quad out of two triangles
#if 0
if( i != triSoup->numTriangles - 1 )
{
int i4, i5, i6;
float *p4;
i4 = triSoup->indexes[i*3+3];
i5 = triSoup->indexes[i*3+4];
i6 = triSoup->indexes[i*3+5];
if( i4 == i3 && i5 == i2 )
{
p4 = triSoup->points[i][5]; // vertex at i6
if(CM_GenerateFacetFor4Points( facet, p1, p2, p4, p3 ))
{
CM_SetBorderInward( facet, triSoup, i, 0 );
if( CM_ValidateFacet( facet ))
{
CM_AddFacetBevels( facet );
numFacets++;
i++; // skip next tri
continue;
}
}
}
}
#endif
if( CM_GenerateFacetFor3Points( facet, p1, p2, p3 ))
{
CM_SetBorderInward( facet, triSoup, i, 0 );
if( CM_ValidateFacet( facet ))
{
CM_AddFacetBevels( facet );
numFacets++;
}
}
}
// copy the results out
sc->numPlanes = numPlanes;
sc->planes = Mem_Alloc( cms.mempool, numPlanes * sizeof( *sc->planes ));
Mem_Copy( sc->planes, planes, numPlanes * sizeof( *sc->planes ));
sc->numFacets = numFacets;
sc->facets = Mem_Alloc( cms.mempool, numFacets * sizeof( *sc->facets ));
Mem_Copy( sc->facets, facets, numFacets * sizeof( *sc->facets ));
}
/*
==================
R_ClipPolygon
==================
*/
bool R_ClipPolygon (int numPoints, vec3_t *points, const cplane_t plane, float epsilon, int *numClipped, vec3_t *clipped){
vec3_t tmpVector, tmpVector2;
float dists[MAX_POLYGON_POINTS];
int sides[MAX_POLYGON_POINTS];
bool frontSide, backSide;
float frac;
int i;
if (numPoints >= MAX_POLYGON_POINTS - 2)
Com_Error(ERR_DROP, "R_ClipPolygon: MAX_POLYGON_POINTS hit");
*numClipped = 0;
// Determine sides for each point
frontSide = false;
backSide = false;
for (i = 0; i < numPoints; i++){
dists[i] = PlaneDistance(plane.normal, plane.dist, points[i]);
if (dists[i] > epsilon){
sides[i] = PLANESIDE_FRONT;
frontSide = true;
continue;
}
if (dists[i] < -epsilon){
sides[i] = PLANESIDE_BACK;
backSide = true;
continue;
}
sides[i] = PLANESIDE_ON;
}
if (!frontSide)
return false; // Not clipped
if (!backSide){
*numClipped = numPoints;
Mem_Copy(clipped, points, numPoints * sizeof(vec3_t));
return true;
}
// Clip it
VectorCopy(points[0], points[i]);
dists[i] = dists[0];
sides[i] = sides[0];
for (i = 0; i < numPoints; i++){
if (sides[i] == PLANESIDE_ON){
VectorCopy(points[i], clipped[(*numClipped)++]);
continue;
}
if (sides[i] == PLANESIDE_FRONT)
VectorCopy(points[i], clipped[(*numClipped)++]);
if (sides[i+1] == PLANESIDE_ON || sides[i+1] == sides[i])
continue;
if (dists[i] == dists[i+1])
VectorCopy(points[i], clipped[(*numClipped)++]);
else {
frac = dists[i] / (dists[i] - dists[i+1]);
VectorSubtract(points[i+1], points[i], tmpVector);
VectorMA(points[i], frac, tmpVector, tmpVector2);
VectorCopy(tmpVector2, clipped[(*numClipped)++]);
}
}
return true;
}
/*
=================
ParseRawBrush
parses the sides into buildBrush->sides[], nothing else.
no validation, back plane removal, etc.
=================
*/
static void ParseRawBrush( bool onlyLights )
{
side_t *side;
float planePoints[3][3];
int planenum;
char name[MAX_SHADERPATH];
char shader[MAX_SHADERPATH];
shaderInfo_t *si;
token_t token;
vects_t vects;
int flags;
buildBrush->numsides = 0;
buildBrush->detail = false;
if( g_bBrushPrimit == BRUSH_RADIANT )
Com_CheckToken( mapfile, "{" );
while( 1 )
{
if( !Com_ReadToken( mapfile, SC_ALLOW_NEWLINES|SC_COMMENT_SEMICOLON, &token ))
break;
if( !com.stricmp( token.string, "}" )) break;
if( g_bBrushPrimit == BRUSH_RADIANT )
{
while( 1 )
{
if( com.strcmp( token.string, "(" ))
Com_ReadToken( mapfile, 0, &token );
else break;
Com_ReadToken( mapfile, SC_ALLOW_NEWLINES, &token );
}
}
Com_SaveToken( mapfile, &token );
if( buildBrush->numsides >= MAX_BUILD_SIDES )
Sys_Break( "Entity %i, Brush %i MAX_BUILD_SIDES\n", buildBrush->entityNum, buildBrush->brushNum );
side = &buildBrush->sides[ buildBrush->numsides ];
Mem_Set( side, 0, sizeof( *side ));
buildBrush->numsides++;
// read the three point plane definition
Com_Parse1DMatrix( mapfile, 3, planePoints[0] );
Com_Parse1DMatrix( mapfile, 3, planePoints[1] );
Com_Parse1DMatrix( mapfile, 3, planePoints[2] );
// read the texture matrix
if( g_bBrushPrimit == BRUSH_RADIANT )
Com_Parse2DMatrix( mapfile, 2, 3, (float *)side->texMat );
// read the texturedef or shadername
Com_ReadToken( mapfile, SC_ALLOW_PATHNAMES|SC_PARSE_GENERIC, &token );
com.strncpy( name, token.string, sizeof( name ));
if( g_bBrushPrimit == BRUSH_WORLDCRAFT_22 || g_bBrushPrimit == BRUSH_GEARCRAFT_40 ) // Worldcraft 2.2+
{
// texture U axis
Com_ReadToken( mapfile, 0, &token );
if( com.strcmp( token.string, "[" )) Sys_Break( "missing '[' in texturedef (U)\n" );
Com_ReadFloat( mapfile, false, &vects.hammer.UAxis[0] );
Com_ReadFloat( mapfile, false, &vects.hammer.UAxis[1] );
Com_ReadFloat( mapfile, false, &vects.hammer.UAxis[2] );
Com_ReadFloat( mapfile, false, &vects.hammer.shift[0] );
Com_ReadToken( mapfile, 0, &token );
if( com.strcmp( token.string, "]" )) Sys_Break( "missing ']' in texturedef (U)\n" );
// texture V axis
Com_ReadToken( mapfile, 0, &token );
if( com.strcmp( token.string, "[" )) Sys_Break( "missing '[' in texturedef (V)\n" );
Com_ReadFloat( mapfile, false, &vects.hammer.VAxis[0] );
Com_ReadFloat( mapfile, false, &vects.hammer.VAxis[1] );
Com_ReadFloat( mapfile, false, &vects.hammer.VAxis[2] );
Com_ReadFloat( mapfile, false, &vects.hammer.shift[1] );
Com_ReadToken( mapfile, 0, &token );
if( com.strcmp( token.string, "]" )) Sys_Break( "missing ']' in texturedef (V)\n");
// texture rotation is implicit in U/V axes.
Com_ReadToken( mapfile, 0, &token );
vects.hammer.rotate = 0;
// texure scale
Com_ReadFloat( mapfile, false, &vects.hammer.scale[0] );
Com_ReadFloat( mapfile, false, &vects.hammer.scale[1] );
if( g_bBrushPrimit == BRUSH_GEARCRAFT_40 )
{
Com_ReadLong( mapfile, false, &flags ); // read gearcraft flags
Com_SkipRestOfLine( mapfile ); // gearcraft lightmap scale and rotate
if( flags & GEARBOX_DETAIL )
side->compileFlags |= C_DETAIL;
}
}
else if( g_bBrushPrimit == BRUSH_WORLDCRAFT_21 || g_bBrushPrimit == BRUSH_QUARK )
{
// worldcraft 2.1-, old Radiant, QuArK
Com_ReadFloat( mapfile, false, &vects.hammer.shift[0] );
Com_ReadFloat( mapfile, false, &vects.hammer.shift[1] );
Com_ReadFloat( mapfile, false, &vects.hammer.rotate );
Com_ReadFloat( mapfile, false, &vects.hammer.scale[0] );
Com_ReadFloat( mapfile, SC_COMMENT_SEMICOLON, &vects.hammer.scale[1] );
}
// set default flags and values
com.sprintf( shader, "textures/%s", name );
if( onlyLights ) si = &shaderInfo[0];
else si = ShaderInfoForShader( shader );
side->shaderInfo = si;
side->surfaceFlags = si->surfaceFlags;
side->contentFlags = si->contentFlags;
side->compileFlags = si->compileFlags;
side->value = si->value;
// bias texture shift for non-radiant sides
if( g_bBrushPrimit != BRUSH_RADIANT && si->globalTexture == false )
{
vects.hammer.shift[0] -= (floor( vects.hammer.shift[0] / si->shaderWidth ) * si->shaderWidth);
vects.hammer.shift[1] -= (floor( vects.hammer.shift[1] / si->shaderHeight ) * si->shaderHeight);
}
// historically, there are 3 integer values at the end of a brushside line in a .map file.
// in quake 3, the only thing that mattered was the first of these three values, which
// was previously the content flags. and only then did a single bit matter, the detail
// bit. because every game has its own special flags for specifying detail, the
// traditionally game-specified BASECONT_DETAIL flag was overridden for Q3Map 2.3.0
// by C_DETAIL, defined in q3map2.h. the value is exactly as it was before, but
// is stored in compileFlags, as opposed to contentFlags, for multiple-game
// portability. :sigh:
if( g_bBrushPrimit != BRUSH_QUARK && Com_ReadToken( mapfile, SC_COMMENT_SEMICOLON, &token ))
{
// overwrite shader values directly from .map file
Com_SaveToken( mapfile, &token );
Com_ReadLong( mapfile, false, &flags );
Com_ReadLong( mapfile, false, NULL );
Com_ReadLong( mapfile, false, NULL );
if( flags & C_DETAIL ) side->compileFlags |= C_DETAIL;
}
if( mapfile->TXcommand == '1' || mapfile->TXcommand == '2' )
{
// we are QuArK mode and need to translate some numbers to align textures its way
// from QuArK, the texture vectors are given directly from the three points
vec3_t texMat[2];
float dot22, dot23, dot33, mdet, aa, bb, dd;
int j, k;
g_bBrushPrimit = BRUSH_QUARK; // we can detect it only here
k = mapfile->TXcommand - '0';
for( j = 0; j < 3; j++ )
texMat[1][j] = (planePoints[k][j] - planePoints[0][j]) * (0.0078125f); // QuArK magic value
k = 3 - k;
for( j = 0; j < 3; j++ )
texMat[0][j] = (planePoints[k][j] - planePoints[0][j]) * (0.0078125f); // QuArK magic value
dot22 = DotProduct( texMat[0], texMat[0] );
dot23 = DotProduct( texMat[0], texMat[1] );
dot33 = DotProduct( texMat[1], texMat[1] );
mdet = dot22 * dot33 - dot23 * dot23;
if( mdet < 1E-6 && mdet > -1E-6 )
{
aa = bb = dd = 0;
MsgDev( D_WARN, "Entity %i, Brush %i: degenerate QuArK-style texture: \n", buildBrush->entityNum, buildBrush->brushNum );
}
else
{
mdet = 1.0 / mdet;
aa = dot33 * mdet;
bb = -dot23 * mdet;
dd = dot22 * mdet;
}
for( j = 0; j < 3; j++ )
{
vects.quark.vecs[0][j] = aa * texMat[0][j] + bb * texMat[1][j];
vects.quark.vecs[1][j] = -(bb * texMat[0][j] + dd * texMat[1][j]);
}
vects.quark.vecs[0][3] = -DotProduct( vects.quark.vecs[0], planePoints[0] );
vects.quark.vecs[1][3] = -DotProduct( vects.quark.vecs[1], planePoints[0] );
}
// find the plane number
planenum = MapPlaneFromPoints( planePoints );
if( planenum == -1 )
{
MsgDev( D_ERROR, "Entity %i, Brush %i: plane with no normal\n", buildBrush->entityNum, buildBrush->brushNum );
continue;
}
side->planenum = planenum;
if( g_bBrushPrimit == BRUSH_QUARK )
{
// QuArK format completely matched with internal
// FIXME: don't calculate vecs, use QuArK texMat instead ?
Mem_Copy( side->vecs, vects.quark.vecs, sizeof( side->vecs ));
}
else if( g_bBrushPrimit != BRUSH_RADIANT )
{
vec3_t vecs[2];
float ang, sinv, cosv, ns, nt;
int i, j, sv, tv;
if( g_bBrushPrimit == BRUSH_WORLDCRAFT_21 )
TextureAxisFromPlane( &mapplanes[planenum], vecs[0], vecs[1] );
if( !vects.hammer.scale[0] ) vects.hammer.scale[0] = 1.0f;
if( !vects.hammer.scale[1] ) vects.hammer.scale[1] = 1.0f;
if( g_bBrushPrimit == BRUSH_WORLDCRAFT_21 )
{
// rotate axis
if( vects.hammer.rotate == 0 )
{
sinv = 0;
cosv = 1;
}
else if( vects.hammer.rotate == 90 )
{
sinv = 1;
cosv = 0;
}
else if( vects.hammer.rotate == 180 )
{
sinv = 0;
cosv = -1;
}
else if( vects.hammer.rotate == 270 )
{
sinv = -1;
cosv = 0;
}
else
{
ang = vects.hammer.rotate / 180 * M_PI;
sinv = sin( ang );
cosv = cos( ang );
}
if( vecs[0][0] ) sv = 0;
else if( vecs[0][1] ) sv = 1;
else sv = 2;
if( vecs[1][0] ) tv = 0;
else if( vecs[1][1] ) tv = 1;
else tv = 2;
for( i = 0; i < 2; i++ )
{
ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];
vecs[i][sv] = ns;
vecs[i][tv] = nt;
}
for( i = 0; i < 2; i++ )
for( j = 0; j < 3; j++ )
side->vecs[i][j] = vecs[i][j] / vects.hammer.scale[i];
}
else if( g_bBrushPrimit == BRUSH_WORLDCRAFT_22 || g_bBrushPrimit == BRUSH_GEARCRAFT_40 )
{
float scale;
scale = 1.0f / vects.hammer.scale[0];
VectorScale( vects.hammer.UAxis, scale, side->vecs[0] );
scale = 1.0f / vects.hammer.scale[1];
VectorScale( vects.hammer.VAxis, scale, side->vecs[1] );
}
// add shifts
side->vecs[0][3] = vects.hammer.shift[0];
side->vecs[1][3] = vects.hammer.shift[1];
}
}
if( g_bBrushPrimit == BRUSH_RADIANT )
{
Com_SaveToken( mapfile, &token );
Com_CheckToken( mapfile, "}" );
Com_CheckToken( mapfile, "}" );
}
}
////////////////////////////////////////////////////////////////////
// 函数名称：
// 函数功能：处理
// 入口参数：void *pdata
//
// MSG_OPTION_CLASS_BEGIN
// 出口参数：无
////////////////////////////////////////////////////////////////////
//void K8_UDP_Rec_Process( tagCommand *pcommand, eip *prec)
void K8_UDP_Rec_Process( void *pdata, eip *prec)
{
uint8 buf[300] = {0}, rev_buf[80], n, *p;
uint16 i;
struct MSG_REV_TYPE rec_type;
struct SFILE_TRANSLATE_TYPE File_type;
struct BASE_MSG Base_msg;
tagCommand pcommand;
p = (uint8 *)pdata;
Mem_Copy((uint8 *)&pcommand, p, sizeof( tagCommand));
rec_type.Type = DEV_XCOM_UDP;
rec_type.des_ip[0] = prec->SourceIp[0];
rec_type.des_ip[1] = prec->SourceIp[1];
rec_type.des_ip[2] = prec->SourceIp[2];
rec_type.des_ip[3] = prec->SourceIp[3];
memcpy(&rev_buf, &rec_type, sizeof(struct MSG_REV_TYPE));
//memcpy(&buf[4], p + sizeof(struct BASE_MSG) + sizeof(struct SFILE_TRANSLATE_TYPE), sizeof(tagCommand));
Base_msg.device = MSG_DEV_LMT;
//IP_printf("recive S:%x R:%x C:%x F:%x\n",pcommand->sender,pcommand->receiver,pcommand->command,pcommand->flag);
//buf[0]=MSG_DEV_LMT;
switch(pcommand.command)
{
case EMCOMMANDREMOTECONTROLLER:
Base_msg.device = MSG_DEV_LAN_KB;
Base_msg.option = MSG_OPTION_LAN_KEY;
buf[2] = KEY_VAL;
switch(pcommand.flag)
{
case EMRCACTIONPOWERON:
buf[3] = KEY_CLASS_BEGIN;
buf[4] = KEY_CLASS_BEGIN >> 8;
break;
case EMRCACTIONPOWEROFF:
buf[3] = KEY_CLASS_BEGIN;
buf[4] = KEY_CLASS_BEGIN >> 8;
break;
case EMRCACTIONRECORDSTART:
buf[3] = KEY_REC_PUSH ;
buf[4] = KEY_REC_PUSH >> 8;
break;
case EMRCACTIONRECORDPAUSE:
buf[3] = KEY_REC_PUSH;
buf[4] = KEY_REC_PUSH >> 8;
break;
case EMRCACTIONRECORDSTOP:
buf[3] = KEY_REC_STOP;
buf[4] = KEY_REC_STOP >> 8;
break;
case EMRCACTIONDEVPC:
buf[3] = KEY_DEVICE_PC;
buf[4] = KEY_DEVICE_PC >> 8;
break;
case EMRCACTIONDEVNPC:
buf[3] = KEY_DEVICE_NPC;
buf[4] = KEY_DEVICE_NPC >> 8;
break;
case EMRCACTIONDEVSHOW:
buf[3] = KEY_DEVICE_SHOW;
buf[4] = KEY_DEVICE_SHOW >> 8;
break;
}
break;
case EMCOMMANDHEARTBEAT:
Base_msg.option = MSG_OPTION_REC_K8;
break;
case EMCOMMANDCOM1:
case EMCOMMANDCOM2:
case EMCOMMANDCOM3:
case EMCOMMANDCOM4:
case EMCOMMANDSETBAUDRATE:
Base_msg.option = MSG_OPTION_SCAMERA_CONTRL;
break;
case EMCOMMANDRESET:
Base_msg.option = MSG_OPTION_RESET;
break;
case EMCOMMANDFILEREQ:
Base_msg.option = MSG_OPTION_FILE_REQ;
File_type.FileType = FILE_TYPE_TABLE;
File_type.FilePage = pcommand.flag;
memcpy(&buf[2], &File_type, sizeof(struct SFILE_TRANSLATE_TYPE));
break;
case EMCOMMANDFILESEND:
Base_msg.option = MSG_OPTION_FILE_SEND;
File_type.FileType = FILE_TYPE_TABLE;
File_type.FilePage = pcommand.flag;
memcpy(&buf[2], &File_type, sizeof(struct SFILE_TRANSLATE_TYPE));
break;
default:
Base_msg.option = MSG_OPTION_NONE;
break;
}
//Msg_send(buf,sizeof(tagCommand)+4,rev_buf);
memcpy(&buf[0], &Base_msg, sizeof(struct BASE_MSG));
if(Base_msg.option == MSG_OPTION_FILE_SEND)
{
n = sizeof(struct BASE_MSG) + sizeof(struct SFILE_TRANSLATE_TYPE);
memcpy(&buf[n], p + sizeof(tagCommand), 256);
//IP_printf_256(&buf[n]);
Msg_send(buf, sizeof(struct BASE_MSG) + sizeof(struct SFILE_TRANSLATE_TYPE) +256, rev_buf);
}
else
{
Msg_send(buf, 30, rev_buf);
}
//IP_printf("buf:%x %x %x %x %x %x %x %x %x %x\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7],buf[8],buf[9]);
}
/*
==================
CIN_LoadPCX
TODO: fill in cinematic_t
==================
*/
static bool CIN_LoadPCX (cinematic_t *cin, const char *name, int flags){
pcxHeader_t *header;
byte *data, *pcxData;
byte *in, *out;
byte palette[768];
int x, y, length;
int dataByte, runLength;
// Load the file
length = FS_ReadFile(name, (void **)&data);
if (!data)
return false;
// Parse the PCX header
header = (pcxHeader_t *)data;
header->xMin = LittleShort(header->xMin);
header->yMin = LittleShort(header->yMin);
header->xMax = LittleShort(header->xMax);
header->yMax = LittleShort(header->yMax);
header->hRes = LittleShort(header->hRes);
header->vRes = LittleShort(header->vRes);
header->bytesPerLine = LittleShort(header->bytesPerLine);
header->paletteType = LittleShort(header->paletteType);
in = &header->data;
if (header->manufacturer != 0x0A || header->version != 5 || header->encoding != 1)
Com_Error(ERR_DROP, "CIN_LoadPCX: invalid PCX header (%s)\n", name);
if (header->bitsPerPixel != 8 || header->colorPlanes != 1)
Com_Error(ERR_DROP, "CIN_LoadPCX: only 8 bit PCX images supported (%s)\n", name);
if (header->xMax <= 0 || header->yMax <= 0 || header->xMax >= 640 || header->yMax >= 480)
Com_Error(ERR_DROP, "CIN_LoadPCX: bad image size (%i x %i) (%s)\n", header->xMax, header->yMax, name);
Mem_Copy(palette, (byte *)data + length - 768, 768);
pcxData = out = (byte *)Mem_Alloc((header->xMax+1) * (header->yMax+1) * 4, TAG_TEMPORARY);
for (y = 0; y <= header->yMax; y++){
for (x = 0; x <= header->xMax; ){
dataByte = *in++;
if ((dataByte & 0xC0) == 0xC0){
runLength = dataByte & 0x3F;
dataByte = *in++;
}
else
runLength = 1;
while (runLength-- > 0){
out[0] = palette[dataByte*3+0];
out[1] = palette[dataByte*3+1];
out[2] = palette[dataByte*3+2];
out[3] = 255;
out += 4;
x++;
}
}
}
if (in - data > length){
Com_DPrintf(S_COLOR_YELLOW "CIN_LoadPCX: PCX file was malformed (%s)\n", name);
FS_FreeFile(data);
Mem_Free(pcxData);
pcxData = NULL;
return false;
}
// Free the file data
FS_FreeFile(data);
// Fill it in
cin->playing = true;
cin->isRoQ = false;
Str_Copy(cin->name, name, sizeof(cin->name));
cin->flags = flags;
cin->file = 0;
cin->size = 0;
cin->offset = 0;
cin->startTime = 0;
cin->frameRate = 0;
cin->frameCount = -1;
// Resample video if needed
CIN_ResampleVideo(cin);
return true;
}
void HSCSI_ISR_Response_Queue(PHSCSI_INSTANCE_DATA Id)
{
HSCSI_EVENT_CONTEXT *p_context;
IOCB_STATUS_ENTRY *p_IOCB;
STATUS status;
HSCSI_TRACE_ENTRY(HSCSI_ISR_Response_Queue);
// Point to IOCB in response FIFO
p_IOCB = (IOCB_STATUS_ENTRY*)
&(Id->HSCSI_p_IOCB_response_FIFO[Id->HSCSI_response_FIFO_index]);
// decide what to do with the IOCB based on the entry_type
switch(p_IOCB->entry_type) {
case HSCSI_IOCB_TYPE_MARKER:
HSCSI_PRINT_STRING(TRACE_L7, "\n\rMarker IOCB");
HSCSI_Response_FIFO_Increment_Index(Id);
return;
case HSCSI_IOCB_TYPE_STATUS:
HSCSI_PRINT_STRING(TRACE_L7, "\n\rStatus IOCB");
// If this IOCB is the result of a request that completed, then
// system_defined2 points to a context.
p_context = (HSCSI_EVENT_CONTEXT*)p_IOCB->system_defined2;
if (p_context == (HSCSI_EVENT_CONTEXT *)0)
{
// If we can't find an event context,
// we can't handle this interrupt!
HSCSI_Log_Error(HSCSI_ERROR_TYPE_FATAL,
"HSCSI_ISR_Response_Queue",
"No event context for Response IOCB",
0,
(UNSIGNED)Id);
return;
}
// Copy IOCB from response FIFO to status_iocb of context
Mem_Copy((char*)&p_context->status_iocb, // to
(char*)p_IOCB, // from
IOCB_SIZE); // number of bytes
break;
default:
// If we don't know what the type is,
// we can't handle this interrupt!
HSCSI_DUMP_HEX(TRACE_L8, "\n\rEntry Data ",
(U8 *)p_IOCB,
sizeof(IOCB_STATUS_ENTRY));
HSCSI_Log_Error(HSCSI_ERROR_TYPE_FATAL,
"HSCSI_ISR_Response_Queue",
"Unknown entry type",
p_IOCB->entry_type,
(UNSIGNED)Id);
return;
}
// Increment the index when we have processed this IOCB.
HSCSI_Response_FIFO_Increment_Index(Id);
// Send a message to HSCSI_Event_Task.
// The action field of the context will tell HSCSI_Event_Task
// what to do next.
status = NU_Send_To_Queue(&Id->HSCSI_event_queue,
&p_context, // message is pointer to context
1, // size is one UNSIGNED
NU_NO_SUSPEND);
if (status != NU_SUCCESS)
HSCSI_Log_Error(HSCSI_ERROR_TYPE_FATAL,
"HSCSI_ISR_Response_Queue",
"NU_Send_To_Queue for request completion failed",
status,
(UNSIGNED)Id);
} // HSCSI_ISR_Response_Queue
