FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

06 Aug 2008

This commit is contained in:
g-cont 2008-08-06 00:00:00 +04:00 committed by Alibek Omarov
parent 6875d3daa1
commit 2c618c1ebc
45 changed files with 7954 additions and 4237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

720
baserc/client.h
View File

@ -1,12 +1,12 @@
const unsigned char client_dat[] = {
0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc2, 0x11, 0x00,
0x00, 0x3f, 0x00, 0x00, 0x00, 0xa2, 0x03, 0x00, 0x00, 0xbf, 0x01,
0x00, 0x00, 0x2e, 0x0b, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x1b,
0x0d, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0xfa, 0x08, 0x00, 0x00,
0x67, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x74, 0x06, 0x00,
0x00, 0x95, 0x0d, 0x00, 0x00, 0xbc, 0x01, 0x00, 0x00, 0x12, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x88, 0x0e, 0x00,
0x00, 0x3f, 0x00, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, 0xee, 0x01,
0x00, 0x00, 0xf7, 0x0b, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x0d,
0x0e, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xb5, 0x09, 0x00, 0x00,
0x68, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x2c, 0x07, 0x00,
0x00, 0xb8, 0x0e, 0x00, 0x00, 0xd9, 0x01, 0x00, 0x00, 0x1b, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x72, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xbe, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0a, 0x0d,
0x0a, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20,
0x77, 0x61, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64,
@ -21,342 +21,372 @@ const unsigned char client_dat[] = {
0x72, 0x2e, 0x0a, 0x54, 0x68, 0x61, 0x6e, 0x6b, 0x73, 0x20, 0x74,
0x6f, 0x20, 0x49, 0x44, 0x20, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61,
0x72, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x2e, 0x00,
0x0d, 0x0a, 0x0d, 0x0a, 0xac, 0x02, 0x00, 0x00, 0x78, 0xda, 0x65,
0x94, 0x4b, 0x73, 0xdc, 0x20, 0x0c, 0xc7, 0x39, 0xf7, 0x53, 0xe4,
0x92, 0x63, 0xb3, 0xcd, 0xe6, 0xd1, 0xc7, 0xad, 0xcd, 0xa3, 0xcd,
0xa1, 0x33, 0x3b, 0xc9, 0xa4, 0xc7, 0x7a, 0xb4, 0x20, 0xdb, 0xcc,
0x62, 0x70, 0x01, 0xaf, 0xc3, 0x7e, 0xfa, 0x0a, 0xb0, 0x89, 0x37,
0xb9, 0x58, 0xbf, 0x3f, 0x16, 0x02, 0x24, 0x04, 0x6b, 0x07, 0xb1,
0xd2, 0x43, 0x57, 0x7d, 0x62, 0x33, 0x9d, 0x17, 0x5a, 0x17, 0xba,
0x28, 0x74, 0x59, 0xe8, 0xaa, 0xd0, 0x75, 0xa1, 0xcf, 0x85, 0xbe,
0x14, 0xfa, 0x5a, 0xe8, 0x63, 0x22, 0xde, 0x9e, 0x4f, 0x76, 0x3d,
0xd9, 0x0b, 0xf6, 0xeb, 0xf9, 0xb6, 0x7a, 0xd0, 0xd2, 0x27, 0x78,
0x44, 0x2d, 0xd0, 0x7e, 0x3b, 0xd9, 0x82, 0x38, 0xe1, 0xca, 0x9d,
0x39, 0x0f, 0x1e, 0x17, 0x7f, 0x12, 0x3e, 0xf9, 0x41, 0x48, 0x73,
0xb7, 0x47, 0x9d, 0x27, 0x3d, 0xf7, 0x82, 0xbc, 0xee, 0xb4, 0x97,
0x5e, 0xa2, 0x63, 0x9d, 0x74, 0x7c, 0xe5, 0x41, 0xed, 0xce, 0x46,
0xd8, 0xb3, 0xbf, 0xd7, 0xa7, 0xee, 0x43, 0x72, 0xdb, 0x80, 0x75,
0xf8, 0x1b, 0x9d, 0x83, 0x26, 0x87, 0x7c, 0x6a, 0x07, 0x2f, 0xcc,
0xa8, 0xd9, 0xa9, 0x4c, 0xfa, 0xd6, 0xc2, 0x78, 0x2f, 0x51, 0x89,
0xa4, 0xee, 0x41, 0xe0, 0x77, 0xd5, 0xb7, 0xc0, 0xb8, 0xe9, 0x3a,
0xa3, 0x57, 0xb5, 0x54, 0xaa, 0xb2, 0xc8, 0x7d, 0x71, 0xfe, 0x01,
0xf6, 0xa1, 0x9b, 0xa3, 0xc5, 0x81, 0x1b, 0xda, 0x12, 0xda, 0x32,
0x3c, 0x4d, 0xdc, 0x82, 0xad, 0xb6, 0xc0, 0x77, 0x4b, 0xad, 0x0c,
0x88, 0x65, 0x9c, 0x9f, 0xa8, 0xd1, 0x4a, 0xfe, 0x3e, 0xd2, 0xdb,
0x1f, 0x8f, 0xb4, 0x01, 0xd0, 0x8d, 0xc2, 0xcd, 0x62, 0x70, 0xf3,
0x6e, 0x66, 0x1c, 0xe1, 0xaa, 0x52, 0xb8, 0x47, 0xe5, 0x5a, 0xe3,
0x2b, 0x0d, 0x1d, 0x32, 0xc7, 0xf3, 0xca, 0x52, 0x37, 0xf3, 0x66,
0xba, 0x32, 0xf0, 0x67, 0xca, 0xf1, 0x46, 0xc1, 0xbf, 0x01, 0x59,
0xdc, 0x71, 0x63, 0xcd, 0xa0, 0xc5, 0xca, 0xf5, 0x0a, 0x5c, 0x5b,
0x1c, 0x9e, 0xb2, 0x9c, 0x02, 0x68, 0xf4, 0xac, 0x87, 0xc1, 0xa1,
0x48, 0xe1, 0x69, 0xb1, 0x31, 0xc9, 0xd7, 0x05, 0xb2, 0x4c, 0x25,
0x30, 0xce, 0x4f, 0x85, 0x8c, 0xe5, 0xaf, 0x81, 0xe3, 0x79, 0xa1,
0x75, 0xa1, 0x8b, 0x42, 0x97, 0x85, 0xae, 0x18, 0xb7, 0xc6, 0xb9,
0x16, 0xa4, 0x2d, 0x1b, 0x49, 0x45, 0x94, 0x31, 0x19, 0xb4, 0xa3,
0x80, 0xf1, 0xc7, 0x0d, 0x28, 0xfe, 0x88, 0xb5, 0xc0, 0x9a, 0xf5,
0xb8, 0x67, 0xa3, 0xb1, 0x54, 0xce, 0x0e, 0xfa, 0x74, 0x7c, 0x8b,
0xa0, 0xbc, 0x24, 0xa8, 0x2d, 0xc9, 0x44, 0x7b, 0x89, 0xe4, 0xd3,
0xcc, 0xb6, 0x7a, 0x29, 0x14, 0x0a, 0x1d, 0x12, 0xa5, 0xa4, 0xbb,
0x05, 0x4e, 0xbe, 0x93, 0x08, 0x4b, 0x41, 0x33, 0xaa, 0xda, 0xd8,
0x11, 0xac, 0x78, 0xa5, 0xe8, 0x5f, 0x38, 0x2c, 0x38, 0x7a, 0x5b,
0xd9, 0xb4, 0x7e, 0xb6, 0xc9, 0x33, 0x53, 0x28, 0x14, 0xbd, 0x86,
0x3e, 0x7d, 0xd2, 0x7f, 0x32, 0x21, 0x9b, 0x03, 0x33, 0x3a, 0x57,
0x8a, 0xe5, 0x3c, 0x50, 0xc3, 0xb1, 0x91, 0x5a, 0xc2, 0xa6, 0xf2,
0xd3, 0x3d, 0x90, 0x74, 0x27, 0x6a, 0x05, 0x8d, 0x8b, 0x77, 0x62,
0x71, 0x98, 0x23, 0x45, 0x51, 0x8f, 0x75, 0x78, 0xa3, 0x0f, 0xcc,
0xc9, 0x2e, 0x06, 0xcc, 0x86, 0xfc, 0x27, 0x08, 0x33, 0x24, 0x8f,
0x98, 0xce, 0x6c, 0xb2, 0x47, 0x4e, 0xe6, 0x04, 0x07, 0x26, 0x05,
0x55, 0xa1, 0x97, 0x9e, 0xb7, 0x29, 0x63, 0x2d, 0xe6, 0x93, 0x17,
0x9c, 0xd2, 0x3a, 0x89, 0xb0, 0x14, 0x07, 0xd6, 0xc6, 0x0a, 0xb6,
0x54, 0xd0, 0x97, 0x0a, 0x4b, 0xbf, 0xc3, 0x4b, 0x3e, 0xa1, 0x63,
0x0a, 0x6d, 0x4f, 0xb5, 0xe5, 0x4c, 0xc6, 0x1e, 0xa0, 0x87, 0xc0,
0x49, 0xa3, 0x99, 0xc0, 0xce, 0xc4, 0xc4, 0xa4, 0x1e, 0xec, 0x07,
0xcd, 0xdb, 0x74, 0xa0, 0x05, 0xd2, 0x9a, 0x0b, 0x11, 0x96, 0xe2,
0xf0, 0x7a, 0xef, 0xf2, 0xac, 0x63, 0x19, 0x93, 0x76, 0x3c, 0x10,
0xde, 0x0e, 0xe4, 0xeb, 0x93, 0xb6, 0x1b, 0xd8, 0x56, 0xd1, 0xcd,
0xad, 0xb8, 0x51, 0xc6, 0x2e, 0x99, 0xc2, 0x2c, 0xd5, 0x91, 0x1f,
0x05, 0xc8, 0x0a, 0xd2, 0x6b, 0x44, 0x4d, 0x86, 0xa8, 0x63, 0x6a,
0x33, 0x84, 0x19, 0xc6, 0x19, 0x5a, 0x16, 0xbd, 0x5d, 0x70, 0x55,
0xa3, 0xcc, 0x16, 0x54, 0xac, 0x33, 0x38, 0x97, 0x5a, 0x20, 0x8f,
0x24, 0xec, 0x8c, 0x40, 0x25, 0xa9, 0x8f, 0x28, 0x54, 0xbc, 0x3c,
0x19, 0xe9, 0xdc, 0x52, 0xe7, 0x7f, 0xcc, 0xd0, 0xcd, 0x23, 0x91,
0x0d, 0xad, 0x38, 0x41, 0x98, 0x81, 0xca, 0x8d, 0xf4, 0x54, 0x68,
0x8e, 0x0c, 0xeb, 0x9a, 0x1e, 0x26, 0x97, 0x3b, 0x8b, 0x6d, 0x8d,
0xa0, 0x6d, 0xed, 0x68, 0xee, 0xbc, 0x93, 0x3a, 0xbe, 0xab, 0x8e,
0xfd, 0x07, 0x1a, 0xe9, 0x5b, 0x64, 0x58, 0x05, 0x00, 0x00, 0x78,
0xda, 0xcd, 0x59, 0x6b, 0x6c, 0x14, 0x55, 0x14, 0x9e, 0x53, 0x68,
0x81, 0x35, 0xd5, 0x62, 0x05, 0x24, 0x15, 0xb7, 0x05, 0xdf, 0xd8,
0x88, 0x5b, 0x5e, 0x55, 0x04, 0x83, 0x21, 0x62, 0x7d, 0x81, 0x82,
0x5a, 0x82, 0x81, 0x54, 0xd1, 0x26, 0x2a, 0x48, 0x20, 0xe9, 0x6e,
0x89, 0x06, 0x1f, 0x18, 0x4c, 0x13, 0x04, 0xa1, 0xd4, 0xd4, 0x04,
0x7c, 0x60, 0x6a, 0x7c, 0x82, 0x88, 0xf0, 0xcb, 0x68, 0xa2, 0x3f,
0xf0, 0x11, 0x8d, 0xff, 0xd5, 0xf8, 0xee, 0x2e, 0x2d, 0xa0, 0xc4,
0x07, 0xbe, 0xea, 0x39, 0x99, 0x33, 0xd9, 0x33, 0x9f, 0xb3, 0x77,
0x76, 0x4b, 0x68, 0x98, 0xe4, 0x32, 0xf7, 0xdb, 0xef, 0xdc, 0x7b,
0xbf, 0x7b, 0xe6, 0x9c, 0x73, 0x67, 0x8a, 0xe7, 0x85, 0xaf, 0x24,
0xb7, 0x36, 0x6e, 0xbd, 0x8a, 0xc7, 0x6a, 0xff, 0x73, 0x6e, 0x59,
0x6e, 0x29, 0xbd, 0x8f, 0x50, 0x7e, 0x8d, 0xb1, 0xcd, 0x71, 0xeb,
0xe0, 0xf6, 0x85, 0xf6, 0x87, 0x73, 0x9b, 0xca, 0xed, 0x7d, 0x98,
0xbf, 0x57, 0x79, 0xb9, 0x2a, 0x14, 0xa7, 0xf5, 0x7e, 0x15, 0xb7,
0xe3, 0x03, 0x03, 0x03, 0xd6, 0xfe, 0x90, 0xce, 0xe5, 0x15, 0x98,
0xaf, 0x2f, 0x86, 0xef, 0x77, 0xf0, 0x78, 0xb5, 0x70, 0x3b, 0xcc,
0xed, 0x34, 0xc5, 0x0d, 0xdc, 0x7e, 0x74, 0xd8, 0x0b, 0xff, 0x43,
0x0c, 0xff, 0x13, 0xe0, 0xef, 0x1d, 0xf6, 0xa2, 0xf7, 0x08, 0xe8,
0x5d, 0xef, 0xb0, 0xbf, 0x57, 0x7d, 0xf7, 0x9b, 0xfa, 0x4c, 0x70,
0x86, 0xdb, 0xef, 0x06, 0xb7, 0x03, 0xbf, 0xce, 0xf0, 0xe8, 0xef,
0x28, 0x7f, 0x1c, 0x35, 0xfe, 0x38, 0xd5, 0x2f, 0xd9, 0xdf, 0x1f,
0xb0, 0xdf, 0xe3, 0x80, 0xff, 0x04, 0xfc, 0x17, 0xe0, 0xbf, 0x01,
0xff, 0x03, 0xf8, 0x5f, 0xc0, 0x03, 0x80, 0x3d, 0x0a, 0x63, 0x62,
0xfc, 0xab, 0xc3, 0xc7, 0x5e, 0x4c, 0xfc, 0xec, 0x87, 0xe7, 0x51,
0xc6, 0xf3, 0x55, 0x1b, 0xfe, 0x5d, 0x88, 0x1f, 0x32, 0xf1, 0x23,
0xb8, 0x9c, 0xf2, 0xf9, 0x2a, 0xb8, 0x82, 0x71, 0x42, 0xf1, 0x74,
0x6e, 0x9f, 0x98, 0xf1, 0x12, 0x0f, 0x55, 0xb0, 0xfe, 0x81, 0x88,
0xf9, 0x87, 0x91, 0x8f, 0x13, 0xda, 0xcf, 0x68, 0x4e, 0xa7, 0xf4,
0x3e, 0xcc, 0xd8, 0x8f, 0xa0, 0x70, 0x3c, 0x7f, 0x06, 0xf3, 0xa3,
0xfe, 0x91, 0x14, 0xd6, 0x4f, 0xa6, 0xde, 0x4c, 0xe3, 0xf6, 0x30,
0xe8, 0x2d, 0x37, 0x78, 0xb2, 0xd6, 0x2f, 0x1b, 0x0f, 0x12, 0xef,
0x87, 0x21, 0x1f, 0x8e, 0x29, 0x46, 0x7b, 0xd1, 0xf3, 0x1e, 0xcc,
0x97, 0x8e, 0xc9, 0xd7, 0x71, 0xa0, 0x77, 0x14, 0x85, 0xf5, 0x6e,
0x37, 0xf6, 0x75, 0xba, 0x9f, 0x2a, 0xca, 0xdb, 0x57, 0x81, 0x7f,
0xba, 0x22, 0xfc, 0x7d, 0xa6, 0xda, 0xd7, 0x72, 0x3b, 0x9b, 0xfb,
0x67, 0x19, 0xff, 0x57, 0x92, 0xbf, 0x07, 0xeb, 0xff, 0x32, 0x33,
0xbe, 0x86, 0x7c, 0x9b, 0xc0, 0xfe, 0xf4, 0x18, 0xfb, 0x73, 0xc8,
0xb7, 0xb1, 0xe7, 0xc1, 0x68, 0xca, 0x9f, 0x07, 0xd2, 0x17, 0x3d,
0x76, 0xfc, 0x0c, 0x53, 0xcf, 0x85, 0x4f, 0xeb, 0xef, 0xb8, 0xbf,
0xa4, 0xf2, 0x36, 0x1e, 0x73, 0x5e, 0x38, 0x1e, 0xbb, 0xcd, 0xfe,
0xef, 0xd6, 0xfd, 0x8f, 0x87, 0xf3, 0xa9, 0x9a, 0xf2, 0xcf, 0x7f,
0x12, 0xf8, 0x2b, 0x0d, 0x7c, 0x1d, 0xf0, 0x19, 0xe0, 0x93, 0xc0,
0xb7, 0x03, 0x3f, 0x01, 0xf8, 0x75, 0xc0, 0xd7, 0x00, 0x3f, 0x89,
0xc2, 0xfc, 0x78, 0xe0, 0xcf, 0x07, 0x7e, 0x1c, 0xf0, 0x17, 0x02,
0x3f, 0x06, 0xf8, 0x8b, 0x81, 0xaf, 0x06, 0x7e, 0x32, 0xf0, 0xa3,
0x81, 0xaf, 0x07, 0xfe, 0x8c, 0x88, 0xf3, 0xdf, 0xf2, 0x95, 0x90,
0x4f, 0x13, 0x98, 0xeb, 0x35, 0xf9, 0x74, 0x2e, 0xe3, 0xac, 0xc1,
0x49, 0x89, 0x0d, 0x83, 0x6b, 0x19, 0x1f, 0x32, 0xb8, 0x8e, 0x71,
0x9f, 0xc1, 0x13, 0x19, 0xf7, 0x1b, 0x7c, 0x1e, 0x85, 0xf3, 0xf5,
0x02, 0xc6, 0x47, 0x0c, 0xbe, 0x88, 0xf1, 0x51, 0x83, 0x2f, 0x61,
0xfc, 0xb3, 0xc1, 0x97, 0x32, 0xfe, 0xc5, 0x9c, 0x6f, 0xc7, 0x4c,
0xed, 0x5d, 0x63, 0xf6, 0x86, 0xef, 0x2b, 0x39, 0xcd, 0xaf, 0x04,
0xc4, 0x6b, 0xce, 0xd4, 0x9f, 0x5a, 0xcd, 0xb7, 0x84, 0xc1, 0x92,
0x8b, 0x95, 0x10, 0x7f, 0x41, 0x0d, 0x9d, 0xc9, 0xed, 0x03, 0xe3,
0xbf, 0xf9, 0xc1, 0x78, 0x0a, 0xe7, 0x43, 0x36, 0x22, 0x7f, 0xe4,
0x2e, 0xfa, 0x0f, 0x3a, 0xce, 0x0e, 0xd1, 0x71, 0x99, 0x23, 0x9f,
0xb1, 0xbe, 0x8d, 0x94, 0xf8, 0xd3, 0x31, 0x97, 0x93, 0x1f, 0x5b,
0x72, 0x9f, 0x42, 0xc5, 0x8d, 0x97, 0x5a, 0x2b, 0xb6, 0x92, 0x03,
0x29, 0xf2, 0xf5, 0x4f, 0x05, 0x7f, 0xa5, 0x20, 0xbf, 0xeb, 0xe1,
0xbc, 0xe9, 0x89, 0xa8, 0x6f, 0x29, 0xca, 0xeb, 0x9b, 0xa2, 0xda,
0x72, 0x5a, 0x6f, 0x72, 0xca, 0x5b, 0x7d, 0xe5, 0x5e, 0xb4, 0x3d,
0x29, 0x9f, 0x36, 0x76, 0xc1, 0xf8, 0x06, 0xf2, 0xf7, 0xd3, 0x40,
0xff, 0xaf, 0x17, 0xc1, 0x6f, 0xc8, 0x4b, 0x77, 0x1a, 0xff, 0x33,
0x9f, 0xf2, 0xf5, 0xac, 0xcd, 0x2b, 0x1c, 0x1f, 0x82, 0xaf, 0x2b,
0x62, 0xbf, 0x57, 0x42, 0x3d, 0x9f, 0x47, 0xf9, 0xf5, 0x1a, 0xc9,
0xe7, 0xe7, 0xaa, 0x7f, 0x9b, 0xc0, 0xbf, 0x8d, 0xe0, 0xdf, 0xeb,
0x8b, 0x58, 0x6f, 0x0e, 0x85, 0xcf, 0x7f, 0x3b, 0xdf, 0x15, 0x30,
0x5f, 0x53, 0x11, 0xf3, 0x5d, 0x43, 0x61, 0x7c, 0xb5, 0xc1, 0x33,
0xb8, 0x3f, 0xcb, 0xe0, 0x99, 0x12, 0xc7, 0x66, 0xbf, 0xb3, 0x60,
0xfd, 0xe9, 0x14, 0xce, 0xaf, 0x39, 0x90, 0x5f, 0xf3, 0x4a, 0xc8,
0xaf, 0xa8, 0xf9, 0x6f, 0x80, 0xf9, 0xe7, 0xc6, 0xcc, 0x7f, 0x23,
0x15, 0x9e, 0x1f, 0x2f, 0x89, 0xbf, 0x5b, 0xd8, 0x7e, 0x01, 0x85,
0xe3, 0x2d, 0x78, 0x1f, 0x12, 0x7e, 0x38, 0x73, 0x0b, 0x35, 0xc7,
0xcb, 0xf5, 0xfb, 0x29, 0xa3, 0x77, 0x59, 0xef, 0x26, 0xd0, 0x7b,
0xb3, 0xe3, 0x7c, 0x4c, 0xea, 0x38, 0xab, 0x77, 0x81, 0xd1, 0x2b,
0x78, 0xa1, 0x79, 0x3f, 0x6c, 0xe4, 0xf6, 0xa5, 0x43, 0xbf, 0x3c,
0x96, 0x5b, 0x4f, 0x42, 0x7c, 0xdf, 0x01, 0xf1, 0xdd, 0x4a, 0xe1,
0xf8, 0xb2, 0xf3, 0xdf, 0x36, 0x88, 0x78, 0x5e, 0xe6, 0x88, 0xe7,
0xdb, 0x07, 0x11, 0xcf, 0xcb, 0x4d, 0xfd, 0x59, 0xa6, 0xef, 0xb3,
0x2d, 0xe4, 0xe3, 0xe5, 0x8a, 0xef, 0x22, 0xdf, 0x56, 0x7e, 0x97,
0xfd, 0xad, 0xd0, 0xfc, 0x94, 0xdf, 0xef, 0x31, 0x7a, 0x16, 0x71,
0xbf, 0xd9, 0xe0, 0xc5, 0xdc, 0x5f, 0x42, 0xf9, 0xfa, 0xbe, 0x48,
0xeb, 0xfb, 0x52, 0xf2, 0xf1, 0x62, 0xc5, 0x77, 0x92, 0xef, 0xaf,
0x66, 0xb3, 0x9f, 0x5a, 0xd5, 0x63, 0xe3, 0xb7, 0x95, 0xc2, 0xf1,
0x90, 0x36, 0xf1, 0x20, 0xef, 0x61, 0x1f, 0x42, 0x3e, 0x2c, 0x05,
0xff, 0xdc, 0x07, 0xf3, 0xb5, 0x40, 0x3e, 0xb4, 0x96, 0x98, 0x6f,
0x38, 0xff, 0xfd, 0x30, 0xff, 0x8a, 0x98, 0xf9, 0x07, 0x93, 0x6f,
0x2b, 0x63, 0xf2, 0x6d, 0x95, 0x23, 0xdf, 0x1e, 0x20, 0x77, 0x7c,
0x67, 0x21, 0xdf, 0x56, 0x82, 0xde, 0x55, 0xa0, 0xf7, 0x6b, 0x87,
0x5e, 0xd9, 0x6f, 0x3b, 0xdb, 0xaf, 0x36, 0xf9, 0xf0, 0x10, 0xf7,
0xd7, 0x42, 0x7e, 0xb4, 0x19, 0xbc, 0x1a, 0xf4, 0x3d, 0x08, 0xfe,
0x5c, 0x0b, 0xfe, 0x6c, 0x2b, 0xe1, 0x79, 0x45, 0x7d, 0xbf, 0x3c,
0xc2, 0xe3, 0x37, 0x98, 0x78, 0x7d, 0x94, 0xfb, 0x4f, 0x18, 0xfc,
0x18, 0xf7, 0x37, 0x1a, 0xfc, 0x38, 0xf7, 0x9f, 0x04, 0xfd, 0x1d,
0x06, 0x6f, 0x00, 0xfd, 0xeb, 0x41, 0xff, 0x46, 0xd0, 0xdf, 0x71,
0x02, 0xfa, 0x83, 0x78, 0xd8, 0x1c, 0x13, 0x0f, 0x5b, 0x1c, 0xf1,
0xf0, 0x54, 0x89, 0xf1, 0xb0, 0x19, 0xf4, 0x6e, 0x81, 0x78, 0xf8,
0x36, 0xc6, 0xdf, 0x4f, 0xc3, 0xf7, 0x5e, 0xa7, 0xe3, 0xfb, 0x5d,
0xf8, 0x6f, 0x80, 0xdf, 0x0a, 0xe3, 0xb7, 0xc6, 0x7c, 0xff, 0x6f,
0x83, 0x7a, 0xd8, 0x09, 0xf5, 0xa3, 0x86, 0xc2, 0xf5, 0xe3, 0xab,
0x18, 0xfd, 0xdb, 0xa9, 0xb0, 0xbe, 0x28, 0xfb, 0x1d, 0x6c, 0xdf,
0x65, 0xe2, 0x67, 0x27, 0xf7, 0x9f, 0x31, 0xf5, 0xb0, 0x59, 0x6b,
0x74, 0xb7, 0xd6, 0xd3, 0x25, 0xdc, 0x9e, 0x35, 0xf1, 0xd4, 0x0d,
0xcf, 0xe7, 0x39, 0xf8, 0xbe, 0x3e, 0x08, 0xf9, 0xd6, 0x05, 0xfa,
0x3e, 0x02, 0x3d, 0xcf, 0x3b, 0xfc, 0x97, 0x52, 0xff, 0x55, 0x18,
0xfb, 0x17, 0x22, 0xfe, 0x1e, 0x91, 0x8b, 0xf1, 0x7f, 0x16, 0xe2,
0x29, 0x78, 0xa5, 0x9c, 0x6d, 0xf8, 0xa8, 0xf7, 0x59, 0xb1, 0x7f,
0x11, 0xd6, 0xeb, 0x84, 0xe7, 0x57, 0x03, 0xe7, 0xd9, 0x26, 0x72,
0xff, 0xfd, 0xe8, 0x53, 0xc0, 0x1f, 0x83, 0xde, 0x57, 0x78, 0xfc,
0x2e, 0xf3, 0x7c, 0x5e, 0xe5, 0xfe, 0x4b, 0x06, 0xbf, 0xc6, 0xfd,
0x97, 0x01, 0xf7, 0x18, 0x7c, 0xad, 0x17, 0x3e, 0xaf, 0x76, 0x41,
0xbe, 0xf7, 0x80, 0xde, 0xef, 0xcc, 0xfa, 0x63, 0x74, 0xfc, 0xeb,
0xf0, 0x7e, 0x6f, 0xf7, 0xfb, 0x06, 0xf8, 0xe3, 0x4d, 0xf0, 0xc7,
0x4e, 0x88, 0xe7, 0xdd, 0x90, 0x9f, 0xbb, 0x1d, 0xf9, 0x39, 0xb6,
0xc0, 0xfa, 0x65, 0xa0, 0x6f, 0x8f, 0xd6, 0x8f, 0xd9, 0xca, 0xe3,
0xf3, 0xb3, 0x7a, 0xde, 0x1a, 0x02, 0xbd, 0x7b, 0x62, 0xf4, 0xee,
0x2d, 0x41, 0xef, 0xdb, 0x43, 0xa0, 0x77, 0x6f, 0x8c, 0xde, 0x7d,
0xa7, 0x98, 0xde, 0x7d, 0x31, 0x7a, 0xeb, 0x4b, 0xd0, 0xfb, 0xce,
0x10, 0xe8, 0xad, 0x77, 0xe4, 0xcf, 0xfe, 0x93, 0xb8, 0xbe, 0xf0,
0x07, 0x1c, 0xf5, 0x34, 0xa1, 0xf5, 0x2e, 0x0d, 0xfe, 0xa9, 0x28,
0xf0, 0xff, 0x3b, 0x41, 0x7d, 0x2b, 0xb6, 0xde, 0xc9, 0xdf, 0x47,
0x46, 0x0d, 0x42, 0x4f, 0xc6, 0x51, 0x7f, 0xfb, 0x40, 0x4f, 0x53,
0xcc, 0xf7, 0xc4, 0x26, 0x2a, 0x7d, 0xfd, 0x76, 0xc7, 0xfa, 0xfd,
0x27, 0xe0, 0x8f, 0xb8, 0xeb, 0x3f, 0x87, 0xa7, 0xe7, 0x64, 0x34,
0x02, 0x00, 0x00, 0x78, 0xda, 0x8d, 0x96, 0xcd, 0x4b, 0x56, 0x41,
0x14, 0x87, 0xef, 0x78, 0xad, 0x90, 0x30, 0x2c, 0x28, 0x50, 0x37,
0x11, 0xb4, 0x0b, 0xa4, 0x85, 0x44, 0x6e, 0x85, 0x36, 0x41, 0x9b,
0x5c, 0xf7, 0x1f, 0x84, 0xfe, 0x09, 0xa2, 0x56, 0x9a, 0x9a, 0x99,
0xf9, 0x11, 0xba, 0x6c, 0xd5, 0x22, 0x2a, 0xcc, 0xfc, 0xfe, 0x28,
0x84, 0x4a, 0xa3, 0x85, 0x56, 0xcb, 0x4c, 0x2b, 0x2d, 0x2b, 0xfb,
0xd0, 0x8d, 0xa6, 0x75, 0xe6, 0x36, 0xb7, 0x19, 0xe4, 0x9e, 0x97,
0x67, 0xe0, 0xc0, 0x9c, 0x97, 0xe7, 0xfd, 0x9d, 0x3b, 0xe7, 0x9c,
0x19, 0x4e, 0x14, 0xb1, 0xf5, 0x47, 0x56, 0xbe, 0xf2, 0x7b, 0xe8,
0xef, 0x28, 0xdc, 0xce, 0x2e, 0x6e, 0x1b, 0xea, 0xfd, 0x56, 0xb8,
0xdd, 0x6b, 0x4b, 0xe1, 0x8c, 0xb3, 0x74, 0x6d, 0x42, 0xbd, 0x0d,
0xa8, 0xb7, 0x0e, 0xb9, 0x5f, 0x90, 0xfb, 0x09, 0xb9, 0x1f, 0x90,
0xfb, 0x0e, 0xcf, 0xbb, 0x06, 0xf5, 0xbe, 0x29, 0x5c, 0x6c, 0x39,
0xe3, 0xc9, 0xaf, 0x0a, 0x97, 0x97, 0x70, 0xde, 0xff, 0x02, 0xe3,
0xae, 0x42, 0xbd, 0xcf, 0x90, 0xfb, 0x94, 0x83, 0x8b, 0x63, 0xef,
0xaf, 0xc0, 0xf3, 0x2e, 0xc3, 0xb8, 0x1f, 0xe1, 0x79, 0x3f, 0x40,
0xbd, 0xf7, 0x50, 0x6f, 0x09, 0xde, 0xb7, 0x45, 0xa8, 0xf7, 0x0e,
0x72, 0x0b, 0x30, 0xee, 0x5b, 0x98, 0xe7, 0x37, 0xb0, 0x9f, 0x5f,
0xc3, 0xef, 0x7b, 0x05, 0xb9, 0x79, 0x58, 0x8f, 0x17, 0x90, 0x9b,
0x85, 0x71, 0x67, 0x20, 0xf7, 0x1c, 0x72, 0xcf, 0xe0, 0xf7, 0x3d,
0x85, 0xdc, 0x13, 0xc8, 0x3d, 0x86, 0xdc, 0x14, 0xec, 0x83, 0x49,
0xa8, 0x37, 0x01, 0xf3, 0x32, 0x0e, 0xb9, 0x31, 0xc8, 0x8d, 0x42,
0x6e, 0x04, 0x72, 0xc3, 0x90, 0x1b, 0x82, 0xdc, 0x20, 0xe4, 0x1e,
0x41, 0x6e, 0x00, 0x72, 0x0f, 0x21, 0xd7, 0x0f, 0xeb, 0x7b, 0x3f,
0x87, 0x5e, 0xf0, 0x8c, 0x47, 0xf7, 0x20, 0xd7, 0x0b, 0xdf, 0x97,
0x5b, 0x90, 0xeb, 0x81, 0x5c, 0x37, 0xe4, 0xba, 0x20, 0xd7, 0x09,
0xb9, 0x9b, 0x90, 0xeb, 0x80, 0xdc, 0x0d, 0xc8, 0xb5, 0x43, 0xee,
0x3a, 0xec, 0x97, 0x36, 0x85, 0xdb, 0x63, 0xeb, 0x6b, 0xe2, 0x38,
0x65, 0xaf, 0x41, 0xae, 0x15, 0x72, 0x2d, 0x0a, 0x97, 0x9f, 0xcc,
0x11, 0xff, 0xb1, 0xa8, 0x59, 0xe1, 0xf6, 0x26, 0x9c, 0x17, 0xbc,
0x9a, 0xeb, 0xfd, 0x0b, 0x06, 0x93, 0x26, 0x98, 0x97, 0xc6, 0x5c,
0x73, 0x4e, 0x00, 0x5e, 0x81, 0xf7, 0xe3, 0x32, 0xac, 0xdb, 0x25,
0xf8, 0x8e, 0x37, 0x40, 0xbd, 0x7a, 0x78, 0x8e, 0x3a, 0x98, 0x17,
0xbb, 0x5f, 0x71, 0xf9, 0x4f, 0xce, 0xaf, 0xc4, 0x3d, 0x68, 0x67,
0x5e, 0x17, 0xc7, 0xae, 0x3b, 0x8a, 0xde, 0x31, 0x3b, 0x6b, 0x8b,
0x1d, 0x4a, 0xdf, 0xb9, 0xa0, 0x0f, 0x4c, 0x50, 0xb8, 0xd3, 0x56,
0x2b, 0xf8, 0xe3, 0xb4, 0x12, 0xb7, 0xc2, 0x71, 0xfb, 0xd2, 0x39,
0x59, 0x89, 0x7b, 0x5e, 0xac, 0x20, 0xf8, 0x61, 0x5b, 0xd1, 0xab,
0x72, 0xdc, 0x71, 0xe7, 0x17, 0x9a, 0xec, 0xbe, 0xea, 0x13, 0x2b,
0x33, 0x3e, 0x2f, 0xa5, 0x26, 0xfb, 0xdd, 0x7d, 0x20, 0x56, 0x2e,
0x7e, 0x71, 0xfa, 0xbd, 0xc6, 0xf7, 0xb3, 0x49, 0x96, 0x9b, 0x9b,
0xc4, 0xce, 0x99, 0x7f, 0xf7, 0xc6, 0xae, 0xb3, 0x26, 0xcc, 0x8b,
0x57, 0x5c, 0xb0, 0x67, 0x11, 0xaf, 0x24, 0xad, 0xa3, 0xf1, 0xf7,
0x2d, 0x90, 0x8b, 0xf6, 0xcb, 0xe6, 0xa2, 0xf1, 0x3d, 0xd9, 0x69,
0xb2, 0xfb, 0xea, 0x88, 0x6c, 0x6b, 0xc4, 0x8a, 0x9c, 0x7f, 0xd7,
0x64, 0xe7, 0xef, 0xa8, 0x38, 0xb5, 0x62, 0x07, 0xd2, 0x79, 0x46,
0x89, 0x7b, 0x42, 0x36, 0x6d, 0x41, 0xdc, 0x97, 0x4a, 0xdc, 0x53,
0xb2, 0xed, 0x0a, 0x02, 0x14, 0xe5, 0x65, 0xd7, 0xa3, 0x52, 0x98,
0xee, 0x80, 0x3b, 0xa9, 0x70, 0x67, 0x1c, 0x57, 0xe8, 0xfc, 0x6a,
0x85, 0xbb, 0x20, 0xcc, 0x6d, 0xb1, 0xc3, 0xe9, 0xbc, 0xa0, 0x70,
0xe3, 0xc2, 0x0c, 0x05, 0x71, 0xe7, 0x14, 0xee, 0x2f, 0xfb, 0xd6,
0x64, 0xfe, 0xed, 0x01, 0x00, 0x00, 0x78, 0xda, 0x4d, 0xd3, 0x4b,
0x6c, 0x4c, 0x51, 0x1c, 0xc7, 0xf1, 0xdb, 0xce, 0x4c, 0x37, 0xc2,
0x46, 0xc2, 0x82, 0x8d, 0xd6, 0xab, 0xea, 0xfd, 0x68, 0x19, 0xaf,
0x4b, 0xd1, 0xd2, 0x96, 0x96, 0x16, 0xd5, 0x96, 0x7a, 0x96, 0xa2,
0x1e, 0x55, 0x36, 0x12, 0x61, 0x63, 0x21, 0x62, 0x61, 0x27, 0xb1,
0x96, 0xb0, 0x92, 0x78, 0x2c, 0x44, 0x62, 0x41, 0x42, 0xec, 0xb0,
0x23, 0x62, 0x61, 0xe3, 0x91, 0x48, 0x24, 0x6c, 0x44, 0xe2, 0xfb,
0xef, 0xf9, 0x26, 0x35, 0x99, 0xdf, 0x3d, 0x9f, 0xfc, 0xf3, 0x3f,
0x67, 0xe6, 0x9e, 0x7b, 0x6e, 0x96, 0x8d, 0x7d, 0x8a, 0x59, 0x96,
0x57, 0x33, 0x7e, 0xaa, 0x4c, 0xae, 0xc1, 0x9f, 0x71, 0x05, 0x9e,
0x8e, 0xbf, 0x62, 0xbe, 0xf9, 0x0c, 0xfc, 0x53, 0xcf, 0xc4, 0x7f,
0x40, 0x01, 0xcf, 0xc2, 0xa5, 0xc2, 0x68, 0x3d, 0x0b, 0x8f, 0xd7,
0xb3, 0xc9, 0x64, 0x5d, 0x4b, 0xa6, 0x15, 0x52, 0xff, 0x1c, 0x5c,
0x67, 0x3d, 0x5c, 0xaf, 0xeb, 0x48, 0xa3, 0x9e, 0x4b, 0xda, 0xed,
0x9f, 0x87, 0xfb, 0xac, 0x87, 0x07, 0xf4, 0x7c, 0x32, 0xac, 0x17,
0x90, 0x4b, 0xf6, 0x2f, 0xc4, 0xd7, 0xac, 0x87, 0x6f, 0xea, 0x45,
0xe4, 0xb6, 0x5e, 0x4c, 0xee, 0xd8, 0xbf, 0x04, 0xdf, 0xb7, 0x1e,
0x7e, 0xa4, 0x97, 0x92, 0xa7, 0x7a, 0x19, 0x79, 0x9e, 0x9c, 0xd7,
0xe3, 0xd7, 0xba, 0x01, 0xbf, 0xd3, 0xcb, 0xf1, 0x47, 0xbd, 0x02,
0x7f, 0x71, 0xfd, 0x32, 0xfe, 0xe5, 0x3a, 0xe1, 0x42, 0x31, 0x79,
0x25, 0x99, 0xa8, 0x57, 0x91, 0x9a, 0x62, 0xea, 0x5f, 0x1d, 0xff,
0xc3, 0x7a, 0xb8, 0xac, 0xd7, 0xc4, 0xfe, 0xe8, 0xb5, 0xa4, 0xd5,
0xfe, 0x1c, 0x77, 0x59, 0x0f, 0xf7, 0xea, 0x75, 0xe4, 0xb0, 0x5e,
0x4f, 0x86, 0x92, 0xf3, 0x46, 0x7c, 0xc1, 0xb9, 0x1b, 0xf0, 0x15,
0x7b, 0xc2, 0xd7, 0xf5, 0x46, 0x72, 0x4b, 0x6f, 0x8a, 0xbd, 0x72,
0x6e, 0x13, 0x7e, 0xa0, 0x9b, 0xf1, 0x13, 0xbd, 0x19, 0xbf, 0xd4,
0x5b, 0xf0, 0x5b, 0xdd, 0x82, 0x3f, 0xe8, 0xd6, 0xd8, 0x13, 0xdd,
0x86, 0x5b, 0x3c, 0x3f, 0x5b, 0xf1, 0x6f, 0x7f, 0x2b, 0x5c, 0x51,
0x4a, 0xde, 0x46, 0x26, 0xe8, 0x76, 0x32, 0xa5, 0x94, 0xfa, 0x3b,
0xe2, 0x6c, 0x59, 0x0f, 0x37, 0xe8, 0xed, 0xa4, 0x59, 0xef, 0x20,
0xdd, 0xa5, 0x74, 0x9e, 0x3b, 0xf1, 0xa0, 0x73, 0xbb, 0xf0, 0x88,
0x3d, 0xe1, 0xcb, 0x7a, 0x27, 0xb9, 0xa1, 0x77, 0xc5, 0x39, 0x49,
0xce, 0x77, 0xe3, 0x7b, 0xba, 0x1b, 0x3f, 0xd6, 0x7b, 0xf0, 0x33,
0xdd, 0x83, 0x5f, 0xe9, 0x5e, 0xfc, 0x06, 0x57, 0xe1, 0x3e, 0x7c,
0x35, 0x4b, 0xde, 0xcb, 0xf8, 0x50, 0xef, 0x63, 0xfc, 0xae, 0xfb,
0x19, 0xef, 0xea, 0xfd, 0x8c, 0x2f, 0xf4, 0x01, 0xc6, 0xbf, 0xfa,
0x60, 0xec, 0x67, 0xe5, 0xe8, 0xab, 0x9a, 0x1f, 0xe2, 0xf2, 0x9e,
0xf5, 0x4b, 0xf1, 0x6c, 0xc9, 0x37, 0x7d, 0x24, 0xce, 0x98, 0x1e,
0xc8, 0xd2, 0xc4, 0xf0, 0x51, 0x32, 0x4e, 0x1f, 0x23, 0x93, 0xf4,
0x20, 0x99, 0xaa, 0x8f, 0x93, 0xea, 0xff, 0x5c, 0xab, 0x4f, 0xc4,
0x7b, 0xa2, 0x4f, 0xc6, 0x79, 0xd5, 0x43, 0xf1, 0xbe, 0x15, 0xc6,
0x5c, 0xd6, 0xa7, 0x48, 0x93, 0x3e, 0x4d, 0x3a, 0xf5, 0x99, 0x38,
0x5b, 0xce, 0x3d, 0x4b, 0xda, 0xf4, 0x70, 0x3c, 0x03, 0x7d, 0x8e,
0xf4, 0xe8, 0x11, 0xd2, 0x5f, 0x95, 0xee, 0xf7, 0x7c, 0xdc, 0xa7,
0xf5, 0x8b, 0xe4, 0x07, 0x6b, 0xfe, 0x03, 0xe3, 0x54, 0x5c, 0x52,
0x7a, 0x00, 0x00, 0x00, 0x78, 0xda, 0x45, 0xcc, 0x31, 0x0f, 0x82,
0x30, 0x10, 0x86, 0xe1, 0x53, 0xa4, 0x82, 0x80, 0xe0, 0xc2, 0xe4,
0xe4, 0xc6, 0x64, 0xc2, 0x28, 0x2b, 0x09, 0x13, 0x1b, 0x4e, 0x2e,
0xfe, 0x7f, 0x06, 0x27, 0x76, 0xde, 0xe6, 0xbe, 0xc4, 0x26, 0x4f,
0xee, 0x4d, 0x7b, 0xa9, 0xd9, 0xff, 0x1c, 0x34, 0xd7, 0xd4, 0x3b,
0xda, 0xe8, 0xa3, 0x39, 0x0b, 0x3e, 0x13, 0x14, 0xf4, 0xc9, 0x5c,
0x1b, 0x7c, 0x97, 0x55, 0xbb, 0x07, 0x7f, 0x67, 0xd8, 0x43, 0xfb,
0xb1, 0x3b, 0xf5, 0x19, 0xbd, 0x3a, 0xc3, 0xa0, 0xfd, 0x1c, 0xcf,
0xc4, 0xef, 0x63, 0xbf, 0xd4, 0x17, 0x4c, 0xea, 0x02, 0x8b, 0xba,
0xc4, 0xa8, 0x7f, 0x2a, 0xcc, 0xea, 0x2b, 0xde, 0xea, 0x1a, 0x1f,
0x75, 0x83, 0xaf, 0xfa, 0x86, 0x1f, 0xff, 0xec, 0x4f, 0xce, 0x07,
0xa2, 0xdd, 0x01, 0x00, 0x00, 0x78, 0xda, 0xed, 0xd4, 0x3b, 0x4c,
0x53, 0x51, 0x18, 0xc0, 0xf1, 0xd3, 0xf2, 0x50, 0x5a, 0xc5, 0x82,
0x0a, 0xbe, 0x4a, 0xab, 0xa0, 0x88, 0xa0, 0x52, 0xaa, 0x3c, 0x04,
0xea, 0xbd, 0xb7, 0xbd, 0x50, 0x40, 0x79, 0xf9, 0x80, 0xa2, 0x68,
0x6d, 0xa1, 0x71, 0x31, 0x1a, 0x17, 0x37, 0xb9, 0x23, 0x83, 0x83,
0x71, 0x12, 0x53, 0x08, 0x13, 0x33, 0x83, 0x9b, 0x4b, 0x47, 0x46,
0x37, 0x98, 0x08, 0x2e, 0xc6, 0x91, 0xc4, 0xc1, 0x51, 0xfe, 0xf7,
0xde, 0x43, 0x2c, 0x4d, 0x24, 0x04, 0x0a, 0x13, 0x27, 0xfd, 0xf5,
0xcb, 0x97, 0x9c, 0xc7, 0xd7, 0x73, 0xbf, 0x5b, 0x21, 0x0e, 0xc7,
0x41, 0x8f, 0x07, 0x78, 0x84, 0x11, 0x3c, 0xc4, 0x63, 0x8c, 0x22,
0x95, 0x35, 0xc7, 0x01, 0x27, 0x0a, 0x50, 0x88, 0x22, 0x14, 0xe3,
0x08, 0x8e, 0xa2, 0x04, 0x2e, 0xb8, 0x71, 0x0c, 0xc7, 0x51, 0x8a,
0x13, 0xf0, 0x6c, 0x39, 0xcd, 0xb8, 0xcb, 0x97, 0xc2, 0x07, 0x86,
0x52, 0x96, 0xa7, 0xfd, 0xcd, 0x7d, 0xca, 0x71, 0x12, 0xa7, 0x70,
0x1a, 0x15, 0xa8, 0xc4, 0x19, 0x9c, 0xc5, 0x39, 0x9c, 0xc7, 0x05,
0x78, 0x51, 0x05, 0x1f, 0xfc, 0xb8, 0x88, 0x4b, 0xa8, 0x46, 0x0d,
0x2e, 0xe3, 0x0a, 0x6a, 0x71, 0x15, 0x75, 0xb8, 0x86, 0x7a, 0x34,
0xe0, 0x3a, 0x6e, 0xe0, 0x26, 0x1a, 0x11, 0x40, 0x13, 0x82, 0xb8,
0x85, 0xdb, 0x68, 0x46, 0x0b, 0x5a, 0xd1, 0x86, 0x3b, 0x68, 0x47,
0x07, 0x3a, 0x11, 0x82, 0xbc, 0x0c, 0xa1, 0x42, 0x43, 0x18, 0x11,
0xe8, 0xe8, 0x42, 0x37, 0xa2, 0xe8, 0x41, 0x2f, 0xfa, 0x70, 0x0f,
0xf7, 0xd1, 0x8f, 0x01, 0x0c, 0x62, 0x08, 0xc3, 0xd6, 0x4d, 0x36,
0xaa, 0x2e, 0x79, 0x9f, 0x6e, 0x79, 0x0f, 0x3e, 0x59, 0x7f, 0x50,
0x9e, 0xdb, 0x2d, 0xe7, 0x3f, 0xc1, 0xa4, 0x8c, 0x4f, 0x31, 0x8e,
0x67, 0x78, 0x8e, 0x38, 0x62, 0x98, 0x40, 0x02, 0x49, 0x39, 0x37,
0x7b, 0xbc, 0xc6, 0x3b, 0x4c, 0xc9, 0xfc, 0xe3, 0x4e, 0x9a, 0x2d,
0x9a, 0xd6, 0xc5, 0x67, 0xfc, 0x42, 0xeb, 0xac, 0x2e, 0x06, 0x89,
0x71, 0xbc, 0xc4, 0x77, 0x72, 0xff, 0x9c, 0x2e, 0xa6, 0xbf, 0xe9,
0xff, 0x16, 0xac, 0x73, 0x25, 0x6f, 0x60, 0xa8, 0x2b, 0x64, 0x3f,
0xf7, 0xd0, 0xe7, 0x2e, 0xc7, 0x66, 0xff, 0x6d, 0x32, 0xaf, 0x5c,
0xd1, 0x4a, 0x64, 0xdf, 0x78, 0xe5, 0xf3, 0x0e, 0xc8, 0xe7, 0x24,
0xc4, 0xbc, 0x62, 0x17, 0x92, 0x51, 0x06, 0xac, 0xb8, 0xa6, 0xc4,
0xec, 0xad, 0xd4, 0xa4, 0x15, 0x3c, 0xea, 0x2b, 0x2b, 0xfa, 0xd5,
0xb1, 0xff, 0x9c, 0xf9, 0x65, 0x66, 0x26, 0x94, 0xcf, 0x77, 0xd5,
0xb5, 0x5c, 0x4d, 0xfb, 0x2c, 0x51, 0xb7, 0x61, 0xb6, 0x4b, 0xa4,
0xce, 0xfa, 0x4d, 0x56, 0x1b, 0xe5, 0x0c, 0x7f, 0x64, 0xbf, 0xff,
0x37, 0x12, 0x9c, 0xfd, 0xd6, 0x91, 0x8f, 0x9d, 0xcc, 0x5a, 0xcd,
0xe7, 0xbc, 0xfb, 0xf1, 0x22, 0x27, 0xff, 0x41, 0x5d, 0xbf, 0xf1,
0xd7, 0xae, 0x2f, 0xec, 0x73, 0x6e, 0xb7, 0xba, 0x9c, 0xb3, 0xff,
0x60, 0x2d, 0xac, 0x30, 0xaf, 0x0f, 0xc3, 0x88, 0x6f, 0xbb, 0x26,
0x15, 0x16, 0xc6, 0x2a, 0x6b, 0x32, 0xbc, 0xba, 0x5f, 0xb5, 0xf7,
0xd6, 0xdc, 0x28, 0xf9, 0x3c, 0xf9, 0x07, 0x6d, 0xda, 0xce, 0xb5,
0x4f, 0x56, 0x5c, 0x57, 0xd3, 0xc4, 0x05, 0x2c, 0xe6, 0xec, 0xb9,
0x01, 0xd2, 0xd6, 0x52, 0xfa
0x0d, 0x0a, 0x0d, 0x0a, 0x0f, 0x03, 0x00, 0x00, 0x78, 0xda, 0x65,
0x94, 0x4b, 0x73, 0xdc, 0x20, 0x0c, 0x80, 0x75, 0xee, 0xaf, 0xe8,
0xa5, 0xc7, 0x36, 0xcd, 0xa3, 0xcf, 0x5b, 0x5f, 0x69, 0x7b, 0xe8,
0x4c, 0x26, 0x99, 0xe4, 0x58, 0x8f, 0x16, 0x64, 0x9b, 0x09, 0x06,
0x17, 0xf0, 0x3a, 0xec, 0xaf, 0xaf, 0x00, 0x9b, 0x78, 0x93, 0x83,
0xad, 0x4f, 0x20, 0x04, 0x48, 0x42, 0xd0, 0x4f, 0xf2, 0xc4, 0x4c,
0x43, 0xf3, 0x16, 0x56, 0x3a, 0xad, 0x74, 0x56, 0xe9, 0xbc, 0xd2,
0x45, 0xa5, 0x77, 0x95, 0xde, 0x57, 0xfa, 0x50, 0xe9, 0x63, 0xa5,
0x4f, 0x95, 0x5e, 0x67, 0x12, 0xfd, 0xe9, 0x22, 0xcf, 0x16, 0x79,
0x0e, 0xf7, 0x4a, 0x6b, 0x98, 0x3c, 0x81, 0x74, 0x76, 0x04, 0x8f,
0x31, 0x7d, 0x4d, 0x20, 0x1c, 0x80, 0xd2, 0x4a, 0x14, 0x41, 0xed,
0x55, 0x88, 0xa0, 0x4c, 0x6b, 0x61, 0x74, 0xb6, 0x83, 0x4e, 0xed,
0x09, 0x3a, 0x2b, 0xa1, 0xd5, 0x11, 0x8c, 0x0d, 0xe8, 0x3a, 0x0a,
0x0c, 0x42, 0xab, 0x11, 0x66, 0xc2, 0xd1, 0xd0, 0x43, 0xc8, 0x30,
0x3a, 0xda, 0x83, 0x70, 0xd6, 0xfb, 0x1e, 0x95, 0x83, 0x5f, 0xb7,
0xdf, 0x9b, 0xdf, 0x46, 0x85, 0x0c, 0xd7, 0x64, 0x24, 0xb9, 0xcf,
0x2f, 0x77, 0x28, 0x5f, 0x0a, 0xed, 0xdf, 0xf8, 0x80, 0x81, 0x36,
0x33, 0x19, 0x6f, 0xc2, 0x24, 0x95, 0xfd, 0xb1, 0x27, 0x53, 0x16,
0xdd, 0x8e, 0x92, 0xad, 0x7e, 0x98, 0xa0, 0x82, 0x22, 0x0f, 0x83,
0xf2, 0xe2, 0x24, 0xa0, 0xbe, 0x7f, 0x33, 0xe3, 0x1e, 0xfe, 0xbe,
0x7f, 0xe5, 0x5f, 0x64, 0xb3, 0x2b, 0x74, 0x9e, 0xfe, 0x90, 0xf7,
0xd8, 0x15, 0x97, 0x37, 0xfd, 0x14, 0xa4, 0x9d, 0x0d, 0xbc, 0x52,
0x59, 0xff, 0xee, 0x70, 0xbe, 0x54, 0xa4, 0x65, 0xd6, 0x2e, 0x51,
0xd2, 0x17, 0x3d, 0xf6, 0x08, 0xc2, 0x0e, 0x83, 0x35, 0x27, 0x2d,
0x07, 0xa5, 0x71, 0x24, 0x42, 0x35, 0xfe, 0x8a, 0xee, 0xf7, 0xb0,
0x7a, 0x4b, 0x03, 0xdf, 0xf8, 0x48, 0xe4, 0xea, 0xf0, 0xb2, 0x70,
0x87, 0xae, 0xd9, 0xa1, 0xb8, 0xdf, 0xea, 0xda, 0xa2, 0xdc, 0xfa,
0xf9, 0x49, 0x86, 0x9c, 0x12, 0xcf, 0x3d, 0x3d, 0x9d, 0xb8, 0xe6,
0x03, 0xa0, 0xe9, 0x34, 0x5d, 0x6d, 0x06, 0xaf, 0x9e, 0xad, 0x4c,
0x23, 0x42, 0x37, 0x9a, 0xf6, 0xa4, 0x7d, 0x6f, 0x43, 0x63, 0x70,
0x20, 0xf0, 0xa2, 0xec, 0xac, 0x4c, 0xb7, 0x1e, 0x66, 0xa8, 0x03,
0x69, 0x32, 0x85, 0x23, 0x1f, 0xed, 0x6e, 0x09, 0xf8, 0x95, 0xc6,
0x7f, 0x13, 0x41, 0x3a, 0x7e, 0xe7, 0xec, 0x64, 0xe4, 0x89, 0x1f,
0x35, 0xfa, 0xbe, 0x1a, 0xdc, 0x14, 0x75, 0xf1, 0x66, 0x38, 0xe7,
0x23, 0x72, 0xe5, 0xc8, 0xec, 0x8e, 0x77, 0x9e, 0xb3, 0xfa, 0xb8,
0x5b, 0x51, 0x73, 0x3e, 0xac, 0x0f, 0x4b, 0x56, 0x53, 0xdd, 0xb5,
0x28, 0xe8, 0xb4, 0xd2, 0x59, 0xa5, 0xf3, 0x4a, 0x17, 0x95, 0xde,
0xd5, 0xed, 0x73, 0x1e, 0x55, 0x8a, 0x07, 0x9f, 0x23, 0xb2, 0xab,
0xbb, 0xe6, 0x1b, 0x6a, 0x71, 0x4d, 0xad, 0xa4, 0x16, 0x46, 0xae,
0xb4, 0xd9, 0x3a, 0xce, 0xe8, 0xc0, 0x05, 0x98, 0x22, 0xe0, 0x08,
0x75, 0x50, 0x0c, 0xad, 0x63, 0x35, 0xd3, 0x5e, 0x11, 0xdb, 0x74,
0xab, 0x6c, 0x1e, 0x2a, 0xc5, 0x4a, 0x87, 0x4c, 0x39, 0xee, 0x7e,
0x83, 0x8b, 0xed, 0xa2, 0xc4, 0xad, 0xc2, 0x2b, 0x9a, 0xd6, 0xba,
0x19, 0x9d, 0x7c, 0xa4, 0x64, 0x5f, 0x39, 0x6e, 0x38, 0x59, 0x3b,
0xd5, 0xf5, 0x61, 0x95, 0xd9, 0xb2, 0x50, 0xac, 0x94, 0xac, 0xa6,
0x31, 0xff, 0xf2, 0x3c, 0x8b, 0x58, 0xc4, 0x01, 0xac, 0x29, 0xf9,
0x81, 0x12, 0x07, 0x7e, 0xa5, 0x30, 0xf3, 0xab, 0x70, 0xb9, 0x02,
0xb8, 0x14, 0x14, 0x97, 0x45, 0xab, 0xb1, 0xf3, 0xa9, 0x2c, 0x36,
0x97, 0x39, 0xd2, 0xd8, 0xeb, 0xb1, 0x1e, 0x9f, 0xe8, 0x07, 0xf0,
0x6a, 0x48, 0x0e, 0x8b, 0x60, 0xfb, 0x05, 0xe2, 0x0a, 0xd9, 0x22,
0x85, 0xb3, 0x88, 0x62, 0x51, 0x82, 0xb9, 0xc0, 0x01, 0x94, 0xe4,
0x2c, 0x8c, 0x2a, 0x88, 0x3e, 0x47, 0xac, 0xa7, 0x72, 0xf3, 0x8a,
0x4b, 0x58, 0x17, 0x25, 0x6e, 0x95, 0x03, 0xf4, 0x29, 0x83, 0x3d,
0x27, 0xf4, 0xa1, 0xa1, 0xfa, 0xe4, 0xf1, 0xa1, 0xdc, 0xd0, 0x83,
0x26, 0x37, 0x72, 0x6e, 0x05, 0xb7, 0x26, 0xbe, 0x3d, 0xf7, 0x02,
0xaf, 0xac, 0x01, 0x49, 0x83, 0x4d, 0x81, 0xc9, 0xcf, 0x70, 0x9c,
0x8c, 0xe8, 0xf3, 0x85, 0x36, 0xc8, 0x7b, 0x6e, 0x94, 0xb8, 0x55,
0x0e, 0x8f, 0xdd, 0xaa, 0xac, 0x3a, 0x56, 0x53, 0xd0, 0x8e, 0x07,
0xe2, 0xd3, 0x81, 0x52, 0x3e, 0xf9, 0xb8, 0x11, 0x76, 0x9a, 0x2b,
0xb7, 0x11, 0x56, 0x5b, 0xb7, 0x65, 0x76, 0xb3, 0xd5, 0x8e, 0xec,
0xd8, 0x41, 0xd1, 0x30, 0x37, 0x24, 0x7e, 0x5a, 0x44, 0x26, 0x85,
0xb6, 0x40, 0x5c, 0x61, 0x5e, 0xa1, 0x87, 0x64, 0xed, 0xa3, 0x6f,
0x3a, 0x6d, 0x77, 0xa8, 0x53, 0x9e, 0xd1, 0xfb, 0xfc, 0x04, 0xca,
0x48, 0xc6, 0xc1, 0x4a, 0xd2, 0x8a, 0xdf, 0x11, 0xbb, 0x4a, 0xc5,
0x53, 0x90, 0xef, 0xad, 0x0c, 0x70, 0x27, 0xe0, 0xe7, 0x94, 0x2d,
0xc0, 0x72, 0xfd, 0xa5, 0xa1, 0x2c, 0x78, 0xdf, 0x05, 0xe2, 0x0a,
0x07, 0x6e, 0xba, 0xc6, 0xe7, 0x1f, 0xcf, 0x66, 0x11, 0x8b, 0x38,
0xa4, 0xdc, 0xe4, 0x04, 0xe5, 0x99, 0x24, 0x62, 0x11, 0x5c, 0x28,
0x56, 0x2b, 0xee, 0x13, 0xc4, 0x0d, 0xc6, 0x08, 0x02, 0x6a, 0x5b,
0xee, 0x6d, 0xbe, 0xbc, 0x4c, 0xd8, 0x59, 0xc9, 0xd7, 0xba, 0xe7,
0x5d, 0xd7, 0x9b, 0xb4, 0xa9, 0x35, 0x7b, 0x40, 0x55, 0xca, 0x18,
0xfe, 0x03, 0xef, 0x12, 0x9d, 0x72, 0xb0, 0x05, 0x00, 0x00, 0x78,
0xda, 0xcd, 0x59, 0x6b, 0x6c, 0x54, 0x45, 0x14, 0xbe, 0xa7, 0xd0,
0x02, 0x25, 0x44, 0x4d, 0x6d, 0xb1, 0x22, 0x6e, 0x2b, 0x92, 0x68,
0xea, 0x23, 0x56, 0x5d, 0x40, 0xa5, 0xbe, 0x5d, 0xc5, 0xe2, 0x0b,
0xc5, 0x94, 0x60, 0x48, 0xb0, 0x8a, 0x82, 0x82, 0x5a, 0x83, 0x81,
0x60, 0xe8, 0x6e, 0x51, 0xa8, 0x4d, 0x48, 0x48, 0x4c, 0x48, 0x10,
0x29, 0x01, 0x49, 0x10, 0xd4, 0xe2, 0x03, 0x83, 0x89, 0xa8, 0xd4,
0x60, 0x78, 0x68, 0x2b, 0x16, 0x34, 0x1a, 0xff, 0x0b, 0xf2, 0xee,
0x2e, 0x45, 0x7c, 0xd5, 0x33, 0xb9, 0x67, 0xb3, 0xe7, 0x7e, 0xde,
0x9d, 0xd9, 0x6d, 0x43, 0xc3, 0x26, 0xd3, 0x3b, 0xdf, 0x7e, 0x67,
0x66, 0xbe, 0x39, 0xf7, 0x9c, 0x33, 0xf7, 0x6e, 0x3d, 0x2f, 0xf8,
0x89, 0x70, 0x6b, 0xe4, 0xd6, 0x2d, 0xb8, 0x4c, 0xfa, 0xbf, 0x70,
0x4b, 0x72, 0xab, 0x96, 0xeb, 0x10, 0xe1, 0x1b, 0x94, 0x6d, 0x8a,
0x5b, 0x0b, 0xb7, 0x5f, 0xa5, 0x3f, 0x98, 0xdb, 0x0d, 0xdc, 0xf6,
0xc2, 0xfc, 0xdd, 0xc2, 0x9b, 0x4f, 0x91, 0xe0, 0xb8, 0x5c, 0x27,
0x72, 0x3b, 0xd3, 0xdb, 0xdb, 0xab, 0xed, 0x4f, 0xc9, 0x5c, 0x5e,
0x96, 0xf9, 0x7a, 0x1c, 0xfc, 0x69, 0x07, 0xff, 0x07, 0xf0, 0xef,
0x00, 0x7f, 0xc6, 0xc1, 0xff, 0xe9, 0xe0, 0xff, 0x72, 0xf0, 0x7f,
0x3b, 0xf8, 0x7f, 0x1c, 0xfc, 0xbf, 0x0e, 0xbe, 0xd7, 0xc1, 0x7b,
0x64, 0xe7, 0xc9, 0xc1, 0x17, 0x38, 0xf8, 0x41, 0x0e, 0x7e, 0xb0,
0x83, 0x2f, 0x74, 0xf0, 0x45, 0x0e, 0x7e, 0x88, 0xe2, 0x0d, 0x1e,
0x4a, 0x99, 0xf8, 0x8d, 0x48, 0xec, 0x15, 0x0b, 0x8e, 0x72, 0x5b,
0xe5, 0x65, 0xff, 0xcc, 0xe4, 0x36, 0x8c, 0xc7, 0x0f, 0x17, 0x7c,
0x3d, 0xb7, 0x13, 0x16, 0x7b, 0xc3, 0x1f, 0x77, 0xf0, 0x27, 0x01,
0x1f, 0xb3, 0xd8, 0x1b, 0xbd, 0xc5, 0xb0, 0xdf, 0x66, 0x8b, 0xfd,
0x2c, 0xd9, 0x5f, 0x8f, 0xe4, 0x94, 0xc1, 0x09, 0x93, 0x13, 0x0a,
0x37, 0x01, 0xbf, 0x44, 0xf1, 0x98, 0x8f, 0x61, 0xfe, 0x18, 0xae,
0xfc, 0x71, 0xae, 0x7f, 0xcc, 0xfe, 0x4a, 0x28, 0xb8, 0xdf, 0x0b,
0x01, 0x97, 0x02, 0x2e, 0x03, 0x3c, 0x12, 0xf0, 0x45, 0x80, 0xcb,
0x01, 0x5f, 0x0c, 0x78, 0x14, 0xe0, 0x4b, 0x18, 0x9f, 0xb2, 0xf8,
0xd8, 0x73, 0xc4, 0xcf, 0x0e, 0xb8, 0x1f, 0xa3, 0x79, 0xbe, 0x12,
0xc5, 0xef, 0xc2, 0x7c, 0xf6, 0x82, 0xf9, 0x50, 0x01, 0xf9, 0x50,
0x49, 0xc1, 0x7c, 0xf8, 0x51, 0x8d, 0x37, 0xf1, 0x70, 0x3e, 0xac,
0xdf, 0x1e, 0x32, 0xff, 0xa5, 0xe4, 0xe3, 0x62, 0xe9, 0x27, 0xa4,
0xe6, 0x57, 0xcb, 0x75, 0x90, 0xb2, 0xbf, 0x0c, 0xe2, 0xf9, 0x67,
0x98, 0x1f, 0xf5, 0x8f, 0x81, 0x7c, 0x26, 0x75, 0x1e, 0xdd, 0xc8,
0x6d, 0x29, 0xe8, 0x2d, 0x54, 0xb8, 0x4a, 0xce, 0x37, 0x1d, 0x0f,
0x26, 0xde, 0x8f, 0x41, 0x3e, 0x24, 0x05, 0xa3, 0xbd, 0xd1, 0xb3,
0x07, 0xe6, 0x8b, 0x3b, 0xf2, 0xb5, 0x1a, 0xf4, 0x5e, 0x4e, 0x41,
0xbd, 0xad, 0xca, 0xbe, 0x52, 0xf6, 0x53, 0x45, 0x19, 0xfb, 0x2a,
0xf0, 0xcf, 0xda, 0x10, 0x7f, 0x5f, 0x2d, 0xf6, 0x15, 0x46, 0x23,
0xf7, 0xaf, 0x55, 0xfe, 0xbf, 0x82, 0xfc, 0x3d, 0x68, 0xff, 0x17,
0xa8, 0xf1, 0x51, 0xf2, 0x6d, 0xd2, 0xf6, 0x57, 0x3a, 0xec, 0xc7,
0x91, 0x6f, 0xa3, 0x9f, 0x17, 0xae, 0xa2, 0xcc, 0xf3, 0x82, 0xe9,
0x1b, 0x3d, 0x7a, 0xfc, 0x38, 0x75, 0xde, 0x1b, 0x3e, 0x2e, 0xdf,
0xe3, 0xfe, 0x22, 0xc2, 0xeb, 0x78, 0x4c, 0x41, 0x7d, 0x5e, 0xaf,
0xf6, 0x5f, 0x2f, 0xfb, 0x2f, 0x87, 0xe7, 0x97, 0x6b, 0x28, 0x73,
0xff, 0xc7, 0x80, 0xbf, 0xe2, 0xc0, 0x57, 0x02, 0x9f, 0x00, 0x3e,
0x02, 0x7c, 0x13, 0xf0, 0xa3, 0x81, 0x5f, 0x02, 0xfc, 0x28, 0xe0,
0x27, 0x52, 0x90, 0x2f, 0x07, 0xfe, 0x56, 0xe0, 0x47, 0x02, 0x7f,
0x3b, 0xf0, 0xa5, 0xc0, 0xdf, 0x09, 0x7c, 0x09, 0xf0, 0x77, 0x03,
0x7f, 0x01, 0xf0, 0x31, 0xe0, 0xcf, 0x0b, 0x79, 0x3e, 0xd4, 0xfc,
0x08, 0xc8, 0x27, 0x73, 0xbe, 0x1e, 0x54, 0xf9, 0x34, 0x9e, 0xf1,
0x21, 0x85, 0x27, 0x30, 0xfe, 0x5d, 0xe1, 0x9b, 0x18, 0x1f, 0x56,
0xf8, 0x66, 0xc6, 0x47, 0x14, 0xbe, 0x85, 0xf1, 0x51, 0x85, 0x6b,
0x28, 0x98, 0xaf, 0xb7, 0x31, 0x3e, 0xae, 0xf0, 0x1d, 0x8c, 0x4f,
0x28, 0x7c, 0x17, 0xe3, 0x93, 0x0a, 0xdf, 0xc3, 0xb8, 0x5b, 0x9d,
0x6f, 0x49, 0x55, 0x7b, 0x1b, 0xd4, 0xde, 0xf0, 0x79, 0x36, 0x25,
0xf9, 0x35, 0x16, 0xe2, 0x35, 0xa5, 0xea, 0x4f, 0x85, 0xe4, 0x5b,
0xb1, 0xc2, 0x26, 0x17, 0x47, 0x40, 0xfc, 0xa5, 0x6b, 0xe8, 0x78,
0x6e, 0x1d, 0xca, 0x7f, 0xf7, 0xca, 0xf8, 0xb1, 0x14, 0xcc, 0x87,
0x64, 0x48, 0xfe, 0x98, 0xab, 0xd1, 0xbf, 0xdb, 0x72, 0x76, 0x18,
0x1d, 0xf7, 0x59, 0xf2, 0x19, 0xeb, 0xdb, 0x50, 0xb3, 0x3f, 0x19,
0x73, 0x3f, 0xf9, 0xb1, 0x65, 0xae, 0x93, 0x28, 0xb7, 0xf1, 0xa6,
0xd6, 0x1a, 0x5b, 0x93, 0x03, 0xb5, 0xe4, 0xeb, 0x7f, 0x00, 0xfc,
0x55, 0x0b, 0xf9, 0x1d, 0x83, 0xf3, 0xe6, 0xc3, 0x90, 0xfa, 0x56,
0x4b, 0x19, 0x7d, 0x93, 0x44, 0x5b, 0x4a, 0xea, 0x4d, 0x4a, 0x78,
0xad, 0xaf, 0xd0, 0x0b, 0xb7, 0x27, 0xe1, 0xe3, 0xca, 0x2e, 0x3d,
0x7e, 0x32, 0xf9, 0xfb, 0x99, 0x4c, 0xff, 0xaf, 0x17, 0xe9, 0xef,
0x90, 0x37, 0xdd, 0x07, 0xf9, 0xcf, 0x4c, 0xca, 0xd4, 0xb3, 0x46,
0x2f, 0x7b, 0x7c, 0x18, 0xfc, 0x64, 0x0e, 0xfb, 0x7d, 0x0c, 0xea,
0xf9, 0x0c, 0xca, 0xac, 0x37, 0x85, 0x7c, 0x7e, 0xba, 0xf8, 0xb7,
0x1e, 0xfc, 0x3b, 0x05, 0xfc, 0xfb, 0x54, 0x0e, 0xeb, 0xd5, 0x51,
0xf0, 0xfc, 0xd7, 0xf3, 0x3d, 0x0a, 0xf3, 0xd5, 0xe7, 0x30, 0xdf,
0x13, 0x14, 0xc4, 0xd3, 0x14, 0x7e, 0x98, 0xfb, 0x53, 0x15, 0x7e,
0x84, 0xfb, 0x8f, 0xab, 0xfd, 0x4e, 0x85, 0xf5, 0x1f, 0xa2, 0x60,
0x7e, 0xd5, 0x41, 0x7e, 0xcd, 0xc8, 0x23, 0xbf, 0xc2, 0xe6, 0x7f,
0x1a, 0xe6, 0x9f, 0xee, 0x98, 0x7f, 0x16, 0x65, 0x9f, 0x1f, 0x3f,
0x26, 0xfe, 0x9e, 0x63, 0xfb, 0xd9, 0x14, 0x8c, 0xb7, 0xf4, 0xf3,
0x90, 0xe1, 0x23, 0xcc, 0xcd, 0x91, 0x1c, 0x2f, 0x94, 0xf7, 0xeb,
0x84, 0x5c, 0xcd, 0x7a, 0xcf, 0x80, 0xde, 0x67, 0x2d, 0xe7, 0x63,
0x44, 0xc6, 0x69, 0xbd, 0xb3, 0x95, 0x5e, 0x83, 0xe7, 0xa8, 0xe7,
0xc3, 0x09, 0xdc, 0x7e, 0xb3, 0xe8, 0x37, 0xb7, 0xe5, 0xf9, 0xb3,
0x10, 0xdf, 0x2f, 0x41, 0x7c, 0x27, 0x28, 0x18, 0x5f, 0x7a, 0xfe,
0x17, 0xfa, 0x10, 0xcf, 0x0b, 0x2c, 0xf1, 0xfc, 0x62, 0x1f, 0xe2,
0x79, 0xa1, 0xaa, 0x3f, 0x0b, 0xe4, 0x79, 0x76, 0x11, 0xf9, 0x78,
0xa1, 0xe0, 0x57, 0xc9, 0xb7, 0x35, 0xdf, 0x9b, 0xfd, 0x2d, 0x96,
0xfc, 0x34, 0xdf, 0x37, 0x2a, 0x3d, 0x73, 0xb9, 0xdf, 0xa0, 0xf0,
0x3c, 0xee, 0xbf, 0x4c, 0x99, 0xfa, 0x3e, 0x57, 0xea, 0xfb, 0x7c,
0xf2, 0xf1, 0x3c, 0xc1, 0xaf, 0x90, 0xef, 0xaf, 0x06, 0xb5, 0x9f,
0x0a, 0xd1, 0xa3, 0xe3, 0x37, 0x41, 0xc1, 0x78, 0x88, 0xab, 0x78,
0x30, 0xcf, 0x61, 0x9d, 0x90, 0x0f, 0xf3, 0xc1, 0x3f, 0xaf, 0xc1,
0x7c, 0x8b, 0x20, 0x1f, 0x12, 0x79, 0xe6, 0x1b, 0xce, 0xff, 0x3a,
0xcc, 0xbf, 0xd8, 0x31, 0x7f, 0x5f, 0xf2, 0x6d, 0x99, 0x23, 0xdf,
0x9a, 0x2d, 0xf9, 0xb6, 0x94, 0xec, 0xf1, 0x9d, 0x84, 0x7c, 0x5b,
0x06, 0x7a, 0x9b, 0x41, 0xef, 0x21, 0x8b, 0x5e, 0xb3, 0xdf, 0x37,
0xd9, 0xbe, 0x45, 0xe5, 0xc3, 0x4a, 0xee, 0x2f, 0x87, 0xfc, 0x58,
0xa1, 0x70, 0x0b, 0xe8, 0x7b, 0x03, 0xfc, 0xb9, 0x1c, 0xfc, 0xb9,
0x22, 0x8f, 0xfb, 0x15, 0xf6, 0xfe, 0xf2, 0x16, 0x8f, 0x6f, 0x55,
0xf1, 0xba, 0x9a, 0xfb, 0x6b, 0x15, 0x7e, 0x9b, 0xfb, 0xeb, 0x14,
0x5e, 0xc3, 0xfd, 0xf5, 0xa0, 0x7f, 0x83, 0xc2, 0xad, 0xa0, 0x7f,
0x15, 0xe8, 0x5f, 0x07, 0xfa, 0x37, 0xf4, 0x43, 0x7f, 0x3a, 0x1e,
0x36, 0x39, 0xe2, 0x61, 0xb3, 0x25, 0x1e, 0xde, 0xcd, 0x33, 0x1e,
0x36, 0x81, 0xde, 0xcd, 0x10, 0x0f, 0x47, 0x1c, 0xfe, 0x7e, 0x0f,
0xde, 0xf7, 0xd6, 0x58, 0xde, 0xdf, 0x0d, 0x7f, 0x18, 0xf8, 0xf7,
0x61, 0xfc, 0x6a, 0xc7, 0xfb, 0xff, 0x07, 0x50, 0x0f, 0xdb, 0xa0,
0x7e, 0x44, 0x29, 0x58, 0x3f, 0x0e, 0xc2, 0x7c, 0x5b, 0x2c, 0xeb,
0x5d, 0x27, 0xeb, 0x15, 0x58, 0xf6, 0xbb, 0xa5, 0x9f, 0x7a, 0x3f,
0x02, 0xbd, 0x1f, 0x83, 0xff, 0xdb, 0xe0, 0xfc, 0x8b, 0xe6, 0x71,
0xfe, 0x19, 0xfb, 0x4f, 0x28, 0xbb, 0xbf, 0xc3, 0xec, 0x3f, 0x67,
0xfb, 0xad, 0x2a, 0x1f, 0xb6, 0x73, 0xff, 0x53, 0x55, 0xdf, 0xeb,
0xe4, 0xcc, 0xd9, 0x26, 0xe7, 0xc3, 0x34, 0x6e, 0x9f, 0xa9, 0xfc,
0xd8, 0x06, 0xf1, 0xf6, 0x05, 0xfc, 0x5e, 0xd0, 0x05, 0xf5, 0x63,
0x2b, 0xe8, 0xdb, 0x0f, 0x7a, 0xbe, 0xb4, 0xf8, 0xb7, 0x5a, 0xfc,
0x5b, 0xa4, 0xec, 0xbf, 0x0a, 0xf9, 0x7d, 0x25, 0xe5, 0xb8, 0x3f,
0x49, 0xc8, 0x8f, 0xf4, 0x23, 0x72, 0x8d, 0xe2, 0xc3, 0x9e, 0xcf,
0x8d, 0xfd, 0x0e, 0x58, 0xaf, 0x0d, 0xee, 0x6f, 0x14, 0xce, 0xe7,
0x8d, 0x64, 0xff, 0x3d, 0xec, 0x27, 0xc0, 0x07, 0x40, 0xef, 0x2e,
0x1e, 0xdf, 0xae, 0xee, 0xcf, 0x6e, 0xee, 0x7f, 0xad, 0xf0, 0x1e,
0xee, 0x7f, 0x03, 0x78, 0xa7, 0xc2, 0x31, 0x2f, 0x78, 0xfe, 0xb6,
0x43, 0xfd, 0xda, 0x09, 0x7a, 0x8f, 0xaa, 0xf5, 0x4b, 0x65, 0xfc,
0x5e, 0x78, 0x5f, 0xd1, 0xfb, 0xfd, 0x16, 0xfc, 0xf1, 0x1d, 0xf8,
0x63, 0x3b, 0xc4, 0x7b, 0x07, 0xc4, 0x7b, 0x87, 0xa5, 0xde, 0x94,
0x65, 0x59, 0xbf, 0x00, 0xf4, 0x75, 0x4a, 0x3d, 0xac, 0x11, 0x1e,
0xef, 0x9f, 0xd6, 0xf3, 0xfd, 0x00, 0xe8, 0xed, 0x74, 0xe8, 0xdd,
0x97, 0x87, 0xde, 0x1f, 0x06, 0x40, 0xef, 0x3e, 0x87, 0xde, 0xae,
0x73, 0x4c, 0x6f, 0x97, 0x43, 0x6f, 0x2c, 0x0f, 0xbd, 0xfb, 0x07,
0x40, 0x6f, 0xcc, 0x92, 0x3f, 0x07, 0xce, 0xe2, 0xfa, 0xf8, 0xff,
0x24, 0xac, 0x87, 0xc5, 0x52, 0xef, 0xe2, 0xe0, 0x9f, 0xa2, 0x2c,
0xff, 0xcf, 0x4c, 0xd7, 0xb7, 0x5c, 0xeb, 0x9d, 0xf9, 0xbd, 0x67,
0x58, 0x1f, 0xf4, 0x24, 0x2c, 0xf5, 0xb7, 0x07, 0xf4, 0xd4, 0x3b,
0xde, 0x8f, 0x36, 0x52, 0xfe, 0xeb, 0x37, 0x59, 0xd6, 0x3f, 0xdd,
0x0f, 0x7f, 0xb8, 0x3e, 0xff, 0x01, 0x71, 0x69, 0x23, 0x9d, 0x42,
0x02, 0x00, 0x00, 0x78, 0xda, 0x8d, 0x97, 0xbb, 0x4f, 0x15, 0x41,
0x14, 0x87, 0xf7, 0xec, 0x22, 0xc6, 0x10, 0x0d, 0x21, 0x04, 0x03,
0x89, 0x85, 0x09, 0x8d, 0x85, 0x31, 0x84, 0xc6, 0x84, 0x8e, 0xd0,
0xd8, 0x40, 0xab, 0xd1, 0x3f, 0x40, 0x0b, 0x1a, 0x12, 0x4c, 0x6c,
0x7d, 0xf2, 0x10, 0x45, 0x41, 0x50, 0xec, 0x4d, 0xb4, 0x92, 0x04,
0x04, 0x11, 0x41, 0xb1, 0xf1, 0xd9, 0x21, 0x76, 0x8a, 0x2f, 0x14,
0x14, 0x79, 0xf8, 0x28, 0x50, 0x81, 0x73, 0x77, 0x67, 0xd9, 0x81,
0xcc, 0xdc, 0x7c, 0x93, 0x9c, 0x64, 0xce, 0xe6, 0xbb, 0xbf, 0xdf,
0xce, 0xcc, 0x99, 0xb9, 0xb3, 0x41, 0xc0, 0xda, 0x9a, 0xb6, 0x02,
0xcf, 0x73, 0x3b, 0x5f, 0xf5, 0x70, 0xab, 0x5b, 0xb8, 0xff, 0x50,
0xef, 0x9f, 0x87, 0xdb, 0xda, 0xfe, 0x7a, 0x38, 0x31, 0x91, 0xb6,
0x15, 0xa8, 0xf7, 0x1b, 0xea, 0xfd, 0x82, 0xdc, 0x4f, 0xc8, 0x2d,
0x43, 0x6e, 0x09, 0x72, 0x8b, 0x70, 0xbc, 0x0b, 0x50, 0xef, 0x87,
0x87, 0x8b, 0x72, 0x9c, 0x64, 0xe4, 0xbc, 0x87, 0x0b, 0x63, 0x2e,
0xcb, 0xbf, 0x43, 0xdf, 0x6f, 0x50, 0x6f, 0x0e, 0x72, 0xb3, 0x79,
0xb8, 0x28, 0xca, 0xf2, 0xaf, 0x70, 0xbc, 0x5f, 0xa0, 0xef, 0x0c,
0x1c, 0xef, 0x67, 0xa8, 0xf7, 0x09, 0xea, 0x7d, 0x84, 0xfb, 0xed,
0x03, 0xd4, 0x7b, 0x0f, 0xb9, 0x69, 0xe8, 0xfb, 0x0e, 0xce, 0xf3,
0x5b, 0xe8, 0xfb, 0x06, 0xd6, 0xfd, 0x14, 0xd4, 0x7b, 0x0d, 0xb9,
0x49, 0xb8, 0x6e, 0xaf, 0x20, 0xf7, 0x12, 0xfa, 0xbe, 0x80, 0xdc,
0x73, 0xc8, 0x3d, 0x83, 0xef, 0xf7, 0x14, 0x72, 0x4f, 0x20, 0x37,
0x01, 0xb9, 0xc7, 0xb0, 0x5e, 0x1e, 0x41, 0xbd, 0x71, 0x38, 0x2f,
0x63, 0x90, 0x7b, 0x08, 0xb9, 0x51, 0xc8, 0x3d, 0x80, 0xdc, 0x08,
0xe4, 0xee, 0x43, 0x6e, 0x18, 0x72, 0x43, 0x90, 0xbb, 0x07, 0xb9,
0x41, 0xc8, 0x0d, 0xc0, 0xf5, 0xed, 0xcf, 0xa3, 0x67, 0x1d, 0xf7,
0xc1, 0x5d, 0xc8, 0xdd, 0x84, 0xe7, 0xcb, 0x0d, 0xc8, 0x5d, 0x87,
0x5c, 0x2f, 0xe4, 0x7a, 0x20, 0x77, 0x0d, 0x72, 0xdd, 0x90, 0xeb,
0x82, 0xdc, 0x55, 0xc8, 0x5d, 0x81, 0x5c, 0x27, 0xac, 0x97, 0xcb,
0x1e, 0x6e, 0x5b, 0x6e, 0x7d, 0x25, 0x8a, 0x52, 0xf6, 0x12, 0xe4,
0x3a, 0x20, 0x77, 0xd1, 0xc3, 0x15, 0xc4, 0xf7, 0x8d, 0x0d, 0x2c,
0x68, 0xf7, 0x70, 0x85, 0x31, 0x97, 0x09, 0xb6, 0xe5, 0x3b, 0xff,
0xac, 0x0b, 0x4c, 0x2b, 0x9c, 0x97, 0x96, 0x7c, 0xf7, 0x21, 0x0b,
0xbc, 0x00, 0xf7, 0xc7, 0x79, 0xb8, 0x6e, 0xe7, 0xe0, 0x39, 0x7e,
0x16, 0xea, 0x9d, 0x81, 0xe3, 0x38, 0x0d, 0xe7, 0x25, 0xd7, 0x5f,
0xd6, 0xd8, 0x9d, 0xde, 0xe3, 0x3d, 0xbe, 0xd5, 0x1a, 0x3b, 0x24,
0xf1, 0xc9, 0xb5, 0x32, 0x71, 0xeb, 0xd5, 0x69, 0x14, 0xe9, 0x83,
0x12, 0x93, 0xef, 0x95, 0xac, 0x0e, 0xc4, 0x5a, 0xb8, 0xa3, 0x1a,
0x7b, 0xac, 0x1f, 0x56, 0x89, 0xdb, 0xf7, 0x98, 0xe1, 0xb6, 0x9b,
0xfc, 0xb0, 0xc7, 0xb7, 0x59, 0xa3, 0xd2, 0x7a, 0x70, 0xc2, 0xa3,
0x77, 0xd2, 0x70, 0x95, 0x26, 0x3f, 0x25, 0xee, 0xba, 0x1a, 0xd3,
0x38, 0x24, 0x49, 0x5d, 0xc6, 0x75, 0x21, 0xee, 0x73, 0x77, 0x52,
0xa3, 0x41, 0xf3, 0x72, 0x93, 0xdf, 0x92, 0xac, 0x9e, 0x25, 0x6e,
0x49, 0xfe, 0x47, 0xe3, 0xb8, 0x24, 0xfb, 0x26, 0xfe, 0x3f, 0xd9,
0x34, 0x2f, 0x99, 0x62, 0xa8, 0xbd, 0x46, 0x8d, 0x8a, 0xf4, 0x7b,
0x44, 0xb2, 0xfd, 0x66, 0xc9, 0x05, 0xfb, 0x25, 0x79, 0xa7, 0xf4,
0x8d, 0x25, 0x74, 0xd7, 0xd5, 0x41, 0xed, 0xb6, 0x69, 0x14, 0x9b,
0xbc, 0x22, 0x74, 0xcf, 0x5f, 0xad, 0x26, 0x7d, 0x1a, 0xbb, 0x4c,
0x7e, 0x20, 0x74, 0xfb, 0xd6, 0x6b, 0xe7, 0xb6, 0xe5, 0x5b, 0xe3,
0xf1, 0x3d, 0xa2, 0xdd, 0x01, 0xcb, 0xa0, 0x35, 0x74, 0xaf, 0x47,
0x93, 0x32, 0x83, 0x16, 0x77, 0xc7, 0xc3, 0x35, 0x1b, 0x6e, 0x67,
0xfa, 0xdd, 0xe2, 0xe1, 0x3a, 0x94, 0x99, 0xd0, 0x28, 0x35, 0xf9,
0xbe, 0xc8, 0xcd, 0xcd, 0x2b, 0x33, 0x65, 0xf9, 0xd6, 0x7a, 0xb8,
0x75, 0xa8, 0xe8, 0x68, 0x64, 0x16, 0x02, 0x00, 0x00, 0x78, 0xda,
0x4d, 0xd4, 0x49, 0x6c, 0x4d, 0x61, 0x18, 0x87, 0xf1, 0xdb, 0xe1,
0x56, 0x88, 0xc4, 0x46, 0x2c, 0xac, 0x50, 0xad, 0x79, 0x1e, 0x5a,
0x35, 0x5d, 0x6a, 0x6c, 0x55, 0x51, 0x43, 0x5b, 0x94, 0x52, 0x43,
0x6b, 0x68, 0x55, 0x4d, 0xd5, 0x92, 0x48, 0x6a, 0xc1, 0x06, 0x1b,
0x89, 0x85, 0x85, 0x04, 0xe9, 0x4e, 0x2c, 0x88, 0x48, 0x58, 0x20,
0x91, 0xb0, 0x23, 0xc2, 0x42, 0x24, 0x22, 0x76, 0x84, 0xd8, 0x89,
0x88, 0xe7, 0xf5, 0x3d, 0x49, 0x7b, 0x73, 0xfe, 0xe7, 0xfc, 0xf2,
0xde, 0xf7, 0x9c, 0xfb, 0xe5, 0xbd, 0xdf, 0xbd, 0x99, 0xcc, 0xc0,
0xab, 0x30, 0x93, 0xc9, 0x8d, 0xe3, 0x5a, 0x5b, 0x90, 0x5c, 0x8c,
0xeb, 0x70, 0x1e, 0x1e, 0x8f, 0x1b, 0x70, 0x3e, 0x2e, 0xc1, 0xcd,
0xba, 0x14, 0xb7, 0x61, 0x8e, 0xdc, 0x04, 0xdc, 0x95, 0xea, 0x99,
0x70, 0x8f, 0x9e, 0x48, 0x2e, 0xea, 0x49, 0xe4, 0x8a, 0xfd, 0x93,
0xf1, 0x0d, 0xeb, 0xe1, 0xdb, 0x7a, 0x0a, 0xb9, 0xaf, 0xa7, 0x92,
0xa7, 0xf6, 0x4f, 0xc3, 0xaf, 0xad, 0x87, 0xdf, 0xe9, 0xe9, 0xe4,
0xb3, 0x9e, 0x41, 0xbe, 0xdb, 0x3f, 0x13, 0xff, 0xb6, 0x1e, 0xce,
0x2f, 0x4c, 0x9e, 0x45, 0x86, 0xeb, 0xd9, 0x64, 0x54, 0x61, 0xea,
0x9f, 0x83, 0xc7, 0x58, 0x0f, 0x97, 0xe8, 0xb9, 0xb1, 0x0e, 0x3d,
0x2f, 0xde, 0x4b, 0xce, 0xcd, 0xc7, 0x15, 0xba, 0x0c, 0x57, 0xea,
0x72, 0x5c, 0xa3, 0x17, 0xe0, 0x7a, 0x9f, 0x5f, 0x81, 0x5b, 0x7c,
0x4e, 0xb8, 0x53, 0x2f, 0x24, 0x17, 0xf4, 0x22, 0x72, 0xcd, 0xfe,
0xc5, 0xf8, 0x96, 0xf5, 0x70, 0xbf, 0x5e, 0x12, 0xf3, 0xd1, 0x4b,
0xc9, 0x63, 0xfb, 0x73, 0xf8, 0xb9, 0xf5, 0xf0, 0x2b, 0xbd, 0x8c,
0xbc, 0xd5, 0xcb, 0xc9, 0x47, 0xd7, 0x56, 0x89, 0xbf, 0x7a, 0xef,
0x0a, 0xfc, 0xd3, 0x9e, 0xf0, 0x1f, 0xbd, 0x92, 0x0c, 0xcd, 0x26,
0xaf, 0x8a, 0x59, 0x25, 0xe7, 0x56, 0xe3, 0x62, 0xbd, 0x26, 0xbe,
0x3f, 0xbd, 0x16, 0x97, 0xe9, 0xaa, 0xf8, 0x3c, 0x5d, 0x8d, 0xab,
0xf5, 0xba, 0x98, 0x89, 0xae, 0x89, 0x35, 0xe7, 0xa7, 0x35, 0xac,
0xc7, 0xfb, 0xfc, 0xac, 0x70, 0x87, 0xae, 0x25, 0xbd, 0x7a, 0x03,
0xb9, 0x94, 0x4d, 0xfd, 0x1b, 0xf1, 0x75, 0xeb, 0xe1, 0x3b, 0x7a,
0x13, 0x79, 0xa8, 0xeb, 0xc8, 0xcb, 0x6c, 0xda, 0xcf, 0x9b, 0xf1,
0x07, 0xef, 0xdd, 0x82, 0xbf, 0xd8, 0x13, 0xfe, 0xa1, 0xb7, 0x92,
0xbf, 0x7a, 0x5b, 0xec, 0x93, 0xa2, 0xb4, 0xce, 0x7a, 0x3c, 0x5a,
0x37, 0xe0, 0x52, 0xdd, 0x18, 0x7b, 0x4e, 0x6f, 0xc7, 0xe5, 0x7a,
0x47, 0xcc, 0x1d, 0x73, 0xe4, 0x76, 0xe2, 0x5f, 0x99, 0xe4, 0x26,
0xae, 0x63, 0xf3, 0x92, 0x77, 0xc5, 0x1c, 0xf4, 0xee, 0x98, 0xad,
0x6e, 0x8e, 0x3d, 0xaa, 0xf7, 0xe0, 0x56, 0xbd, 0x37, 0xe6, 0x59,
0xf0, 0xff, 0xa7, 0x9a, 0x6b, 0xe1, 0x54, 0x45, 0x31, 0x1b, 0x33,
0x23, 0x8d, 0x7a, 0x7f, 0xec, 0x31, 0x7d, 0x80, 0xb4, 0xeb, 0x83,
0xa4, 0x5b, 0xb7, 0x92, 0x3e, 0xdd, 0x46, 0x2e, 0xeb, 0x43, 0xe4,
0xaa, 0x3e, 0x1c, 0xb3, 0x1d, 0xe4, 0x9b, 0xfa, 0x08, 0xb9, 0xab,
0x8f, 0x92, 0x7b, 0xba, 0x3d, 0x7a, 0x0a, 0x06, 0xdc, 0xaf, 0x3b,
0xc8, 0x03, 0x7d, 0x8c, 0x3c, 0xd3, 0x9d, 0xe4, 0x51, 0xd1, 0x80,
0x9f, 0xe8, 0xe3, 0xe4, 0x85, 0xee, 0x8a, 0xdf, 0xbb, 0x3e, 0x41,
0xde, 0x0c, 0xf2, 0x7b, 0x7d, 0x92, 0x7c, 0xd2, 0xa7, 0x62, 0x3f,
0xeb, 0xd3, 0xe4, 0x9b, 0x3e, 0x13, 0xf3, 0xd7, 0xdd, 0xb1, 0xb7,
0xf5, 0xd9, 0xf8, 0xcf, 0x1b, 0x92, 0xdc, 0x43, 0x86, 0xe9, 0x5e,
0x32, 0x42, 0x9f, 0x23, 0x4d, 0x85, 0x69, 0xe6, 0xe7, 0x39, 0x8d,
0xb4, 0xde, 0x17, 0xfb, 0x1f, 0xff, 0x03, 0x7d, 0x37, 0x69, 0x44,
0xab, 0x00, 0x00, 0x00, 0x78, 0xda, 0x45, 0xd0, 0x29, 0x0f, 0xc2,
0x40, 0x14, 0x45, 0xe1, 0x81, 0x96, 0x96, 0x7d, 0xdf, 0x2d, 0xff,
0x0a, 0x81, 0xc2, 0xd7, 0xe3, 0x51, 0x28, 0x14, 0x0e, 0x4b, 0x70,
0x28, 0x12, 0x0c, 0x86, 0xe0, 0x70, 0x18, 0x1c, 0x0e, 0x87, 0xc2,
0x22, 0xb8, 0x2f, 0xef, 0x24, 0x34, 0x39, 0x99, 0x2f, 0x93, 0x37,
0xd3, 0xa6, 0x21, 0xfc, 0x9f, 0x1c, 0xeb, 0x34, 0x71, 0x5b, 0x73,
0x39, 0x1f, 0xbc, 0x0c, 0x47, 0x6a, 0x21, 0xc7, 0xc1, 0x5b, 0xe2,
0x82, 0x5a, 0x71, 0x56, 0x4b, 0x58, 0x27, 0x3e, 0x9b, 0xaa, 0x0d,
0x67, 0xcd, 0x5b, 0x5c, 0x54, 0x3b, 0x5c, 0x52, 0x07, 0xe6, 0xcb,
0x36, 0x13, 0xf9, 0xbe, 0x79, 0x8f, 0x2b, 0xea, 0x88, 0xab, 0xea,
0x12, 0xf9, 0x7c, 0x4d, 0x9d, 0xb8, 0xc7, 0x7c, 0xc6, 0x75, 0x75,
0xc5, 0x0d, 0x75, 0xe3, 0xfe, 0xa6, 0xba, 0xb3, 0x6f, 0x7e, 0xe0,
0x96, 0x7a, 0xe2, 0xb6, 0x7a, 0xe1, 0x8e, 0x7a, 0xe3, 0xae, 0xfa,
0xe0, 0x9e, 0xfa, 0xe2, 0xbe, 0xfd, 0x8b, 0xd4, 0x3d, 0xb0, 0xef,
0xc6, 0x43, 0x7b, 0x37, 0x1e, 0xa9, 0x59, 0xec, 0x1e, 0xab, 0x89,
0xf6, 0x7f, 0xeb, 0xca, 0x15, 0x07, 0x06, 0x02, 0x00, 0x00, 0x78,
0xda, 0xed, 0xd4, 0xb9, 0x4f, 0x14, 0x51, 0x1c, 0xc0, 0xf1, 0x99,
0x5d, 0x05, 0xdd, 0x55, 0x41, 0x0e, 0xb9, 0xd4, 0x5d, 0x44, 0x45,
0x05, 0x15, 0xb9, 0xe4, 0x50, 0x98, 0x63, 0x47, 0xd6, 0x03, 0x41,
0xbc, 0xb8, 0x14, 0xe4, 0x4e, 0x08, 0x81, 0x4a, 0x1b, 0x12, 0xa6,
0x93, 0x82, 0x82, 0x86, 0x84, 0x35, 0x6a, 0x88, 0x7f, 0x81, 0x05,
0x16, 0x6a, 0x21, 0x89, 0x24, 0x90, 0x90, 0x10, 0x42, 0x43, 0x68,
0xc8, 0x96, 0xd8, 0xd1, 0xd1, 0x50, 0xf0, 0x9d, 0xb7, 0x8f, 0x28,
0x10, 0x89, 0x21, 0x48, 0xc5, 0xcb, 0x7e, 0xf6, 0x97, 0x97, 0x7d,
0xd7, 0xfe, 0xe6, 0x37, 0x4f, 0x51, 0x0e, 0xda, 0x7e, 0xb7, 0x27,
0x78, 0x86, 0x5a, 0x3c, 0xc5, 0x73, 0xd4, 0xa1, 0xf3, 0x8f, 0x31,
0x2a, 0x5c, 0x70, 0xe3, 0x10, 0x0e, 0x23, 0x0a, 0xd1, 0x38, 0x82,
0xa3, 0xf0, 0xc0, 0x8b, 0x63, 0x38, 0x8e, 0x13, 0x88, 0x41, 0x2c,
0x4e, 0x22, 0x0e, 0xf1, 0x48, 0x40, 0x22, 0x4e, 0x21, 0x09, 0xc9,
0x48, 0xd9, 0x74, 0x22, 0xbb, 0x9c, 0x2f, 0x8d, 0x0f, 0x6c, 0x2d,
0x75, 0x1f, 0xcf, 0xe0, 0xec, 0x95, 0x86, 0xd3, 0x38, 0x83, 0xb3,
0xf0, 0xc1, 0x8f, 0x74, 0x9c, 0x43, 0x06, 0xce, 0xe3, 0x02, 0x2e,
0x22, 0x13, 0x97, 0x70, 0x19, 0x57, 0x90, 0x85, 0x6c, 0x5c, 0xc5,
0x35, 0x5c, 0x47, 0x0e, 0x6e, 0x20, 0x17, 0x79, 0xc8, 0x47, 0x01,
0x0a, 0x71, 0x13, 0x45, 0x28, 0x46, 0x09, 0x4a, 0x71, 0x0b, 0xb7,
0x51, 0x06, 0x99, 0x0c, 0x45, 0x87, 0x01, 0x13, 0x01, 0x58, 0xb8,
0x83, 0x0a, 0x04, 0x71, 0x17, 0xf7, 0x70, 0x1f, 0x0f, 0x50, 0x89,
0x87, 0xa8, 0x42, 0x35, 0x1e, 0xa1, 0x06, 0x8f, 0x45, 0x36, 0x73,
0x74, 0x8f, 0xcc, 0xa9, 0x57, 0xe6, 0xc2, 0x27, 0xff, 0x43, 0x9e,
0xdc, 0xbb, 0x42, 0xce, 0x69, 0x40, 0x3b, 0x1a, 0xf1, 0x02, 0x2f,
0xd1, 0x84, 0x66, 0xbc, 0x42, 0xbd, 0xfc, 0xbd, 0x15, 0x6d, 0xe8,
0xd8, 0x52, 0x5f, 0xbd, 0x78, 0x83, 0x01, 0xbc, 0xc5, 0x10, 0x86,
0x31, 0x82, 0x10, 0x3e, 0xe1, 0x33, 0xbe, 0xe0, 0x1b, 0x7e, 0xe0,
0x27, 0xa6, 0x30, 0x87, 0x05, 0x84, 0xf1, 0x4b, 0x3e, 0x63, 0xa7,
0xad, 0xfd, 0x4b, 0x61, 0x07, 0xdf, 0x5b, 0xca, 0x28, 0x96, 0x51,
0xf4, 0xc1, 0x52, 0xaa, 0x89, 0xcd, 0xe8, 0xc2, 0x1c, 0x7d, 0xff,
0x47, 0x4b, 0x19, 0xfc, 0x6e, 0xfd, 0x9e, 0xb0, 0x42, 0x6a, 0xfb,
0x60, 0xeb, 0x01, 0x12, 0x53, 0xa3, 0xee, 0xfe, 0x9d, 0x7a, 0xad,
0x6e, 0xd4, 0xf1, 0x06, 0xe7, 0xd1, 0x69, 0x46, 0xbc, 0xac, 0xab,
0x4c, 0x59, 0x0f, 0xa5, 0x62, 0xf4, 0x98, 0x16, 0x39, 0xc4, 0x84,
0x56, 0x25, 0x62, 0x58, 0xab, 0x8b, 0x2c, 0xa3, 0xb7, 0x8a, 0x10,
0xab, 0xf7, 0x88, 0xe8, 0xd7, 0x1b, 0xfe, 0xb2, 0xdf, 0xbb, 0x50,
0xa8, 0x6c, 0x2f, 0xef, 0x04, 0xcf, 0x42, 0x06, 0x25, 0x38, 0xcd,
0x99, 0x6d, 0xa7, 0xe4, 0x02, 0x23, 0x91, 0x5c, 0x94, 0x6f, 0x1f,
0xe9, 0x0f, 0xfc, 0xef, 0xfb, 0x69, 0x96, 0xbd, 0x97, 0xd4, 0xbd,
0x58, 0xc9, 0x39, 0xab, 0xf3, 0x8c, 0x77, 0xdf, 0x5a, 0xb6, 0xf4,
0x2b, 0xb9, 0x90, 0x9a, 0xd0, 0xed, 0x12, 0x5d, 0xb3, 0x3f, 0x12,
0x29, 0x5f, 0x9b, 0x7d, 0xe6, 0xcd, 0x51, 0xd7, 0x4e, 0xab, 0xc5,
0x31, 0x66, 0x15, 0x61, 0xf3, 0x2b, 0xe3, 0x26, 0x31, 0x83, 0xc5,
0x1d, 0xe7, 0x74, 0x98, 0x8a, 0xbd, 0xc4, 0x9c, 0x09, 0xae, 0x83,
0x71, 0x63, 0x55, 0x8c, 0x0d, 0xd2, 0x1f, 0xa3, 0x3f, 0x64, 0xa8,
0x6e, 0xd1, 0x37, 0xbc, 0x22, 0xae, 0xe8, 0x89, 0x44, 0x9f, 0x7b,
0xf3, 0x0a, 0xeb, 0x87, 0x8d, 0x61, 0xd4
};

4154
baserc/server.h
View File

File diff suppressed because it is too large Load Diff

2081
baserc/uimenu.h
View File

File diff suppressed because it is too large Load Diff

153
common/spritegen.c
View File

@ -15,7 +15,10 @@
dsprite_t sprite;
byte *spritepool;
rgbdata_t *byteimage;
byte *sprite_pal;
byte *frame_buffer;
int frame_width;
int frame_height;
char spriteoutname[MAX_SYSPATH];
float frameinterval;
int framecount;
@ -45,9 +48,9 @@ void WriteFrame( file_t *f, int framenum )
pframe->width = LittleLong (pframe->width);
pframe->height = LittleLong (pframe->height);
// write frame as normal 32-bit image
// write frame as 32-bit indexed image
FS_Write(f, pframe, sizeof(*pframe));
FS_Write(f, (byte *)(pframe + 1), pframe->height * pframe->width * 4 );
FS_Write(f, (byte *)(pframe + 1), pframe->height * pframe->width );
}
/*
@ -57,12 +60,23 @@ WriteSprite
*/
void WriteSprite( file_t *f )
{
int i, curframe = 0, groupframe = 0;
int i;
short cnt = 256;
int curframe = 0;
int groupframe = 0;
// calculate bounding radius
sprite.boundingradius = sqrt(((sprite.bounds[0]>>1) * (sprite.bounds[0]>>1))
+ ((sprite.bounds[1]>>1) * (sprite.bounds[1]>>1)));
// write out the sprite header
SwapBlock((int *)&sprite, sizeof(dsprite_t));
FS_Write( f, &sprite, sizeof(sprite));
// write out palette (768 bytes)
FS_Write( f, (void *)&cnt, sizeof(cnt));
FS_Write( f, sprite_pal, cnt * 3 );
for (i = 0; i < sprite.numframes; i++)
{
FS_Write( f, &frames[curframe].type, sizeof(frames[curframe].type));
@ -84,10 +98,10 @@ void WriteSprite( file_t *f )
// set and write the group header
dsgroup.numframes = LittleLong( numframes );
FS_Write(f, &dsgroup, sizeof(dsgroup));
FS_Write( f, &dsgroup, sizeof(dsgroup));
totinterval = 0.0f; // write the interval array
for(j = 0; j < numframes; j++)
for( j = 0; j < numframes; j++ )
{
dspriteinterval_t temp;
@ -95,7 +109,7 @@ void WriteSprite( file_t *f )
temp.interval = LittleFloat(totinterval);
FS_Write(f, &temp, sizeof(temp));
}
for(j = 0; j < numframes; j++)
for( j = 0; j < numframes; j++ )
{
WriteFrame(f, curframe);
curframe++;
@ -114,7 +128,7 @@ bool WriteSPRFile( void )
file_t *f;
uint i, groups = 0, grpframes = 0, sngframes = framecount;
if(sprite.numframes == 0)
if( sprite.numframes == 0 )
{
MsgDev(D_WARN, "WriteSPRFile: ignoring blank sprite %s\n", spriteoutname );
return false;
@ -127,8 +141,8 @@ bool WriteSPRFile( void )
// release framebuffer
for( i = 0; i < framecount; i++)
{
if(frames[i].pdata) Mem_Free( frames[i].pdata );
if(frames[i].numgroupframes )
if( frames[i].pdata ) Mem_Free( frames[i].pdata );
if( frames[i].numgroupframes )
{
groups++;
sngframes -= frames[i].numgroupframes;
@ -143,7 +157,7 @@ bool WriteSPRFile( void )
Msg(" contain %d frame%s\n", grpframes, grpframes > 1 ? "s":"" );
}
if( sngframes - groups )
Msg("%d ungrouped frame%s\n", sngframes - groups, (sngframes - groups) > 1 ? "s" : "");
Msg("%d ungrouped frame%s\n", sngframes - groups, (sngframes - groups) > 1 ? "s" : "" );
return true;
}
@ -163,8 +177,6 @@ void Cmd_Type( void )
else if (Com_MatchToken( "vp_parallel" )) sprite.type = SPR_FWD_PARALLEL;
else if (Com_MatchToken( "oriented" )) sprite.type = SPR_ORIENTED;
else if (Com_MatchToken( "vp_parallel_oriented")) sprite.type = SPR_FWD_PARALLEL_ORIENTED;
else if (Com_MatchToken( "label")) sprite.type = SPR_LABEL;
else if (Com_MatchToken( "label_scaled")) sprite.type = SPR_LABEL_SCALE;
else sprite.type = SPR_FWD_PARALLEL; // default
}
@ -179,11 +191,12 @@ void Cmd_RenderMode( void )
{
Com_GetToken( false );
if (Com_MatchToken( "additive")) sprite.rendermode = SPR_ADDITIVE;
else if (Com_MatchToken( "solid")) sprite.rendermode = SPR_SOLID;
else if (Com_MatchToken( "alpha")) sprite.rendermode = SPR_ALPHA;
else if (Com_MatchToken( "glow")) sprite.rendermode = SPR_GLOW;
else sprite.rendermode = SPR_ADDITIVE; // default
if (Com_MatchToken( "additive")) sprite.texFormat = SPR_ADDITIVE;
else if (Com_MatchToken( "normal")) sprite.texFormat = SPR_NORMAL;
else if (Com_MatchToken( "indexalpha")) sprite.texFormat = SPR_INDEXALPHA;
else if (Com_MatchToken( "alphatest")) sprite.texFormat = SPR_ALPHTEST;
else if (Com_MatchToken( "glow")) sprite.texFormat = SPR_ADDGLOW;
else sprite.texFormat = SPR_ADDITIVE; // default
}
/*
@ -225,42 +238,42 @@ Cmd_Load
syntax "$load fire01.tga"
===============
*/
void Cmd_Load (void)
void Cmd_Load( void )
{
char *framename;
size_t image_size;
byte *error_tga = FS_LoadInternal( "error.tga", &image_size );
char *framename;
static byte base_pal[256*3];
if( byteimage ) Image->FreeImage( byteimage ); // release old image
framename = Com_GetToken(false);
FS_DefaultExtension( framename, ".tga" );
byteimage = Image->LoadImage( framename, error_tga, image_size );
framename = Com_GetToken( false );
FS_DefaultExtension( framename, ".bmp" );
frame_buffer = ReadBMP( framename, &sprite_pal, &frame_width, &frame_height );
if( sprite.numframes == 0 ) Mem_Copy( base_pal, sprite_pal, sizeof( base_pal ));
else if( memcmp( base_pal, sprite_pal, sizeof( base_pal )))
MsgDev( D_WARN, "Cmd_Load: %s doesn't share a pallette with the previous frame\n", framename );
if(Com_TryToken())
{
uint line = byteimage->width * 4;
uint line = frame_width;
byte *fout, *fin;
int x, y, c;
int x, y;
fin = byteimage->buffer;
fout = Mem_Alloc( zonepool, byteimage->size );
fin = frame_buffer;
fout = Mem_Alloc( zonepool, frame_width * frame_height );
if(Com_MatchToken("flip_x"))
{
for (y = 0; y < byteimage->height; y++)
for (x = byteimage->width - 1; x >= 0; x--)
for(c = 0; c < 4; c++, fin++)
fout[y*line+x*4+c] = *fin;
for( y = 0; y < frame_height; y++ )
for( x = frame_width - 1; x >= 0; x--)
fout[y*line+x] = *fin;
}
else if(Com_MatchToken("flip_y"))
{
for (y = byteimage->height - 1; y >= 0; y--)
for (x = 0; x < byteimage->width; x++)
for(c = 0; c < 4; c++, fin++)
fout[y*line+x*4+c] = *fin;
for( y = frame_height - 1; y >= 0; y-- )
for( x = 0; x < frame_width; x++)
fout[y*line+x] = *fin;
}
Mem_Free( byteimage->buffer );
byteimage->buffer = fout;
Mem_Free( frame_buffer );
frame_buffer = fout;
}
}
@ -273,54 +286,45 @@ syntax "$frame xoffset yoffset width height <interval> <origin x> <origin y>"
*/
void Cmd_Frame( void )
{
int i, x, y, xl, yl, xh, yh, w, h;
int x, y, xl, yl, xh, yh, w, h;
int pixels, linedelta;
dframe_t *pframe;
byte *fin, *plump;
if(!byteimage || !byteimage->buffer) Sys_Break("frame not loaded\n");
if (framecount >= MAX_FRAMES) Sys_Break("Too many frames in package\n");
pixels = byteimage->width * byteimage->height;
xl = atoi(Com_GetToken(false));
yl = atoi(Com_GetToken(false));
w = atoi(Com_GetToken(false));
h = atoi(Com_GetToken(false));
if( !frame_buffer ) Sys_Break( "frame not loaded\n" );
if( framecount >= MAX_FRAMES ) Sys_Break( "too many frames in package\n" );
pixels = frame_width * frame_height;
xl = com.atoi(Com_GetToken(false));
yl = com.atoi(Com_GetToken(false));
w = com.atoi(Com_GetToken(false));
h = com.atoi(Com_GetToken(false));
if((xl & 0x07)||(yl & 0x07)||(w & 0x07)||(h & 0x07))
{
// render will be resampled image, just throw warning
MsgDev( D_WARN, "frame dimensions not multiples of 8\n" );
//return;
}
if ((w > MAX_FRAME_DIM) || (h > MAX_FRAME_DIM))
{
w = min(w, MAX_FRAME_DIM);
h = min(h, MAX_FRAME_DIM);
Image->ResampleImage( "frame", &byteimage, w, h, true );
}
if((w > MAX_FRAME_DIM) || (h > MAX_FRAME_DIM))
Sys_Break( "sprite has a dimension longer than %d\n", MAX_FRAME_DIM );
if((w > byteimage->width) || (h > byteimage->height))
{
// probably default frame "error.tga" mismatch size
// but may be mistake in the script ?
Image->ResampleImage( "frame", &byteimage, w, h, true );
}
if((w > frame_width) || (h > frame_height))
Sys_Break("frame size [%ix%i] longer than image [%ix%i]\n", w, h, frame_width, frame_height );
xh = xl + w;
yh = yl + h;
plump = (byte *)Mem_Alloc( spritepool, sizeof(dframe_t) + (w * h * 4));
plump = (byte *)Mem_Alloc( spritepool, sizeof(dframe_t) + (w * h));
pframe = (dframe_t *)plump;
frames[framecount].pdata = plump;
frames[framecount].type = SPR_SINGLE;
// get interval
if(Com_TryToken())
if( Com_TryToken())
{
frames[framecount].interval = bound(MIN_INTERVAL, com.atof(com_token), MAX_INTERVAL );
}
else if(frameinterval != 0)
else if( frameinterval != 0 )
{
frames[framecount].interval = frameinterval;
}
@ -356,15 +360,14 @@ void Cmd_Frame( void )
if(h > sprite.bounds[1]) sprite.bounds[1] = h;
plump = (byte *)(pframe + 1); // move pointer
fin = byteimage->buffer + yl * byteimage->width + xl;
linedelta = byteimage->width - w;
fin = frame_buffer + yl * frame_width + xl;
linedelta = frame_width - w;
for (y = yl; y < yh; y++)
for( y = yl; y < yh; y++ )
{
for( x = xl; x < xh; x++ )
for( i = 0; i < 4; i++)
*plump++ = *fin++;
fin += linedelta * 4;
*plump++ = *fin++;
fin += linedelta;
}
framecount++;
}
@ -431,7 +434,7 @@ void Cmd_Group( bool angled )
{
// don't create blank groups, rewind frames
framecount--, sprite.numframes--;
MsgDev(D_WARN, "Cmd_Group: remove blank group\n");
MsgDev( D_WARN, "Cmd_Group: remove blank group\n" );
}
else if( angled && frames[groupframe].numgroupframes != 8 )
{
@ -514,7 +517,7 @@ bool ParseSpriteScript (void)
{
if(!Com_GetToken (true)) break;
if (Com_MatchToken( "$spritename" )) Cmd_Spritename();
else if (Com_MatchToken( "$render" )) Cmd_RenderMode();
else if (Com_MatchToken( "$texture" )) Cmd_RenderMode();
else if (Com_MatchToken( "$facetype" )) Cmd_FaceType();
else if (Com_MatchToken( "$origin" )) Cmd_Origin();
else if (Com_MatchToken( "$rand" )) Cmd_Rand();
@ -549,7 +552,7 @@ bool CompileCurrentSprite( const char *name )
FS_DefaultExtension( gs_filename, ".qc" );
load = Com_LoadScript( gs_filename, NULL, 0 );
if(load)
if( load )
{
if(!ParseSpriteScript())
return false;
@ -562,10 +565,10 @@ bool CompileCurrentSprite( const char *name )
bool CompileSpriteModel ( byte *mempool, const char *name, byte parms )
{
if(mempool) spritepool = mempool;
if( mempool ) spritepool = mempool;
else
{
MsgDev(D_ERROR, "can't allocate memory pool.\nAbort compilation\n");
MsgDev( D_ERROR, "can't allocate memory pool.\nAbort compilation\n");
return false;
}
return CompileCurrentSprite( name );

6
engine/client/cl_frame.c
View File

@ -192,7 +192,7 @@ CL_ParseFrame
*/
void CL_ParseFrame( sizebuf_t *msg )
{
int cmd, len;
int cmd, len, idx;
edict_t *clent;
frame_t *old;
@ -245,7 +245,9 @@ void CL_ParseFrame( sizebuf_t *msg )
// read clientinfex
cmd = MSG_ReadByte( msg );
if( cmd != svc_clientindex ) Host_Error( "CL_ParseFrame: not clientindex\n" );
clent = PRVM_EDICT_NUM( MSG_ReadByte( msg )); // get client
idx = MSG_ReadByte( msg );
clent = PRVM_EDICT_NUM( idx ); // get client
if((idx-1) != cl.playernum ) Host_Error("CL_ParseFrame: invalid playernum (%d should be %d)\n", idx-1, cl.playernum );
// read packet entities
cmd = MSG_ReadByte( msg );

5
engine/client/cl_main.c
View File

@ -732,7 +732,6 @@ void CL_PrepVideo( void )
for( i = 1, mdlcount = 0; i < MAX_MODELS && cl.configstrings[CS_MODELS+1+i][0]; i++ )
mdlcount++; // total num models
// create thread here ?
for( i = 0; i < pe->NumTextures(); i++ )
{
if(!re->RegisterImage( cl.configstrings[CS_MODELS+1], i ))
@ -740,11 +739,10 @@ void CL_PrepVideo( void )
Cvar_SetValue( "scr_loading", scr_loading->value + 70.0f );
break; // hey, textures already loaded!
}
Cvar_SetValue("scr_loading", scr_loading->value + 70.0f / pe->NumTextures());
Cvar_SetValue( "scr_loading", scr_loading->value + 70.0f / pe->NumTextures());
SCR_UpdateScreen();
}
// create thread here ?
for( i = 1; i < MAX_MODELS && cl.configstrings[CS_MODELS+1+i][0]; i++ )
{
com.strncpy( name, cl.configstrings[CS_MODELS+1+i], MAX_STRING );
@ -1201,6 +1199,7 @@ void CL_Frame( dword time )
return;
// decide the simulation time
cl.oldtime = cl.time; // used for lerping animations
cl.time += time; // can be merged by cl.frame.servertime
cls.realtime += time;
cls.frametime = time * 0.001;

22
engine/client/cl_progs.c
View File

@ -100,6 +100,28 @@ void CL_StudioEvent ( mstudioevent_t *event, entity_state_t *ent )
PRVM_ExecuteProgram( prog->globals.cl->HUD_StudioEvent, "HUD_StudioEvent");
}
/*
====================
GetClientEntity
Render callback for studio models
====================
*/
entity_state_t *CL_GetEdictByIndex( int index )
{
return &PRVM_EDICT_NUM( index )->priv.cl->current;
}
entity_state_t *CL_GetLocalPlayer( void )
{
return &PRVM_EDICT_NUM( cl.playernum + 1 )->priv.cl->current;
}
int CL_GetMaxClients( void )
{
return com.atoi(cl.configstrings[CS_MAXCLIENTS]);
}
/*
===============================================================================
Client Builtin Functions

3
engine/client/cl_view.c
View File

@ -181,7 +181,8 @@ void V_RenderView( void )
cl.refdef.areabits = cl.frame.areabits;
cl.refdef.rdflags = cl.frame.ps.renderfx;
cl.refdef.fov_y = V_CalcFov( cl.refdef.fov_x, cl.refdef.rect.width, cl.refdef.rect.height );
cl.refdef.time = cls.realtime * 0.001f; // render use realtime now
cl.refdef.time = cl.time * 0.001f; // cl.time for right lerping
cl.refdef.oldtime = cl.oldtime * 0.001f;
}
re->RenderFrame( &cl.refdef );
}

7
engine/client/client.h
View File

@ -99,6 +99,7 @@ typedef struct
vec3_t viewangles;
dword time; // this is the time value that the client
dword oldtime;
// is rendering at. always <= cls.realtime
float lerpfrac; // between oldframe and frame
@ -456,6 +457,7 @@ void CL_Stop_f( void );
//
void CL_InitClientProgs( void );
void CL_FreeClientProgs( void );
int CL_GetMaxClients( void );
void CL_DrawHUD( void );
edict_t *CL_GetEdict( int entnum );
float *CL_FadeColor( float starttime, float endtime );
@ -557,6 +559,8 @@ cdlight_t *CL_AllocDlight (int key);
void CL_AddParticles (void);
void CL_ClearEffects( void );
void CL_StudioEvent( mstudioevent_t *event, entity_state_t *ent );
entity_state_t *CL_GetEdictByIndex( int index );
entity_state_t *CL_GetLocalPlayer( void );
//
// cl_pred.c
@ -591,7 +595,7 @@ extern field_t g_consoleField;
extern field_t chatField;
//
// cl_keys.c
// cl_menu.c
//
extern bool ui_active;
extern const int vm_ui_numbuiltins;
@ -624,6 +628,7 @@ void Key_ClearStates (void);
char *Key_KeynumToString (int keynum);
int Key_StringToKeynum (char *str);
int Key_GetKey( char *binding );
void Key_EnumCmds_f( void );
//
// cl_cin.c

124
engine/common/con_keys.c
View File

@ -40,72 +40,72 @@ static int matchCount;
keyname_t keynames[] =
{
{"TAB", K_TAB, "inven" },
{"ENTER", K_ENTER, "invuse" },
{"ESCAPE", K_ESCAPE, "togglemenu" }, // hardcoded
{"SPACE", K_SPACE, "+moveup" },
{"BACKSPACE", K_BACKSPACE, "invdrop" },
{"UPARROW", K_UPARROW,"+forward" },
{"DOWNARROW", K_DOWNARROW, "+back" },
{"LEFTARROW", K_LEFTARROW, "+left" },
{"RIGHTARROW", K_RIGHTARROW, "+right" },
{"ALT", K_ALT, "" },
{"CTRL", K_CTRL, "+attack" },
{"SHIFT", K_SHIFT, "+speed" },
{"COMMAND", K_COMMAND, "" },
{"CAPSLOCK", K_CAPSLOCK, "" },
{"F1", K_F1, "cmd help" },
{"F2", K_F2, "menu_savegame" },
{"F3", K_F3, "menu_loadgame" },
{"F4", K_F4, "menu_keys" },
{"F5", K_F5, "menu_startserver" },
{"F6", K_F6, "save quick" },
{"F7", K_F7, "load quick" }, // half-life style
{"F8", K_F8, "" },
{"F9", K_F9, "load quick" }, // quake style
{"F10", K_F10, "menu_quit" },
{"F11", K_F11, "" },
{"F12", K_F12, "screenshot" },
{"INS", K_INS, "+klook" },
{"DEL", K_DEL, "+lookdown" },
{"PGDN", K_PGDN, "+lookup" },
{"PGUP", K_PGUP, "" },
{"HOME", K_HOME, "" },
{"END", K_END, "centerview" },
{"TAB", K_TAB, "" },
{"ENTER", K_ENTER, "" },
{"ESCAPE", K_ESCAPE, "togglemenu" }, // hardcoded
{"SPACE", K_SPACE, "+moveup" },
{"BACKSPACE", K_BACKSPACE, "" },
{"UPARROW", K_UPARROW, "+forward" },
{"DOWNARROW", K_DOWNARROW, "+back" },
{"LEFTARROW", K_LEFTARROW, "+left" },
{"RIGHTARROW", K_RIGHTARROW, "+right" },
{"ALT", K_ALT, "+strafe" },
{"CTRL", K_CTRL, "+attack" },
{"SHIFT", K_SHIFT, "+speed" }, // replace with +attack2 ?
{"COMMAND", K_COMMAND, "" },
{"CAPSLOCK", K_CAPSLOCK, "" },
{"F1", K_F1, "cmd help" },
{"F2", K_F2, "menu_savegame" },
{"F3", K_F3, "menu_loadgame" },
{"F4", K_F4, "menu_keys" },
{"F5", K_F5, "menu_startserver" },
{"F6", K_F6, "save quick" },
{"F7", K_F7, "load quick" }, // half-life style
{"F8", K_F8, "" },
{"F9", K_F9, "load quick" }, // quake style
{"F10", K_F10, "menu_quit" },
{"F11", K_F11, "" },
{"F12", K_F12, "screenshot" },
{"INS", K_INS, "" },
{"DEL", K_DEL, "+lookdown" },
{"PGDN", K_PGDN, "+lookup" },
{"PGUP", K_PGUP, "" },
{"HOME", K_HOME, "" },
{"END", K_END, "centerview" },
// mouse buttouns
{"MOUSE1", K_MOUSE1, "+attack" },
{"MOUSE2", K_MOUSE2, "" },
{"MOUSE3", K_MOUSE3, "" },
{"MOUSE4", K_MOUSE4, "" },
{"MOUSE5", K_MOUSE5, "" },
{"MWHEELUP", K_MWHEELUP, "" },
{"MWHEELDOWN", K_MWHEELDOWN, "" },
{"MOUSE1", K_MOUSE1, "+attack" },
{"MOUSE2", K_MOUSE2, "+atack2" },
{"MOUSE3", K_MOUSE3, "" },
{"MOUSE4", K_MOUSE4, "" },
{"MOUSE5", K_MOUSE5, "" },
{"MWHEELUP", K_MWHEELUP, "" },
{"MWHEELDOWN", K_MWHEELDOWN, "" },
// digital keyboard
{"KP_HOME", K_KP_HOME, "" },
{"KP_UPARROW", K_KP_UPARROW, "+forward"},
{"KP_PGUP", K_KP_PGUP, "" },
{"KP_LEFTARROW", K_KP_LEFTARROW, "+left" },
{"KP_5", K_KP_5, "" },
{"KP_RIGHTARROW", K_KP_RIGHTARROW, "+right" },
{"KP_END", K_KP_END, "centerview" },
{"KP_DOWNARROW", K_KP_DOWNARROW, "+back" },
{"KP_PGDN", K_KP_PGDN, "+lookup" },
{"KP_ENTER", K_KP_ENTER, "invuse" },
{"KP_INS", K_KP_INS, "+klook" },
{"KP_DEL", K_KP_DEL, "+lookdown" },
{"KP_SLASH", K_KP_SLASH, "" },
{"KP_MINUS", K_KP_MINUS, "" },
{"KP_PLUS", K_KP_PLUS, "" },
{"KP_NUMLOCK", K_KP_NUMLOCK, "" },
{"KP_STAR", K_KP_STAR, "" },
{"KP_EQUALS", K_KP_EQUALS, "" },
{"PAUSE", K_PAUSE, "pause" },
{"KP_HOME", K_KP_HOME, "" },
{"KP_UPARROW", K_KP_UPARROW, "+forward" },
{"KP_PGUP", K_KP_PGUP, "" },
{"KP_LEFTARROW", K_KP_LEFTARROW, "+left" },
{"KP_5", K_KP_5, "" },
{"KP_RIGHTARROW", K_KP_RIGHTARROW, "+right" },
{"KP_END", K_KP_END, "centerview" },
{"KP_DOWNARROW", K_KP_DOWNARROW, "+back" },
{"KP_PGDN", K_KP_PGDN, "+lookup" },
{"KP_ENTER", K_KP_ENTER, "" },
{"KP_INS", K_KP_INS, "" },
{"KP_DEL", K_KP_DEL, "+lookdown" },
{"KP_SLASH", K_KP_SLASH, "" },
{"KP_MINUS", K_KP_MINUS, "" },
{"KP_PLUS", K_KP_PLUS, "" },
{"KP_NUMLOCK", K_KP_NUMLOCK, "" },
{"KP_STAR", K_KP_STAR, "" },
{"KP_EQUALS", K_KP_EQUALS, "" },
{"PAUSE", K_PAUSE, "pause" },
// raw semicolon seperates commands
{"SEMICOLON", ';', "" },
{NULL, 0, NULL },
{"SEMICOLON", ';', "" },
{NULL, 0, NULL },
};
/*
@ -276,7 +276,6 @@ void Field_CompleteCommand( field_t *field )
Cvar_LookupVars( 0, NULL, NULL, PrintMatches );
}
/*
===================
Field_Draw
@ -998,7 +997,7 @@ void Key_Bindlist_f( void )
Key_Init
===================
*/
void Key_Init (void)
void Key_Init( void )
{
keyname_t *kn;
@ -1007,6 +1006,7 @@ void Key_Init (void)
Cmd_AddCommand ("unbind", Key_Unbind_f, "removes a command on the specified key in bindmap" );
Cmd_AddCommand ("unbindall", Key_Unbindall_f, "removes all commands from all keys in bindmap" );
Cmd_AddCommand ("bindlist", Key_Bindlist_f, "display current key bindings" );
Cmd_AddCommand ("makehelp", Key_EnumCmds_f, "write help.txt that contains all console cvars and cmds" );
// setup hardcode binding. "unbindall" from keys.rc will be reset it
for( kn = keynames; kn->name; kn++ ) Key_SetBinding( kn->keynum, kn->binding );

31
engine/common/con_utils.c
View File

@ -687,6 +687,14 @@ static void Cmd_WriteCvar(const char *name, const char *string, const char *desc
FS_Printf(f, "seta %s \"%s\"\n", name, string );
}
static void Cmd_WriteHelp(const char *name, const char *unused, const char *desc, void *f )
{
if( !desc ) return; // ignore fantom cmds
if( !com.strcmp( desc, "" )) return; // blank description
if( name[0] == '+' || name[0] == '-' ) return; // key bindings
FS_Printf( f, "%s\t\t\t\"%s\"\n", name, desc );
}
void Cmd_WriteVariables( file_t *f )
{
FS_Printf( f, "unsetall\n" );
@ -704,7 +712,7 @@ void CL_WriteConfiguration( void )
{
file_t *f;
if (cls.state == ca_uninitialized) return;
if( !cls.initialized ) return;
f = FS_Open("scripts/config/keys.rc", "w");
if(f)
@ -729,4 +737,25 @@ void CL_WriteConfiguration( void )
FS_Close (f);
}
else MsgDev( D_ERROR, "Couldn't write vars.rc.\n");
}
void Key_EnumCmds_f( void )
{
file_t *f = FS_Open( "docs/help.txt", "w" );
if( f )
{
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "//\t\t\tCopyright XashXT Group 2007 ©\n");
FS_Printf( f, "//\t\thelp.txt - xash commands and console variables\n");
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "\n\n\t\t\tconsole variables\n\n");
Cvar_LookupVars( 0, NULL, f, Cmd_WriteHelp );
FS_Printf( f, "\n\n\t\t\tconsole commands\n\n");
Cmd_LookupCmds( NULL, f, Cmd_WriteHelp );
FS_Printf( f, "\n\n");
FS_Close( f );
}
else MsgDev( D_ERROR, "Couldn't write help.txt.\n");
Msg( "write docs/help.txt" );
}

5
engine/common/engfuncs.c
View File

@ -6,6 +6,7 @@
#include "common.h"
#include "byteorder.h"
#include "mathlib.h"
#include "const.h"
#include "client.h"
#include "server.h"
@ -1274,14 +1275,12 @@ void VM_drawmodel( void )
re->ClearScene( &refdef );
re->RegisterModel( modname, MAX_MODELS - 1 );
ent.renderfx = RF_FULLBRIGHT;
ent.ed_type = ED_CLIENT;
ent.model.sequence = sequence;
ent.model.index = MAX_MODELS - 1;
VectorCopy( origin, ent.origin );
VectorCopy( origin, ent.old_origin );
VectorCopy( angles, ent.angles );
ent.model.controller[0] = ent.model.controller[1] = 90.0;
ent.model.controller[2] = ent.model.controller[3] = 180.0;
ent.model.frame = frame += 0.7f;//FXIME
re->AddRefEntity( &refdef, &ent, NULL, 1.0f );

3
engine/host.c
View File

@ -79,6 +79,9 @@ void Host_InitRender( void )
// studio callbacks
ri.StudioEvent = CL_StudioEvent;
ri.ShowCollision = pe->DrawCollision;
ri.GetClientEdict = CL_GetEdictByIndex;
ri.GetLocalPlayer = CL_GetLocalPlayer;
ri.GetMaxClients = CL_GetMaxClients;
ri.WndProc = IN_WndProc;
Sys_LoadLibrary( &render_dll );

1
engine/server/sv_client.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "common.h"
#include "const.h"
#include "server.h"
typedef struct ucmd_s

9
engine/server/sv_edict.h
View File

@ -93,21 +93,22 @@ struct sv_entvars_s
float alpha;
float frame;
float speed;
float animtime;
float sequence;
float animtime;
float gaitsequence;
float effects;
float colormap;
float renderfx;
float flags;
float aiflags;
float spawnflags;
vec3_t view_ofs;
vec3_t v_angle;
vec3_t view_ofs;
vec3_t punchangle;
float button0;
float button1;
float button2;
float impulse;
vec3_t punchangle;
string_t v_model;
float v_frame;
float v_body;
@ -138,6 +139,6 @@ struct sv_entvars_s
float team;
};
#define PROG_CRC_SERVER 1476
#define PROG_CRC_SERVER 15812
#endif//SV_EDICT_H

1
engine/server/sv_frame.c
View File

@ -80,6 +80,7 @@ void SV_UpdateEntityState( edict_t *ent )
ent->priv.sv->s.model.skin = (short)ent->progs.sv->skin; // studio model skin
ent->priv.sv->s.model.body = (byte)ent->progs.sv->body; // studio model submodel
ent->priv.sv->s.model.frame = ent->progs.sv->frame; // any model current frame
ent->priv.sv->s.model.gaitsequence = (int)ent->progs.sv->gaitsequence;// player sequence, that will be playing on client
ent->priv.sv->s.model.sequence = (byte)ent->progs.sv->sequence; // studio model sequence
ent->priv.sv->s.effects = (uint)ent->progs.sv->effects; // shared client and render flags
ent->priv.sv->s.renderfx = (int)ent->progs.sv->renderfx; // renderer flags

103
engine/server/sv_progs.c
View File

@ -1677,6 +1677,104 @@ void PF_tracebox( void )
VM_SetTraceGlobals( &trace );
}
/*
=============
PF_lookupactivity
float LookupActivity( string model, float activity )
=============
*/
void PF_lookupactivity( void )
{
cmodel_t *mod;
mstudioseqdesc_t *pseqdesc;
studiohdr_t *pstudiohdr;
int i, seq = -1;
int activity, weighttotal = 0;
if(!VM_ValidateArgs( "LookupActivity", 2 )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = 0;
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (studiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
activity = (int)PRVM_G_FLOAT(OFS_PARM1);
for( i = 0; i < pstudiohdr->numseq; i++)
{
if( pseqdesc[i].activity == activity )
{
weighttotal += pseqdesc[i].actweight;
if( !weighttotal || RANDOM_LONG( 0, weighttotal - 1 ) < pseqdesc[i].actweight )
seq = i;
}
}
PRVM_G_FLOAT(OFS_RETURN) = seq;
}
/*
=============
PF_geteyepos
vector GetEyePosition( string model )
=============
*/
void PF_geteyepos( void )
{
cmodel_t *mod;
studiohdr_t *pstudiohdr;
if(!VM_ValidateArgs( "GetEyePosition", 1 )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
VectorCopy( vec3_origin, PRVM_G_VECTOR(OFS_RETURN));
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (studiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
VectorCopy( pstudiohdr->eyeposition, PRVM_G_VECTOR(OFS_RETURN));
}
/*
=============
PF_lookupsequence
float LookupSequence( string model, string label )
=============
*/
void PF_lookupsequence( void )
{
cmodel_t *mod;
studiohdr_t *pstudiohdr;
mstudioseqdesc_t *pseqdesc;
int i;
if(!VM_ValidateArgs( "LookupSequence", 2 )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
VM_ValidateString(PRVM_G_STRING(OFS_PARM1));
PRVM_G_FLOAT(OFS_RETURN) = -1;
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (studiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
for( i = 0; i < pstudiohdr->numseq; i++ )
{
if(!com.stricmp( pseqdesc[i].label, PRVM_G_STRING(OFS_PARM1)))
{
PRVM_G_FLOAT(OFS_RETURN) = i;
break;
}
}
}
/*
=============
PF_aim
@ -2297,7 +2395,7 @@ PF_inphs, // #119 entity EntitiesInPHS( entity ent, float player )
PF_makevectors, // #120 void makevectors( vector dir, float hand )
VM_EdictError, // #121 void objerror( string s )
PF_dropclient, // #122 void dropclient( entity client )
NULL, // #123 --reserved--
PF_lookupactivity, // #123 float LookupActivity( string model, float activity )
PF_create, // #124 void CreateNamedEntity( string classname, vector org, vector ang )
PF_makestatic, // #125 void makestatic(entity e)
NULL, // #126 isEntOnFloor
@ -2342,13 +2440,14 @@ NULL, // #164 setView
NULL, // #165 crosshairangle
PF_AreaPortalState, // #166 void areaportal( float num, float state )
NULL, // #167 compareFileTime
NULL, // #168
PF_geteyepos, // #168 vector GetEyePosition( string model )
PF_InfoPrint, // #169 void Info_Print( entity client )
PF_InfoValueForKey, // #170 string Info_ValueForKey( entity client, string key )
PF_InfoRemoveKey, // #171 void Info_RemoveKey( entity client, string key )
PF_InfoSetValueForKey, // #172 void Info_SetValueForKey( entity client, string key, string value )
PF_setsky, // #173 void setsky( string name, vector angles, float speed )
NULL, // #174 staticDecal
PF_lookupsequence // #175 float LookupSequence( string model, string label )
};
const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t); //num of builtins

6
imglib/imagelib.h
View File

@ -39,10 +39,12 @@ rgbdata_t *Image_Load(const char *filename, const byte *buffer, size_t buffsize
//
// formats
//
bool Image_LoadMIP( const char *name, const byte *buffer, size_t filesize );
bool Image_SaveMIP( const char *name, rgbdata_t *pix, int saveformat );
bool Image_LoadTGA( const char *name, const byte *buffer, size_t filesize );
bool Image_SaveTGA( const char *name, rgbdata_t *pix, int saveformat);
bool Image_SaveTGA( const char *name, rgbdata_t *pix, int saveformat );
bool Image_LoadDDS( const char *name, const byte *buffer, size_t filesize );
bool Image_SaveDDS( const char *name, rgbdata_t *pix, int saveformat);
bool Image_SaveDDS( const char *name, rgbdata_t *pix, int saveformat );
//
// img_utils.c

100
imglib/img_mip.c Normal file
View File

@ -0,0 +1,100 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// img_mip.c - hl1 q1 image mips
//=======================================================================
#include "imagelib.h"
#include "byteorder.h"
#include "img_formats.h"
/*
=============
Image_LoadMIP
=============
*/
bool Image_LoadMIP( const char *name, const byte *buffer, size_t filesize )
{
dmip_t mip;
byte *fin, *pal;
int ofs[4], rendermode;
int i, k, l, pixels, numcolors;
if( filesize < (int)sizeof(mip))
{
MsgDev( D_ERROR, "Image_LoadMIP: file (%s) have invalid size\n", name );
return false;
}
memset( &pic, 0, sizeof(pic));
Mem_Copy(&mip, buffer, sizeof(mip));
pic.width = LittleLong(mip.width);
pic.height = LittleLong(mip.height);
for(i = 0; i < 4; i++) ofs[i] = LittleLong(mip.offsets[i]);
pixels = pic.width * pic.height;
pic.numLayers = 1;
pic.type = PF_RGBA_32;
if(!com.stricmp( savedname, "gfx/conchars" ))
{
// greatest hack from id software
pic.width = pic.height = 128;
pic.flags |= IMAGE_HAS_ALPHA;
rendermode = LUMP_QFONT;
pixels = pic.width * pic.height;
pal = NULL; // clear palette
fin = buffer;
com.snprintf( filepath, MAX_STRING, "%s/gfx/%s.tga", gs_gamedir, savedname );
}
else if(filesize >= (int)sizeof(mip) + ((pixels * 85)>>6) + sizeof(short) + 768)
{
// half-life 1.0.0.1 mip version with palette
fin = buffer + mip.offsets[0];
pal = buffer + mip.offsets[0] + (((pic.width * pic.height) * 85)>>6);
numcolors = BuffLittleShort( pal );
if(numcolors != 256) pal = NULL; // corrupted mip ?
else pal += sizeof(short); // skip colorsize
// detect rendermode
if( com.strchr( savedname, '{' ))
{
// qlumpy used this color for transparent textures, otherwise it's decals
if(pal[255*3+0] == 0 && pal[255*3+1] == 0 && pal[255*3+2] == 255)
rendermode = LUMP_TRANSPARENT;
else rendermode = LUMP_DECAL;
pic.flags |= IMAGE_HAS_ALPHA;
}
else rendermode = LUMP_NORMAL;
com.snprintf( filepath, MAX_STRING, "%s/textures/%s.tga", gs_gamedir, savedname );
}
else if(filesize >= (int)sizeof(mip) + ((pixels * 85)>>6))
{
// quake1 1.01 mip version without palette
pal = NULL; // clear palette
rendermode = LUMP_NORMAL;
fin = buffer + mip.offsets[0];
com.snprintf( filepath, MAX_STRING, "%s/textures/%s.tga", gs_gamedir, savedname );
}
else
{
MsgDev( D_ERROR, "LoadMIP: lump (%s) is corrupted\n", savedname );
return false;
}
if(!Lump_ValidSize( savedname, &pic, 640, 640 )) return false;
pic.size = pixels * 4;
pic.buffer = (byte *)Mem_Alloc(zonepool, pic.size );
Conv_GetPaletteLMP( pal, rendermode );
Conv_Copy8bitRGBA( fin, pic.buffer, pixels );
Image->SaveImage( filepath, &pic ); // save converted image
Conv_CreateShader( name, &pic, "mip", NULL, 0, 0 );
Mem_Free( pic.buffer ); // release buffer
Msg("%s.mip\n", savedname ); // echo to console about current texture
return true;
}
bool Image_SaveMIP( const char *name, rgbdata_t *pix, int saveformat )
{
return false;
}

2
launch/common/filesystem.c
View File

@ -1495,7 +1495,7 @@ void FS_Init( void )
Cmd_AddCommand( "fs_path", FS_Path_f, "show filesystem search pathes" );
Cmd_AddCommand( "fs_clearpaths", FS_ClearPaths_f, "clear filesystem search pathes" );
fs_wadsupport = Cvar_Get( "fs_wadsupport", "0", CVAR_SYSTEMINFO, "enable wad-archive support" );
fs_defaultdir = Cvar_Get( "fs_defaultfir", "tmpQuArK", CVAR_SYSTEMINFO, "engine default directory" );
fs_defaultdir = Cvar_Get( "fs_defaultdir", "tmpQuArK", CVAR_SYSTEMINFO, "engine default directory" );
Cbuf_ExecuteText( EXEC_NOW, "systemcfg\n" );
Cbuf_Execute(); // apply system cvars immediately

4
physic/cm_local.h
View File

@ -211,8 +211,8 @@ typedef struct studio_s
studiohdr_t *hdr;
mstudiomodel_t *submodel;
mstudiobodyparts_t *bodypart;
matrix3x4 rotmatrix;
matrix3x4 bones[MAXSTUDIOBONES];
matrix4x4 rotmatrix;
matrix4x4 bones[MAXSTUDIOBONES];
vec3_t vertices[MAXSTUDIOVERTS];
vec3_t indices[MAXSTUDIOVERTS];
vec3_t vtransform[MAXSTUDIOVERTS];

23
physic/cm_model.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
clipmap_t cm;
studio_t studio;
@ -81,6 +82,7 @@ CM_FreeModel
*/
void CM_FreeModel( cmodel_t *mod )
{
Msg("free model %s\n", mod->name );
Mem_FreePool( &mod->mempool );
memset( mod, 0, sizeof(*mod));
mod = NULL;
@ -882,7 +884,7 @@ void CM_FreeBSP( void )
CM_FreeWorld();
for( i = 0, mod = &cm.cmodels[0]; i < cm.numcmodels; i++, mod++)
{
CM_FreeModel( mod );
if( mod->name ) CM_FreeModel( mod );
}
}
@ -1063,10 +1065,10 @@ void CM_EndRegistration( void )
cmodel_t *mod;
int i;
for (i = 0, mod = &cm.cmodels[0]; i < cm.numcmodels; i++, mod++)
for( i = 0, mod = &cm.cmodels[0]; i < cm.numcmodels; i++, mod++)
{
if(!mod->name[0]) continue;
if(mod->registration_sequence != registration_sequence)
if( mod->registration_sequence != registration_sequence )
CM_FreeModel( mod );
}
}
@ -1214,20 +1216,16 @@ void CM_StudioSetupBones( void )
mstudiobone_t *pbones;
static float pos[MAXSTUDIOBONES][3];
static vec4_t q[MAXSTUDIOBONES];
matrix3x4 bonematrix;
matrix4x4 bonematrix;
CM_StudioCalcRotations( pos, q );
pbones = (mstudiobone_t *)((byte *)studio.hdr + studio.hdr->boneindex);
for (i = 0; i < studio.hdr->numbones; i++)
{
QuaternionMatrix( q[i], bonematrix );
bonematrix[0][3] = pos[i][0];
bonematrix[1][3] = pos[i][1];
bonematrix[2][3] = pos[i][2];
if (pbones[i].parent == -1) R_ConcatTransforms (studio.rotmatrix, bonematrix, studio.bones[i]);
else R_ConcatTransforms(studio.bones[pbones[i].parent], bonematrix, studio.bones[i]);
Matrix4x4_FromOriginQuat( bonematrix, pos[i][0], pos[i][1], pos[i][2], q[i][0], q[i][1], q[i][2], q[i][3] );
if( pbones[i].parent == -1 ) Matrix4x4_ConcatTransforms( studio.bones[i], studio.rotmatrix, bonematrix );
else Matrix4x4_ConcatTransforms( studio.bones[i], studio.bones[pbones[i].parent], bonematrix );
}
}
@ -1344,6 +1342,8 @@ bool CM_StudioModel( byte *buffer, uint filesize )
loadmodel->numbodies = 0;
loadmodel->type = mod_studio;
loadmodel->extradata = Mem_Alloc( loadmodel->mempool, filesize );
Mem_Copy( loadmodel->extradata, buffer, filesize );
// calcualte bounding box
pseqdesc = (mstudioseqdesc_t *)((byte *)phdr + phdr->seqindex);
@ -1416,7 +1416,6 @@ cmodel_t *CM_RegisterModel( const char *name )
MsgDev(D_WARN, "CM_InlineModel: bad submodel number %d\n", i );
return NULL;
}
// prolonge registration
cm.bmodels[i].registration_sequence = registration_sequence;
return &cm.bmodels[i];

5
physic/cm_pmove.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
int characterID;
uint m_jumpTimer;
@ -205,11 +206,11 @@ void CM_ServerMove( pmove_t *pmove )
collisionPadding[2][2] = step[0];
// get the transpose of the matrix
MatrixTranspose( transpose, collisionPadding );
Matrix4x4_Transpose( transpose, collisionPadding );
VectorScale( transpose[0], dist / m_maxTranslation, transpose[0] ); // scale factor
// calculate and oblique scale matrix by using a similar transformation matrix of the for, R'* S * R
MatrixConcat( collisionPadding, collisionPadding, transpose );
Matrix4x4_Concat( collisionPadding, collisionPadding, transpose );
}
// set the collision modifierMatrix;

30
public/const.h Normal file
View File

@ -0,0 +1,30 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// const.h - shared engine constants
//=======================================================================
#ifndef CONST_H
#define CONST_H
// entity_state_t->renderfx
#define RF_MINLIGHT (1<<0) // allways have some light (viewmodel)
#define RF_PLAYERMODEL (1<<1) // don't draw through eyes, only mirrors
#define RF_VIEWMODEL (1<<2) // it's a viewmodel
#define RF_FULLBRIGHT (1<<3) // allways draw full intensity
#define RF_DEPTHHACK (1<<4) // for view weapon Z crunching
#define RF_TRANSLUCENT (1<<5)
#define RF_IR_VISIBLE (1<<6) // skin is an index in image_precache
#define RF_HOLOGRAMM (1<<7)
// entity_state_t->effects
#define EF_BRIGHTFIELD (1<<0) // swirling cloud of particles
#define EF_MUZZLEFLASH (1<<1) // single frame ELIGHT on entity attachment 0
#define EF_BRIGHTLIGHT (1<<2) // DLIGHT centered at entity origin
#define EF_DIMLIGHT (1<<3) // player flashlight
#define EF_INVLIGHT (1<<4) // get lighting from ceiling
#define EF_NOINTERP (1<<5) // don't interpolate the next frame
#define EF_LIGHT (1<<6) // rocket flare glow sprite
#define EF_NODRAW (1<<7) // don't draw entity
#define EF_TELEPORT (1<<8) // create teleport splash
#define EF_ROTATE (1<<9) // rotate bonus item
#endif//CONST_H

112
public/mathlib.h
View File

@ -206,35 +206,11 @@ _inline bool VectorCompare (const vec3_t v1, const vec3_t v2)
return true;
}
_inline bool VectorICompare( const int* v1, const int* v2 )
{
int i;
for( i = 0; i < 3; i++ )
if( abs(v1[i] - v2[i]) > 0)
return false;
return true;
}
_inline void VectorRotate (const vec3_t in1, vec3_t in2[3], vec3_t out)
{
out[0] = DotProduct(in1, in2[0]);
out[1] = DotProduct(in1, in2[1]);
out[2] = DotProduct(in1, in2[2]);
}
// rotate by the inverse of the matrix
_inline void VectorIRotate (const vec3_t in1, const matrix3x4 in2, vec3_t out)
{
out[0] = in1[0] * in2[0][0] + in1[1] * in2[1][0] + in1[2] * in2[2][0];
out[1] = in1[0] * in2[0][1] + in1[1] * in2[1][1] + in1[2] * in2[2][1];
out[2] = in1[0] * in2[0][2] + in1[1] * in2[1][2] + in1[2] * in2[2][2];
}
/*
====================
VectorTransform
FIXME: replace with Matrix4x4_Transform
====================
*/
_inline void VectorTransform (const vec3_t in1, matrix3x4 in2, vec3_t out)
@ -244,7 +220,7 @@ _inline void VectorTransform (const vec3_t in1, matrix3x4 in2, vec3_t out)
out[2] = DotProduct(in1, in2[2]) + in2[2][3];
}
_inline void CrossProduct (vec3_t v1, vec3_t v2, vec3_t cross)
_inline void CrossProduct( vec3_t v1, vec3_t v2, vec3_t cross )
{
cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
@ -284,26 +260,6 @@ _inline void VectorVectors(vec3_t forward, vec3_t right, vec3_t up)
CrossProduct(right, forward, up);
}
_inline void MatrixTranspose( matrix4x4 out, const matrix4x4 in1 )
{
out[0][0] = in1[0][0];
out[0][1] = in1[1][0];
out[0][2] = in1[2][0];
out[0][3] = in1[3][0];
out[1][0] = in1[0][1];
out[1][1] = in1[1][1];
out[1][2] = in1[2][1];
out[1][3] = in1[3][1];
out[2][0] = in1[0][2];
out[2][1] = in1[1][2];
out[2][2] = in1[2][2];
out[2][3] = in1[3][2];
out[3][0] = in1[0][3];
out[3][1] = in1[1][3];
out[3][2] = in1[2][3];
out[3][3] = in1[3][3];
}
_inline void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
{
float angle;
@ -711,28 +667,6 @@ _inline void QuaternionAngles( vec4_t q, vec3_t angles )
angles[ROLL] = RAD2DEG( atan2(m23, m33));
}
/*
====================
QuaternionMatrix
====================
*/
_inline void QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] )
{
matrix[0][0] = 1.0 - 2.0 * quaternion[1] * quaternion[1] - 2.0 * quaternion[2] * quaternion[2];
matrix[1][0] = 2.0 * quaternion[0] * quaternion[1] + 2.0 * quaternion[3] * quaternion[2];
matrix[2][0] = 2.0 * quaternion[0] * quaternion[2] - 2.0 * quaternion[3] * quaternion[1];
matrix[0][1] = 2.0 * quaternion[0] * quaternion[1] - 2.0 * quaternion[3] * quaternion[2];
matrix[1][1] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[2] * quaternion[2];
matrix[2][1] = 2.0 * quaternion[1] * quaternion[2] + 2.0 * quaternion[3] * quaternion[0];
matrix[0][2] = 2.0 * quaternion[0] * quaternion[2] + 2.0 * quaternion[3] * quaternion[1];
matrix[1][2] = 2.0 * quaternion[1] * quaternion[2] - 2.0 * quaternion[3] * quaternion[0];
matrix[2][2] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[1] * quaternion[1];
}
/*
====================
QuaternionSlerp
@ -834,26 +768,6 @@ _inline void R_ConcatTransforms( matrix3x4 in1, matrix3x4 in2, matrix3x4 out )
out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] + in1[2][2] * in2[2][3] + in1[2][3];
}
_inline void MatrixConcat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 )
{
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] + in1[0][2] * in2[2][0] + in1[0][3] * in2[3][0];
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] + in1[0][2] * in2[2][1] + in1[0][3] * in2[3][1];
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] + in1[0][2] * in2[2][2] + in1[0][3] * in2[3][2];
out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] + in1[0][2] * in2[2][3] + in1[0][3] * in2[3][3];
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] + in1[1][2] * in2[2][0] + in1[1][3] * in2[3][0];
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] + in1[1][2] * in2[2][1] + in1[1][3] * in2[3][1];
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] + in1[1][2] * in2[2][2] + in1[1][3] * in2[3][2];
out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] + in1[1][2] * in2[2][3] + in1[1][3] * in2[3][3];
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] + in1[2][2] * in2[2][0] + in1[2][3] * in2[3][0];
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] + in1[2][2] * in2[2][1] + in1[2][3] * in2[3][1];
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] + in1[2][2] * in2[2][2] + in1[2][3] * in2[3][2];
out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] + in1[2][2] * in2[2][3] + in1[2][3] * in2[3][3];
out[3][0] = in1[3][0] * in2[0][0] + in1[3][1] * in2[1][0] + in1[3][2] * in2[2][0] + in1[3][3] * in2[3][0];
out[3][1] = in1[3][0] * in2[0][1] + in1[3][1] * in2[1][1] + in1[3][2] * in2[2][1] + in1[3][3] * in2[3][1];
out[3][2] = in1[3][0] * in2[0][2] + in1[3][1] * in2[1][2] + in1[3][2] * in2[2][2] + in1[3][3] * in2[3][2];
out[3][3] = in1[3][0] * in2[0][3] + in1[3][1] * in2[1][3] + in1[3][2] * in2[2][3] + in1[3][3] * in2[3][3];
}
_inline void TransformRGB( vec3_t in, vec3_t out )
{
out[0] = in[0]/255.0f;
@ -924,28 +838,6 @@ _inline vec_t ColorNormalize (vec3_t in, vec3_t out)
return max;
}
_inline int ColorStrlen( const char *string )
{
int len;
const char *p;
if( !string ) return 0;
len = 0;
p = string;
while( *p )
{
if(IsColorString( p ))
{
p += 2;
continue;
}
p++;
len++;
}
return len;
}
_inline void PlaneClassify( cplane_t *p )
{
// for optimized plane comparisons

184
public/matrixlib.h
View File

@ -6,7 +6,7 @@
#define BASEMATRIX_H
#include <math.h>
//#define OPENGL_STYLE
//#define OPENGL_STYLE //TODO: enable OpenGL style someday
static const matrix4x4 identitymatrix =
{
@ -16,6 +16,11 @@ static const matrix4x4 identitymatrix =
{ 0, 0, 0, 1 }, // ORIGIN
};
_inline void Matrix4x4_Copy( matrix4x4 out, const matrix4x4 in )
{
memcpy( out, in, sizeof(matrix4x4));
}
_inline void Matrix4x4_Transform( const matrix4x4 in, const float v[3], float out[3] )
{
#ifdef OPENGL_STYLE
@ -29,6 +34,20 @@ _inline void Matrix4x4_Transform( const matrix4x4 in, const float v[3], float ou
#endif
}
_inline void Matrix4x4_Rotate( const matrix4x4 in, const float v[3], float out[3] )
{
//FIXME: we need InvserseRotation of OpenGL style
#ifndef OPENGL_STYLE
out[0] = v[0] * in[0][0] + v[1] * in[1][0] + v[2] * in[2][0];
out[1] = v[0] * in[0][1] + v[1] * in[1][1] + v[2] * in[2][1];
out[2] = v[0] * in[0][2] + v[1] * in[1][2] + v[2] * in[2][2];
#else
out[0] = v[0] * in[0][0] + v[1] * in[0][1] + v[2] * in[0][2];
out[1] = v[0] * in[1][0] + v[1] * in[1][1] + v[2] * in[1][2];
out[2] = v[0] * in[2][0] + v[1] * in[2][1] + v[2] * in[2][2];
#endif
}
_inline void Matrix4x4_Transform3x3( const matrix4x4 in, const float v[3], float out[3] )
{
#ifdef OPENGL_STYLE
@ -302,4 +321,167 @@ _inline void Matrix4x4_CreateFromEntity( matrix4x4 out, double x, double y, doub
}
}
_inline void Matrix4x4_FromOriginQuat( matrix4x4 out, double ox, double oy, double oz, double x, double y, double z, double w )
{
#ifdef OPENGL_STYLE
out[0][0] = 1-2*(y*y+z*z);
out[1][0] = 2*(x*y-z*w);
out[2][0] = 2*(x*z+y*w);
out[3][0] = ox;
out[0][1] = 2*(x*y+z*w);
out[1][1] = 1-2*(x*x+z*z);
out[2][1] = 2*(y*z-x*w);
out[3][1] = oy;
out[0][2] = 2*(x*z-y*w);
out[1][2] = 2*(y*z+x*w);
out[2][2] = 1-2*(x*x+y*y);
out[3][2] = oz;
out[0][3] = 0;
out[1][3] = 0;
out[2][3] = 0;
out[3][3] = 1;
#else
out[0][0] = 1-2*(y*y+z*z);
out[0][1] = 2*(x*y-z*w);
out[0][2] = 2*(x*z+y*w);
out[0][3] = ox;
out[1][0] = 2*(x*y+z*w);
out[1][1] = 1-2*(x*x+z*z);
out[1][2] = 2*(y*z-x*w);
out[1][3] = oy;
out[2][0] = 2*(x*z-y*w);
out[2][1] = 2*(y*z+x*w);
out[2][2] = 1-2*(x*x+y*y);
out[2][3] = oz;
out[3][0] = 0;
out[3][1] = 0;
out[3][2] = 0;
out[3][3] = 1;
#endif
}
/*
================
ConcatTransforms
================
*/
_inline void Matrix4x4_ConcatTransforms( matrix4x4 out, matrix4x4 in1, matrix4x4 in2 )
{
#ifdef OPENGL_STYLE
out[0][0] = in1[0][0] * in2[0][0] + in1[1][0] * in2[0][1] + in1[2][0] * in2[0][2];
out[1][0] = in1[0][0] * in2[1][0] + in1[1][0] * in2[1][1] + in1[2][0] * in2[1][2];
out[2][0] = in1[0][0] * in2[2][0] + in1[1][0] * in2[2][1] + in1[2][0] * in2[2][2];
out[3][0] = in1[0][0] * in2[3][0] + in1[1][0] * in2[3][1] + in1[2][0] * in2[3][2] + in1[3][0];
out[0][1] = in1[0][1] * in2[0][0] + in1[1][1] * in2[0][1] + in1[2][1] * in2[0][2];
out[1][1] = in1[0][1] * in2[1][0] + in1[1][1] * in2[1][1] + in1[2][1] * in2[1][2];
out[2][1] = in1[0][1] * in2[2][0] + in1[1][1] * in2[2][1] + in1[2][1] * in2[2][2];
out[3][1] = in1[0][1] * in2[3][0] + in1[1][1] * in2[3][1] + in1[2][1] * in2[3][2] + in1[3][1];
out[0][2] = in1[0][2] * in2[0][0] + in1[1][2] * in2[0][1] + in1[2][2] * in2[0][2];
out[1][2] = in1[0][2] * in2[1][0] + in1[1][2] * in2[1][1] + in1[2][2] * in2[1][2];
out[2][2] = in1[0][2] * in2[2][0] + in1[1][2] * in2[2][1] + in1[2][2] * in2[2][2];
out[3][2] = in1[0][2] * in2[3][0] + in1[1][2] * in2[3][1] + in1[2][2] * in2[3][2] + in1[3][2];
#else
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] + in1[0][2] * in2[2][0];
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] + in1[0][2] * in2[2][1];
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] + in1[0][2] * in2[2][2];
out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] + in1[0][2] * in2[2][3] + in1[0][3];
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] + in1[1][2] * in2[2][0];
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] + in1[1][2] * in2[2][1];
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] + in1[1][2] * in2[2][2];
out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] + in1[1][2] * in2[2][3] + in1[1][3];
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] + in1[2][2] * in2[2][0];
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] + in1[2][2] * in2[2][1];
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] + in1[2][2] * in2[2][2];
out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] + in1[2][2] * in2[2][3] + in1[2][3];
#endif
}
_inline void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 )
{
#ifdef OPENGL_STYLE
out[0][0] = in1[0][0] * in2[0][0] + in1[1][0] * in2[0][1] + in1[2][0] * in2[0][2] + in1[3][0] * in2[0][3];
out[1][0] = in1[0][0] * in2[1][0] + in1[1][0] * in2[1][1] + in1[2][0] * in2[1][2] + in1[3][0] * in2[1][3];
out[2][0] = in1[0][0] * in2[2][0] + in1[1][0] * in2[2][1] + in1[2][0] * in2[2][2] + in1[3][0] * in2[2][3];
out[3][0] = in1[0][0] * in2[3][0] + in1[1][0] * in2[3][1] + in1[2][0] * in2[3][2] + in1[3][0] * in2[3][3];
out[0][1] = in1[0][1] * in2[0][0] + in1[1][1] * in2[0][1] + in1[2][1] * in2[0][2] + in1[3][1] * in2[0][3];
out[1][1] = in1[0][1] * in2[1][0] + in1[1][1] * in2[1][1] + in1[2][1] * in2[1][2] + in1[3][1] * in2[1][3];
out[2][1] = in1[0][1] * in2[2][0] + in1[1][1] * in2[2][1] + in1[2][1] * in2[2][2] + in1[3][1] * in2[2][3];
out[3][1] = in1[0][1] * in2[3][0] + in1[1][1] * in2[3][1] + in1[2][1] * in2[3][2] + in1[3][1] * in2[3][3];
out[0][2] = in1[0][2] * in2[0][0] + in1[1][2] * in2[0][1] + in1[2][2] * in2[0][2] + in1[3][2] * in2[0][3];
out[1][2] = in1[0][2] * in2[1][0] + in1[1][2] * in2[1][1] + in1[2][2] * in2[1][2] + in1[3][2] * in2[1][3];
out[2][2] = in1[0][2] * in2[2][0] + in1[1][2] * in2[2][1] + in1[2][2] * in2[2][2] + in1[3][2] * in2[2][3];
out[3][2] = in1[0][2] * in2[3][0] + in1[1][2] * in2[3][1] + in1[2][2] * in2[3][2] + in1[3][2] * in2[3][3];
out[0][3] = in1[0][3] * in2[0][0] + in1[1][3] * in2[0][1] + in1[2][3] * in2[0][2] + in1[3][3] * in2[0][3];
out[1][3] = in1[0][3] * in2[1][0] + in1[1][3] * in2[1][1] + in1[2][3] * in2[1][2] + in1[3][3] * in2[1][3];
out[2][3] = in1[0][3] * in2[2][0] + in1[1][3] * in2[2][1] + in1[2][3] * in2[2][2] + in1[3][3] * in2[2][3];
out[3][3] = in1[0][3] * in2[3][0] + in1[1][3] * in2[3][1] + in1[2][3] * in2[3][2] + in1[3][3] * in2[3][3];
#else
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] + in1[0][2] * in2[2][0] + in1[0][3] * in2[3][0];
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] + in1[0][2] * in2[2][1] + in1[0][3] * in2[3][1];
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] + in1[0][2] * in2[2][2] + in1[0][3] * in2[3][2];
out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] + in1[0][2] * in2[2][3] + in1[0][3] * in2[3][3];
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] + in1[1][2] * in2[2][0] + in1[1][3] * in2[3][0];
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] + in1[1][2] * in2[2][1] + in1[1][3] * in2[3][1];
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] + in1[1][2] * in2[2][2] + in1[1][3] * in2[3][2];
out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] + in1[1][2] * in2[2][3] + in1[1][3] * in2[3][3];
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] + in1[2][2] * in2[2][0] + in1[2][3] * in2[3][0];
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] + in1[2][2] * in2[2][1] + in1[2][3] * in2[3][1];
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] + in1[2][2] * in2[2][2] + in1[2][3] * in2[3][2];
out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] + in1[2][2] * in2[2][3] + in1[2][3] * in2[3][3];
out[3][0] = in1[3][0] * in2[0][0] + in1[3][1] * in2[1][0] + in1[3][2] * in2[2][0] + in1[3][3] * in2[3][0];
out[3][1] = in1[3][0] * in2[0][1] + in1[3][1] * in2[1][1] + in1[3][2] * in2[2][1] + in1[3][3] * in2[3][1];
out[3][2] = in1[3][0] * in2[0][2] + in1[3][1] * in2[1][2] + in1[3][2] * in2[2][2] + in1[3][3] * in2[3][2];
out[3][3] = in1[3][0] * in2[0][3] + in1[3][1] * in2[1][3] + in1[3][2] * in2[2][3] + in1[3][3] * in2[3][3];
#endif
}
_inline void Matrix4x4_Transpose( matrix4x4 out, const matrix4x4 in1 )
{
out[0][0] = in1[0][0];
out[0][1] = in1[1][0];
out[0][2] = in1[2][0];
out[0][3] = in1[3][0];
out[1][0] = in1[0][1];
out[1][1] = in1[1][1];
out[1][2] = in1[2][1];
out[1][3] = in1[3][1];
out[2][0] = in1[0][2];
out[2][1] = in1[1][2];
out[2][2] = in1[2][2];
out[2][3] = in1[3][2];
out[3][0] = in1[0][3];
out[3][1] = in1[1][3];
out[3][2] = in1[2][3];
out[3][3] = in1[3][3];
}
_inline void Matrix4x4_CreateScale( matrix4x4 out, double x )
{
out[0][0] = x;
out[0][1] = 0.0f;
out[0][2] = 0.0f;
out[0][3] = 0.0f;
out[1][0] = 0.0f;
out[1][1] = x;
out[1][2] = 0.0f;
out[1][3] = 0.0f;
out[2][0] = 0.0f;
out[2][1] = 0.0f;
out[2][2] = x;
out[2][3] = 0.0f;
out[3][0] = 0.0f;
out[3][1] = 0.0f;
out[3][2] = 0.0f;
out[3][3] = 1.0f;
}
_inline void Matrix4x4_ConcatScale( matrix4x4 out, double x )
{
matrix4x4 base, temp;
Matrix4x4_Copy( base, out );
Matrix4x4_CreateScale( temp, x );
Matrix4x4_Concat( out, base, temp );
}
#endif//BASEMATRIX_H

55
public/ref_dfiles.h
View File

@ -10,12 +10,12 @@
SPRITE MODELS
.spr32 extended version (Darkplaces non-paletted 32-bit sprites)
.spr extended version (Half-Life compatible sprites with some xash extensions)
==============================================================================
*/
#define IDSPRITEHEADER (('P'<<24)+('S'<<16)+('D'<<8)+'I') // little-endian "IDSP"
#define SPRITE_VERSION 32 // DarkPlaces SPR32
#define SPRITE_VERSION 2 // Half-Life sprites
typedef enum
{
@ -27,15 +27,16 @@ typedef enum
{
SPR_SINGLE = 0,
SPR_GROUP,
SPR_ANGLED
SPR_ANGLED // xash ext
} frametype_t;
typedef enum
{
SPR_SOLID = 0,
SPR_NORMAL = 0,
SPR_ADDITIVE,
SPR_GLOW,
SPR_ALPHA
SPR_INDEXALPHA,
SPR_ALPHTEST,
SPR_ADDGLOW // xash ext
} drawtype_t;
typedef enum
@ -45,8 +46,6 @@ typedef enum
SPR_FWD_PARALLEL,
SPR_ORIENTED,
SPR_FWD_PARALLEL_ORIENTED,
SPR_LABEL, // DP extension
SPR_LABEL_SCALE,
} angletype_t;
typedef enum
@ -61,7 +60,8 @@ typedef struct
int ident; // LittleLong 'ISPR'
int version; // current version 3
angletype_t type; // camera align
drawtype_t rendermode; // rendering mode (Xash3D ext)
drawtype_t texFormat; // rendering mode (Xash3D ext)
int boundingradius; // quick face culling
int bounds[2]; // minsmaxs
int numframes; // including groups
facetype_t facetype; // cullface (Xash3D ext)
@ -399,6 +399,27 @@ typedef struct
uint numtypes;
} dprograms_t;
/*
========================================================================
.MIP image format ( Half-Life textures )
<format>
header: dmip_t[dmip_t]
mipmap1: byte[dmip_t->width>>0*dmip_t->height>>0];
mipmap2: byte[dmip_t->width>>1*dmip_t->height>>1];
mipmap3: byte[dmip_t->width>>2*dmip_t->height>>2];
mipmap4: byte[dmip_t->width>>3*dmip_t->height>>3];
byte: palette[768]
========================================================================
*/
typedef struct dmip_s
{
char name[16];
uint width;
uint height;
uint offsets[4]; // four mip maps stored
} dmip_t;
/*
========================================================================
.WAD archive format (WhereAllData - WAD)
@ -437,10 +458,10 @@ infotable dlumpinfo_t[dwadinfo_t->numlumps]
#define TYPE_QPAL 64 // quake palette
#define TYPE_QTEX 65 // probably was never used
#define TYPE_QPIC 66 // quake1 and hl pic (lmp_t)
#define TYPE_MIPTEX2 67 // half-life (mip_t) previous TYP_SOUND but never used in quake1
#define TYPE_MIPTEX2 67 // half-life (dmip_t) previous was TYP_SOUND but never used in quake1
#define TYPE_MIPTEX 68 // quake1 (mip_t)
#define TYPE_RAW 69 // raw data
#define TYPE_QFONT 70 // half-life font (qfont_t)
#define TYPE_QFONT 70 // half-life font (qfont_t)
#define TYPE_VPROGS 71 // Xash3D QC compiled progs
#define TYPE_SCRIPT 72 // txt script file (e.g. shader)
#define TYPE_GFXPIC 73 // any known image format
@ -459,9 +480,9 @@ typedef struct
// doom1 and doom2 lump header
typedef struct
{
int filepos;
int size;
char name[8];
int filepos;
int size;
char name[8]; // null not included
} dlumpfile_t;
// quake1 and half-life lump header
@ -474,7 +495,7 @@ typedef struct
char compression; // probably not used
char pad1;
char pad2;
char name[16]; // must be null terminated
char name[16]; // must be null terminated
} dlumpinfo_t;
/*
@ -541,12 +562,16 @@ Studio models are position independent, so the cache manager can move them.
#define STUDIO_TYPES 0x7FFF
#define STUDIO_RLOOP 0x8000 // controller that wraps shortest distance
// bonecontroller types
#define STUDIO_MOUTH 4
// sequence flags
#define STUDIO_LOOPING 0x0001
// render flags
#define STUDIO_RENDER 0x0001
#define STUDIO_EVENTS 0x0002
#define STUDIO_MIRROR 0x0004 // a local player in mirror
// bone flags
#define STUDIO_HAS_NORMALS 0x0001

17
public/ref_dllapi.h
View File

@ -894,18 +894,6 @@ typedef struct cvar_s
#define MAX_PARTICLES 32768 // pre one frame
#define MAX_EDICTS 65535 // absolute limit that never be reached, (do not edit!)
// entity_state_t->effects
#define EF_ROTATE (1<<0) // rotate (bonus items)
// entity_state_t->renderfx
#define RF_MINLIGHT (1<<0) // allways have some light (viewmodel)
#define RF_PLAYERMODEL (1<<1) // don't draw through eyes, only mirrors
#define RF_VIEWMODEL (1<<2) // it's a viewmodel
#define RF_FULLBRIGHT (1<<3) // allways draw full intensity
#define RF_DEPTHHACK (1<<4) // for view weapon Z crunching
#define RF_TRANSLUCENT (1<<5)
#define RF_IR_VISIBLE (1<<6) // skin is an index in image_precache
// FIXME: player_state_t->renderfx
#define RDF_NOWORLDMODEL (1<<0) // used for player configuration screen
#define RDF_IRGOGGLES (1<<1)
@ -1027,6 +1015,7 @@ typedef struct cmodel_s
int numframes; // sprite framecount
int numbodies; // physmesh numbody
cmesh_t *col[256]; // max bodies
byte *extradata; // server studio uses this
// g-cont: stupid pushmodel stuff
vec3_t normalmins; // bounding box at angles '0 0 0'
@ -1150,6 +1139,7 @@ typedef struct
vec3_t viewangles;
vec4_t blend; // rgba 0-1 full screen blend
float time; // time is used to auto animate
float oldtime; // oldtime using for lerping
uint rdflags; // RDF_UNDERWATER, etc
byte *mempool; // entities, dlights etc
@ -1301,6 +1291,9 @@ typedef struct render_imp_s
void (*StudioEvent)( mstudioevent_t *event, entity_state_t *ent );
void (*ShowCollision)( cmdraw_t callback ); // debug
long (*WndProc)( void *hWnd, uint uMsg, uint wParam, long lParam );
entity_state_t *(*GetClientEdict)( int index );
entity_state_t *(*GetLocalPlayer)( void );
int (*GetMaxClients)( void );
} render_imp_t;
/*

10
public/vectorlib.h Normal file
View File

@ -0,0 +1,10 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// vectorlib.h - vector operations
//=======================================================================
#ifndef BASEVECTOR_H
#define BASEVECTOR_H
#include <math.h>
#endif//BASEVECTOR_H

6
render/gl_backend.c
View File

@ -354,6 +354,7 @@ void GL_InitCommands( void )
r_pause = Cvar_Get("paused", "0", 0, "renderer pause" );
r_pause_bw = Cvar_Get("r_pause_effect", "0", CVAR_ARCHIVE, "allow pause effect" );
r_physbdebug = Cvar_Get( "cm_debugdraw", "0", CVAR_ARCHIVE, "draw physics hulls" );
r_hqmodels = Cvar_Get( "cl_himodels", "1", CVAR_ARCHIVE, "draw high-resolution models in multiplayer" );
r_testmode = Cvar_Get("r_test", "0", CVAR_ARCHIVE, "developer cvar, for testing new effects" );
r_lightlevel = Cvar_Get ("r_lightlevel", "0", 0, "no description" );
@ -439,6 +440,7 @@ void GL_RemoveCommands( void )
void GL_InitBackend( void )
{
int i;
char dev_level[4];
GL_InitCommands();
@ -448,6 +450,10 @@ void GL_InitBackend( void )
// init tables
for( i = 0; i < 256; i++ ) r_turbsin[i] *= 0.5f;
// check developer mode
if(FS_GetParmFromCmdLine("-dev", dev_level ))
glw_state.developer = com.atoi(dev_level);
}
void GL_ShutdownBackend( void )

2
render/gl_light.c
View File

@ -332,7 +332,7 @@ void R_LightPoint (vec3_t p, vec3_t color)
dl = r_newrefdef.dlights;
for (lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++, dl++)
{
VectorSubtract (currententity->origin,
VectorSubtract (m_pCurrentEntity->origin,
dl->origin,
dist);
add = dl->intensity - VectorLength(dist);

20
render/gl_local.h
View File

@ -54,10 +54,6 @@ extern dll_info_t opengl_dll;
// r_utils.c
void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees );
void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal );
void PerpendicularVector( vec3_t dst, const vec3_t src );
void R_ConcatRotations (float in1[3][3], float in2[3][3], float out[3][3]);
void R_ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]);
#define Host_Error com.error
@ -122,13 +118,13 @@ extern image_t *r_notexture;
extern image_t *r_particletexture;
extern image_t *r_radarmap;
extern image_t *r_around;
extern ref_entity_t *currententity;
extern rmodel_t *currentmodel;
extern int r_visframecount;
extern int r_framecount;
extern rmodel_t *m_pRenderModel;
extern ref_entity_t *m_pCurrentEntity;
extern int r_visframecount;
extern int r_framecount;
extern cplane_t frustum[4];
extern int c_brush_polys;
extern int c_brush_polys;
extern int m_pStudioModelCount;
extern int gl_filter_min, gl_filter_max;
@ -147,6 +143,7 @@ extern refdef_t r_newrefdef;
extern int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2;
extern cvar_t *r_check_errors;
extern cvar_t *r_hqmodels;
extern cvar_t *r_norefresh;
extern cvar_t *r_lefthand;
extern cvar_t *r_drawentities;
@ -448,12 +445,9 @@ BUILT-IN MATHLIB FUNCTIONS
====================================================================
*/
void VectorTransform (const vec3_t in1, matrix3x4 in2, vec3_t out);
void AngleQuaternion( float *angles, vec4_t quaternion );
void QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] );
void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt );
void AngleMatrix (const float *angles, float (*matrix)[4] );
void MatrixCopy( matrix3x4 in, matrix3x4 out );
uint ShortToFloat( word y );
void R_DXTReadColor(word data, color32* out);

2
render/gl_model.c
View File

@ -561,7 +561,7 @@ void Mod_LoadFaces (lump_t *l)
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
currentmodel = loadmodel;
m_pRenderModel = loadmodel;
GL_BeginBuildingLightmaps (loadmodel);

60
render/gl_rmain.c
View File

@ -20,6 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// r_main.c
#include "gl_local.h"
#include "r_mirror.h"
#include "const.h"
void R_Clear (void);
@ -48,8 +49,8 @@ image_t *r_particletexture;// little dot for particles
image_t *r_radarmap; // wall texture for radar texgen
image_t *r_around;
ref_entity_t *currententity;
rmodel_t *currentmodel;
rmodel_t *m_pRenderModel;
ref_entity_t *m_pCurrentEntity;
cplane_t frustum[4];
@ -93,6 +94,7 @@ cvar_t *r_nocull;
cvar_t *r_lerpmodels;
cvar_t *r_lefthand;
cvar_t *r_testmode;
cvar_t *r_hqmodels;
cvar_t *r_lightlevel; // FIXME: This is a HACK to get the client's light level
cvar_t *r_mirroralpha;
@ -207,13 +209,12 @@ void R_DrawNullModel (void)
vec3_t shadelight;
int i;
if ( currententity->flags & RF_FULLBRIGHT )
if( m_pCurrentEntity->renderfx & RF_FULLBRIGHT )
shadelight[0] = shadelight[1] = shadelight[2] = 1.0F;
else
R_LightPoint (currententity->origin, shadelight);
else R_LightPoint( m_pCurrentEntity->origin, shadelight );
pglPushMatrix ();
R_RotateForEntity (currententity);
pglPushMatrix ();
R_RotateForEntity( m_pCurrentEntity );
pglDisable (GL_TEXTURE_2D);
pglColor3fv (shadelight);
@ -249,15 +250,15 @@ void R_DrawEntitiesOnList (void)
// draw non-transparent first
for (i = 0; i < r_newrefdef.num_entities; i++)
{
currententity = &r_newrefdef.entities[i];
currentmodel = currententity->model;
m_pCurrentEntity = &r_newrefdef.entities[i];
m_pRenderModel = m_pCurrentEntity->model;
if (!currentmodel)
if (!m_pRenderModel)
{
R_DrawNullModel();
continue;
}
switch (currentmodel->type)
switch (m_pRenderModel->type)
{
case mod_brush:
R_DrawBrushModel( RENDERPASS_SOLID );
@ -279,15 +280,15 @@ void R_DrawEntitiesOnList (void)
pglDepthMask (0); // no z writes
for (i = 0; i < r_newrefdef.num_entities; i++)
{
currententity = &r_newrefdef.entities[i];
currentmodel = currententity->model;
m_pCurrentEntity = &r_newrefdef.entities[i];
m_pRenderModel = m_pCurrentEntity->model;
if (!currentmodel)
if (!m_pRenderModel)
{
R_DrawNullModel ();
continue;
}
switch (currentmodel->type)
switch (m_pRenderModel->type)
{
case mod_brush:
R_DrawBrushModel( RENDERPASS_ALPHA );
@ -930,9 +931,8 @@ void R_SetLightLevel (void)
static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t *s2, float lerpfrac )
{
uint i, effects;
ref_entity_t *refent;
int max_edicts = Cvar_VariableValue( "prvm_maxedicts" );
int i, max_edicts = Cvar_VariableValue( "prvm_maxedicts" );
if( !fd || !fd->entities ) return false; // not init
if( !s1 || !s1->model.index ) return false; // if set to invisible, skip
@ -943,16 +943,21 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
refent = &fd->entities[fd->num_entities];
if( !s2 ) s2 = s1; // no lerping state
effects = s1->effects;
refent->frame = s1->model.frame;
// copy state to render
refent->index = s1->number;
refent->prev.frame = s2->model.frame;
refent->backlerp = 1.0f - lerpfrac;
refent->alpha = s1->renderamt;
refent->renderamt = s1->renderamt;
refent->body = s1->model.body;
refent->sequence = s1->model.sequence;
refent->animtime = s1->model.animtime;
refent->movetype = s1->movetype;
refent->scale = s1->model.scale ? s1->model.scale : 1.0f;
refent->colormap = s1->model.colormap;
refent->effects = s1->effects;
VectorCopy( s1->rendercolor, refent->rendercolor );
// setup latchedvars
refent->prev.animtime = s2->model.animtime;
@ -964,16 +969,16 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
// interpolate origin
for( i = 0; i < 3; i++ )
refent->origin[i] = refent->oldorigin[i] = LerpPoint( s2->origin[i], s1->origin[i], lerpfrac );
refent->origin[i] = LerpPoint( s2->origin[i], s1->origin[i], lerpfrac );
// set skin
refent->skin = s1->model.skin;
refent->model = r_models[s1->model.index];
refent->weaponmodel = r_models[s1->pmodel.index];
refent->flags = s1->renderfx;
refent->renderfx = s1->renderfx;
// calculate angles
if( effects & EF_ROTATE )
if( refent->effects & EF_ROTATE )
{
// some bonus items auto-rotate
VectorSet( refent->angles, 0, anglemod(fd->time / 10), 0 );
@ -1001,13 +1006,10 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
if( s1->ed_type == ED_CLIENT )
{
refent->flags |= RF_PLAYERMODEL; // only draw from mirrors
// just only for test
refent->controller[0] = refent->controller[1] = 90.0;
refent->controller[2] = refent->controller[3] = 180.0;
refent->sequence = 0;
refent->frame = 0;
// only draw from mirrors
refent->renderfx |= RF_PLAYERMODEL;
refent->gaitsequence = s1->model.gaitsequence;
//refent->gaitframe = s1->model.frame;
}
// add entity

51
render/gl_rsurf.c
View File

@ -20,6 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// GL_RSURF.C: surface-related refresh code
#include "gl_local.h"
#include "r_mirror.h"
#include "const.h"
static vec3_t modelorg; // relative to viewpoint
@ -85,7 +86,7 @@ image_t *R_TextureAnimation (mtexinfo_t *tex)
if (!tex->next) return tex->image;
c = (int)currententity->frame % tex->numframes;
c = (int)m_pCurrentEntity->frame % tex->numframes;
while (c)
{
tex = tex->next;
@ -287,7 +288,7 @@ void R_BlendLightmaps (void)
}
}
if ( currentmodel == r_worldmodel )
if ( m_pRenderModel == r_worldmodel )
c_visible_lightmaps = 0;
/*
@ -297,7 +298,7 @@ void R_BlendLightmaps (void)
{
if ( gl_lms.lightmap_surfaces[i] )
{
if (currentmodel == r_worldmodel)
if (m_pRenderModel == r_worldmodel)
c_visible_lightmaps++;
GL_Bind( gl_state.lightmap_textures + i);
@ -318,7 +319,7 @@ void R_BlendLightmaps (void)
GL_Bind( gl_state.lightmap_textures+0 );
if (currentmodel == r_worldmodel)
if (m_pRenderModel == r_worldmodel)
c_visible_lightmaps++;
newdrawsurf = gl_lms.lightmap_surfaces[0];
@ -807,13 +808,13 @@ void R_DrawInlineBModel (void)
lt = r_newrefdef.dlights;
for (k=0 ; k<r_newrefdef.num_dlights ; k++, lt++)
{
R_MarkLights (lt, 1<<k, currentmodel->nodes + currentmodel->firstnode);
R_MarkLights (lt, 1<<k, m_pRenderModel->nodes + m_pRenderModel->firstnode);
}
}
psurf = &currentmodel->surfaces[currentmodel->firstmodelsurface];
psurf = &m_pRenderModel->surfaces[m_pRenderModel->firstmodelsurface];
if ( currententity->flags & RF_TRANSLUCENT )
if ( m_pCurrentEntity->renderfx & RF_TRANSLUCENT )
{
GL_EnableBlend();
pglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@ -824,7 +825,7 @@ void R_DrawInlineBModel (void)
//
// draw texture
//
for (i=0 ; i<currentmodel->nummodelsurfaces ; i++, psurf++)
for (i=0 ; i<m_pRenderModel->nummodelsurfaces ; i++, psurf++)
{
// find which side of the node we are on
pplane = psurf->plane;
@ -844,7 +845,7 @@ void R_DrawInlineBModel (void)
{
mirror = true;
psurf->texturechain = mirrorchain;
mirror_entity = currententity;
mirror_entity = m_pCurrentEntity;
mirrorchain = psurf;
continue;
}
@ -861,7 +862,7 @@ void R_DrawInlineBModel (void)
}
}
if(!(currententity->flags & RF_TRANSLUCENT) )
if(!(m_pCurrentEntity->renderfx & RF_TRANSLUCENT) )
{
if( !pglMultiTexCoord2f )
R_BlendLightmaps();
@ -884,15 +885,15 @@ void R_DrawBrushModel ( int passnum )
vec3_t mins, maxs;
int i;
bool rotated;
ref_entity_t *e = currententity;
ref_entity_t *e = m_pCurrentEntity;
if ( (e->flags & RF_TRANSLUCENT) && (passnum == RENDERPASS_SOLID)) return;// solid
if (!(e->flags & RF_TRANSLUCENT) && (passnum == RENDERPASS_ALPHA)) return;// solid
if ( (e->renderfx & RF_TRANSLUCENT) && (passnum == RENDERPASS_SOLID)) return;// solid
if (!(e->renderfx & RF_TRANSLUCENT) && (passnum == RENDERPASS_ALPHA)) return;// solid
if (currentmodel->nummodelsurfaces == 0)
if (m_pRenderModel->nummodelsurfaces == 0)
return;
//currententity = e;
//m_pCurrentEntity = e;
gl_state.texNum[0] = gl_state.texNum[1] = -1;
if( !VectorIsNull( e->angles ))
@ -900,15 +901,15 @@ void R_DrawBrushModel ( int passnum )
rotated = true;
for( i = 0; i < 3; i++ )
{
mins[i] = e->origin[i] - currentmodel->radius;
maxs[i] = e->origin[i] + currentmodel->radius;
mins[i] = e->origin[i] - m_pRenderModel->radius;
maxs[i] = e->origin[i] + m_pRenderModel->radius;
}
}
else
{
rotated = false;
VectorAdd (e->origin, currentmodel->mins, mins);
VectorAdd (e->origin, currentmodel->maxs, maxs);
VectorAdd (e->origin, m_pRenderModel->mins, mins);
VectorAdd (e->origin, m_pRenderModel->maxs, maxs);
}
if (R_CullBox (mins, maxs))
@ -1149,14 +1150,14 @@ void R_DrawWorld (void)
if ( r_newrefdef.rdflags & RDF_NOWORLDMODEL )
return;
currentmodel = r_worldmodel;
m_pRenderModel = r_worldmodel;
VectorCopy (r_newrefdef.vieworg, modelorg);
// auto cycle the world frame for texture animation
memset (&ent, 0, sizeof(ent));
ent.frame = (int)(r_newrefdef.time * 6.0f);
currententity = &ent;
m_pCurrentEntity = &ent;
gl_state.texNum[0] = gl_state.texNum[1] = -1;
@ -1405,7 +1406,7 @@ void GL_BuildPolygonFromSurface(msurface_t *fa)
vec3_t total;
// reconstruct the polygon
pedges = currentmodel->edges;
pedges = m_pRenderModel->edges;
lnumverts = fa->numedges;
vertpage = 0;
@ -1421,17 +1422,17 @@ void GL_BuildPolygonFromSurface(msurface_t *fa)
for( i = 0; i < lnumverts; i++ )
{
lindex = currentmodel->surfedges[fa->firstedge + i];
lindex = m_pRenderModel->surfedges[fa->firstedge + i];
if( lindex > 0 )
{
r_pedge = &pedges[lindex];
vec = currentmodel->vertexes[r_pedge->v[0]].position;
vec = m_pRenderModel->vertexes[r_pedge->v[0]].position;
}
else
{
r_pedge = &pedges[-lindex];
vec = currentmodel->vertexes[r_pedge->v[1]].position;
vec = m_pRenderModel->vertexes[r_pedge->v[1]].position;
}
s = DotProduct( vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
if( fa->texinfo->size[0] != -1 ) s /= fa->texinfo->size[0];

42
render/r_local.h
View File

@ -42,6 +42,13 @@ typedef enum
R_EXTCOUNT
} r_opengl_extensions;
typedef struct
{
byte open; // 0 = mouth closed, 255 = mouth agape
byte sndcount; // counter for running average
int sndavg; // running average
} mouth_t;
typedef struct latchedvars_s
{
float animtime;
@ -49,6 +56,7 @@ typedef struct latchedvars_s
vec3_t origin;
vec3_t angles;
vec3_t gaitorigin;
int sequence;
float frame;
@ -61,40 +69,48 @@ typedef struct latchedvars_s
// client entity
typedef struct ref_entity_s
{
edtype_t ent_type; // entity type
int index; // entity index
rmodel_t *model; // opaque type outside refresh
rmodel_t *weaponmodel; // opaque type outside refresh
latchedvars_t prev; // previous frame values for lerping
vec3_t angles;
vec3_t origin; // also used as RF_BEAM's "from"
float oldorigin[3]; // also used as RF_BEAM's "to"
vec3_t origin; // position
float animtime;
float framerate; // custom framerate
float animtime; // lerping animtime
float frame; // also used as RF_BEAM's diameter
float framerate;
int body;
int skin;
byte blending[MAXSTUDIOBLENDS];
vec3_t attachment[MAXSTUDIOATTACHMENTS];
byte controller[MAXSTUDIOCONTROLLERS];
byte mouth; //TODO: move to struct
mouth_t mouth; // for synchronizing mouth movements.
int movetype; //entity moving type
int movetype; // entity moving type
int sequence;
float scale;
vec3_t attachment[MAXSTUDIOATTACHMENTS];
// misc
float backlerp; // 0.0 = current, 1.0 = old
int skinnum; // also used as RF_BEAM's palette index
int lightstyle; // for flashing entities
float alpha; // ignore if RF_TRANSLUCENT isn't set
int flags;
vec3_t rendercolor; // hl1 rendercolor
float renderamt; // hl1 alphavalues
int renderfx; // server will be translate hl1 values into flags
int colormap; // q1 and hl1 model colormap (can applied for sprites)
int effects; // q1 effect flags, EF_ROTATE, EF_DIMLIGHT etc
// these values will be calculated locally, not from entity_state
vec3_t realangles;
int m_fSequenceLoops;
int m_fSequenceFinished;
int renderframe; // using for gait cycle
int gaitsequence; // client->sequence + yaw
float gaitframe; // client->frame + yaw
float gaityaw; // local value
} ref_entity_t;
typedef struct lightstyle_s

4
render/r_opengl.h
View File

@ -926,10 +926,8 @@ typedef struct
HINSTANCE hinstOpenGL; // HINSTANCE for the OpenGL library
bool minidriver;
bool allowdisplaydepthchange;
bool mcd_accelerated;
int developer; // engine developer level;
FILE *log_fp;
} glwstate_t;
extern glwstate_t glw_state;

161
render/r_sprite.c
View File

@ -5,6 +5,7 @@
#include "gl_local.h"
#include "byteorder.h"
#include "const.h"
/*
=============================================================
@ -14,6 +15,7 @@
=============================================================
*/
string frame_prefix;
byte *spr_palette;
/*
====================
@ -50,8 +52,10 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
pspriteframe->left = origin[0];
pspriteframe->right = width + origin[0];
pspriteframe->texnum = 0;
spr_frame->type = PF_RGBA_32;
spr_frame->type = PF_INDEXED_32;
spr_frame->flags = IMAGE_HAS_ALPHA;
spr_frame->palette = spr_palette;
spr_frame->numLayers = 1;
spr_frame->numMips = 1;
// extract sprite name from path
@ -73,7 +77,7 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
return (dframetype_t *)((byte *)(pinframe + 1) + spr_frame->size);
}
dframetype_t *R_SpriteLoadGroup (rmodel_t *mod, void * pin, mspriteframe_t **ppframe, int framenum )
dframetype_t *R_SpriteLoadGroup( rmodel_t *mod, void * pin, mspriteframe_t **ppframe, int framenum )
{
dspritegroup_t *pingroup;
mspritegroup_t *pspritegroup;
@ -113,14 +117,16 @@ dframetype_t *R_SpriteLoadGroup (rmodel_t *mod, void * pin, mspriteframe_t **ppf
void R_SpriteLoadModel( rmodel_t *mod, void *buffer )
{
dsprite_t *pin;
short *numi;
msprite_t *psprite;
dframetype_t *pframetype;
static byte pal[256][4];
int i, size, numframes;
pin = (dsprite_t *)buffer;
i = LittleLong(pin->version);
if( i != SPRITE_VERSION)
if( i != SPRITE_VERSION )
{
Msg("Warning: %s has wrong version number (%i should be %i)\n", mod->name, i, SPRITE_VERSION );
return;
@ -134,27 +140,90 @@ void R_SpriteLoadModel( rmodel_t *mod, void *buffer )
mod->numtexinfo = 0; // reset frames
psprite->type = LittleLong(pin->type);
psprite->rendermode = LittleLong(pin->rendermode);
psprite->rendermode = LittleLong(pin->texFormat);
psprite->numframes = numframes;
mod->mins[0] = mod->mins[1] = -LittleLong(pin->bounds[0]) / 2;
mod->maxs[0] = mod->maxs[1] = LittleLong(pin->bounds[0]) / 2;
mod->mins[2] = -LittleLong(pin->bounds[1]) / 2;
mod->maxs[2] = LittleLong(pin->bounds[1]) / 2;
pframetype = (dframetype_t *)(pin + 1);
numi = (short *)(pin + 1);
MsgDev(D_LOAD, "%s, rendermode %d\n", mod->name, psprite->rendermode );
if(numframes < 1)
if( LittleShort(*numi) == 256 )
{
byte *src = (byte *)(numi+1);
switch( psprite->rendermode )
{
case SPR_NORMAL:
for( i = 0; i < 256; i++ )
{
pal[i][0] = *src++;
pal[i][1] = *src++;
pal[i][2] = *src++;
pal[i][3] = 0;
}
break;
case SPR_ADDGLOW:
case SPR_ADDITIVE:
for( i = 0; i < 256; i++ )
{
pal[i][0] = *src++;
pal[i][1] = *src++;
pal[i][2] = *src++;
pal[i][3] = 255;
}
break;
case SPR_INDEXALPHA:
for( i = 0; i < 256; i++ )
{
pal[i][0] = *src++;
pal[i][1] = *src++;
pal[i][2] = *src++;
pal[i][3] = i;
}
break;
case SPR_ALPHTEST:
for( i = 0; i < 256; i++ )
{
pal[i][0] = *src++;
pal[i][1] = *src++;
pal[i][2] = *src++;
pal[i][3] = 255;
}
pal[255][0] = pal[255][1] = pal[255][2] = pal[255][3] = 0;
break;
default:
for (i = 0; i < 256; i++)
{
pal[i][0] = *src++;
pal[i][1] = *src++;
pal[i][2] = *src++;
pal[i][3] = 0;
}
MsgDev( D_ERROR, "%s has unknown texFormat (%i, should be in range 0-4 )\n", mod->name, psprite->rendermode );
break;
}
pframetype = (dframetype_t *)(src);
}
else
{
MsgDev( D_ERROR, "%s has wrong number of palette colors %i (should be 256)\n", mod->name, numi );
return;
}
if( numframes < 1 )
{
MsgDev( D_ERROR, "%s has invalid # of frames: %d\n", mod->name, numframes );
return;
}
}
MsgDev(D_LOAD, "%s, rendermode %d\n", mod->name, psprite->rendermode );
mod->registration_sequence = registration_sequence;
spr_palette = (byte *)(&pal[0][0]);
for (i = 0; i < numframes; i++ )
{
frametype_t frametype = LittleLong (pframetype->type);
frametype_t frametype = LittleLong( pframetype->type );
psprite->frames[i].type = frametype;
switch( frametype )
@ -181,7 +250,7 @@ void R_SpriteLoadModel( rmodel_t *mod, void *buffer )
R_GetSpriteFrame
================
*/
mspriteframe_t *R_GetSpriteFrame( ref_entity_t *currententity )
mspriteframe_t *R_GetSpriteFrame( ref_entity_t *m_pCurrentEntity )
{
msprite_t *psprite;
mspritegroup_t *pspritegroup;
@ -189,16 +258,16 @@ mspriteframe_t *R_GetSpriteFrame( ref_entity_t *currententity )
int i, numframes, frame;
float *pintervals, fullinterval, targettime, time;
psprite = currententity->model->extradata;
frame = currententity->frame;
psprite = m_pCurrentEntity->model->extradata;
frame = m_pCurrentEntity->frame;
if ((frame >= psprite->numframes) || (frame < 0))
if((frame >= psprite->numframes) || (frame < 0))
{
MsgDev(D_WARN, "R_GetSpriteFrame: no such frame %d (%s)\n", frame, currententity->model->name);
MsgDev( D_WARN, "R_GetSpriteFrame: no such frame %d (%s)\n", frame, m_pCurrentEntity->model->name );
frame = 0;
}
if (psprite->frames[frame].type == SPR_SINGLE)
if( psprite->frames[frame].type == SPR_SINGLE )
{
pspriteframe = psprite->frames[frame].frameptr;
}
@ -214,17 +283,17 @@ mspriteframe_t *R_GetSpriteFrame( ref_entity_t *currententity )
// are positive, so we don't have to worry about division by zero
targettime = time - ((int)(time / fullinterval)) * fullinterval;
for (i = 0; i < (numframes - 1); i++)
for( i = 0; i < (numframes - 1); i++ )
{
if (pintervals[i] > targettime)
break;
}
pspriteframe = pspritegroup->frames[i];
}
else if (psprite->frames[frame].type == SPR_ANGLED)
else if( psprite->frames[frame].type == SPR_ANGLED )
{
// e.g. doom-style sprite monsters
int angleframe = (int)((r_newrefdef.viewangles[1] - currententity->angles[1])/360*8 + 0.5 - 4) & 7;
int angleframe = (int)((r_newrefdef.viewangles[1] - m_pCurrentEntity->angles[1])/360*8 + 0.5 - 4) & 7;
pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
pspriteframe = pspritegroup->frames[angleframe];
}
@ -233,24 +302,26 @@ mspriteframe_t *R_GetSpriteFrame( ref_entity_t *currententity )
bool R_AcceptSpritePass( ref_entity_t *e, int pass )
{
msprite_t *psprite = (msprite_t *)currentmodel->extradata;
msprite_t *psprite = (msprite_t *)m_pRenderModel->extradata;
if(pass == RENDERPASS_SOLID)
if( pass == RENDERPASS_SOLID )
{
// pass for solid ents
if(psprite->rendermode == SPR_SOLID) return true; // solid sprite
if(psprite->rendermode == SPR_GLOW) return false; // draw it at second pass
if(psprite->rendermode == SPR_ADDITIVE) return false; // must be draw first always
if(psprite->rendermode == SPR_ALPHA) return false; // already blended by alphatest
if( psprite->rendermode == SPR_NORMAL ) return true; // solid sprite
if( psprite->rendermode == SPR_ADDGLOW ) return false; // draw it at second pass
if( psprite->rendermode == SPR_ADDITIVE ) return false; // must be draw first always
if( psprite->rendermode == SPR_ALPHTEST ) return true; // already blended by alphatest
if( psprite->rendermode == SPR_INDEXALPHA ) return true; // already blended by alphatest
}
if(pass == RENDERPASS_ALPHA)
if( pass == RENDERPASS_ALPHA )
{
// pass for blended ents
if(e->flags & RF_TRANSLUCENT) return true; // solid sprite with custom blend
if(psprite->rendermode == SPR_SOLID) return false; // solid sprite
if(psprite->rendermode == SPR_GLOW) return true; // can draw
if(psprite->rendermode == SPR_ADDITIVE) return true; // can draw
if(psprite->rendermode == SPR_ALPHA) return true; // already drawed
if( e->renderfx & RF_TRANSLUCENT ) return true; // solid sprite with custom blend
if( psprite->rendermode == SPR_NORMAL ) return false; // solid sprite
if( psprite->rendermode == SPR_ADDGLOW ) return true; // can draw
if( psprite->rendermode == SPR_ADDITIVE ) return true; // can draw
if( psprite->rendermode == SPR_ALPHTEST ) return false; // already drawed
if( psprite->rendermode == SPR_INDEXALPHA ) return false; // already drawed
}
return true;
}
@ -260,17 +331,17 @@ void R_SpriteSetupLighting( rmodel_t *mod )
int i;
vec3_t vlight = {0.0f, 0.0f, -1.0f}; // get light from floor
if(currententity->flags & RF_FULLBRIGHT)
if(m_pCurrentEntity->renderfx & RF_FULLBRIGHT)
{
for (i = 0; i < 3; i++)
mod->lightcolor[i] = 1.0f;
}
else
{
R_LightPoint( currententity->origin, mod->lightcolor );
R_LightPoint( m_pCurrentEntity->origin, mod->lightcolor );
// doom sprite models
if( currententity->flags & RF_VIEWMODEL )
if( m_pCurrentEntity->renderfx & RF_VIEWMODEL )
r_lightlevel->value = bound(0, VectorLength(mod->lightcolor) * 75.0f, 255);
}
@ -280,8 +351,8 @@ void R_DrawSpriteModel( int passnum )
{
mspriteframe_t *frame;
vec3_t point, forward, right, up;
ref_entity_t *e = currententity;
rmodel_t *mod = currentmodel;
ref_entity_t *e = m_pCurrentEntity;
rmodel_t *mod = m_pRenderModel;
float alpha = 1.0f, angle, sr, cr;
vec3_t distance;
msprite_t *psprite;
@ -297,7 +368,7 @@ void R_DrawSpriteModel( int passnum )
frame = R_GetSpriteFrame(e);
// merge alpha value
if( e->flags & RF_TRANSLUCENT ) alpha = e->alpha;
if( e->renderfx & RF_TRANSLUCENT ) alpha = e->renderamt;
if( e->scale == 0 ) e->scale = 1.0f; // merge scale
R_SpriteSetupLighting( mod );
@ -350,27 +421,29 @@ void R_DrawSpriteModel( int passnum )
// setup rendermode
switch( psprite->rendermode )
{
case SPR_SOLID:
case SPR_NORMAL:
// solid sprite ignore color and light values
break;
case SPR_GLOW:
case SPR_ADDGLOW:
//FIXME: get to work
VectorCopy( r_origin, distance );
alpha = VectorLength( distance ) * 0.001;
e->scale = 1/(alpha * 1.5);
// intentional falltrough
case SPR_ADDITIVE:
GL_EnableBlend();
pglBlendFunc(GL_SRC_ALPHA, GL_ONE);
pglBlendFunc( GL_SRC_ALPHA, GL_ONE );
pglColor4f( 1.0f, 1.0f, 1.0f, alpha );
break;
case SPR_ALPHA:
case SPR_ALPHTEST:
case SPR_INDEXALPHA:
GL_EnableBlend();
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
pglColor4f( mod->lightcolor[0], mod->lightcolor[1], mod->lightcolor[2], 1.0f );
break;
}
if (currententity->flags & RF_DEPTHHACK) // hack the depth range to prevent view model from poking into walls
if (m_pCurrentEntity->renderfx & RF_DEPTHHACK) // hack the depth range to prevent view model from poking into walls
pglDepthRange (gldepthmin, gldepthmin + 0.3 * (gldepthmax-gldepthmin));
pglDisable(GL_CULL_FACE);
@ -401,7 +474,7 @@ void R_DrawSpriteModel( int passnum )
GL_EnableDepthTest();
GL_TexEnv(GL_REPLACE);
pglEnable(GL_CULL_FACE);
if(e->flags & RF_DEPTHHACK) pglDepthRange (gldepthmin, gldepthmax);
if(e->renderfx & RF_DEPTHHACK) pglDepthRange (gldepthmin, gldepthmax);
pglColor4f( 1, 1, 1, 1 );
}

1217
render/r_studio.c
View File

File diff suppressed because it is too large Load Diff

2480
render/r_studio.c.old Normal file
View File

File diff suppressed because it is too large Load Diff

10
render/r_texture.c
View File

@ -823,13 +823,13 @@ bool qrsDecompressedTexImage2D( uint target, int level, int internalformat, uint
switch( PFDesc[internalformat].format )
{
case PF_INDEXED_24:
if (image_desc.flags & IMAGE_HAS_ALPHA)
if( image_desc.flags & IMAGE_HAS_ALPHA )
{
// studio model indexed texture probably with alphachannel
for (i = 0; i < width * height; i++)
{
p = fin[i];
if (p == 255) noalpha = false;
if( p == 255 ) noalpha = false;
fout[(i<<2)+0] = image_desc.pal[p*3+0];
fout[(i<<2)+1] = image_desc.pal[p*3+1];
fout[(i<<2)+2] = image_desc.pal[p*3+2];
@ -839,7 +839,7 @@ bool qrsDecompressedTexImage2D( uint target, int level, int internalformat, uint
else
{
// studio model indexed texture without alphachannel
for (i = 0; i < width * height; i++)
for( i = 0; i < width * height; i++ )
{
p = fin[i];
fout[(i<<2)+0] = image_desc.pal[p*3+0];
@ -852,7 +852,7 @@ bool qrsDecompressedTexImage2D( uint target, int level, int internalformat, uint
break;
case PF_INDEXED_32:
// sprite indexed frame with alphachannel
for (i = 0; i < width*height; i++ )
for( i = 0; i < width*height; i++ )
{
fout[(i<<2)+0] = image_desc.pal[fin[i]*4+0];
fout[(i<<2)+1] = image_desc.pal[fin[i]*4+1];
@ -862,7 +862,7 @@ bool qrsDecompressedTexImage2D( uint target, int level, int internalformat, uint
break;
case PF_RGB_24:
case PF_RGB_24_FLIP:
// 24-bit image, that will not expanded to RGBA in imagelib.c for some reasons
// 24-bit image, that will not expanded to RGBA in imglib.dll for some reasons
for (i = 0; i < width * height; i++ )
{
fout[(i<<2)+0] = fin[i+0];

139
render/r_utils.c
View File

@ -8,128 +8,39 @@
/*
====================
RotatePointAroundVector
====================
*/
void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees )
{
float m[3][3];
float im[3][3];
float zrot[3][3];
float tmpmat[3][3];
float rot[3][3];
int i;
vec3_t vr, vup, vf;
float t0, t1;
float angle, c, s;
vec3_t vr, vu, vf;
vf[0] = dir[0];
vf[1] = dir[1];
vf[2] = dir[2];
angle = DEG2RAD( degrees );
c = cos( angle );
s = sin( angle );
VectorCopy( dir, vf );
VectorVectors( vf, vr, vu );
PerpendicularVector( vr, dir );
CrossProduct( vr, vf, vup );
t0 = vr[0] * c + vu[0] * -s;
t1 = vr[0] * s + vu[0] * c;
dst[0] = (t0 * vr[0] + t1 * vu[0] + vf[0] * vf[0]) * point[0]
+ (t0 * vr[1] + t1 * vu[1] + vf[0] * vf[1]) * point[1]
+ (t0 * vr[2] + t1 * vu[2] + vf[0] * vf[2]) * point[2];
m[0][0] = vr[0];
m[1][0] = vr[1];
m[2][0] = vr[2];
t0 = vr[1] * c + vu[1] * -s;
t1 = vr[1] * s + vu[1] * c;
dst[1] = (t0 * vr[0] + t1 * vu[0] + vf[1] * vf[0]) * point[0]
+ (t0 * vr[1] + t1 * vu[1] + vf[1] * vf[1]) * point[1]
+ (t0 * vr[2] + t1 * vu[2] + vf[1] * vf[2]) * point[2];
m[0][1] = vup[0];
m[1][1] = vup[1];
m[2][1] = vup[2];
m[0][2] = vf[0];
m[1][2] = vf[1];
m[2][2] = vf[2];
memcpy( im, m, sizeof( im ) );
im[0][1] = m[1][0];
im[0][2] = m[2][0];
im[1][0] = m[0][1];
im[1][2] = m[2][1];
im[2][0] = m[0][2];
im[2][1] = m[1][2];
memset( zrot, 0, sizeof( zrot ) );
zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;
zrot[0][0] = cos( DEG2RAD( degrees ) );
zrot[0][1] = sin( DEG2RAD( degrees ) );
zrot[1][0] = -sin( DEG2RAD( degrees ) );
zrot[1][1] = cos( DEG2RAD( degrees ) );
R_ConcatRotations( m, zrot, tmpmat );
R_ConcatRotations( tmpmat, im, rot );
for ( i = 0; i < 3; i++ )
{
dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
}
t0 = vr[2] * c + vu[2] * -s;
t1 = vr[2] * s + vu[2] * c;
dst[2] = (t0 * vr[0] + t1 * vu[0] + vf[2] * vf[0]) * point[0]
+ (t0 * vr[1] + t1 * vu[1] + vf[2] * vf[1]) * point[1]
+ (t0 * vr[2] + t1 * vu[2] + vf[2] * vf[2]) * point[2];
}
/*
====================
ProjectPointOnPlane
====================
*/
void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )
{
float d;
vec3_t n;
float inv_denom;
inv_denom = 1.0F / DotProduct( normal, normal );
d = DotProduct( normal, p ) * inv_denom;
n[0] = normal[0] * inv_denom;
n[1] = normal[1] * inv_denom;
n[2] = normal[2] * inv_denom;
dst[0] = p[0] - d * n[0];
dst[1] = p[1] - d * n[1];
dst[2] = p[2] - d * n[2];
}
/*
====================
PerpendicularVector
====================
*/
void PerpendicularVector( vec3_t dst, const vec3_t src )
{
int pos;
int i;
float minelem = 1.0F;
vec3_t tempvec;
/*
** find the smallest magnitude axially aligned vector
*/
for ( pos = 0, i = 0; i < 3; i++ )
{
if ( fabs( src[i] ) < minelem )
{
pos = i;
minelem = fabs( src[i] );
}
}
tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
tempvec[pos] = 1.0F;
/*
** project the point onto the plane defined by src
*/
ProjectPointOnPlane( dst, tempvec, src );
/*
** normalize the result
*/
VectorNormalize( dst );
}
/*
====================
Image Decompress
@ -143,8 +54,8 @@ uint ShortToFloat( word y )
int e = (y >> 10) & 0x0000001f;
int m = y & 0x000003ff;
//float: 1 sign bit, 8 exponent bits, 23 mantissa bits
//half: 1 sign bit, 5 exponent bits, 10 mantissa bits
// float: 1 sign bit, 8 exponent bits, 23 mantissa bits
// half: 1 sign bit, 5 exponent bits, 10 mantissa bits
if (e == 0)
{

2
ripper/conv_wadlumps.c
View File

@ -130,7 +130,7 @@ bool ConvFLT( const char *name, char *buffer, int filesize )
/*
============
ConvFLT
ConvFLP
============
*/
bool ConvFLP( const char *name, char *buffer, int filesize )

17
todo.log
View File

@ -17,12 +17,29 @@ fopen
3. перенести ripper.dll в common.dll
4. doom snd extractor (write PCM header 8bit 11kHz, dump data)
GLOBAL: Достигнуть уровня xash 0.45 к очередному релизу
TODO LIST
придумать как вернуть cmodel_t обратно в physic.dll
баг с повторной загрузкой некоторых карт (исчезают все текстуры - становятся белыми)
включить интерполяцию для studio моделей
научить игрока лазить по лестницам
Провериться боундс-чекером на течку
Найти наконец эту йобанную утечку
Перенести ripper.dll в common.dll
Поддержка Jpg чтение\запись
Поддержка bmp 8-bit чтение\запись
перевести движок на matrix4x4 instead of matrix3x4
избавится от идиотскова RF_TRANSLUCENT
Кстати приделать thirdperson чтобы удобнее было настраивать StudioDrawPlayer
Вернуть поддержку lmp, mip в image lib
Переместить imglib.dll и ripper.dll обратно в launch.dll
Упорядочить загружаемые типы, создание шейдеров налету
Поддержка Jpg и Png
Упорядочить EF_, RF_ ed_type проверки
Список доступных рендереров: Что в них интересного

2
vprogs/pr_utils.c
View File

@ -510,7 +510,7 @@ word PR_WriteProgdefs( void )
switch( crc )
{
case 1476:
case 15812:
PR_Message("Xash3D unmodified server.dat\n");
if(!com.strcmp(progsoutname, "unknown.dat")) com.strcpy(progsoutname, "server.dat");
break;