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

26 Nov 2008

This commit is contained in:
g-cont 2008-11-26 00:00:00 +03:00 committed by Alibek Omarov
parent c68cdd234a
commit 52a489fc55
86 changed files with 7520 additions and 6456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
baserc/baserc.dsp
View File

@ -119,6 +119,26 @@ SOURCE=.\rc_main.c
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\client.h
# End Source File
# Begin Source File
SOURCE=.\images.h
# End Source File
# Begin Source File
SOURCE=.\q1texture.h
# End Source File
# Begin Source File
SOURCE=.\server.h
# End Source File
# Begin Source File
SOURCE=.\uimenu.h
# End Source File
# End Group
# End Target
# End Project

819
baserc/client.h
View File

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

5041
baserc/server.h
View File

File diff suppressed because it is too large Load Diff

2145
baserc/uimenu.h
View File

File diff suppressed because it is too large Load Diff

131
common/bsplib/ambient.c Normal file
View File

@ -0,0 +1,131 @@
//=======================================================================
// Copyright XashXT Group 2008 ©
// ambient.c - calcualte ambient sounds level
//=======================================================================
#include "bsplib.h"
/*
Some textures (sky, water, slime, lava) are considered ambient sound emiters.
Find an aproximate distance to the nearest emiter of each class for each leaf.
*/
#define MIN_AMBIENT_DIST 128
#define MAX_AMBIENT_DIST 1024
/*
====================
SurfaceBBox
====================
*/
void SurfaceBBox( dsurface_t *s, vec3_t mins, vec3_t maxs )
{
int i, e, vi;
vec3_t v;
ClearBounds( mins, maxs );
for( i = 0; i < s->numedges; i++ )
{
e = dsurfedges[s->firstedge+i];
if( e >= 0 ) vi = dedges[e].v[0];
else vi = dedges[-e].v[1];
VectorCopy( dvertexes[vi].point, v );
AddPointToBounds( v, mins, maxs );
}
}
void AmbientForLeaf( dleaf_t *leaf, float *dists )
{
int j;
float vol;
for( j = 0; j < NUM_AMBIENTS; j++ )
{
if( dists[j] < MIN_AMBIENT_DIST ) vol = 1.0;
else if( dists[j] < MAX_AMBIENT_DIST )
{
vol = 1.0f - (dists[j] / MAX_AMBIENT_DIST);
vol = bound( 0.0f, vol, 1.0f );
}
else vol = 0.0f;
leaf->sounds[j] = (byte)(vol * 255);
}
}
/*
====================
CalcAmbientSounds
FIXME: make work
====================
*/
void CalcAmbientSounds( void )
{
int i, j, k, l;
dleaf_t *leaf, *hit;
byte *vis;
dsurface_t *surf;
vec3_t mins, maxs;
float d, maxd;
int ambient_type;
dtexinfo_t *info;
dshader_t *shader;
float dists[NUM_AMBIENTS];
Msg( "---- CalcAmbientSounds ----\n" );
for( i = 0; i < portalclusters; i++ )
{
leaf = &dleafs[i+1];
// clear ambients
for( j = 0; j < NUM_AMBIENTS; j++ )
dists[j] = MAX_AMBIENT_DIST;
vis = PhsForCluster( i );
for( j = 0; j < portalclusters; j++ )
{
if(!(vis[j>>3] & (1<<(j & 7))))
continue;
// check this leaf for sound textures
hit = &dleafs[j+1];
for( k = 0; k < hit->numleafsurfaces; k++ )
{
surf = &dsurfaces[dleafsurfaces[hit->firstleafsurface + k]];
info = &texinfo[surf->texinfo];
shader = &dshaders[info->shadernum];
if( shader->contentFlags & CONTENTS_SKY )
ambient_type = AMBIENT_SKY;
else if( shader->contentFlags & CONTENTS_SOLID )
continue;
else if( shader->contentFlags & CONTENTS_WATER )
ambient_type = AMBIENT_WATER;
else if( shader->contentFlags & CONTENTS_SLIME )
ambient_type = AMBIENT_SLIME;
else if( shader->contentFlags & CONTENTS_LAVA )
ambient_type = AMBIENT_LAVA;
else continue;
// find distance from source leaf to polygon
SurfaceBBox( surf, mins, maxs );
for( l = maxd = 0; l < 3; l++ )
{
if (maxs[l] > leaf->maxs[l] )
d = maxs[l] - leaf->maxs[l];
else if( mins[l] < leaf->mins[l] )
d = leaf->mins[l] - mins[l];
else d = 0;
if( d > maxd ) maxd = d;
}
if( maxd < dists[ambient_type] )
dists[ambient_type] = maxd;
}
}
AmbientForLeaf( leaf, dists );
}
}

5
common/bsplib/bsplib.c
View File

@ -77,6 +77,7 @@ bool PrepareBSPModel( const char *dir, const char *name )
if( FS_CheckParm( "-hlrad" )) bsp_parms |= BSPLIB_MAKEHLRAD;
if( FS_CheckParm( "-full" )) bsp_parms |= BSPLIB_FULLCOMPILE;
if( FS_CheckParm( "-onlyents" )) bsp_parms |= BSPLIB_ONLYENTS;
if( FS_CheckParm( "-info" )) bsp_parms |= BSPLIB_SHOWINFO;
// famous q1 "notexture" image: purple-black checkerboard
checkermate_dds = FS_LoadInternal( "checkerboard.dds", &checkermate_dds_size );
@ -131,8 +132,10 @@ bool CompileBSPModel ( void )
if( bsp_parms & (BSPLIB_MAKEQ2RAD|BSPLIB_MAKEHLRAD))
WradMain();
if( bsp_parms & BSPLIB_SHOWINFO )
PrintBSPFileSizes();
Free_PhysicLibrary();
PrintBSPFileSizes();
// close log before deleting temporaries
enable_log = false;

8
common/bsplib/bsplib.h
View File

@ -24,7 +24,7 @@ enum
#define VALVE_FORMAT 220
#define MAX_BRUSH_SIDES 128
#define BOGUS_RANGE 131072
#define BOGUS_RANGE MAX_WORLD_COORD
#define TEXINFO_NODE -1 // side is allready on a node
#define MAX_PORTALS 32768
#define PORTALFILE "PRT1"
@ -50,6 +50,7 @@ typedef enum
BSPLIB_RAD_NOBLOCK = BIT(7),
BSPLIB_RAD_NOCOLOR = BIT(8),
BSPLIB_DELETE_TEMP = BIT(9), // delete itermediate files
BSPLIB_SHOWINFO = BIT(10),
} bsplibFlags_t;
extern uint bsp_parms;
@ -559,7 +560,7 @@ extern byte *vismap, *vismap_p, *vismap_end; // past visfile
extern int testlevel;
extern byte *uncompressed;
extern byte *uncompressedvis;
extern int leafbytes, leaflongs;
extern int portalbytes, portallongs;
@ -576,6 +577,9 @@ int CountBits( byte *bits, int numbits );
int PointInLeafnum( vec3_t point );
dleaf_t *PointInLeaf( vec3_t point );
bool PvsForOrigin( vec3_t org, byte *pvs );
byte *PhsForCluster( int cluster );
void CalcAmbientSounds( void );
//=============================================================================
// rad.c

4
common/bsplib/lightmap.c
View File

@ -1022,10 +1022,6 @@ void CreateDirectLights( void )
dl->lightscale = intensity * entity_scale;
}
}
if( bsp_parms & BSPLIB_MAKEHLRAD )
Msg("intensity ( %g %g %g)\n", dl->intensity[0], dl->intensity[1], dl->intensity[2] );
else Msg( "color( %g %g %g)( %g)\n", dl->color[0], dl->color[1], dl->color[2], dl->lightscale );
}
Msg( "%i direct lights\n", numdlights );
}

14
common/bsplib/qvis3.c
View File

@ -128,6 +128,16 @@ bool PvsForOrigin( vec3_t org, byte *pvs )
return true;
}
byte *PhsForCluster( int cluster )
{
static byte phs[(MAX_MAP_LEAFS+7)/8];
Mem_Set( phs, 0x00, (numleafs+7)/8 );
DecompressVis( dvisdata + dvis->bitofs[cluster][DVIS_PHS], phs );
return phs;
}
//=============================================================================
void PlaneFromWinding( viswinding_t *w, visplane_t *plane )
@ -585,7 +595,7 @@ void WvisMain( void )
if( numnodes == 0 || numsurfaces == 0 )
Sys_Break( "Empty map %s.bsp\n", gs_filename );
Msg ("\n---- vis ---- [%s]\n", (bsp_parms & BSPLIB_FULLCOMPILE) ? "full" : "fast" );
Msg( "\n---- vis ---- [%s]\n", (bsp_parms & BSPLIB_FULLCOMPILE) ? "full" : "fast" );
LoadPortals();
CalcPVS();
@ -594,5 +604,7 @@ void WvisMain( void )
visdatasize = vismap_p - dvisdata;
MsgDev( D_INFO, "visdatasize:%i compressed from %i\n", visdatasize, originalvismapsize * 2 );
CalcAmbientSounds();
WriteBSPFile();
}

2
common/bsplib/writebsp.c
View File

@ -267,7 +267,7 @@ void WriteBSP( node_t *headnode )
c_facenodes = 0;
oldsurfaces = numsurfaces;
dmodels[nummodels].headnode = EmitDrawNode_r( headnode );
EmitDrawNode_r( headnode );
EmitAreaPortals( headnode );
}

8
common/common.dsp
View File

@ -113,6 +113,10 @@ SOURCE="$(InputPath)"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\bsplib\ambient.c
# End Source File
# Begin Source File
SOURCE=.\bsplib\brushbsp.c
# End Source File
# Begin Source File
@ -253,10 +257,6 @@ SOURCE=.\bsplib\bsplib.h
# End Source File
# Begin Source File
SOURCE=.\image.h
# End Source File
# Begin Source File
SOURCE=.\mdllib.h
# End Source File
# Begin Source File

3
common/platform.h
View File

@ -7,7 +7,8 @@
#include <windows.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
#include "vprogs_api.h"
//=====================================
// platform export

2
common/studio.c
View File

@ -4,7 +4,7 @@
//=======================================================================
#include "mdllib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
bool cdset;
bool ignore_errors;

1
engine/client/cl_frame.c
View File

@ -60,7 +60,6 @@ void CL_DeltaEntity( sizebuf_t *msg, frame_t *frame, int newnum, entity_state_t
{
// duplicate the current state so lerping doesn't hurt anything
ent->priv.cl->prev = *state;
VectorCopy( state->old_origin, ent->priv.cl->prev.origin );
}
else
{ // shuffle the last state to previous

165
engine/client/cl_fx.c
View File

@ -264,6 +264,7 @@ typedef struct cparticle_s
int flags;
vec3_t org;
vec3_t org2;
vec3_t vel;
vec3_t accel;
vec3_t color;
@ -276,8 +277,6 @@ typedef struct cparticle_s
float lengthVel;
float rotation;
float bounceFactor;
vec3_t old_origin;
} cparticle_t;
cparticle_t *cl_active_particles, *cl_free_particles;
@ -467,7 +466,7 @@ void CL_AddParticles( void )
VectorSet(mins, -radius, -radius, -radius);
VectorSet(maxs, radius, radius, radius);
trace = CL_Trace( p->old_origin, mins, maxs, org, MOVE_NORMAL, clent, MASK_SOLID );
trace = CL_Trace( p->org2, mins, maxs, org, MOVE_NORMAL, clent, MASK_SOLID );
if( trace.fraction != 0.0 && trace.fraction != 1.0 )
{
// reflect velocity
@ -518,8 +517,8 @@ void CL_AddParticles( void )
// save current origin if needed
if( p->flags & (PARTICLE_BOUNCE|PARTICLE_STRETCH))
{
VectorCopy( p->old_origin, org2 );
VectorCopy( org, p->old_origin ); // FIXME: pause
VectorCopy( p->org2, org2 );
VectorCopy( org, p->org2 ); // FIXME: pause
}
if( p->flags & PARTICLE_VERTEXLIGHT )
@ -546,6 +545,68 @@ void CL_AddParticles( void )
cl_active_particles = active;
}
/*
===============
PF_addparticle
void AddParticle(vector, vector, vector, vector, vector, vector, vector, string, float)
===============
*/
void PF_addparticle( void )
{
float *pos, *vel, *color, *colorVel;
float *alphaVel, *radiusVel, *lengthVel;
shader_t shader;
uint flags;
cparticle_t *p;
if( !VM_ValidateArgs( "AddParticle", 9 ))
return;
VM_ValidateString( PRVM_G_STRING( OFS_PARM7 ));
pos = PRVM_G_VECTOR(OFS_PARM0);
vel = PRVM_G_VECTOR(OFS_PARM1);
color = PRVM_G_VECTOR(OFS_PARM2);
colorVel = PRVM_G_VECTOR(OFS_PARM3);
alphaVel = PRVM_G_VECTOR(OFS_PARM4);
radiusVel = PRVM_G_VECTOR(OFS_PARM5);
lengthVel = PRVM_G_VECTOR(OFS_PARM6);
shader = re->RegisterShader( PRVM_G_STRING(OFS_PARM7), SHADER_GENERIC );
flags = (uint)PRVM_G_FLOAT(OFS_PARM8);
p = CL_AllocParticle();
if( !p )
{
VM_Warning( "AddParticle: no free particles\n" );
PRVM_G_FLOAT(OFS_RETURN) = 0;
return;
}
p->shader = shader;
p->time = cl.time;
p->flags = flags;
VectorCopy( pos, p->org );
VectorCopy( vel, p->vel );
VectorSet( p->accel, 0.0f, 0.0f, alphaVel[2] );
VectorCopy( color, p->color );
VectorCopy( colorVel, p->colorVel );
p->alpha = alphaVel[0];
p->alphaVel = alphaVel[1];
p->radius = radiusVel[0];
p->radiusVel = radiusVel[1];
p->length = lengthVel[0];
p->lengthVel = lengthVel[1];
p->rotation = radiusVel[2];
p->bounceFactor = lengthVel[2];
// needs to save old origin
if( flags & (PARTICLE_BOUNCE|PARTICLE_FRICTION))
VectorCopy( p->org, p->org2 );
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
/*
===============
CL_ParticleEffect
@ -651,6 +712,100 @@ void CL_TeleportSplash( vec3_t org )
}
}
/*
=================
CL_ExplosionParticles
=================
*/
void CL_ExplosionParticles( const vec3_t org )
{
cparticle_t *p;
int i, flags;
shader_t sparksShader;
shader_t smokeShader;
if( !cl_particles->integer )
return;
// sparks
flags = PARTICLE_STRETCH;
flags |= PARTICLE_BOUNCE;
flags |= PARTICLE_FRICTION;
sparksShader = re->RegisterShader( "particles/sparks", SHADER_GENERIC );
smokeShader = re->RegisterShader( "particles/smoke", SHADER_GENERIC );
for( i = 0; i < 384; i++ )
{
p = CL_AllocParticle();
if( !p ) return;
p->shader = sparksShader;
p->time = cl.time;
p->flags = flags;
p->org[0] = org[0] + ((rand() % 32) - 16);
p->org[1] = org[1] + ((rand() % 32) - 16);
p->org[2] = org[2] + ((rand() % 32) - 16);
p->vel[0] = (rand() % 512) - 256;
p->vel[1] = (rand() % 512) - 256;
p->vel[2] = (rand() % 512) - 256;
p->accel[0] = 0;
p->accel[1] = 0;
p->accel[2] = -60 + (30 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->color[0] = 1.0;
p->color[1] = 1.0;
p->color[2] = 1.0;
p->colorVel[0] = 0;
p->colorVel[1] = 0;
p->colorVel[2] = 0;
p->alpha = 1.0;
p->alphaVel = -3.0;
p->radius = 0.5 + (0.2 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->radiusVel = 0;
p->length = 8 + (4 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->lengthVel = 8 + (4 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->rotation = 0;
p->bounceFactor = 0.2;
VectorCopy( p->org, p->org2 );
}
// Smoke
flags = 0;
flags |= PARTICLE_VERTEXLIGHT;
for( i = 0; i < 5; i++ )
{
p = CL_AllocParticle();
if( !p ) return;
p->shader = smokeShader;
p->time = cl.time;
p->flags = flags;
p->org[0] = org[0] + RANDOM_FLOAT( -1.0f, 1.0f ) * 10;
p->org[1] = org[1] + RANDOM_FLOAT( -1.0f, 1.0f ) * 10;
p->org[2] = org[2] + RANDOM_FLOAT( -1.0f, 1.0f ) * 10;
p->vel[0] = RANDOM_FLOAT( -1.0f, 1.0f ) * 10;
p->vel[1] = RANDOM_FLOAT( -1.0f, 1.0f ) * 10;
p->vel[2] = RANDOM_FLOAT( -1.0f, 1.0f ) * 10 + (25 + RANDOM_FLOAT( -1.0f, 1.0f ) * 5);
p->accel[0] = 0;
p->accel[1] = 0;
p->accel[2] = 0;
p->color[0] = 0;
p->color[1] = 0;
p->color[2] = 0;
p->colorVel[0] = 0.75f;
p->colorVel[1] = 0.75f;
p->colorVel[2] = 0.75f;
p->alpha = 0.5f;
p->alphaVel = -(0.1 + RANDOM_FLOAT( 0.0f, 1.0f ) * 0.1f);
p->radius = 30 + (15 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->radiusVel = 15 + (7.5 * RANDOM_FLOAT( -1.0f, 1.0f ));
p->length = 1;
p->lengthVel = 0;
p->rotation = rand() % 360;
}
}
/*
==============

47
engine/client/cl_parse.c
View File

@ -269,48 +269,6 @@ ACTION MESSAGES
=====================================================================
*/
/*
==================
CL_ParseStartSoundPacket
==================
*/
void CL_ParseStartSoundPacket( sizebuf_t *msg )
{
vec3_t pos_v;
float *pos = NULL;
int channel = 0;
int sound_num;
float volume;
int attenuation;
int flags, ent = 0;
flags = MSG_ReadByte( msg );
sound_num = MSG_ReadByte( msg );
if( flags & SND_VOL ) volume = MSG_ReadBits( msg, NET_COLOR );
else volume = 1.0f;
if( flags & SND_ATTN ) attenuation = MSG_ReadByte( msg );
else attenuation = ATTN_NORM;
if( flags & SND_ENT )
{
// entity reletive
channel = MSG_ReadShort( msg );
ent = channel>>3;
if( ent > host.max_edicts ) Host_Error("CL_ParseStartSoundPacket: ent out of range\n" );
channel &= 7;
}
if( flags & SND_POS )
{
// positioned in space
MSG_ReadPos( msg, pos_v );
pos = pos_v;
}
if(!cl.sound_precache[sound_num]) return;
S_StartSound( pos, ent, channel, cl.sound_precache[sound_num], volume, attenuation );
}
/*
=====================
CL_ParseServerMessage
@ -367,15 +325,14 @@ void CL_ParseServerMessage( sizebuf_t *msg )
case svc_configstring:
CL_ParseConfigString( msg );
break;
case svc_sound:
CL_ParseStartSoundPacket( msg );
break;
case svc_spawnbaseline:
CL_ParseBaseline( msg );
break;
/*
case svc_temp_entity:
CL_ParseTempEnts( msg );
break;
*/
case svc_download:
CL_ParseDownload( msg );
break;

11
engine/client/cl_pred.c
View File

@ -20,7 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "common.h"
#include "client.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
/*
@ -235,7 +235,7 @@ void CL_PMTrace( vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, trace_t *tr
*tr = CL_Trace( start, mins, maxs, end, MOVE_NORMAL, NULL, CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY );
}
int CL_PointContents( vec3_t point )
int CL_PointContents( const vec3_t point )
{
// get world supercontents at this point
if( cl.worldmodel && cl.worldmodel->PointContents )
@ -243,6 +243,13 @@ int CL_PointContents( vec3_t point )
return 0;
}
bool CL_AmbientLevel( const vec3_t point, float *volumes )
{
// get world supercontents at this point
if( cl.worldmodel && cl.worldmodel->AmbientLevel )
return cl.worldmodel->AmbientLevel( point, volumes, cl.worldmodel );
return 0;
}
/*
=================

44
engine/client/cl_progs.c
View File

@ -59,6 +59,7 @@ void CL_DrawHUD( void )
// setup pparms
prog->globals.cl->health = cl.frame.ps.health;
prog->globals.cl->maxclients = com.atoi(cl.configstrings[CS_MAXCLIENTS]);
prog->globals.cl->max_entities = host.max_edicts;
prog->globals.cl->realtime = cls.realtime * 0.001f;
prog->globals.cl->paused = cl_paused->integer;
@ -234,8 +235,8 @@ void PF_ReadChar (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar( cls.multicast
void PF_ReadShort (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort( cls.multicast ); }
void PF_ReadLong (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong( cls.multicast ); }
void PF_ReadFloat (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat( cls.multicast ); }
void PF_ReadAngle (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat( cls.multicast ); }
void PF_ReadCoord (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat( cls.multicast ); }
void PF_ReadAngle (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadBits( cls.multicast, NET_FLOAT ); }
void PF_ReadCoord (void){ PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadBits( cls.multicast, NET_FLOAT ); }
void PF_ReadString (void){ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString( MSG_ReadString( cls.multicast) ); }
void PF_ReadEntity (void){ VM_RETURN_EDICT( PRVM_PROG_TO_EDICT( MSG_ReadShort( cls.multicast ))); } // entindex
@ -483,6 +484,39 @@ void PF_setcolor( void )
re->SetColor( GetRGBA( rgb[0], rgb[1], rgb[2], alpha ));
}
/*
=========
PF_startsound
CL_StartSound( vector pos, entity e, float chan, float sfx, float vol, float attn )
=========
*/
void PF_startsound( void )
{
float volume;
int channel;
int sound_num;
int attenuation;
float *pos = NULL;
int ent = 0;
if( !VM_ValidateArgs( "CL_StartSound", 6 ))
return;
pos = PRVM_G_VECTOR(OFS_PARM0);
ent = PRVM_G_EDICTNUM(OFS_PARM1);
channel = (int)PRVM_G_FLOAT(OFS_PARM2);
sound_num = (int)PRVM_G_FLOAT(OFS_PARM3);
volume = PRVM_G_FLOAT(OFS_PARM4);
attenuation = (int)PRVM_G_FLOAT(OFS_PARM5);
if( !cl.sound_precache[sound_num] )
{
VM_Warning( "CL_StartSound: invalid sound index: %i\n", sound_num );
return;
}
S_StartSound( pos, ent, channel, cl.sound_precache[sound_num], volume, attenuation );
}
//NOTE: intervals between various "interfaces" was leave for future expansions
prvm_builtin_t vm_cl_builtins[] =
{
@ -508,7 +542,7 @@ VM_ComFileTime, // #14 float Com_FileTime( string filename )
VM_ComLoadScript, // #15 float Com_LoadScript( string filename )
VM_ComResetScript, // #16 void Com_ResetScript( void )
VM_ComReadToken, // #17 string Com_ReadToken( float newline )
NULL, // #18 -- reserved --
VM_Random, // #18 float Random( void )
VM_ComSearchFiles, // #19 float Com_Search( string mask, float casecmp )
VM_ComSearchNames, // #20 string Com_SearchFilename( float num )
VM_RandomLong, // #21 float RandomLong( float min, float max )
@ -572,7 +606,7 @@ VM_rint, // #72 float rint (float v)
VM_floor, // #73 float floor(float v)
VM_ceil, // #74 float ceil (float v)
VM_fabs, // #75 float fabs (float f)
VM_mod, // #76 float fmod( float val, float m )
VM_fmod, // #76 float fmod( float val, float m )
NULL, // #77 -- reserved --
NULL, // #78 -- reserved --
VM_VectorNormalize, // #79 vector VectorNormalize( vector v )
@ -608,6 +642,8 @@ PF_centerprint, // #123 void HUD_CenterPrint( string text, float y, float char
PF_levelshot, // #124 float HUD_MakeLevelShot( void )
PF_setcolor, // #125 void HUD_SetColor( vector rgb, float alpha )
VM_localsound, // #126 void HUD_PlaySound( string sample )
PF_startsound, // #127 void CL_StartSound( vector pos, entity e, float chan, float sfx, float vol, float attn )
PF_addparticle, // #128 float AddParticle(vector, vector, vector, vector, vector, vector, vector, string, float)
};
const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t); //num of builtins

64
engine/client/cl_tent.c
View File

@ -26,10 +26,51 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
typedef enum
{
TE_TELEPORT = 0,
TE_SPIKE,
TE_SPARKS,
TE_GUNSHOT,
TE_BLOOD,
TE_SUPERSPIKE,
TE_EXPLOSION,
TE_LIGHTNING1,
TE_LIGHTNING2,
TE_LIGHTNING3,
TE_LAVASPLASH,
TE_BLOOD
} temp_event_t;
/*
=================
CL_FindExplosionPlane
Disgusting hack
=================
*/
static void CL_FindExplosionPlane( const vec3_t org, float radius, vec3_t dir )
{
static vec3_t planes[6] = {{0, 0, 1}, {0, 1, 0}, {1, 0, 0}, {0, 0, -1}, {0, -1, 0}, {-1, 0, 0}};
trace_t trace;
vec3_t point;
float best = 1.0;
int i;
VectorClear( dir );
for( i = 0; i < 6; i++ )
{
VectorMA( org, radius, planes[i], point );
trace = CL_Trace( org, vec3_origin, vec3_origin, point, MOVE_WORLDONLY, NULL, MASK_SOLID );
if( trace.allsolid || trace.fraction == 1.0 )
continue;
if( trace.fraction < best )
{
best = trace.fraction;
VectorCopy( trace.plane.normal, dir );
}
}
}
/*
=================
CL_ParseTempEnts
@ -39,6 +80,8 @@ void CL_ParseTempEnts( sizebuf_t *msg )
{
int type;
vec3_t pos, dir;
sound_t sound_fx;
shader_t sfx_1, sfx_2;
type = MSG_ReadByte( msg );
@ -53,14 +96,27 @@ void CL_ParseTempEnts( sizebuf_t *msg )
MSG_ReadPos(msg, dir);
CL_ParticleEffect( pos, dir, 0xe8, 60 );
break;
case TE_SPIKE:
MSG_ReadPos(msg, pos);
break;
case TE_GUNSHOT: // bullet hitting wall
MSG_ReadPos(msg, pos);
MSG_ReadPos(msg, dir);
CL_ParticleEffect( pos, dir, 0, 40 );
break;
case TE_EXPLOSION:
MSG_ReadPos(msg, pos);
CL_FindExplosionPlane( pos, 40, dir );
sfx_1 = re->RegisterShader( "engine/explosion", SHADER_GENERIC );
sfx_2 = re->RegisterShader( "engine/{scorch", SHADER_GENERIC );
// CL_Explosion( pos, dir, 40, rand() % 360, 350, 1.0, 0.5, 0.5, sfx_1 );
CL_ExplosionParticles( pos );
// CL_ImpactMark( pos, dir, rand() % 360, 40, 1, 1, 1, 1, false, sfx_2, false );
sound_fx = S_RegisterSound( "weapons/r_exp3.wav" );
S_StartSound( pos, 0, CHAN_AUTO, sound_fx, 1.0f, ATTN_NORM );
break;
default:
Host_Error( "CL_ParseTEnt: bad type\n" );
Host_Error( "CL_ParseTEnt: bad type %i\n", type );
break;
}
}

8
engine/client/cl_view.c
View File

@ -21,6 +21,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "common.h"
#include "client.h"
#include "const.h"
/*
====================
@ -176,6 +177,13 @@ void V_RenderView( void )
cl.refdef.fov_y = V_CalcFov( cl.refdef.fov_x, cl.refdef.rect.width, cl.refdef.rect.height );
cl.refdef.time = cl.time * 0.001f; // cl.time for right lerping
cl.refdef.oldtime = (cl.time * 0.001f) - 0.005; // frametime
if( cl.refdef.rdflags & RDF_UNDERWATER )
{
float f = com.sin( cl.time * 0.001 * 0.4 * (M_PI * 2.7));
cl.refdef.fov_x += f;
cl.refdef.fov_y -= f;
}
}
re->RenderFrame( &cl.refdef );
}

5
engine/client/client.h
View File

@ -528,7 +528,8 @@ float V_CalcFov( float fov_x, float width, float height );
void CL_InitPrediction (void);
void CL_PredictMove (void);
void CL_CheckPredictionError (void);
int CL_PointContents( vec3_t point );
int CL_PointContents( const vec3_t point );
bool CL_AmbientLevel( const vec3_t point, float *volumes );
trace_t CL_Trace( const vec3_t s1, const vec3_t m1, const vec3_t m2, const vec3_t s2, int type, edict_t *ed, int mask );
//
@ -544,8 +545,10 @@ cdlight_t *CL_AllocDlight (int key);
void CL_AddParticles (void);
void CL_ClearEffects( void );
void CL_StudioEvent( dstudioevent_t *event, entity_state_t *ent );
void CL_ExplosionParticles( const vec3_t org );
entity_state_t *CL_GetEdictByIndex( int index );
entity_state_t *CL_GetLocalPlayer( void );
void PF_addparticle( void );
//
// cl_pred.c

13
engine/common.h
View File

@ -11,9 +11,11 @@
#include <windows.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
#include "engine_api.h"
#include "physic_api.h"
#include "vprogs_api.h"
#include "vsound_api.h"
#include "net_msg.h"
// linked interfaces
@ -124,6 +126,9 @@ CLIENT / SERVER SYSTEMS
#define FL_FLOAT (1<<7) // this entity can be floating. FIXME: remove this ?
#define FL_TRACKTRAIN (1<<8) // old stuff...
// encoded bmodel mask
#define SOLID_BMODEL 0xffffff
void CL_Init( void );
void CL_Shutdown( void );
void CL_Frame( dword time );
@ -181,7 +186,8 @@ _inline edict_t *_PRVM_EDICT_NUM( int n, const char * file, const int line )
const char *VM_VarArgs( int start_arg );
bool VM_ValidateArgs( const char *builtin, int num_argc );
void VM_SetTraceGlobals( const trace_t *trace );
void VM_ValidateString( const char *s );
#define VM_ValidateString( str ) _VM_ValidateString( str, __FILE__, __LINE__ )
void _VM_ValidateString( const char *s, const char *filename, const int fileline );
void VM_Cmd_Init( void );
void VM_Cmd_Reset( void );
@ -243,6 +249,7 @@ void VM_CvarGetValue( void );
void VM_CvarSetString( void );
void VM_CvarGetString( void );
void VM_AddCommand( void );
void VM_Random( void );
void VM_ComVA( void );
void VM_ComStrlen( void );
void VM_TimeStamp( void );
@ -269,7 +276,7 @@ void VM_getimagesize( void );
void VM_min( void );
void VM_max( void );
void VM_bound( void );
void VM_mod( void );
void VM_fmod( void );
void VM_pow( void );
void VM_sin( void );
void VM_cos( void );

42
engine/common/engfuncs.c
View File

@ -31,9 +31,9 @@ bool VM_ValidateArgs( const char *builtin, int num_argc )
return true;
}
void VM_ValidateString( const char *s )
void _VM_ValidateString( const char *s, const char *filename, const int fileline )
{
if( s[0] <= ' ' ) PRVM_ERROR( "%s: bad string\n", PRVM_NAME );
if( s[0] <= ' ' ) PRVM_ERROR( "%s: bad string (called at %s:%i)\n", PRVM_NAME, filename, fileline );
}
void VM_SetTraceGlobals( const trace_t *trace )
@ -467,6 +467,20 @@ void VM_ComSearchNames( void )
else PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString( NULL );
}
/*
=========
VM_Random
float Random( void )
=========
*/
void VM_Random( void )
{
if(!VM_ValidateArgs( "Random", 0 ))
return;
PRVM_G_FLOAT(OFS_RETURN) = (float)rand();
}
/*
=========
VM_RandomLong
@ -763,9 +777,9 @@ void VM_localsound( void )
return;
s = PRVM_G_STRING( OFS_PARM0 );
if(!S_StartLocalSound(s))
if(!S_StartLocalSound( s ))
{
VM_Warning("localsound: can't play %s!\n", s );
VM_Warning( "localsound: can't play %s!\n", s );
PRVM_G_FLOAT(OFS_RETURN) = 0;
return;
}
@ -1244,7 +1258,6 @@ void VM_drawmodel( void )
re->ClearScene();
re->RegisterModel( modname, MAX_MODELS - 1 );
ent.renderfx = RF_FULLBRIGHT;
ent.model.sequence = sequence;
ent.model.index = MAX_MODELS - 1;
ent.model.controller[0] = 127;
@ -1252,7 +1265,6 @@ void VM_drawmodel( void )
ent.model.controller[2] = 127;
ent.model.controller[3] = 127;
VectorCopy( origin, ent.origin );
VectorCopy( origin, ent.old_origin );
VectorCopy( angles, ent.angles );
ent.model.frame = frame += 0.7f; // FXIME: needs flag EF_AUTOANIMATE or somewhat
@ -1493,20 +1505,20 @@ void VM_fabs( void )
/*
=========
VM_modulo
VM_fmod
float mod( float val, float m )
float fmod( float val, float m )
=========
*/
void VM_mod( void )
void VM_fmod( void )
{
int val, m;
float val, m;
if(!VM_ValidateArgs( "fmod", 2 )) return;
val = (int)PRVM_G_FLOAT(OFS_PARM0);
m = (int)PRVM_G_FLOAT(OFS_PARM1);
PRVM_G_FLOAT(OFS_RETURN) = (float)(val % m);
val = PRVM_G_FLOAT(OFS_PARM0);
m = PRVM_G_FLOAT(OFS_PARM1);
PRVM_G_FLOAT(OFS_RETURN) = fmod( val, m );
}
/*
@ -1559,7 +1571,7 @@ VM_ComFileTime, // #14 float Com_FileTime( string filename )
VM_ComLoadScript, // #15 float Com_LoadScript( string filename )
VM_ComResetScript, // #16 void Com_ResetScript( void )
VM_ComReadToken, // #17 string Com_ReadToken( float newline )
NULL, // #18 -- reserved --
VM_Random, // #18 float Random( void )
VM_ComSearchFiles, // #19 float Com_Search( string mask, float casecmp )
VM_ComSearchNames, // #20 string Com_SearchFilename( float num )
VM_RandomLong, // #21 float RandomLong( float min, float max )
@ -1623,7 +1635,7 @@ VM_rint, // #72 float rint (float v)
VM_floor, // #73 float floor(float v)
VM_ceil, // #74 float ceil (float v)
VM_fabs, // #75 float fabs (float f)
VM_mod, // #76 float fmod( float val, float m )
VM_fmod, // #76 float fmod( float val, float m )
NULL, // #77 -- reserved --
NULL, // #78 -- reserved --
VM_VectorNormalize, // #79 vector VectorNormalize( vector v )

23
engine/common/menu.c
View File

@ -51,7 +51,6 @@ static const char *xash_credits[] =
"",
"^3THANKS TO",
"ID Software at all",
"Lord Havoc (Darkplaces Team)",
"Georg Destroy for icon graphics",
"",
"",
@ -60,6 +59,24 @@ static const char *xash_credits[] =
"",
"",
"",
"^3Xash3D using some parts of:",
"Doom 1 (Id Software)",
"Quake 1 (Id Software)",
"Quake 2 (Id Software)",
"Quake 3 (Id Software)",
"Half-Life (Valve Software)",
"Darkplaces (Darkplaces Team)",
"Quake 2 Evolved (Team Blur)",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"Copyright XashXT Group 2008 (C)",
@ -665,7 +682,7 @@ VM_ComFileTime, // #14 float Com_FileTime( string filename )
VM_ComLoadScript, // #15 float Com_LoadScript( string filename )
VM_ComResetScript, // #16 void Com_ResetScript( void )
VM_ComReadToken, // #17 string Com_ReadToken( float newline )
NULL, // #18 -- reserved --
VM_Random, // #18 float Random( void )
VM_ComSearchFiles, // #19 float Com_Search( string mask, float casecmp )
VM_ComSearchNames, // #20 string Com_SearchFilename( float num )
VM_RandomLong, // #21 float RandomLong( float min, float max )
@ -729,7 +746,7 @@ VM_rint, // #72 float rint (float v)
VM_floor, // #73 float floor(float v)
VM_ceil, // #74 float ceil (float v)
VM_fabs, // #75 float fabs (float f)
VM_mod, // #76 float fmod( float val, float m )
VM_fmod, // #76 float fmod( float val, float m )
NULL, // #77 -- reserved --
NULL, // #78 -- reserved --
VM_VectorNormalize, // #79 vector VectorNormalize( vector v )

42
engine/common/net_msg.c
View File

@ -9,8 +9,8 @@
static net_field_t ent_fields[] =
{
{ ES_FIELD(ed_type), NET_BYTE, true },
{ ES_FIELD(classname), NET_WORD, true },
{ ES_FIELD(ed_type), NET_BYTE, false }, // stateflags_t #0 (4 bytes)
{ ES_FIELD(classname), NET_WORD, false },
{ ES_FIELD(soundindex), NET_WORD, false }, // 512 sounds ( OpenAL software limit is 255 )
{ ES_FIELD(origin[0]), NET_FLOAT, false },
{ ES_FIELD(origin[1]), NET_FLOAT, false },
@ -21,9 +21,6 @@ static net_field_t ent_fields[] =
{ ES_FIELD(velocity[0]), NET_FLOAT, false },
{ ES_FIELD(velocity[1]), NET_FLOAT, false },
{ ES_FIELD(velocity[2]), NET_FLOAT, false },
{ ES_FIELD(old_origin[0]), NET_FLOAT, true }, // send always
{ ES_FIELD(old_origin[1]), NET_FLOAT, true },
{ ES_FIELD(old_origin[2]), NET_FLOAT, true },
{ ES_FIELD(infotarget[0]), NET_FLOAT, false }, // beam endpoint, portal camera pos, etc
{ ES_FIELD(infotarget[1]), NET_FLOAT, false },
{ ES_FIELD(infotarget[2]), NET_FLOAT, false },
@ -38,13 +35,12 @@ static net_field_t ent_fields[] =
{ ES_FIELD(model.skin), NET_CHAR, false }, // negative skins are contents
{ ES_FIELD(model.body), NET_BYTE, false }, // 255 bodies
{ ES_FIELD(pmodel.index), NET_WORD, false }, // 4096 models
{ ES_FIELD(pmodel.colormap), NET_LONG, false }, // 4096 models
{ ES_FIELD(pmodel.sequence), NET_WORD, false }, // 1024 sequences
{ ES_FIELD(pmodel.frame), NET_FLOAT, false }, // interpolate value
{ ES_FIELD(pmodel.body), NET_BYTE, false }, // 255 bodies
{ ES_FIELD(pmodel.skin), NET_BYTE, false }, // 255 skins
{ ES_FIELD(model.blending[0]), NET_COLOR, false }, // animation blending
{ ES_FIELD(model.blending[1]), NET_COLOR, false },
{ ES_FIELD(model.blending[0]), NET_COLOR, false },
{ ES_FIELD(model.blending[1]), NET_COLOR, false }, // stateflags_t #1 (4 bytes)
{ ES_FIELD(model.blending[2]), NET_COLOR, false },
{ ES_FIELD(model.blending[3]), NET_COLOR, false },
{ ES_FIELD(model.blending[4]), NET_COLOR, false },
@ -63,16 +59,10 @@ static net_field_t ent_fields[] =
{ ES_FIELD(model.controller[7]), NET_COLOR, false },
{ ES_FIELD(model.controller[8]), NET_COLOR, false },
{ ES_FIELD(solidtype), NET_BYTE, false },
{ ES_FIELD(movetype), NET_BYTE, false }, // send flags (second 4 bytes)
{ ES_FIELD(movetype), NET_BYTE, false },
{ ES_FIELD(gravity), NET_SHORT, false }, // gravity multiplier
{ ES_FIELD(aiment), NET_WORD, false }, // entity index
{ ES_FIELD(solid), NET_LONG, false }, // encoded mins/maxs
{ ES_FIELD(model.blending[10]), NET_COLOR, false },
{ ES_FIELD(model.blending[11]), NET_COLOR, false },
{ ES_FIELD(model.blending[12]), NET_COLOR, false },
{ ES_FIELD(model.blending[13]), NET_COLOR, false },
{ ES_FIELD(model.blending[14]), NET_COLOR, false },
{ ES_FIELD(model.blending[15]), NET_COLOR, false },
{ ES_FIELD(mins[0]), NET_FLOAT, false },
{ ES_FIELD(mins[1]), NET_FLOAT, false },
{ ES_FIELD(mins[2]), NET_FLOAT, false },
@ -82,20 +72,12 @@ static net_field_t ent_fields[] =
{ ES_FIELD(effects), NET_LONG, false }, // effect flags
{ ES_FIELD(renderfx), NET_LONG, false }, // renderfx flags
{ ES_FIELD(renderamt), NET_COLOR, false }, // alpha amount
{ ES_FIELD(rendercolor[0]), NET_COLOR, false }, // animation blending
{ ES_FIELD(rendercolor[0]), NET_COLOR, false }, // stateflags_t #2 (4 bytes)
{ ES_FIELD(rendercolor[1]), NET_COLOR, false },
{ ES_FIELD(rendercolor[2]), NET_COLOR, false },
{ ES_FIELD(rendermode), NET_BYTE, false }, // render mode (legacy stuff)
{ ES_FIELD(model.controller[9]), NET_COLOR, false },
{ ES_FIELD(model.controller[10]), NET_COLOR, false },
{ ES_FIELD(model.controller[11]), NET_COLOR, false },
{ ES_FIELD(model.controller[12]), NET_COLOR, false },
{ ES_FIELD(model.controller[13]), NET_COLOR, false },
{ ES_FIELD(model.controller[14]), NET_COLOR, false },
{ ES_FIELD(model.controller[15]), NET_COLOR, false },
{ ES_FIELD(pm_type), NET_BYTE, false }, // 16 player movetypes allowed
{ ES_FIELD(pm_flags), NET_WORD, false }, // 16 movetype flags allowed
{ ES_FIELD(pm_time), NET_BYTE, false }, // each unit 8 msec
{ ES_FIELD(delta_angles[0]), NET_FLOAT, false },
{ ES_FIELD(delta_angles[1]), NET_FLOAT, false },
{ ES_FIELD(delta_angles[2]), NET_FLOAT, false },
@ -108,9 +90,10 @@ static net_field_t ent_fields[] =
{ ES_FIELD(viewoffset[0]), NET_SCALE, false },
{ ES_FIELD(viewoffset[1]), NET_SCALE, false },
{ ES_FIELD(viewoffset[2]), NET_SCALE, false },
{ ES_FIELD(maxspeed), NET_WORD, false }, // send flags (third 4 bytes )
{ ES_FIELD(maxspeed), NET_WORD, false },
{ ES_FIELD(fov), NET_FLOAT, false }, // client horizontal field of view
{ ES_FIELD(health), NET_FLOAT, false }, // client health
// reserve for 10-11 fields without enlarge null_msg_size
{ NULL }, // terminator
};
@ -585,7 +568,7 @@ identical, under the assumption that the in-order delta code will catch it.
void _MSG_WriteDeltaEntity( entity_state_t *from, entity_state_t *to, sizebuf_t *msg, bool force, bool newentity, const char *filename, int fileline )
{
net_field_t *field, *field2;
int i, j, k, flags;
int i, j, k, flags = 0;
int *fromF, *toF;
int num_fields;
size_t null_msg_size;
@ -620,7 +603,7 @@ void _MSG_WriteDeltaEntity( entity_state_t *from, entity_state_t *to, sizebuf_t
{
if( k > 31 ) break; // return to main cycle
toF = (int *)((byte *)to + field2->offset );
if( flags & 1<<k ) MSG_WriteBits( msg, *toF, field2->name, field2->bits );
if( flags & (1<<k)) MSG_WriteBits( msg, *toF, field2->name, field2->bits );
}
j = flags = 0;
}
@ -628,9 +611,9 @@ void _MSG_WriteDeltaEntity( entity_state_t *from, entity_state_t *to, sizebuf_t
// NOTE: null_msg_size is number of (ent_fields / 32) + (1),
// who indicates flags count multiplied by sizeof(long)
// plus sizeof(short) (head number). If message equal null_message_size
// plus sizeof(short) (head number). if message equal null_message_size
// we will be ignore it
if(!force && (( msg->cursize - buff_size ) == null_msg_size ))
if( !force && (( msg->cursize - buff_size ) == null_msg_size ))
msg->cursize = buff_size; // kill message
}
@ -656,7 +639,6 @@ void MSG_ReadDeltaEntity( sizebuf_t *msg, entity_state_t *from, entity_state_t *
Host_Error( "MSG_ReadDeltaEntity: bad delta entity number: %i\n", number );
*to = *from;
VectorCopy( from->origin, to->old_origin );
to->number = number;
if(*(int *)&msg->data[msg->readcount] == -99 )

4
engine/common/net_msg.h
View File

@ -77,7 +77,7 @@ enum clc_ops_e
typedef enum
{
MSG_ONE,
MSG_ONE = 0, // never send by QC-code (just not declared)
MSG_ALL,
MSG_PHS,
MSG_PVS,
@ -258,7 +258,7 @@ typedef struct netchan_s
#define PORT_MASTER 27900
#define PORT_CLIENT 27901
#define PORT_SERVER 27910
#define UPDATE_BACKUP 64 // copies of entity_state_t to keep buffered, must be power of two
#define UPDATE_BACKUP 32 // copies of entity_state_t to keep buffered, must be power of two
#define UPDATE_MASK (UPDATE_BACKUP - 1)
void Netchan_Init( void );

8
engine/engine.dsp
View File

@ -258,10 +258,6 @@ SOURCE=.\server\sv_world.c
# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
# Begin Source File
SOURCE=..\public\basetypes.h
# End Source File
# Begin Source File
SOURCE=.\client\cl_edict.h
# End Source File
# Begin Source File
@ -284,10 +280,6 @@ SOURCE=.\server\server.h
SOURCE=.\server\sv_edict.h
# End Source File
# Begin Source File
SOURCE=.\client\ui_edict.h
# End Source File
# End Group
# End Target
# End Project

1
engine/host.c
View File

@ -140,6 +140,7 @@ void Host_InitSound( void )
si.api_size = sizeof(vsound_imp_t);
si.GetSoundSpatialization = CL_GetEntitySoundSpatialization;
si.PointContents = CL_PointContents;
si.AmbientLevel = CL_AmbientLevel;
si.AddLoopingSounds = CL_AddLoopingSounds;
Sys_LoadLibrary( &vsound_dll );

8
engine/server/sv_client.c
View File

@ -501,7 +501,6 @@ void SV_PutClientInServer( edict_t *ent )
PRVM_ExecuteProgram( prog->globals.sv->PutClientInServer, "PutClientInServer" );
ent->progs.sv->v_angle[ROLL] = 0; // cut off any camera rolling
ent->progs.sv->origin[2] += 1; // make sure off ground
VectorCopy( ent->progs.sv->origin, ent->progs.sv->old_origin );
// create viewmodel
viewmodel = PRVM_ED_Alloc();
@ -511,13 +510,10 @@ void SV_PutClientInServer( edict_t *ent )
VectorCopy( ent->progs.sv->angles, viewmodel->progs.sv->angles );
viewmodel->progs.sv->model = ent->progs.sv->v_model;
viewmodel->progs.sv->movetype = MOVETYPE_FOLLOW;
// make cross links for consistency
viewmodel->progs.sv->aiment = PRVM_NUM_FOR_EDICT( ent );
ent->progs.sv->aiment = PRVM_NUM_FOR_EDICT( viewmodel );
// setup viewflags
viewmodel->progs.sv->renderfx = RF_MINLIGHT | RF_DEPTHHACK | RF_VIEWMODEL;
}
else
{
@ -813,7 +809,7 @@ void SV_UserinfoChanged( sv_client_t *cl )
if( com.strlen( val ))
{
i = com.atoi( val );
cl->rate = bound( 1000, i, 90000 );
cl->rate = bound( 3000, i, 90000 );
}
else cl->rate = 3000;
}

14
engine/server/sv_edict.h
View File

@ -82,6 +82,7 @@ struct sv_entvars_s
vec3_t size;
float mass;
float solid;
float scale;
float contents;
float movetype;
float waterlevel;
@ -96,15 +97,18 @@ struct sv_entvars_s
float animtime;
float framerate;
float style;
float gaitsequence;
float effects;
float rendermode;
float renderfx;
float rendermode;
float renderamt;
vec3_t rendercolor;
float colormap;
float gaitsequence;
float flags;
float aiflags;
float spawnflags;
float blending[16];
float controller[16];
float fixangle;
vec3_t v_angle;
vec3_t view_ofs;
@ -113,6 +117,9 @@ struct sv_entvars_s
float button1;
float button2;
float impulse;
float weapon;
float items;
float currentammo;
string_t v_model;
float v_frame;
float v_body;
@ -135,6 +142,7 @@ struct sv_entvars_s
float yaw_speed;
float m_flGroundSpeed;
float m_flFrameRate;
float m_flWeaponFrameRate;
int groundentity;
float takedamage;
float nextthink;
@ -144,6 +152,6 @@ struct sv_entvars_s
float team;
};
#define PROG_CRC_SERVER 8066
#define PROG_CRC_SERVER 16873
#endif//SV_EDICT_H

25
engine/server/sv_frame.c
View File

@ -5,6 +5,7 @@
#include "common.h"
#include "server.h"
#include "const.h"
#define MAX_VISIBLE_PACKET 1024
typedef struct
@ -46,6 +47,7 @@ Copy PRVM values into entity state
void SV_UpdateEntityState( edict_t *ent )
{
edict_t *client;
int i;
// copy progs values to state
ent->priv.sv->s.number = ent->priv.sv->serialnumber;
@ -53,14 +55,12 @@ void SV_UpdateEntityState( edict_t *ent )
VectorCopy (ent->progs.sv->origin, ent->priv.sv->s.origin);
VectorCopy (ent->progs.sv->angles, ent->priv.sv->s.angles);
VectorCopy (ent->progs.sv->old_origin, ent->priv.sv->s.old_origin);
ent->priv.sv->s.model.index = (int)ent->progs.sv->modelindex;
ent->priv.sv->s.health = ent->progs.sv->health;
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
ent->priv.sv->s.rendermode = ent->progs.sv->rendermode; // rendering mode
@ -68,6 +68,18 @@ void SV_UpdateEntityState( edict_t *ent )
ent->priv.sv->s.model.framerate = ent->progs.sv->framerate;
ent->priv.sv->s.model.animtime = (int)(1000.0 * ent->progs.sv->animtime) * 0.001; // sequence time
ent->priv.sv->s.aiment = ent->progs.sv->aiment; // viewmodel parent
ent->priv.sv->s.model.scale = ent->progs.sv->scale; // shared client and render flags
VectorCopy( ent->progs.sv->rendercolor, ent->priv.sv->s.rendercolor );
// studio model sequence
if( ent->progs.sv->sequence != -1 ) ent->priv.sv->s.model.sequence = ent->progs.sv->sequence;
for( i = 0; i < 16; i++ )
{
// copy blendings and bone ctrls
ent->priv.sv->s.model.blending[i] = ent->progs.sv->blending[i];
ent->priv.sv->s.model.controller[i] = ent->progs.sv->controller[i];
}
if( ent->priv.sv->s.ed_type == ED_VIEWMODEL )
{
@ -79,9 +91,10 @@ void SV_UpdateEntityState( edict_t *ent )
ent->priv.sv->s.model.frame = ent->progs.sv->frame = client->progs.sv->v_frame;
ent->priv.sv->s.model.body = ent->progs.sv->body = client->progs.sv->v_body;
ent->priv.sv->s.model.skin = ent->progs.sv->skin = client->progs.sv->v_skin;
ent->priv.sv->s.model.sequence = ent->progs.sv->sequence = client->progs.sv->v_sequence;
VectorCopy( ent->progs.sv->origin, ent->priv.sv->s.old_origin );
ent->progs.sv->sequence = client->progs.sv->v_sequence;
if( ent->progs.sv->sequence != -1 ) ent->priv.sv->s.model.sequence = ent->progs.sv->sequence;
ent->priv.sv->s.model.colormap = ent->progs.sv->colormap = client->progs.sv->colormap;
ent->priv.sv->s.effects |= EF_MINLIGHT; // always have some light
}
else if( ent->priv.sv->s.ed_type == ED_AMBIENT )
{
@ -187,7 +200,8 @@ void SV_EmitPacketEntities( client_frame_t *from, client_frame_t *to, sizebuf_t
}
if( newnum > oldnum )
{
MSG_WriteDeltaEntity( oldent, NULL, msg, true, true );
// remove from message
MSG_WriteDeltaEntity( oldent, NULL, msg, false, false );
oldindex++;
continue;
}
@ -515,6 +529,7 @@ bool SV_SendClientDatagram( sv_client_t *cl )
MsgDev( D_WARN, "msg overflowed for %s\n", cl->name );
MSG_Clear( &msg );
}
// send the datagram
Netchan_Transmit( &cl->netchan, msg.cursize, msg.data );

1
engine/server/sv_init.c
View File

@ -99,7 +99,6 @@ void SV_CreateBaseline( void )
svent->priv.sv->serialnumber = entnum;
// take current state as baseline
VectorCopy (svent->progs.sv->origin, svent->progs.sv->old_origin);
SV_UpdateEntityState( svent );
svs.baselines[entnum] = svent->priv.sv->s;

2
engine/server/sv_move.c
View File

@ -5,7 +5,7 @@
#include "common.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "server.h"
#include "const.h"

10
engine/server/sv_phys.c
View File

@ -5,7 +5,7 @@
#include "common.h"
#include "server.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
/*
@ -331,8 +331,8 @@ bool SV_RunThink( edict_t *ent )
{
prog->globals.sv->time = max( sv.time, ent->progs.sv->nextthink );
ent->progs.sv->nextthink = 0;
prog->globals.sv->pev = PRVM_EDICT_TO_PROG(ent);
prog->globals.sv->other = PRVM_EDICT_TO_PROG(prog->edicts);
prog->globals.sv->pev = PRVM_EDICT_TO_PROG( ent );
prog->globals.sv->other = PRVM_EDICT_TO_PROG( prog->edicts );
PRVM_ExecuteProgram( ent->progs.sv->think, "pev->think" );
// mods often set nextthink to time to cause a think every frame,
// we don't want to loop in that case, so exit if the new nextthink is
@ -361,8 +361,8 @@ void SV_Impact( edict_t *e1, trace_t *trace )
prog->globals.sv->time = sv.time;
if( !e1->priv.sv->free && !e2->priv.sv->free && e1->progs.sv->touch && e1->progs.sv->solid != SOLID_NOT )
{
prog->globals.sv->pev = PRVM_EDICT_TO_PROG(e1);
prog->globals.sv->other = PRVM_EDICT_TO_PROG(e2);
prog->globals.sv->pev = PRVM_EDICT_TO_PROG( e1 );
prog->globals.sv->other = PRVM_EDICT_TO_PROG( e2 );
PRVM_ExecuteProgram( e1->progs.sv->touch, "pev->touch" );
}

341
engine/server/sv_progs.c
View File

@ -1385,108 +1385,6 @@ void PF_setorigin( void )
SV_LinkEdict( e );
}
/*
=================
PF_sound
void EmitSound(entity e, float chan, string samp, float vol, float attn)
=================
*/
void PF_sound( void )
{
const char *sample;
int channel, sound_idx;
edict_t *entity;
float attenuation;
int flags = 0, ent, volume;
vec3_t snd_origin;
int sendchan;
bool use_phs;
if(!VM_ValidateArgs( "EmitSound", 5 )) return;
entity = PRVM_G_EDICT(OFS_PARM0);
channel = (int)PRVM_G_FLOAT(OFS_PARM1);
sample = PRVM_G_STRING(OFS_PARM2);
volume = PRVM_G_FLOAT(OFS_PARM3);
attenuation = PRVM_G_FLOAT(OFS_PARM4);
ent = PRVM_NUM_FOR_EDICT( entity );
if( attenuation < 0 || attenuation > 4 )
{
VM_Warning("SV_StartSound: attenuation must be in range 0-4\n");
return;
}
if( channel < 0 || channel > 7 )
{
VM_Warning("SV_StartSound: channel must be in range 0-7\n");
return;
}
if( volume != 1.0f ) flags |= SND_VOL;
if( attenuation != 1.0f ) flags |= SND_ATTN;
flags |= SND_POS|SND_ENT;
// use the entity origin unless it is a bmodel or explicitly specified
if( entity->progs.sv->solid == SOLID_BSP || VectorIsNull( entity->progs.sv->origin ))
{
VectorAverage( entity->progs.sv->mins, entity->progs.sv->maxs, snd_origin );
VectorAdd( snd_origin, entity->progs.sv->origin, snd_origin );
channel |= CHAN_RELIABLE;
use_phs = false;
channel &= 7;
}
else
{
VectorCopy( entity->progs.sv->origin, snd_origin );
use_phs = true;
}
sound_idx = SV_SoundIndex( sample );
sendchan = (ent<<3)|(channel & 7);
MSG_Begin( svc_sound );
MSG_WriteByte( &sv.multicast, flags );
MSG_WriteByte( &sv.multicast, sound_idx );
if( flags & SND_VOL ) MSG_WriteBits( &sv.multicast, volume, "voulme", NET_COLOR );
if( flags & SND_ATTN) MSG_WriteByte( &sv.multicast, attenuation );
if( flags & SND_ENT ) MSG_WriteWord( &sv.multicast, sendchan );
if( flags & SND_POS ) MSG_WritePos( &sv.multicast, snd_origin );
if( channel & CHAN_RELIABLE )
{
if( use_phs ) MSG_Send( MSG_PHS_R, snd_origin, NULL );
else MSG_Send( MSG_ALL_R, snd_origin, NULL );
}
else
{
if( use_phs ) MSG_Send( MSG_PHS, snd_origin, NULL );
else MSG_Send( MSG_ALL, snd_origin, NULL );
}
}
/*
=================
PF_ambientsound
void EmitAmbientSound(entity e, string samp)
=================
*/
void PF_ambientsound( void )
{
const char *samp;
edict_t *ent;
if(!VM_ValidateArgs( "EmitAmbientSound", 2 )) return;
ent = PRVM_G_EDICT(OFS_PARM0);
samp = PRVM_G_STRING(OFS_PARM1);
if( !ent ) return;
// check to see if samp was properly precached
ent->progs.sv->loopsound = PRVM_G_INT(OFS_PARM1);
ent->priv.sv->s.soundindex = SV_SoundIndex( samp );
if( !ent->progs.sv->modelindex ) SV_LinkEdict( ent );
}
/*
=================
PF_traceline
@ -1605,6 +1503,7 @@ void PF_lookupactivity( void )
int activity, weighttotal = 0;
if(!VM_ValidateArgs( "LookupActivity", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = 0;
@ -1628,6 +1527,48 @@ void PF_lookupactivity( void )
PRVM_G_FLOAT(OFS_RETURN) = seq;
}
/*
=============
PF_lookupactivity
float LookupActivityHeaviest( string model, float activity )
=============
*/
void PF_lookupactivityheaviest( void )
{
cmodel_t *mod;
dstudioseqdesc_t *pseqdesc;
dstudiohdr_t *pstudiohdr;
int i, seq = -1;
int activity, weight = 0;
if(!VM_ValidateArgs( "LookupActivityHeaviest", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) 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 = (dstudiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
pseqdesc = (dstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
activity = (int)PRVM_G_FLOAT(OFS_PARM1);
for( i = 0; i < pstudiohdr->numseq; i++ )
{
if( pseqdesc[i].activity == activity )
{
if( pseqdesc[i].actweight > weight )
{
weight = pseqdesc[i].actweight;
seq = i;
}
}
}
PRVM_G_FLOAT(OFS_RETURN) = seq;
}
/*
=============
PF_geteyepos
@ -1641,6 +1582,7 @@ void PF_geteyepos( void )
dstudiohdr_t *pstudiohdr;
if(!VM_ValidateArgs( "GetEyePosition", 1 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
VectorCopy( vec3_origin, PRVM_G_VECTOR(OFS_RETURN));
@ -1666,10 +1608,11 @@ void PF_lookupsequence( void )
dstudioseqdesc_t *pseqdesc;
int i;
if(!VM_ValidateArgs( "LookupSequence", 2 )) return;
PRVM_G_FLOAT(OFS_RETURN) = -1;
if( !VM_ValidateArgs( "LookupSequence", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) 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;
@ -1703,6 +1646,7 @@ void PF_getsequenceinfo( void )
int sequence;
if(!VM_ValidateArgs( "GetSequenceInfo", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = 0;
@ -1735,6 +1679,51 @@ void PF_getsequenceinfo( void )
PRVM_G_FLOAT(OFS_RETURN) = 1; // all done
}
/*
=============
PF_getweaponsequenceinfo
float GetWeaponSequenceInfo( string model, float sequence )
=============
*/
void PF_getweaponsequenceinfo( void )
{
cmodel_t *mod;
edict_t *ent;
dstudiohdr_t *pstudiohdr;
dstudioseqdesc_t *pseqdesc;
int sequence;
if(!VM_ValidateArgs( "GetWeaponSequenceInfo", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = 0;
sequence = (int)PRVM_G_FLOAT(OFS_PARM1);
ent = PRVM_PROG_TO_EDICT( prog->globals.sv->pev );
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (dstudiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
if( sequence >= pstudiohdr->numseq )
{
ent->progs.sv->m_flWeaponFrameRate = 0.0;
return;
}
pseqdesc = (dstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + sequence;
if( pseqdesc->numframes > 1 )
{
ent->progs.sv->m_flWeaponFrameRate = 256.0 * (pseqdesc->fps / (pseqdesc->numframes - 1));
}
else
{
ent->progs.sv->m_flWeaponFrameRate = 256.0;
}
PRVM_G_FLOAT(OFS_RETURN) = 1; // all done
}
/*
=============
PF_getsequenceflags
@ -1751,6 +1740,7 @@ void PF_getsequenceflags( void )
int sequence;
if(!VM_ValidateArgs( "GetSequenceFlags", 2 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = -1;
@ -1766,6 +1756,130 @@ void PF_getsequenceflags( void )
PRVM_G_FLOAT(OFS_RETURN) = (float )pseqdesc->flags;
}
/*
=============
PF_setcontroller
float SetController( string model, float controller, float value )
=============
*/
void PF_setcontroller( void )
{
cmodel_t *mod;
edict_t *ent;
dstudiohdr_t *pstudiohdr;
dstudiobonecontroller_t *pbonecontroller;
int i, iController;
int setting;
float flValue;
if(!VM_ValidateArgs( "SetController", 3 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
flValue = PRVM_G_FLOAT(OFS_PARM2); // not modified value
PRVM_G_FLOAT(OFS_RETURN) = flValue;
ent = PRVM_PROG_TO_EDICT( prog->globals.sv->pev );
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (dstudiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
iController = (int)PRVM_G_FLOAT(OFS_PARM1);
pbonecontroller = (dstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex );
// find first controller that matches the index
for( i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++ )
if( pbonecontroller->index == iController ) break;
if( i >= pstudiohdr->numbonecontrollers ) return;
// wrap 0..360 if it's a rotational controller
if( pbonecontroller->type & (STUDIO_XR|STUDIO_YR|STUDIO_ZR))
{
// ugly hack, invert value if end < start
if( pbonecontroller->end < pbonecontroller->start)
flValue = -flValue;
// does the controller not wrap?
if( pbonecontroller->start + 359.0 >= pbonecontroller->end )
{
if( flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0f) + 180.0f )
flValue = flValue - 360.0f;
if( flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0f) - 180.0f )
flValue = flValue + 360.0f;
}
else
{
if( flValue > 360.0f ) flValue = flValue - (int)(flValue / 360.0f) * 360.0f;
else if( flValue < 0.0f ) flValue = flValue + (int)((flValue / -360.0f) + 1) * 360.0f;
}
}
// round to byte
setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
ent->progs.sv->controller[iController] = setting = bound( 0, setting, 255 );
// returns full range value
PRVM_G_FLOAT(OFS_RETURN) = setting * (1.0f / 255.0f) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
}
/*
=============
PF_setblending
float SetBlending( string model, float blender, float value )
=============
*/
void PF_setblending( void )
{
cmodel_t *mod;
edict_t *ent;
dstudioseqdesc_t *pseqdesc;
dstudiohdr_t *pstudiohdr;
int iBlender;
int setting;
float flValue;
if(!VM_ValidateArgs( "SetBlending", 3 )) return;
if( !com.strcmp( PRVM_G_STRING( OFS_PARM0 ), "" )) return;
VM_ValidateString(PRVM_G_STRING(OFS_PARM0));
flValue = PRVM_G_FLOAT(OFS_PARM2); // not modified value
PRVM_G_FLOAT(OFS_RETURN) = flValue;
ent = PRVM_PROG_TO_EDICT( prog->globals.sv->pev );
mod = pe->RegisterModel(PRVM_G_STRING(OFS_PARM0));
if( !mod ) return;
pstudiohdr = (dstudiohdr_t *)mod->extradata;
if( !pstudiohdr ) return;
pseqdesc = (dstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)ent->progs.sv->sequence;
iBlender = (int)PRVM_G_FLOAT(OFS_PARM1);
if( pseqdesc->blendtype[iBlender] == 0 ) return;
if( pseqdesc->blendtype[iBlender] & (STUDIO_XR|STUDIO_YR|STUDIO_ZR))
{
// ugly hack, invert value if end < start
if( pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender] )
flValue = -flValue;
// does the controller not wrap?
if( pseqdesc->blendstart[iBlender] + 359.0f >= pseqdesc->blendend[iBlender] )
{
if( flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0f) + 180.0f)
flValue = flValue - 360.0f;
if( flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0f) - 180.0f)
flValue = flValue + 360.0f;
}
}
setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);
ent->progs.sv->blending[iBlender] = setting = bound( 0, setting, 255 );
// returns full range value
PRVM_G_FLOAT(OFS_RETURN) = setting * (1.0f / 255.0f) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
}
/*
=============
PF_aim
@ -1783,7 +1897,7 @@ void PF_aim( void )
float speed;
int flags = Cvar_VariableValue( "dmflags" );
if(!VM_ValidateArgs( "tracebox", 6 )) return;
if(!VM_ValidateArgs( "tracebox", 2 )) return;
VectorCopy(prog->globals.sv->v_forward, PRVM_G_VECTOR(OFS_RETURN)); // assume failure if it returns early
ent = PRVM_G_EDICT(OFS_PARM0);
@ -2021,7 +2135,7 @@ void PF_WriteLong (void){ MSG_WriteLong(&sv.multicast, (int)PRVM_G_FLOAT(OFS_PAR
void PF_WriteAngle (void){ MSG_WriteAngle32(&sv.multicast, PRVM_G_FLOAT(OFS_PARM0)); }
void PF_WriteCoord (void){ MSG_WriteCoord32(&sv.multicast, PRVM_G_FLOAT(OFS_PARM0)); }
void PF_WriteString (void){ MSG_WriteString(&sv.multicast, PRVM_G_STRING(OFS_PARM0)); }
void PF_WriteEntity (void){ MSG_WriteShort(&sv.multicast, PRVM_G_EDICTNUM(OFS_PARM1)); }
void PF_WriteEntity (void){ MSG_WriteShort(&sv.multicast, PRVM_G_EDICTNUM(OFS_PARM0)); }
/*
=============
@ -2294,7 +2408,7 @@ VM_ComFileTime, // #14 float Com_FileTime( string filename )
VM_ComLoadScript, // #15 float Com_LoadScript( string filename )
VM_ComResetScript, // #16 void Com_ResetScript( void )
VM_ComReadToken, // #17 string Com_ReadToken( float newline )
NULL, // #18 -- reserved --
VM_Random, // #18 float Random( void )
VM_ComSearchFiles, // #19 float Com_Search( string mask, float casecmp )
VM_ComSearchNames, // #20 string Com_SearchFilename( float num )
VM_RandomLong, // #21 float RandomLong( float min, float max )
@ -2358,7 +2472,7 @@ VM_rint, // #72 float rint (float v)
VM_floor, // #73 float floor(float v)
VM_ceil, // #74 float ceil (float v)
VM_fabs, // #75 float fabs (float f)
VM_mod, // #76 float fmod( float val, float m )
VM_fmod, // #76 float fmod( float val, float m )
NULL, // #77 -- reserved --
NULL, // #78 -- reserved --
VM_VectorNormalize, // #79 vector VectorNormalize( vector v )
@ -2395,8 +2509,8 @@ NULL, // #126 isEntOnFloor
PF_droptofloor, // #127 float droptofloor( void )
PF_walkmove, // #128 float walkmove(float yaw, float dist)
PF_setorigin, // #129 void setorigin(entity e, vector o)
PF_sound, // #130 void EmitSound(entity e, float chan, string samp, float vol, float attn)
PF_ambientsound, // #131 void EmitAmbientSound(entity e, string samp)
NULL, // #130 -- reserved --
NULL, // #131 -- reserved --
PF_traceline, // #132 void traceline(vector v1, vector v2, float mask, entity ignore)
PF_tracetoss, // #133 void tracetoss (entity e, entity ignore)
NULL, // #134 traceMonsterHull
@ -2432,7 +2546,7 @@ NULL, // #163 getAttachment
NULL, // #164 setView
NULL, // #165 crosshairangle
PF_AreaPortalState, // #166 void areaportal( entity ent, float state )
NULL, // #167 compareFileTime
PF_lookupactivityheaviest, // #167 float LookupActivityHeaviest( string model, float activity )
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 )
@ -2440,7 +2554,10 @@ 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 )
PF_lookupsequence, // #175 float LookupSequence( string model, string label )
PF_setcontroller, // #176 float SetController( string model, float controller, float value )
PF_setblending, // #177 float SetBlending( string model, float blender, float value )
PF_getweaponsequenceinfo, // #178 float GetWeaponSequenceInfo( string model, float sequence )
};
const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t); //num of builtins

14
engine/server/sv_world.c
View File

@ -183,6 +183,9 @@ void SV_ClassifyEdict( edict_t *ent )
if( sv_ent->s.ed_type != ED_SPAWNED )
return;
// null state ?
if( !sv_ent->s.number ) SV_UpdateEntityState( ent );
classname = PRVM_GetString( ent->progs.sv->classname );
if( !com.strnicmp( "worldspawn", classname, 10 ))
@ -391,13 +394,14 @@ void SV_LinkEdict( edict_t *ent )
}
}
// if first time, make sure old_origin is valid
if( !ent->priv.sv->linkcount )
{
VectorCopy( ent->progs.sv->origin, ent->progs.sv->old_origin );
}
ent->priv.sv->linkcount++;
// update ambient sound here
if( ent->progs.sv->loopsound )
{
ent->priv.sv->s.soundindex = SV_SoundIndex( PRVM_GetString( ent->progs.sv->loopsound ));
}
// don't link not solid or rigid bodies
if( ent->progs.sv->solid == SOLID_NOT || ent->progs.sv->solid >= SOLID_BOX )
{

9
launch/filesystem.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "launch.h"
#include "qfiles_ref.h"
#include "filesystem.h"
#include "byteorder.h"
@ -3173,13 +3174,7 @@ wadtype_t wad_types[] =
{"bin", TYPE_BINDATA}, // xash binary data
{"str", TYPE_STRDATA}, // xash string data
{"raw", TYPE_RAW }, // signed raw data
{"txt", TYPE_SCRIPT }, // xash script file
{"lst", TYPE_SCRIPT }, // xash script file
{"aur", TYPE_SCRIPT }, // xash aurora file
{"qc", TYPE_SCRIPT }, // xash qc-script file
{"qh", TYPE_SCRIPT }, // xash qc-header file
{"c", TYPE_SCRIPT }, // xash c-source file
{"h", TYPE_SCRIPT }, // xash c-header file
{"txt", TYPE_SCRIPT }, // any script file
{"dat", TYPE_VPROGS }, // xash progs
{ NULL, TYPE_NONE }
};

1
launch/imagelib/img_wad.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "imagelib.h"
#include "qfiles_ref.h"
/*
============

1
launch/launch.h
View File

@ -18,7 +18,6 @@
#define LAUNCH_DLL // ignore alias names
#include "launch_api.h"
#include "ref_dllapi.h"
#define XASH_VERSION 0.51f // current version will be shared across gameinfo struct

1
launch/utils.c
View File

@ -4,6 +4,7 @@
//=======================================================================
#include "launch.h"
#include "qfiles_ref.h"
#include "mathlib.h"
#include "const.h"

2
physic/cm_callback.c
View File

@ -4,7 +4,7 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
#include "matrix_lib.h"
int Callback_ContactBegin( const NewtonMaterial* material, const NewtonBody* body0, const NewtonBody* body1 )
{

8
physic/cm_collision.c
View File

@ -4,10 +4,14 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
#define MAX_BRUSHFORBOX 16 // must be power of two
#define MAX_BRUSHFORBOX 16 // must be power of two
#define COLLISION_SNAPSCALE (32.0f)
#define COLLISION_SNAP (1.0f / COLLISION_SNAPSCALE)
#define COLLISION_SNAP2 (2.0f / COLLISION_SNAPSCALE)
#define COLLISION_PLANE_DIST_EPSILON (2.0f / COLLISION_SNAPSCALE)
cvar_t *cm_impactnudge;
cvar_t *cm_startnudge;

2
physic/cm_local.h
View File

@ -86,6 +86,7 @@ typedef struct cleaf_s
int numleafbrushes;
int numleafsurfaces;
int *firstleafsurface;
float ambient_level[NUM_AMBIENTS];
} cleaf_t;
typedef struct
@ -267,6 +268,7 @@ extern float *m_upVector;
int CM_PointLeafnum_r( const vec3_t p, cnode_t *node );
int CM_PointLeafnum( const vec3_t p );
void CM_StoreBrushes( leaflist_t *ll, cnode_t *node );
bool CM_AmbientSounds( const vec3_t p, float *volumes, cmodel_t *model );
int CM_BoxLeafnums( const vec3_t mins, const vec3_t maxs, int *list, int listsize, int *lastleaf );
int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **list, int listsize );
cmodel_t *CM_TempBoxModel( const vec3_t mins, const vec3_t maxs, bool capsule );

7
physic/cm_model.c
View File

@ -4,7 +4,7 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
clipmap_t cm;
@ -107,6 +107,7 @@ void BSP_CreateMeshBuffer( int modelnum )
else loadmodel->type = mod_world; // level static geometry
loadmodel->TraceBox = CM_TraceBmodel;
loadmodel->PointContents = CM_PointContents;
loadmodel->AmbientLevel = CM_AmbientSounds;
// because world loading collision tree from LUMP_COLLISION
if( modelnum < 1 ) return;
@ -433,6 +434,10 @@ void BSP_LoadLeafs( wfile_t *l )
out->mins[j] = LittleLong( in->mins[j] ) - 1;
out->maxs[j] = LittleLong( in->maxs[j] ) + 1;
}
for( j = 0; j < NUM_AMBIENTS; j++ )
out->ambient_level[j] = (float)(in->sounds[j] / 255.0f);
n = LittleLong( in->firstleafsurface );
c = LittleLong( in->numleafsurfaces );
if( n < 0 || n + c > cm.numleafsurfaces )

2
physic/cm_pmove.c
View File

@ -4,7 +4,7 @@
//=======================================================================
#include "cm_local.h"
#include "matrixlib.h"
#include "matrix_lib.h"
int characterID;
uint m_jumpTimer;

290
physic/cm_portals.c.old
View File

@ -1,290 +0,0 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// cm_portals.c - server visibility
//=======================================================================
#include "cm_local.h"
static byte fatpvs[MAX_MAP_LEAFS/8];
/*
===============================================================================
PVS / PHS
===============================================================================
*/
/*
===================
CM_DecompressVis
===================
*/
void CM_DecompressVis( byte *in, byte *out )
{
byte *out_p;
int c, row;
row = (cm.numclusters + 7)>>3;
out_p = out;
if( !in )
{
// no vis info, so make all visible
while( row )
{
*out_p++ = 0xff;
row--;
}
return;
}
do
{
if(*in)
{
*out_p++ = *in++;
continue;
}
c = in[1];
in += 2;
if((out_p - out) + c > row)
{
c = row - (out_p - out);
MsgDev(D_WARN, "CM_DecompressVis: decompression overrun\n");
}
while( c )
{
*out_p++ = 0;
c--;
}
} while( out_p - out < row );
}
byte *CM_ClusterPVS( int cluster )
{
if( cluster < 0 || cluster >= cm.numclusters || !cm.vis )
Mem_Set( cms.pvsrow, 0xFF, (cm.numclusters + 31) & ~31 );
else CM_DecompressVis( cm.visbase + cm.vis->bitofs[cluster][DVIS_PVS], cms.pvsrow );
return cms.pvsrow;
}
byte *CM_ClusterPHS( int cluster )
{
if( cluster < 0 || cluster >= cm.numclusters || !cm.vis )
Mem_Set( cms.phsrow, 0xFF, (cm.numclusters + 31) & ~31 );
else CM_DecompressVis( cm.visbase + cm.vis->bitofs[cluster][DVIS_PHS], cms.phsrow );
return cms.phsrow;
}
/*
============
CM_FatPVS
The client will interpolate the view position,
so we can't use a single PVS point
===========
*/
byte *CM_FatPVS( const vec3_t org, bool portal )
{
int leafs[128];
int i, j, count;
int longs;
byte *src;
vec3_t mins, maxs;
int snap = portal ? 1 : 8;
for( i = 0; i < 3; i++ )
{
mins[i] = org[i] - snap;
maxs[i] = org[i] + snap;
}
count = CM_BoxLeafnums( mins, maxs, leafs, 128, NULL );
if( count < 1 ) Host_Error( "CM_FatPVS: invalid leafnum count\n" );
longs = (CM_NumClusters() + 31)>>5;
// convert leafs to clusters
for( i = 0; i < count; i++ ) leafs[i] = CM_LeafCluster( leafs[i] );
if( !portal ) Mem_Copy( fatpvs, CM_ClusterPVS( leafs[0] ), longs<<2 );
// or in all the other leaf bits
for( i = portal ? 0 : 1; i < count; i++ )
{
for( j = 0; j < i; j++ )
{
if( leafs[i] == leafs[j] )
break;
}
if( j != i ) continue; // already have the cluster we want
src = CM_ClusterPVS( leafs[i] );
for( j = 0; j < longs; j++ ) ((long *)fatpvs)[j] |= ((long *)src)[j];
}
return fatpvs;
}
/*
===============================================================================
AREAPORTALS
===============================================================================
*/
void CM_FloodArea_r( carea_t *area, int floodnum )
{
int i;
dareaportal_t *p;
if( area->floodvalid == cm.floodvalid )
{
if( area->floodnum == floodnum ) return;
Host_Error( "CM_FloodArea_r: reflooded\n" );
}
area->floodnum = floodnum;
area->floodvalid = cm.floodvalid;
p = &cm.areaportals[area->firstareaportal];
for( i = 0; i < area->numareaportals; i++, p++ )
{
if( cms.portalopen[p->portalnum] )
CM_FloodArea_r( &cm.areas[p->otherarea], floodnum );
}
}
/*
====================
CM_FloodAreaConnections
====================
*/
void CM_FloodAreaConnections( void )
{
carea_t *area;
int i, floodnum = 0;
// all current floods are now invalid
cm.floodvalid++;
// area 0 is not used
for( i = 1; i < cm.numareas; i++ )
{
area = &cm.areas[i];
if( area->floodvalid == cm.floodvalid )
continue; // already flooded into
floodnum++;
CM_FloodArea_r( area, floodnum );
}
}
void CM_SetAreaPortals ( byte *portals, size_t size )
{
if( size == sizeof( cms.portalopen ))
{
Mem_Copy( cms.portalopen, portals, size );
CM_FloodAreaConnections();
return;
}
MsgDev( D_ERROR, "CM_SetAreaPortals: portals mismatch size (%i should be %i)\n", size, cm.numareaportals );
}
void CM_GetAreaPortals ( byte **portals, size_t *size )
{
byte *prt = *portals;
if( prt ) Mem_Copy( prt, cms.portalopen, sizeof( cms.portalopen ));
if( size) *size = sizeof( cms.portalopen );
}
void CM_SetAreaPortalState( int portalnum, bool open )
{
if( portalnum > cm.numareaportals )
Host_Error( "CM_SetAreaPortalState: areaportal > numareaportals\n" );
cms.portalopen[portalnum] = open;
CM_FloodAreaConnections();
}
bool CM_AreasConnected( int area, int otherarea )
{
if( cm_noareas->integer ) return true;
if( area > cm.numareas || otherarea > cm.numareas )
Host_Error("CM_AreasConnected: area >= cm.numareas\n" );
if( !area || !otherarea ) return false;
if( area == otherarea ) return true; // quick test
if( cm.areas[area].floodnum == cm.areas[otherarea].floodnum )
return true;
return false;
}
/*
=================
CM_WriteAreaBits
Writes a length byte followed by a bit vector of all the areas
that area in the same flood as the area parameter
This is used by the client refreshes to cull visibility
=================
*/
int CM_WriteAreaBits( byte *buffer, int area, bool portal )
{
int i, size;
size = (cm.numareas + 7)>>3;
if( cm_noareas->integer )
{
if( !portal ) Mem_Set( buffer, 0xFF, size );
}
else
{
if( !portal ) Mem_Set( buffer, 0x00, size );
for( i = 0; i < cm.numareas; i++ )
{
if(CM_AreasConnected( i, area ) || !area )
{
if( !portal ) buffer[i>>3] |= 1 << (i & 7);
else buffer[i>>3] |= 1 << (i & 7) ^ ~0;
}
}
}
return size;
}
/*
=============
CM_HeadnodeVisible
Returns true if any leaf under headnode has a cluster that
is potentially visible
=============
*/
bool CM_HeadnodeVisible( int nodenum, byte *visbits )
{
int leafnum, cluster;
cnode_t *node;
if( nodenum < 0 )
{
leafnum = -1 - nodenum;
if( leafnum < 0 || leafnum >= cm.numleafs )
Host_Error("CM_HeadnodeVisible: bad leaf %i >= %i\n", leafnum, cm.numleafs );
cluster = cm.leafs[leafnum].cluster;
if( cluster == -1 ) return false;
if( visbits[cluster>>3] & (1<<(cluster&7)))
return true;
return false;
}
if( nodenum < 0 || nodenum >= cm.numnodes )
Host_Error( "CM_HeadnodeVisible: bad node %i >= %i\n", nodenum, cm.numnodes );
node = cm.nodes + nodenum;
if( CM_HeadnodeVisible( node->children[0] - cm.nodes, visbits ))
return true;
return CM_HeadnodeVisible( node->children[1] - cm.nodes, visbits );
}

2
physic/cm_rigidbody.c
View File

@ -5,7 +5,7 @@
#include "physic.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "cm_utils.h"
physbody_t *Phys_CreateBody( sv_edict_t *ed, cmodel_t *mod, matrix4x3 transform, int solid )

16
physic/cm_test.c
View File

@ -215,4 +215,20 @@ int CM_TransformedPointContents( const vec3_t p, cmodel_t *model, const vec3_t o
p_l[2] = DotProduct( temp, up );
}
return CM_PointContents( p_l, model );
}
bool CM_AmbientSounds( const vec3_t p, float *volumes, cmodel_t *model )
{
cleaf_t *leaf;
if( !volumes ) return false;
leaf = cm.leafs + CM_PointLeafnum( p );
if( leaf )
{
Mem_Copy( volumes, leaf->ambient_level, sizeof( float ) * NUM_AMBIENTS );
return true;
}
Mem_Set( volumes, 0x00, sizeof( volumes ));
return false;
}

2
physic/cm_trace.c
View File

@ -5,7 +5,7 @@
#include "cm_local.h"
#include "cm_utils.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
/*

4
physic/physic.dsp
View File

@ -175,10 +175,6 @@ SOURCE=.\cm_utils.h
SOURCE=.\physic.h
# End Source File
# Begin Source File
SOURCE=.\transform.h
# End Source File
# End Group
# Begin Group "Resource Files"

2
physic/physic.h
View File

@ -10,7 +10,7 @@
#include "launch_api.h"
#include "engine_api.h"
#include "physic_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
typedef struct physbody_s NewtonBody;
typedef struct physworld_s NewtonWorld;

121
public/const.h
View File

@ -5,51 +5,9 @@
#ifndef CONST_H
#define CONST_H
// dlumpinfo_t->compression
#define CMP_NONE 0 // compression none
#define CMP_LZSS 1 // currently not used
#define CMP_ZLIB 2 // zip-archive compression
// dlumpinfo_t->type
#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_MIPTEX 67 // half-life (mip_t) previous was TYP_SOUND but never used in quake1
#define TYPE_QMIP 68 // quake1 (mip_t)
#define TYPE_BINDATA 69 // engine internal data (map lumps, save lumps etc)
#define TYPE_STRDATA 70 // big unterminated string (stringtable marked as TYPE_BINARYDATA)
#define TYPE_RAW 71 // unrecognized raw data
#define TYPE_SCRIPT 72 // .txt scrips (xash ext)
#define TYPE_VPROGS 73 // .dat progs (xash ext)
// edict_t->spawnflags
#define SF_START_ON 0x1
// 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) // FIXME: remove or replace
#define RF_IR_VISIBLE (1<<6) // skin is an index in image_precache
#define RF_HOLOGRAMM (1<<7) // studio hologramm effect (like hl1)
#define RF_OCCLUSIONTEST (1<<8) // do occlusion test for this entity
#define RF_PLANARSHADOW (1<<9) // force shadow to planar
#define RF_NOSHADOW (1<<10) // disable shadow at all
// FIXME: player_state_t->renderfx
#define RDF_UNDERWATER (1<<0) // warp the screen as apropriate
#define RDF_NOWORLDMODEL (1<<1) // used for player configuration screen
#define RDF_BLOOM (1<<2) // light blooms
#define RDF_OLDAREABITS (1<<3) // forces R_MarkLeaves() if not set
#define RDF_PAIN (1<<4) // motion blur effects
#define RDF_IRGOGGLES (1<<5) // infra red goggles effect
#define RDF_PORTALINVIEW (1<<6) // cull entities using vis too because areabits are merged serverside
#define RDF_SKYPORTALINVIEW (1<<7) // draw skyportal instead of regular sky
#define RDF_NOFOVADJUSTMENT (1<<8) // do not adjust fov for widescreen
// 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
@ -57,70 +15,9 @@
#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
// bsp contents
typedef enum
{
CONTENTS_NONE = 0, // just a mask for source tabulation
CONTENTS_SOLID = BIT(0), // an eye is never valid in a solid
CONTENTS_WINDOW = BIT(1), // translucent, but not watery
CONTENTS_AUX = BIT(2),
CONTENTS_LAVA = BIT(3),
CONTENTS_SLIME = BIT(4),
CONTENTS_WATER = BIT(5),
CONTENTS_SKY = BIT(6),
// space for new user contents
CONTENTS_MIST = BIT(12),// g-cont. what difference between fog and mist ?
LAST_VISIBLE_CONTENTS = BIT(12),// mask (LAST_VISIBLE_CONTENTS-1)
CONTENTS_FOG = BIT(13),// future expansion
CONTENTS_AREAPORTAL = BIT(14),// func_areaportal volume
CONTENTS_PLAYERCLIP = BIT(15),// clip affect only by player or bot
CONTENTS_MONSTERCLIP = BIT(16),// clip affect only by monster or npc
CONTENTS_CLIP = (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP), // both type clip
CONTENTS_ORIGIN = BIT(17),// removed before bsping an entity
CONTENTS_BODY = BIT(18),// should never be on a brush, only in game
CONTENTS_CORPSE = BIT(19),// deadbody
CONTENTS_DETAIL = BIT(20),// brushes to be added after vis leafs
CONTENTS_TRANSLUCENT = BIT(21),// auto set if any surface has trans
CONTENTS_LADDER = BIT(22),// like water but ladder : )
CONTENTS_TRIGGER = BIT(23),// trigger volume
// content masks
MASK_SOLID = (CONTENTS_SOLID|CONTENTS_WINDOW),
MASK_PLAYERSOLID = (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_BODY),
MASK_MONSTERSOLID = (CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_BODY),
MASK_DEADSOLID = (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_WINDOW),
MASK_WATER = (CONTENTS_WATER|CONTENTS_LAVA|CONTENTS_SLIME),
MASK_OPAQUE = (CONTENTS_SOLID|CONTENTS_SLIME|CONTENTS_LAVA),
MASK_SHOT = (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_WINDOW|CONTENTS_CORPSE)
} contentType_t;
typedef enum
{
SURF_NONE = 0, // just a mask for source tabulation
SURF_LIGHT = BIT(0), // value will hold the light strength
SURF_SLICK = BIT(1), // effects game physics
SURF_SKY = BIT(2), // don't draw, but add to skybox
SURF_WARP = BIT(3), // turbulent water warp
SURF_TRANS = BIT(4), // translucent
SURF_BLEND = BIT(5), // same as blend
SURF_ALPHA = BIT(6), // alphatest
SURF_ADDITIVE = BIT(7), // additive surface
SURF_NODRAW = BIT(8), // don't bother referencing the texture
SURF_HINT = BIT(9), // make a primary bsp splitter
SURF_SKIP = BIT(10),// completely ignore, allowing non-closed brushes
SURF_NULL = BIT(11),// remove face after compile
SURF_NOLIGHTMAP = BIT(12),// don't place lightmap for this surface
SURF_MIRROR = BIT(12),// remove face after compile
SURF_CHROME = BIT(13),// chrome surface effect
SURF_GLOW = BIT(14),// sprites glow
} surfaceType_t;
#define EF_NODRAW (1<<6) // don't draw entity
#define EF_ROTATE (1<<7) // rotate bonus item
#define EF_MINLIGHT (1<<8) // allways have some light (viewmodel)
// rendering constants
enum
@ -133,10 +30,12 @@ enum
kRenderTransAdd, // src*a+dest
} kRenderMode_t;
// engine physics constants
#define COLLISION_SNAPSCALE (32.0f)
#define COLLISION_SNAP (1.0f / COLLISION_SNAPSCALE)
#define COLLISION_SNAP2 (2.0f / COLLISION_SNAPSCALE)
#define COLLISION_PLANE_DIST_EPSILON (2.0f / COLLISION_SNAPSCALE)
enum
{
kRenderFxNone = 0,
kRenderFxHologram, // kRenderFxDistort + distance fade
kRenderFxGlowShell, // Glowing Shell
kRenderFxNoReflect, // Don't reflecting in mirrors
} kRenderFx_t;
#endif//CONST_H

3
public/engine_api.h
View File

@ -102,7 +102,6 @@ typedef struct entity_state_s
vec3_t origin;
vec3_t angles; // entity angles, not viewangles
vec3_t velocity; // player velocity
vec3_t old_origin; // for lerping animation
vec3_t infotarget; // portal camera, etc
model_state_t model; // general entity model
solid_t solidtype; // entity solidtype
@ -123,7 +122,6 @@ typedef struct entity_state_s
// client specific
int pm_type; // client movetype
int pm_flags; // ducked, jump_held, etc
int pm_time; // each unit = 8 ms
vec3_t delta_angles; // add to command angles to get view direction
vec3_t punch_angles; // add to view direction to get render angles
vec3_t viewangles; // already calculated view angles on server-side
@ -208,6 +206,7 @@ typedef struct cmodel_s
// custom traces for various model types
void (*TraceBox)( const vec3_t, const vec3_t, const vec3_t, const vec3_t, struct cmodel_s*, struct trace_s*, int );
int (*PointContents)( const vec3_t point, struct cmodel_s *model );
bool (*AmbientLevel)( const vec3_t point, float *volumes, struct cmodel_s *model );
} cmodel_t;
typedef struct csurface_s

4
public/mathlib.h
View File

@ -239,8 +239,8 @@ _inline void CrossProduct( vec3_t v1, vec3_t v2, vec3_t cross )
_inline void ClearBounds( vec3_t mins, vec3_t maxs )
{
// make bogus range
mins[0] = mins[1] = mins[2] = MAX_WORLD_COORD;
maxs[0] = maxs[1] = maxs[2] = MIN_WORLD_COORD;
mins[0] = mins[1] = mins[2] = 999999;
maxs[0] = maxs[1] = maxs[2] = -999999;
}
_inline void AddPointToBounds( vec3_t v, vec3_t mins, vec3_t maxs )

1575
public/matrix_lib.h
View File

File diff suppressed because it is too large Load Diff

1594
public/matrixlib.h
View File

File diff suppressed because it is too large Load Diff

20
public/physic_api.h
View File

@ -5,7 +5,25 @@
#ifndef PHYSIC_API_H
#define PHYSIC_API_H
// FIXME: killme
// pmove_state_t is the information necessary for client side movement
#define PM_NORMAL 0 // can accelerate and turn
#define PM_SPECTATOR 1
#define PM_DEAD 2 // no acceleration or turning
#define PM_GIB 3 // different bounding box
#define PM_FREEZE 4
#define PM_INTERMISSION 5
#define PM_NOCLIP 6
// pmove->pm_flags
#define PMF_DUCKED 1
#define PMF_JUMP_HELD 2
#define PMF_ON_GROUND 4
#define PMF_TIME_WATERJUMP 8 // pm_time is waterjump
#define PMF_TIME_LAND 16 // pm_time is time before rejump
#define PMF_TIME_TELEPORT 32 // pm_time is non-moving time
#define PMF_NO_PREDICTION 64 // temporarily disables prediction (used for grappling hook)
#define PMF_ALL_TIMES (PMF_TIME_WATERJUMP|PMF_TIME_LAND|PMF_TIME_TELEPORT)
typedef struct pmove_s
{
entity_state_t ps; // state (in / out)

111
public/ref_dfiles.h → public/qfiles_ref.h
View File

@ -1,12 +1,46 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// ref_dfiles.h - xash supported formats
// Copyright XashXT Group 2008 ©
// qfiles_ref.h - xash supported formats
//=======================================================================
#ifndef REF_DFILES_H
#define REF_DFILES_H
/*
========================================================================
.WAD archive format (WhereAllData - WAD)
List of compressed files, that can be identify only by TYPE_*
<format>
header: dwadinfo_t[dwadinfo_t]
file_1: byte[dwadinfo_t[num]->disksize]
file_2: byte[dwadinfo_t[num]->disksize]
file_3: byte[dwadinfo_t[num]->disksize]
...
file_n: byte[dwadinfo_t[num]->disksize]
infotable dlumpinfo_t[dwadinfo_t->numlumps]
========================================================================
*/
#define IDWAD3HEADER (('3'<<24)+('D'<<16)+('A'<<8)+'W')
// dlumpinfo_t->compression
#define CMP_NONE 0 // compression none
#define CMP_LZSS 1 // currently not used
#define CMP_ZLIB 2 // zip-archive compression
// dlumpinfo_t->type
#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_MIPTEX 67 // half-life (mip_t) previous was TYP_SOUND but never used in quake1
#define TYPE_QMIP 68 // quake1 (mip_t) (replaced with TYPE_MIPTEX while loading)
#define TYPE_BINDATA 69 // engine internal data (map lumps, save lumps etc)
#define TYPE_STRDATA 70 // stringdata type (stringtable marked as TYPE_BINDATA)
#define TYPE_RAW 71 // unrecognized raw data
#define TYPE_SCRIPT 72 // .txt scripts (xash ext)
#define TYPE_VPROGS 73 // .dat progs (xash ext)
/*
==============================================================================
@ -178,6 +212,15 @@ BRUSH MODELS
#define MAX_LIGHT_STYLES 64
#define MAX_SWITCHED_LIGHTS 32
typedef enum
{
AMBIENT_SKY = 0, // windfly1.wav
AMBIENT_WATER,
AMBIENT_SLIME,
AMBIENT_LAVA,
NUM_AMBIENTS // automatic ambient sounds
} bsp_sounds_t;
// lump names
#define LUMP_MAPINFO "mapinfo"
#define LUMP_ENTITIES "entities"
@ -202,6 +245,66 @@ BRUSH MODELS
#define LUMP_AREAS "areas"
#define LUMP_AREAPORTALS "areaportals"
typedef enum
{
SURF_NONE = 0, // just a mask for source tabulation
SURF_LIGHT = BIT(0), // value will hold the light strength
SURF_SLICK = BIT(1), // effects game physics
SURF_SKY = BIT(2), // don't draw, but add to skybox
SURF_WARP = BIT(3), // turbulent water warp
SURF_TRANS = BIT(4), // translucent
SURF_BLEND = BIT(5), // same as blend
SURF_ALPHA = BIT(6), // alphatest
SURF_ADDITIVE = BIT(7), // additive surface
SURF_NODRAW = BIT(8), // don't bother referencing the texture
SURF_HINT = BIT(9), // make a primary bsp splitter
SURF_SKIP = BIT(10), // completely ignore, allowing non-closed brushes
SURF_NULL = BIT(11), // remove face after compile
SURF_NOLIGHTMAP = BIT(12), // don't place lightmap for this surface
SURF_MIRROR = BIT(12), // remove face after compile
SURF_CHROME = BIT(13), // chrome surface effect
SURF_GLOW = BIT(14), // sprites glow
} surfaceType_t;
// bsp contents
typedef enum
{
CONTENTS_NONE = 0, // just a mask for source tabulation
CONTENTS_SOLID = BIT(0), // an eye is never valid in a solid
CONTENTS_WINDOW = BIT(1), // translucent, but not watery
CONTENTS_AUX = BIT(2),
CONTENTS_LAVA = BIT(3),
CONTENTS_SLIME = BIT(4),
CONTENTS_WATER = BIT(5),
CONTENTS_SKY = BIT(6),
// space for new user contents
CONTENTS_MIST = BIT(12),// g-cont. what difference between fog and mist ?
LAST_VISIBLE_CONTENTS = BIT(12),// mask (LAST_VISIBLE_CONTENTS-1)
CONTENTS_FOG = BIT(13),// future expansion
CONTENTS_AREAPORTAL = BIT(14),// func_areaportal volume
CONTENTS_PLAYERCLIP = BIT(15),// clip affect only by player or bot
CONTENTS_MONSTERCLIP = BIT(16),// clip affect only by monster or npc
CONTENTS_CLIP = (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP), // both type clip
CONTENTS_ORIGIN = BIT(17),// removed before bsping an entity
CONTENTS_BODY = BIT(18),// should never be on a brush, only in game
CONTENTS_CORPSE = BIT(19),// deadbody
CONTENTS_DETAIL = BIT(20),// brushes to be added after vis leafs
CONTENTS_TRANSLUCENT = BIT(21),// auto set if any surface has trans
CONTENTS_LADDER = BIT(22),// like water but ladder : )
CONTENTS_TRIGGER = BIT(23),// trigger volume
// content masks
MASK_SOLID = (CONTENTS_SOLID|CONTENTS_WINDOW),
MASK_PLAYERSOLID = (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_BODY),
MASK_MONSTERSOLID = (CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_BODY),
MASK_DEADSOLID = (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_WINDOW),
MASK_WATER = (CONTENTS_WATER|CONTENTS_LAVA|CONTENTS_SLIME),
MASK_OPAQUE = (CONTENTS_SOLID|CONTENTS_SLIME|CONTENTS_LAVA),
MASK_SHOT = (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_WINDOW|CONTENTS_CORPSE)
} contentType_t;
typedef struct
{
int ident;
@ -214,7 +317,6 @@ typedef struct
{
float mins[3];
float maxs[3];
int headnode; // FIXME: eliminate this
int firstsurface; // submodels just draw faces
int numsurfaces; // without walking the bsp tree
int firstbrush; // physics stuff
@ -277,6 +379,7 @@ typedef struct
int numleafsurfaces;
int firstleafbrush;
int numleafbrushes;
byte sounds[NUM_AMBIENTS];
} dleaf_t;
typedef struct
@ -797,7 +900,7 @@ included global, and both (client & server) pent list
#define LUMP_MAPCMDS "map_cmds"
#define LUMP_GAMECVARS "latched_cvars"
#define LUMP_GAMEENTS "entities"
#define LUMP_SNAPSHOT "levelshot" // currently not implemented
#define LUMP_SNAPSHOT "saveshot" // currently not implemented
#define DENT_KEY 0
#define DENT_VAL 1

335
public/ref_dllapi.h
View File

@ -1,335 +0,0 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// ref_dllapi.h - shared ifaces between engine parts
//=======================================================================
#ifndef REF_DLLAPI_H
#define REF_DLLAPI_H
#include "ref_dfiles.h"
/*
========================================================================
internal physic data
hold linear and angular velocity, current position stored too
========================================================================
*/
//
// engine constnat limits, touching networking protocol modify with cation
//
// encoded bmodel mask
#define SOLID_BMODEL 0xffffff
/*
==============================================================================
MAP CONTENTS & SURFACES DESCRIPTION
==============================================================================
*/
// pmove_state_t is the information necessary for client side movement
#define PM_NORMAL 0 // can accelerate and turn
#define PM_SPECTATOR 1
#define PM_DEAD 2 // no acceleration or turning
#define PM_GIB 3 // different bounding box
#define PM_FREEZE 4
#define PM_INTERMISSION 5
#define PM_NOCLIP 6
// pmove->pm_flags
#define PMF_DUCKED 1
#define PMF_JUMP_HELD 2
#define PMF_ON_GROUND 4
#define PMF_TIME_WATERJUMP 8 // pm_time is waterjump
#define PMF_TIME_LAND 16 // pm_time is time before rejump
#define PMF_TIME_TELEPORT 32 // pm_time is non-moving time
#define PMF_NO_PREDICTION 64 // temporarily disables prediction (used for grappling hook)
#define PMF_ALL_TIMES (PMF_TIME_WATERJUMP|PMF_TIME_LAND|PMF_TIME_TELEPORT)
#define PM_MAXTOUCH 32
// sound channels
#define CHAN_AUTO 0
#define CHAN_WEAPON 1
#define CHAN_VOICE 2
#define CHAN_ITEM 3
#define CHAN_BODY 4
#define CHAN_ANNOUNCER 5 // announcer
// flags
#define CHAN_NO_PHS_ADD 8 // Send to all clients, not just ones in PHS (ATTN 0 will also do this)
#define CHAN_RELIABLE 16 // Send by reliable message, not datagram
// Sound attenuation values
#define ATTN_NONE 0 // Full volume the entire level
#define ATTN_NORM 1
#define ATTN_IDLE 2
#define ATTN_STATIC 3 // Diminish very rapidly with distance
/*
==============================================================================
VPROGS.DLL INTERFACE
==============================================================================
*/
#define PRVM_MAX_STACK_DEPTH 1024
#define PRVM_LOCALSTACK_SIZE 16384
#define PRVM_MAX_OPENFILES 256
#define PRVM_MAX_OPENSEARCHES 128
// prog flags
#define PRVM_OP_STATE 1
#define PRVM_FE_CHAIN 4
#define PRVM_FE_CLASSNAME 8
#define PRVM_OP_THINKTIME 16
enum
{
PRVM_SERVERPROG = 0,
PRVM_CLIENTPROG,
PRVM_MENUPROG,
PRVM_DECOMPILED,
PRVM_MAXPROGS, // must be last
};
typedef void (*prvm_builtin_t)( void );
typedef struct edict_state_s
{
bool free;
float freetime;
} vm_edict_t;
struct edict_s
{
// engine-private fields (stored in dynamically resized array)
union
{
void *vp; // generic edict
vm_edict_t *ed; // vm edict state
sv_edict_t *sv; // sv edict state
cl_edict_t *cl; // cl edict state
vm_edict_t *ui; // ui edict state
} priv;
// QuakeC prog fields (stored in dynamically resized array)
union
{
void *vp; // generic entvars
sv_entvars_t *sv; // server entvars
cl_entvars_t *cl; // client entvars
ui_entvars_t *ui; // uimenu entvars
} progs;
};
typedef struct mfunction_s
{
int first_statement; // negative numbers are builtins
int parm_start;
int locals; // total ints of parms + locals
// these are doubles so that they can count up to 54bits or so rather than 32bit
double profile; // runtime
double builtinsprofile; // cost of builtin functions called by this function
double callcount; // times the functions has been called since the last profile call
int s_name;
int s_file; // source file defined in
int numparms;
byte parm_size[MAX_PARMS];
} mfunction_t;
typedef struct prvm_stack_s
{
int s;
mfunction_t *f;
} prvm_stack_t;
typedef struct prvm_prog_s
{
dprograms_t *progs;
mfunction_t *functions;
char *strings;
int stringssize;
ddef_t *fielddefs;
ddef_t *globaldefs;
dstatement_t *statements;
dsource_t *sources; // debug version include packed source files
int *linenums; // debug versions only
void *types; // (type_t *)
int edict_size; // in bytes
int edictareasize; // in bytes (for bound checking)
int pev_save; // used by PRVM_PUSH_GLOBALS\PRVM_POP_GLOBALS
int other_save; // used by PRVM_PUSH_GLOBALS\PRVM_POP_GLOBALS
int *statement_linenums;// NULL if not available
double *statement_profile; // only incremented if prvm_statementprofiling is on
union
{
float *gp;
sv_globalvars_t *sv;
cl_globalvars_t *cl;
ui_globalvars_t *ui;
} globals;
int maxknownstrings;
int numknownstrings;
int firstfreeknownstring;
const char **knownstrings;
byte *knownstrings_freeable;
const char ***stringshash;
byte *progs_mempool;
prvm_builtin_t *builtins;
int numbuiltins;
int argc;
int trace;
mfunction_t *xfunction;
int xstatement;
prvm_stack_t stack[PRVM_MAX_STACK_DEPTH + 1];
int depth;
int localstack[PRVM_LOCALSTACK_SIZE];
int localstack_used;
word filecrc;
int intsize;
vfile_t *file[PRVM_MAX_OPENFILES];
script_t *script;
search_t *search;
int num_edicts;
int max_edicts;
int limit_edicts;
int reserved_edicts;
edict_t *edicts;
void *edictsfields;
void *edictprivate;
int edictprivate_size;
float *time;
float _time;
bool protect_world;
bool loadintoworld;
bool loaded;
char *name;
int flag;
ddef_t *pev; // if pev != 0 then there is a global pev
// function pointers
void (*begin_increase_edicts)(void);
void (*end_increase_edicts)(void);
void (*init_edict)(edict_t *edict);
void (*free_edict)(edict_t *ed);
void (*count_edicts)(void);
bool (*load_edict)(edict_t *ent); // initialize edict for first loading
void (*classify_edict)(edict_t *ent); // called after spawn for classify edict
void (*restore_edict)(edict_t *ent); // restore edict from savegame or changelevel
void (*init_cmd)(void);
void (*reset_cmd)(void);
void (*error_cmd)(const char *format, ...);
} prvm_prog_t;
typedef struct vprogs_exp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vprogs_api_t)
void ( *Init ) ( int argc, char **argv ); // init host
void ( *Free ) ( void ); // close host
// compiler functions
void ( *PrepareDAT )( const char *dir, const char *name );
void ( *CompileDAT )( void );
void ( *Update )( dword time ); // refreshing compile, exec some programs e.t.c
// edict operations
edict_t *(*AllocEdict)( void );
void (*FreeEdict)( edict_t *ed );
void (*PrintEdict)( edict_t *ed );
// savegame stuff
void (*WriteGlobals)( void *buffer, void *ptr, setpair_t callback );
void (*ReadGlobals)( int s_table, dkeyvalue_t *globals, int count );
void (*WriteEdict)( edict_t *ed, void *buffer, void *ptr, setpair_t callback );
void (*ReadEdict)( int s_table, int ednum, dkeyvalue_t *fields, int numpairs );
// load ents description
void (*LoadFromFile)( const char *data );
// string manipulations
const char *(*GetString)( int num );
int (*SetEngineString)( const char *s );
int (*SetTempString)( const char *s );
void (*InitProg)( int prognr );
void (*SetProg)( int prognr );
bool (*ProgLoaded)( int prognr );
void (*LoadProgs)( const char *filename );
void (*ResetProg)( void );
// abstract layer for searching globals and locals
func_t (*FindFunctionOffset)( const char *function );
int (*FindGlobalOffset)( const char *global );
int (*FindFieldOffset)( const char *field );
mfunction_t *(*FindFunction)( const char *name );
ddef_t *(*FindGlobal)( const char *name );
ddef_t *(*FindField)( const char *name );
void (*StackTrace)( void );
void (*Warning)( const char *fmt, ... );
void (*Error)( const char *fmt, ... );
void (*ExecuteProgram)( func_t fnum, const char *name, const char *file, const int line );
void (*Crash)( void ); // crash virtual machine
prvm_prog_t *prog; // virtual machine current state
} vprogs_exp_t;
/*
==============================================================================
VSOUND.DLL INTERFACE
==============================================================================
*/
typedef struct vsound_exp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vprogs_api_t)
void (*Init)( void *hInst ); // init host
void (*Shutdown)( void ); // close host
// sound manager
void (*BeginRegistration)( void );
sound_t (*RegisterSound)( const char *name );
void (*EndRegistration)( void );
void (*StartSound)( const vec3_t pos, int entnum, int channel, sound_t sfx, float vol, float attn, bool use_loop );
void (*StreamRawSamples)( int samples, int rate, int width, int channels, const byte *data );
bool (*AddLoopingSound)( int entnum, sound_t handle, float volume, float attn );
bool (*StartLocalSound)( const char *name );
void (*StartBackgroundTrack)( const char *introTrack, const char *loopTrack );
void (*StopBackgroundTrack)( void );
void (*StartStreaming)( void );
void (*StopStreaming)( void );
void (*Frame)( int entnum, const vec3_t pos, const vec3_t vel, const vec3_t at, const vec3_t up );
void (*StopAllSounds)( void );
void (*FreeSounds)( void );
void (*Activate)( bool active );
} vsound_exp_t;
typedef struct vsound_imp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vsound_imp_t)
void (*GetSoundSpatialization)( int entnum, vec3_t origin, vec3_t velocity );
int (*PointContents)( vec3_t point );
void (*AddLoopingSounds)( void );
} vsound_imp_t;
#endif//REF_DLLAPI_H

5
public/render_api.h
View File

@ -11,6 +11,11 @@
#define SHADER_NOMIP 2 // 2d images
#define SHADER_GENERIC 3 // generic shader
// player_state_t->renderfx
#define RDF_UNDERWATER (1<<0) // warp the screen as apropriate
#define RDF_NOWORLDMODEL (1<<1) // used for player configuration screen
#define RDF_BLOOM (1<<2) // light blooms
typedef struct vrect_s
{
int x, y;

217
public/vprogs_api.h
View File

@ -5,4 +5,221 @@
#ifndef VPROGS_API_H
#define VPROGS_API_H
/*
==============================================================================
VPROGS.DLL INTERFACE
==============================================================================
*/
#define PRVM_MAX_STACK_DEPTH 1024
#define PRVM_LOCALSTACK_SIZE 16384
#define PRVM_MAX_OPENFILES 256
#define PRVM_MAX_OPENSEARCHES 128
// prog flags
#define PRVM_OP_STATE 1
#define PRVM_FE_CHAIN 4
#define PRVM_FE_CLASSNAME 8
#define PRVM_OP_THINKTIME 16
enum
{
PRVM_SERVERPROG = 0,
PRVM_CLIENTPROG,
PRVM_MENUPROG,
PRVM_DECOMPILED,
PRVM_MAXPROGS // must be last
};
typedef void (*prvm_builtin_t)( void );
typedef struct edict_state_s
{
bool free;
float freetime;
} vm_edict_t;
struct edict_s
{
// engine-private fields (stored in dynamically resized array)
union
{
void *vp; // generic edict
vm_edict_t *ed; // vm edict state
sv_edict_t *sv; // sv edict state
cl_edict_t *cl; // cl edict state
vm_edict_t *ui; // ui edict state
} priv;
// QuakeC prog fields (stored in dynamically resized array)
union
{
void *vp; // generic entvars
sv_entvars_t *sv; // server entvars
cl_entvars_t *cl; // client entvars
ui_entvars_t *ui; // uimenu entvars
} progs;
};
typedef struct mfunction_s
{
int first_statement; // negative numbers are builtins
int parm_start;
int locals; // total ints of parms + locals
// these are doubles so that they can count up to 54bits or so rather than 32bit
double profile; // runtime
double builtinsprofile; // cost of builtin functions called by this function
double callcount; // times the functions has been called since the last profile call
int s_name;
int s_file; // source file defined in
int numparms;
byte parm_size[MAX_PARMS];
} mfunction_t;
typedef struct prvm_stack_s
{
int s;
mfunction_t *f;
} prvm_stack_t;
typedef struct prvm_prog_s
{
dprograms_t *progs;
mfunction_t *functions;
char *strings;
int stringssize;
ddef_t *fielddefs;
ddef_t *globaldefs;
dstatement_t *statements;
dsource_t *sources; // debug version include packed source files
int *linenums; // debug versions only
void *types; // (type_t *)
int edict_size; // in bytes
int edictareasize; // in bytes (for bound checking)
int pev_save; // used by PRVM_PUSH_GLOBALS\PRVM_POP_GLOBALS
int other_save; // used by PRVM_PUSH_GLOBALS\PRVM_POP_GLOBALS
int *statement_linenums;// NULL if not available
double *statement_profile; // only incremented if prvm_statementprofiling is on
union
{
float *gp;
sv_globalvars_t *sv;
cl_globalvars_t *cl;
ui_globalvars_t *ui;
} globals;
int maxknownstrings;
int numknownstrings;
int firstfreeknownstring;
const char **knownstrings;
byte *knownstrings_freeable;
const char ***stringshash;
byte *progs_mempool;
prvm_builtin_t *builtins;
int numbuiltins;
int argc;
int trace;
mfunction_t *xfunction;
int xstatement;
prvm_stack_t stack[PRVM_MAX_STACK_DEPTH + 1];
int depth;
int localstack[PRVM_LOCALSTACK_SIZE];
int localstack_used;
word filecrc;
int intsize;
vfile_t *file[PRVM_MAX_OPENFILES];
script_t *script;
search_t *search;
int num_edicts;
int max_edicts;
int limit_edicts;
int reserved_edicts;
edict_t *edicts;
void *edictsfields;
void *edictprivate;
int edictprivate_size;
float *time;
float _time;
bool protect_world;
bool loadintoworld;
bool loaded;
char *name;
int flag;
ddef_t *pev; // if pev != 0 then there is a global pev
// function pointers
void (*begin_increase_edicts)(void);
void (*end_increase_edicts)(void);
void (*init_edict)(edict_t *edict);
void (*free_edict)(edict_t *ed);
void (*count_edicts)(void);
bool (*load_edict)(edict_t *ent); // initialize edict for first loading
void (*restore_edict)(edict_t *ent); // restore edict from savegame or changelevel
void (*init_cmd)(void);
void (*reset_cmd)(void);
void (*error_cmd)(const char *format, ...);
} prvm_prog_t;
typedef struct vprogs_exp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vprogs_api_t)
void ( *Init ) ( int argc, char **argv ); // init host
void ( *Free ) ( void ); // close host
// compiler functions
void ( *PrepareDAT )( const char *dir, const char *name );
void ( *CompileDAT )( void );
void ( *Update )( dword time ); // refreshing compile, exec some programs e.t.c
// edict operations
edict_t *(*AllocEdict)( void );
void (*FreeEdict)( edict_t *ed );
void (*PrintEdict)( edict_t *ed );
// savegame stuff
void (*WriteGlobals)( void *buffer, void *ptr, setpair_t callback );
void (*ReadGlobals)( int s_table, dkeyvalue_t *globals, int count );
void (*WriteEdict)( edict_t *ed, void *buffer, void *ptr, setpair_t callback );
void (*ReadEdict)( int s_table, int ednum, dkeyvalue_t *fields, int numpairs );
// load ents description
void (*LoadFromFile)( const char *data );
// string manipulations
const char *(*GetString)( int num );
int (*SetEngineString)( const char *s );
int (*SetTempString)( const char *s );
void (*InitProg)( int prognr );
void (*SetProg)( int prognr );
bool (*ProgLoaded)( int prognr );
void (*LoadProgs)( const char *filename );
void (*ResetProg)( void );
// abstract layer for searching globals and locals
func_t (*FindFunctionOffset)( const char *function );
int (*FindGlobalOffset)( const char *global );
int (*FindFieldOffset)( const char *field );
mfunction_t *(*FindFunction)( const char *name );
ddef_t *(*FindGlobal)( const char *name );
ddef_t *(*FindField)( const char *name );
void (*StackTrace)( void );
void (*Warning)( const char *fmt, ... );
void (*Error)( const char *fmt, ... );
void (*ExecuteProgram)( func_t fnum, const char *name, const char *file, const int line );
void (*Crash)( void ); // crash virtual machine
prvm_prog_t *prog; // virtual machine current state
} vprogs_exp_t;
#endif//VPROGS_API_H

80
public/vsound_api.h Normal file
View File

@ -0,0 +1,80 @@
//=======================================================================
// Copyright XashXT Group 2008 ©
// vsound_api.h - xash sound engine (OpenAL based)
//=======================================================================
#ifndef VSOUND_API_H
#define VSOUND_API_H
// sound channels
typedef enum
{
CHAN_AUTO = 0,
CHAN_WEAPON,
CHAN_VOICE,
CHAN_ITEM,
CHAN_BODY,
CHAN_ANNOUNCER, // announcer
// snd flags
CHAN_NO_PHS_ADD = 8, // send to all clients, not just ones in PHS (ATTN 0 will also do this)
CHAN_RELIABLE = 16, // send by reliable message, not datagram
} snd_channel_t;
// sound attenuation values
typedef enum
{
ATTN_NONE = 0, // full volume the entire level
ATTN_NORM,
ATTN_IDLE,
ATTN_STATIC, // diminish very rapidly with distance
} snd_attenuation_t;
/*
==============================================================================
VSOUND.DLL INTERFACE
==============================================================================
*/
typedef struct vsound_exp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vprogs_api_t)
void (*Init)( void *hInst ); // init host
void (*Shutdown)( void ); // close host
// sound manager
void (*BeginRegistration)( void );
sound_t (*RegisterSound)( const char *name );
void (*EndRegistration)( void );
void (*StartSound)( const vec3_t pos, int ent, int chan, sound_t sfx, float vol, float attn, bool loop );
void (*StreamRawSamples)( int samples, int rate, int width, int channels, const byte *data );
bool (*AddLoopingSound)( int entnum, sound_t handle, float volume, float attn );
bool (*StartLocalSound)( const char *name );
void (*StartBackgroundTrack)( const char *introTrack, const char *loopTrack );
void (*StopBackgroundTrack)( void );
void (*StartStreaming)( void );
void (*StopStreaming)( void );
void (*Frame)( int entnum, const vec3_t pos, const vec3_t vel, const vec3_t at, const vec3_t up );
void (*StopAllSounds)( void );
void (*FreeSounds)( void );
void (*Activate)( bool active );
} vsound_exp_t;
typedef struct vsound_imp_s
{
// interface validator
size_t api_size; // must matched with sizeof(vsound_imp_t)
void (*GetSoundSpatialization)( int entnum, vec3_t origin, vec3_t velocity );
int (*PointContents)( const vec3_t point );
bool (*AmbientLevel)( const vec3_t point, float *volumes );
void (*AddLoopingSounds)( void );
} vsound_imp_t;
#endif//VSOUND_API_H

3
render/gl_backend.c
View File

@ -5,7 +5,7 @@
#include "r_local.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
// set initial values
extern dll_info_t opengl_dll;
@ -390,6 +390,7 @@ void GL_InitCommands( void )
r_skipfrontend = Cvar_Get("r_skipfronend", "0", CVAR_CHEAT, "skip 3d drawing (scene)" );
r_overbrightbits = Cvar_Get( "r_overbrightbits", "0", CVAR_ARCHIVE|CVAR_LATCH, "hardware gamma overbright" );
r_showlightmaps = Cvar_Get( "r_showlightmaps", "0", CVAR_CHEAT, "show lightmap development tool" );
r_caustics = Cvar_Get( "r_caustics", "0", CVAR_ARCHIVE, "enable water caustics" );
r_modulate = Cvar_Get( "r_modulate", "1.0", CVAR_ARCHIVE|CVAR_LATCH, "modulate light" );
r_ambientscale = Cvar_Get("r_ambientScale", "0.6", CVAR_ARCHIVE, "default ambient light level" );

4
render/r_backend.h
View File

@ -190,6 +190,10 @@ typedef struct
ref_shader_t *lightmapShader;
ref_shader_t *skyboxShader;
ref_shader_t *particleShader;
ref_shader_t *waterCausticsShader;
ref_shader_t *slimeCausticsShader;
ref_shader_t *lavaCausticsShader;
} ref_globals_t;
extern ref_backend_t ref;

21
render/r_backend2.c
View File

@ -6,7 +6,7 @@
#include "r_local.h"
#include "byteorder.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
#define TABLE_SIZE 1024
@ -640,11 +640,22 @@ static void RB_CalcVertexColors( shaderStage_t *stage )
}
break;
case RGBGEN_ENTITY:
for( i = 0; i < ref.numVertex; i++ )
switch( m_pCurrentEntity->rendermode )
{
ref.colorArray[i][0] = m_pCurrentEntity->rendercolor[0];
ref.colorArray[i][1] = m_pCurrentEntity->rendercolor[1];
ref.colorArray[i][2] = m_pCurrentEntity->rendercolor[2];
case kRenderNormal:
case kRenderTransAlpha:
case kRenderTransTexture:
break;
case kRenderGlow:
case kRenderTransAdd:
case kRenderTransColor:
for( i = 0; i < ref.numVertex; i++ )
{
ref.colorArray[i][0] = m_pCurrentEntity->rendercolor[0];
ref.colorArray[i][1] = m_pCurrentEntity->rendercolor[1];
ref.colorArray[i][2] = m_pCurrentEntity->rendercolor[2];
}
break;
}
break;
case RGBGEN_ONEMINUSENTITY:

13
render/r_light.c
View File

@ -5,7 +5,7 @@
#include "r_local.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
/*
@ -289,7 +289,9 @@ static void R_ReadLightGrid( const vec3_t origin, vec3_t lightDir )
if( !r_worldModel->lightGrid )
{
VectorSet( lightDir, 1.0f, 0.0f, -1.0f );
if( m_pCurrentEntity && m_pCurrentEntity->effects & EF_INVLIGHT )
VectorSet( lightDir, 1.0f, 0.0f, 1.0f );
else VectorSet( lightDir, 1.0f, 0.0f, -1.0f );
return;
}
@ -397,21 +399,20 @@ void R_LightingAmbient( void )
VectorScale( r_pointColor, r_ambientscale->value, ambientLight );
// always have some light
if( m_pCurrentEntity->renderfx & RF_MINLIGHT )
if( m_pCurrentEntity->effects & EF_MINLIGHT )
{
for( i = 0; i < 3; i++ )
{
if( ambientLight[i] > 0.1 )
break;
}
if( i == 3 ) VectorSet( ambientLight, 0.1, 0.1, 0.1 );
}
// add dynamic lights
if( r_dynamiclights->integer )
{
if( m_pCurrentEntity->ent_type == ED_NORMAL )
if( m_pCurrentEntity->model && m_pCurrentEntity->ent_type == ED_NORMAL )
radius = m_pCurrentEntity->model->radius;
else radius = m_pCurrentEntity->radius;
@ -477,7 +478,7 @@ void R_LightingDiffuse( void )
R_ReadLightGrid( m_pCurrentEntity->origin, lightDir );
// always have some light
if( m_pCurrentEntity->renderfx & RF_MINLIGHT )
if( m_pCurrentEntity->effects & EF_MINLIGHT )
{
for( i = 0; i < 3; i++ )
{

13
render/r_local.h
View File

@ -8,7 +8,7 @@
#include <windows.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
#include "engine_api.h"
#include "render_api.h"
#include "r_opengl.h"
@ -164,6 +164,10 @@ BRUSH MODELS
=======================================================================
*/
#define SURF_PLANEBACK 1 // fast surface culling
#define SURF_WATERCAUSTICS 2
#define SURF_SLIMECAUSTICS 4
#define SURF_LAVACAUSTICS 8
#define CONTENTS_NODE -1
#define SKY_SIZE 16
#define SKY_INDICES (SKY_SIZE * SKY_SIZE * 6)
@ -188,9 +192,9 @@ typedef struct lightstyle_s
typedef struct particle_s
{
ref_shader_t *shader;
vec3_t origin;
vec3_t old_origin;
ref_shader_t *shader;
vec3_t origin1;
vec3_t origin2;
float radius;
float length;
float rotation;
@ -860,6 +864,7 @@ extern cvar_t *r_swapInterval;
extern cvar_t *r_mode;
extern cvar_t *r_testmode;
extern cvar_t *r_fullscreen;
extern cvar_t *r_caustics;
extern cvar_t *r_minimap;
extern cvar_t *r_minimap_size;
extern cvar_t *r_minimap_zoom;

76
render/r_main.c
View File

@ -5,7 +5,7 @@
#include "r_local.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
render_imp_t ri;
@ -85,6 +85,7 @@ cvar_t *r_vertexbuffers;
cvar_t *r_mode;
cvar_t *r_testmode;
cvar_t *r_fullscreen;
cvar_t *r_caustics;
cvar_t *r_minimap;
cvar_t *r_minimap_size;
cvar_t *r_minimap_zoom;
@ -433,8 +434,8 @@ void R_DrawParticle( void )
if( particle->length != 1 )
{
// find orientation vectors
VectorSubtract( r_refdef.vieworg, particle->origin, axis[0] );
VectorSubtract( particle->old_origin, particle->origin, axis[1] );
VectorSubtract( r_refdef.vieworg, particle->origin1, axis[0] );
VectorSubtract( particle->origin2, particle->origin1, axis[1] );
CrossProduct( axis[0], axis[1], axis[2] );
VectorNormalizeFast( axis[1] );
@ -444,21 +445,21 @@ void R_DrawParticle( void )
CrossProduct( axis[1], axis[2], axis[0] );
VectorNormalizeFast( axis[0] );
VectorMA( particle->origin, -particle->length, axis[1], particle->old_origin );
VectorMA( particle->origin1, -particle->length, axis[1], particle->origin2 );
VectorScale( axis[2], particle->radius, axis[2] );
ref.vertexArray[ref.numVertex+0][0] = particle->old_origin[0] + axis[2][0];
ref.vertexArray[ref.numVertex+0][1] = particle->old_origin[1] + axis[2][1];
ref.vertexArray[ref.numVertex+0][2] = particle->old_origin[2] + axis[2][2];
ref.vertexArray[ref.numVertex+1][0] = particle->origin[0] + axis[2][0];
ref.vertexArray[ref.numVertex+1][1] = particle->origin[1] + axis[2][1];
ref.vertexArray[ref.numVertex+1][2] = particle->origin[2] + axis[2][2];
ref.vertexArray[ref.numVertex+2][0] = particle->origin[0] - axis[2][0];
ref.vertexArray[ref.numVertex+2][1] = particle->origin[1] - axis[2][1];
ref.vertexArray[ref.numVertex+2][2] = particle->origin[2] - axis[2][2];
ref.vertexArray[ref.numVertex+3][0] = particle->old_origin[0] - axis[2][0];
ref.vertexArray[ref.numVertex+3][1] = particle->old_origin[1] - axis[2][1];
ref.vertexArray[ref.numVertex+3][2] = particle->old_origin[2] - axis[2][2];
ref.vertexArray[ref.numVertex+0][0] = particle->origin2[0] + axis[2][0];
ref.vertexArray[ref.numVertex+0][1] = particle->origin2[1] + axis[2][1];
ref.vertexArray[ref.numVertex+0][2] = particle->origin2[2] + axis[2][2];
ref.vertexArray[ref.numVertex+1][0] = particle->origin1[0] + axis[2][0];
ref.vertexArray[ref.numVertex+1][1] = particle->origin1[1] + axis[2][1];
ref.vertexArray[ref.numVertex+1][2] = particle->origin1[2] + axis[2][2];
ref.vertexArray[ref.numVertex+2][0] = particle->origin1[0] - axis[2][0];
ref.vertexArray[ref.numVertex+2][1] = particle->origin1[1] - axis[2][1];
ref.vertexArray[ref.numVertex+2][2] = particle->origin1[2] - axis[2][2];
ref.vertexArray[ref.numVertex+3][0] = particle->origin2[0] - axis[2][0];
ref.vertexArray[ref.numVertex+3][1] = particle->origin2[1] - axis[2][1];
ref.vertexArray[ref.numVertex+3][2] = particle->origin2[2] - axis[2][2];
}
else
{
@ -485,18 +486,18 @@ void R_DrawParticle( void )
VectorScale( r_up, particle->radius, axis[2] );
}
ref.vertexArray[ref.numVertex+0][0] = particle->origin[0] + axis[1][0] + axis[2][0];
ref.vertexArray[ref.numVertex+0][1] = particle->origin[1] + axis[1][1] + axis[2][1];
ref.vertexArray[ref.numVertex+0][2] = particle->origin[2] + axis[1][2] + axis[2][2];
ref.vertexArray[ref.numVertex+1][0] = particle->origin[0] - axis[1][0] + axis[2][0];
ref.vertexArray[ref.numVertex+1][1] = particle->origin[1] - axis[1][1] + axis[2][1];
ref.vertexArray[ref.numVertex+1][2] = particle->origin[2] - axis[1][2] + axis[2][2];
ref.vertexArray[ref.numVertex+2][0] = particle->origin[0] - axis[1][0] - axis[2][0];
ref.vertexArray[ref.numVertex+2][1] = particle->origin[1] - axis[1][1] - axis[2][1];
ref.vertexArray[ref.numVertex+2][2] = particle->origin[2] - axis[1][2] - axis[2][2];
ref.vertexArray[ref.numVertex+3][0] = particle->origin[0] + axis[1][0] - axis[2][0];
ref.vertexArray[ref.numVertex+3][1] = particle->origin[1] + axis[1][1] - axis[2][1];
ref.vertexArray[ref.numVertex+3][2] = particle->origin[2] + axis[1][2] - axis[2][2];
ref.vertexArray[ref.numVertex+0][0] = particle->origin1[0] + axis[1][0] + axis[2][0];
ref.vertexArray[ref.numVertex+0][1] = particle->origin1[1] + axis[1][1] + axis[2][1];
ref.vertexArray[ref.numVertex+0][2] = particle->origin1[2] + axis[1][2] + axis[2][2];
ref.vertexArray[ref.numVertex+1][0] = particle->origin1[0] - axis[1][0] + axis[2][0];
ref.vertexArray[ref.numVertex+1][1] = particle->origin1[1] - axis[1][1] + axis[2][1];
ref.vertexArray[ref.numVertex+1][2] = particle->origin1[2] - axis[1][2] + axis[2][2];
ref.vertexArray[ref.numVertex+2][0] = particle->origin1[0] - axis[1][0] - axis[2][0];
ref.vertexArray[ref.numVertex+2][1] = particle->origin1[1] - axis[1][1] - axis[2][1];
ref.vertexArray[ref.numVertex+2][2] = particle->origin1[2] - axis[1][2] - axis[2][2];
ref.vertexArray[ref.numVertex+3][0] = particle->origin1[0] + axis[1][0] - axis[2][0];
ref.vertexArray[ref.numVertex+3][1] = particle->origin1[1] + axis[1][1] - axis[2][1];
ref.vertexArray[ref.numVertex+3][2] = particle->origin1[2] + axis[1][2] - axis[2][2];
}
ref.inTexCoordArray[ref.numVertex+0][0] = 0;
@ -539,7 +540,7 @@ static void R_AddParticlesToList( void )
// cull
if( !r_nocull->integer )
{
VectorSubtract( particle->origin, r_refdef.vieworg, vec );
VectorSubtract( particle->origin1, r_refdef.vieworg, vec );
VectorNormalizeFast( vec );
if( DotProduct( vec, r_forward ) < 0 )
@ -974,6 +975,9 @@ static bool R_AddEntityToScene( entity_state_t *s1, entity_state_t *s2, float le
refent = &r_entities[r_numEntities];
if( !s2 ) s2 = s1; // no lerping state
if( s1->effects & EF_NODRAW )
return true; // done
// filter ents
switch( s1->ed_type )
{
@ -996,12 +1000,14 @@ static bool R_AddEntityToScene( entity_state_t *s1, entity_state_t *s2, float le
refent->body = s1->model.body;
refent->sequence = s1->model.sequence;
refent->movetype = s1->movetype;
refent->scale = s1->model.scale ? s1->model.scale : 1.0f;
refent->scale = (s1->model.scale != 0.0f) ? s1->model.scale : 1.0f;
refent->colormap = s1->model.colormap;
refent->framerate = s1->model.framerate;
refent->effects = s1->effects;
refent->animtime = s1->model.animtime;
VectorDivide( s1->rendercolor, 255.0f, refent->rendercolor );
if( VectorIsNull( s1->rendercolor ))
VectorSet( refent->rendercolor, 1.0f, 1.0f, 1.0f );
else VectorDivide( s1->rendercolor, 255.0f, refent->rendercolor );
// setup latchedvars
refent->prev.frame = s2->model.frame;
@ -1051,11 +1057,7 @@ static bool R_AddEntityToScene( entity_state_t *s1, entity_state_t *s2, float le
}
if( refent->ent_type == ED_CLIENT )
{
// only draw from mirrors
refent->renderfx |= RF_PLAYERMODEL;
refent->gaitsequence = s1->model.gaitsequence;
}
// because entity without models never added to scene
if( !refent->ent_type )
@ -1120,8 +1122,8 @@ bool R_AddParticleToScene( shader_t shader, const vec3_t org1, const vec3_t org2
p->shader = &r_shaders[shader];
else p->shader = tr.particleShader;
VectorCopy( org1, p->origin );
VectorCopy( org2, p->old_origin );
VectorCopy( org1, p->origin1 );
VectorCopy( org2, p->origin2 );
p->radius = radius;
p->length = length;
p->rotation = rotate;

27
render/r_model.c
View File

@ -6,7 +6,7 @@
#include "r_local.h"
#include "byteorder.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
// the inline models from the current map are kept separate
@ -835,6 +835,23 @@ static void R_LoadLeafs( wfile_t *l )
out->firstMarkSurface = m_pLoadModel->markSurfaces + LittleLong( in->firstleafsurface );
out->numMarkSurfaces = LittleLong( in->numleafsurfaces );
// mark the surfaces for caustics
if( out->contents & MASK_WATER )
{
for( j = 0; j < out->numMarkSurfaces; j++ )
{
if( out->firstMarkSurface[j]->texInfo->surfaceFlags & SURF_WARP )
continue; // HACK: ignore warped surfaces
if( out->contents & CONTENTS_WATER )
out->firstMarkSurface[j]->flags |= SURF_WATERCAUSTICS;
if( out->contents & CONTENTS_SLIME )
out->firstMarkSurface[j]->flags |= SURF_SLIMECAUSTICS;
if( out->contents & CONTENTS_LAVA )
out->firstMarkSurface[j]->flags |= SURF_LAVACAUSTICS;
}
}
// cluster count using for create novis lump
if( out->cluster >= m_pLoadModel->numClusters )
m_pLoadModel->numClusters = out->cluster + 1;
@ -1044,7 +1061,7 @@ void Mod_LoadBrushModel( rmodel_t *mod, const void *buffer )
R_LoadVisibility( handle );
R_LoadSubmodels( handle );
mod->registration_sequence = registration_sequence; // register model
mod->registration_sequence = registration_sequence; // register model
}
/*
@ -1200,8 +1217,14 @@ void R_BeginRegistration( const char *mapname )
Cvar_SetValue( "scr_loading", 50.0f );
if( ri.UpdateScreen ) ri.UpdateScreen();
}
r_worldModel = Mod_ForName( fullname, true );
R_ModRegisterShaders( r_worldModel );
tr.waterCausticsShader = R_FindShader( "engine/waterCaustics", SHADER_TEXTURE, 0 );
tr.slimeCausticsShader = R_FindShader( "engine/slimeCaustics", SHADER_TEXTURE, 0 );
tr.lavaCausticsShader = R_FindShader( "engine/lavaCaustics", SHADER_TEXTURE, 0 );
r_viewCluster = -1;
}

8
render/r_shader.c
View File

@ -4026,18 +4026,20 @@ static ref_shader_t *R_CreateDefaultShader( const char *name, int shaderType, ui
}
else if( shader->surfaceParm & SURF_ADDITIVE )
{
shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC|SHADERSTAGE_ALPHAGEN;
shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC|SHADERSTAGE_ALPHAGEN|SHADERSTAGE_RGBGEN;
shader->stages[0]->blendFunc.src = GL_ONE_MINUS_SRC_ALPHA;
shader->stages[0]->blendFunc.dst = GL_ONE;
shader->stages[0]->alphaGen.type = ALPHAGEN_ENTITY;
shader->stages[0]->rgbGen.type = RGBGEN_ENTITY;
shader->sort = SORT_ADDITIVE;
}
else if( shader->surfaceParm & SURF_GLOW )
{
shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC|SHADERSTAGE_ALPHAGEN;
shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC|SHADERSTAGE_ALPHAGEN|SHADERSTAGE_RGBGEN;
shader->stages[0]->blendFunc.src = GL_ONE_MINUS_SRC_ALPHA;
shader->stages[0]->blendFunc.dst = GL_ONE;
shader->stages[0]->alphaGen.type = ALPHAGEN_ENTITY;
shader->stages[0]->rgbGen.type = RGBGEN_ENTITY;
shader->sort = SORT_ADDITIVE;
}
else if( shader->surfaceParm & SURF_ALPHA )
@ -4352,7 +4354,7 @@ static void R_FinishShader( ref_shader_t *shader )
if( shader->surfaceParm & (SURF_ALPHA|SURF_BLEND))
stage->rgbGen.type = RGBGEN_LIGHTINGAMBIENT;
else if( shader->surfaceParm & (SURF_ADDITIVE|SURF_GLOW))
stage->rgbGen.type = RGBGEN_IDENTITYLIGHTING;
stage->rgbGen.type = RGBGEN_ENTITY;
break;
case SHADER_NOMIP:
case SHADER_GENERIC:

1
render/r_shader.h
View File

@ -385,6 +385,7 @@ typedef struct shaderStage_s
{
bool ignore;
int conditionRegister;
int renderMode;
uint flags;
stageBundle_t *bundles[MAX_TEXTURE_UNITS];

2
render/r_sky.c
View File

@ -5,7 +5,7 @@
#include "r_local.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#define MAX_CLIP_VERTS 64

55
render/r_sprite.c
View File

@ -314,8 +314,10 @@ void R_DrawSpriteModel( void )
mspriteframe_t *frame;
msprite_t *psprite;
vec3_t forward, right, up;
float angle, sr, cr;
vec3_t point;
ref_entity_t *e;
int i;
e = m_pCurrentEntity;
frame = R_GetSpriteFrame( e );
@ -343,12 +345,15 @@ void R_DrawSpriteModel( void )
VectorSet( up, 0, 0, 1 );
break;
case SPR_FWD_PARALLEL_ORIENTED:
right[0] = e->matrix[1][0] * r_forward[0] + e->matrix[1][1] * r_right[0] + e->matrix[1][2] * r_up[0];
right[1] = e->matrix[1][0] * r_forward[1] + e->matrix[1][1] * r_right[1] + e->matrix[1][2] * r_up[1];
right[2] = e->matrix[1][0] * r_forward[2] + e->matrix[1][1] * r_right[2] + e->matrix[1][2] * r_up[2];
up[0] = e->matrix[2][0] * r_forward[0] + e->matrix[2][1] * r_right[0] + e->matrix[2][2] * r_up[0];
up[1] = e->matrix[2][0] * r_forward[1] + e->matrix[2][1] * r_right[1] + e->matrix[2][2] * r_up[1];
up[2] = e->matrix[2][0] * r_forward[2] + e->matrix[2][1] * r_right[2] + e->matrix[2][2] * r_up[2];
angle = e->angles[ROLL] * (M_PI*2.0f/360.0f);
sr = com.sin( angle );
cr = com.cos( angle );
for( i = 0; i < 3; i++ )
{
forward[i] = -r_forward[i];
right[i] = -(r_right[i] * cr + r_up[i] * sr);
up[i] = r_right[i] * -sr + r_up[i] * cr;
}
break;
case SPR_FWD_PARALLEL:
default: // normal sprite
@ -358,6 +363,44 @@ void R_DrawSpriteModel( void )
break;
}
// HACKHACK: manually set rendermode for sprites
if( m_pCurrentShader->stages[0]->renderMode != m_pCurrentEntity->rendermode )
{
switch( m_pCurrentEntity->rendermode )
{
case kRenderNormal:
m_pCurrentShader->stages[0]->flags &= ~(SHADERSTAGE_BLENDFUNC|SHADERSTAGE_ALPHAFUNC);
break;
case kRenderTransColor:
m_pCurrentShader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
m_pCurrentShader->stages[0]->blendFunc.src = GL_SRC_COLOR;
m_pCurrentShader->stages[0]->blendFunc.dst = GL_ZERO;
break;
case kRenderTransTexture:
m_pCurrentShader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
m_pCurrentShader->stages[0]->blendFunc.src = GL_SRC_ALPHA;
m_pCurrentShader->stages[0]->blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
break;
case kRenderGlow:
m_pCurrentShader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
m_pCurrentShader->stages[0]->blendFunc.src = GL_ONE_MINUS_SRC_ALPHA;
m_pCurrentShader->stages[0]->blendFunc.dst = GL_ONE;
break;
case kRenderTransAlpha:
m_pCurrentShader->stages[0]->flags |= SHADERSTAGE_ALPHAFUNC;
m_pCurrentShader->stages[0]->alphaFunc.func = GL_GREATER;
m_pCurrentShader->stages[0]->alphaFunc.ref = 0.666;
m_pCurrentShader->sort = SORT_SEETHROUGH;
break;
case kRenderTransAdd:
m_pCurrentShader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
m_pCurrentShader->stages[0]->blendFunc.src = GL_SRC_ALPHA;
m_pCurrentShader->stages[0]->blendFunc.dst = GL_ONE;
break;
}
m_pCurrentShader->stages[0]->renderMode = m_pCurrentEntity->rendermode;
}
if((m_pCurrentEntity->rendermode == kRenderGlow) || (m_pCurrentShader->surfaceParm & SURF_GLOW))
{
float dist = VectorDistance( m_pCurrentEntity->origin, r_refdef.vieworg );

73
render/r_studio.c
View File

@ -6,7 +6,7 @@
#include "r_local.h"
#include "byteorder.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
/*
@ -286,7 +286,7 @@ void R_StudioAddEntityToRadar( void )
if( r_minimap->value < 2 ) return;
if( numRadarEnts >= MAX_RADAR_ENTS ) return;
if( m_pCurrentEntity->renderfx & RF_VIEWMODEL ) return;
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL ) return;
if( m_pCurrentEntity->ent_type == ED_MONSTER )
{
@ -844,7 +844,7 @@ Studio_FxTransform
*/
void R_StudioFxTransform( ref_entity_t *ent, matrix4x4 transform )
{
if( ent->renderfx & RF_HOLOGRAMM )
if( ent->renderfx == kRenderFxHologram )
{
if(!Com_RandomLong( 0, 49 ))
{
@ -1205,7 +1205,7 @@ static bool R_StudioCheckBBox( void )
int aggregatemask = ~0;
if( m_pCurrentEntity->renderfx & RF_VIEWMODEL )
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL )
return true;
if(!R_StudioComputeBBox( bbox ))
return false;
@ -1255,18 +1255,12 @@ void R_StudioSetupLighting( void )
m_plightvec[1] = 0.0f;
m_plightvec[2] = (m_pCurrentEntity->effects & EF_INVLIGHT) ? 1.0f : -1.0f;
if( m_pCurrentEntity->renderfx & RF_FULLBRIGHT )
{
for (i = 0; i < 3; i++)
m_plightcolor[i] = 1.0f;
}
else
{
vec3_t light_org;
VectorCopy( m_pCurrentEntity->origin, light_org );
light_org[2] += 3; // make sure what lightpoint is off the ground
R_LightForPoint( light_org, m_plightcolor );
if ( m_pCurrentEntity->renderfx & RF_VIEWMODEL )
if ( m_pCurrentEntity->ent_type == ED_VIEWMODEL )
r_lightlevel->value = bound(0, VectorLength(m_plightcolor) * 75.0f, 255);
}
@ -1342,27 +1336,6 @@ void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
pchrome[1] = (n + 1.0) * 32.0f;
}
bool R_AcceptStudioPass( int flags, int pass )
{
if( pass == RENDERPASS_SOLID )
{
if(!flags) return true; // draw all
if(flags & STUDIO_NF_ADDITIVE) return false; // draw it at second pass (and chrome too)
if(flags & STUDIO_NF_CHROME) return true; // chrome drawing once (without additive)
if(flags & STUDIO_NF_TRANSPARENT) return true; // must be draw first always
}
if( pass == RENDERPASS_ALPHA )
{
//pass for blended ents
if(m_pCurrentEntity->renderfx & RF_TRANSLUCENT) return true;
if(!flags) return false; // skip all
if(flags & STUDIO_NF_TRANSPARENT) return false; // must be draw first always
if(flags & STUDIO_NF_ADDITIVE) return true; // draw it at second pass
if(flags & STUDIO_NF_CHROME) return false; // skip chrome without additive
}
return true;
}
void R_StudioDrawMeshes( dstudiotexture_t * ptexture, short *pskinref, int pass )
{
int i, j;
@ -1380,7 +1353,6 @@ void R_StudioDrawMeshes( dstudiotexture_t * ptexture, short *pskinref, int pass
for (j = 0; j < m_pSubModel->nummesh; j++)
{
flags = ptexture[pskinref[pmesh[j].skinref]].flags;
if(!R_AcceptStudioPass( flags, pass )) continue;
for (i = 0; i < pmesh[j].numnorms; i++, lv += 3, pstudionorms++, pnormbone++)
{
@ -1402,8 +1374,6 @@ void R_StudioDrawMeshes( dstudiotexture_t * ptexture, short *pskinref, int pass
ptricmds = (short *)((byte *)m_pStudioHeader + pmesh->triindex);
flags = ptexture[pskinref[pmesh->skinref]].flags;
//if(!R_AcceptStudioPass(flags, pass ))
// continue;
s = 1.0/(float)ptexture[pskinref[pmesh->skinref]].width;
t = 1.0/(float)ptexture[pskinref[pmesh->skinref]].height;
@ -1430,23 +1400,6 @@ void R_StudioDrawMeshes( dstudiotexture_t * ptexture, short *pskinref, int pass
lv = m_pvlightvalues[ptricmds[1]];
GL_Normal3fv( vec3_origin ); // FIXME: apply normals
if ( m_pCurrentEntity->renderfx & RF_FULLBRIGHT )
lv = &fbright[0];
if ( m_pCurrentEntity->renderfx & RF_MINLIGHT ) // used for viewmodel only
VectorBound( 0.01f, lv, 1.0f );
if ( r_refdef.rdflags & RDF_IRGOGGLES && m_pCurrentEntity->renderfx & RF_IR_VISIBLE)
lv = &irgoggles[0];
/*
if( flags & STUDIO_NF_ADDITIVE ) // additive is self-lighting texture
GL_Color4f( 1.0f, 1.0f, 1.0f, 0.8f );
else if( m_pCurrentEntity->renderfx & RF_TRANSLUCENT )
GL_Color4f( 1.0f, 1.0f, 1.0f, m_pCurrentEntity->renderamt );
else GL_Color3fv( lv ); // get light from floor
*/
av = m_pxformverts[ptricmds[0]]; // verts
GL_Vertex3f( av[0], av[1], av[2] );
}
@ -1488,13 +1441,13 @@ void R_StudioDrawPoints ( void )
}
// hack the depth range to prevent view model from poking into walls
if( m_pCurrentEntity->renderfx & RF_DEPTHHACK) pglDepthRange( 0.0, 0.3 );
if(( m_pCurrentEntity->renderfx & RF_VIEWMODEL ) && ( r_lefthand->value == 1.0F ))
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL ) pglDepthRange( 0.0, 0.3 );
if(( m_pCurrentEntity->ent_type == ED_VIEWMODEL ) && ( r_lefthand->value == 1.0F ))
VectorNegate( m_pCurrentEntity->matrix[1], m_pCurrentEntity->matrix[1] );
R_StudioDrawMeshes( ptexture, pskinref, m_PassNum );
// hack the depth range to prevent view model from poking into walls
if( m_pCurrentEntity->renderfx & RF_DEPTHHACK ) pglDepthRange( 0.0, 1.0 );
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL ) pglDepthRange( 0.0, 1.0 );
}
void R_StudioDrawBones( void )
@ -1668,7 +1621,9 @@ void R_StudioDrawHulls ( void )
// we already have code for drawing hulls
// make this go away
if(m_pCurrentEntity->renderfx & RF_VIEWMODEL) return;
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL )
return;
if(!R_StudioComputeBBox( bbox )) return;
pglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
@ -1771,10 +1726,10 @@ StudioDrawModel
*/
bool R_StudioDrawModel( int pass, int flags )
{
//if( !mirror_render && m_pCurrentEntity->renderfx & RF_PLAYERMODEL )
//if( !mirror_render && m_pCurrentEntity->ent_type == ED_CLIENT )
// return 0;
if( m_pCurrentEntity->renderfx & RF_VIEWMODEL )
if( m_pCurrentEntity->ent_type == ED_VIEWMODEL )
{
if( /*mirror_render ||*/ r_lefthand->value == 2 )
return 0;
@ -2020,7 +1975,7 @@ int R_StudioDrawPlayer( int pass, int flags )
{
entity_state_t *pplayer;
if( m_pCurrentEntity->renderfx & RF_PLAYERMODEL )
if( m_pCurrentEntity->ent_type == ED_CLIENT )
return 0;
if(!(flags & STUDIO_MIRROR))

13
render/r_surface.c
View File

@ -5,7 +5,7 @@
#include "r_local.h"
#include "mathlib.h"
#include "matrixlib.h"
#include "matrix_lib.h"
#include "const.h"
#define BACKFACE_EPSILON 0.01
@ -156,6 +156,17 @@ static void R_AddSurfaceToList( surface_t *surf, ref_entity_t *entity )
// add it
R_AddMeshToList( MESH_SURFACE, surf, shader, entity, lmNum );
// also add caustics
if( r_caustics->integer )
{
if( surf->flags & SURF_WATERCAUSTICS )
R_AddMeshToList( MESH_SURFACE, surf, tr.waterCausticsShader, entity, 0 );
if( surf->flags & SURF_SLIMECAUSTICS )
R_AddMeshToList( MESH_SURFACE, surf, tr.slimeCausticsShader, entity, 0 );
if( surf->flags & SURF_LAVACAUSTICS )
R_AddMeshToList( MESH_SURFACE, surf, tr.lavaCausticsShader, entity, 0 );
}
}

4
render/render.dsp
View File

@ -198,10 +198,6 @@ SOURCE=.\r_opengl.h
# End Source File
# Begin Source File
SOURCE=..\public\ref_dfiles.h
# End Source File
# Begin Source File
SOURCE=.\warpsin.h
# End Source File
# End Group

45
todo.log
View File

@ -15,35 +15,21 @@ fopen
1. Поддержка loop для ogg vorbis
2. переписать studiomdl для использования VFS
3. избавится от PR_ParseToken\Word в vprogs.dll
4. поправить генератор шейдеров в extragen
GLOBAL: Достигнуть уровня xash 0.45 к очередному релизу
Beta 13.12.08
qrad3:
0. правильный парсинг light энтитей OK
1. -qrad, -hlrad OK
2. bsp -> wad
0. move effects to client.dat
0. починить IMAGE_FORCE_RGBA (или избавится ?)
1. droptofloor
2. bsplib и финальный формат карты
3. console garbage OK
4. create indexBuffer
5. light_environment
6. сделать 2 типа расчета освещения OK
TODO LIST
поправить поле movedir в bsplib/map.c
придумать как вернуть cmodel_t обратно в physic.dll
научить игрока лазить по лестницам
Провериться боундс-чекером на течку
Найти наконец эту йобанную утечку
избавится от идиотскова RF_TRANSLUCENT
Упорядочить EF_, RF_ ed_type проверки
Анимация (разобраться с pev->animtime)
выбросить лишние ресурсы
забэкапить результат
0. light_environment
1. íàó÷èòü îðóæèå ñòðåëÿòü
2. äîáàâèòü íóæíûõ ýíòèòåé
3. bumpmapping test
4. player ducking
5. pev->animtime
6. bloom
7. pause effect
8. automap
9. Phys matrices
Список доступных рендереров: Что в них интересного
@ -51,7 +37,6 @@ TODO LIST
1. MhQuake (Caustics)
2. Xash 0.45 (Mirrors, Portals, Monitors, Rain, Sky)
3. Paranoia (Sky)
4. EGL (Effects, Shaders)
5. Quake2XP (Effects, Glass, Shadows)
6. Tenebrae (Mirrors, Cubemap Projection, Bump)
9.Darkplaces ALL!!!!!!!!!!!!!!!111111111111
4. Quake2XP (Effects, Glass, Shadows)
5. Tenebrae (Mirrors, Cubemap Projection, Bump)
6. Darkplaces ALL!!!!!!!!!!!!!!!111111111111

1
viewer/viewer.h
View File

@ -12,7 +12,6 @@
#include <stdlib.h>
#include <string.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "mxtk.h"
#include "options.h"

1
vprogs/pr_comp.c
View File

@ -176,6 +176,7 @@ opcode_t pr_opcodes[] =
{"<CALL6>", "CALL6", -1, ASSOC_LEFT, &type_function, &type_void, &type_void},
{"<CALL7>", "CALL7", -1, ASSOC_LEFT, &type_function, &type_void, &type_void},
{"<CALL8>", "CALL8", -1, ASSOC_LEFT, &type_function, &type_void, &type_void},
{"<CALL9>", "CALL9", -1, ASSOC_LEFT, &type_function, &type_void, &type_void},
{"<STATE>", "STATE", -1, ASSOC_LEFT, &type_float, &type_float, &type_void},
{"<GOTO>", "GOTO", -1, ASSOC_RIGHT,NULL, &type_void, &type_void},
{"&&", "AND", 7, ASSOC_LEFT, &type_float, &type_float, &type_float},

16
vprogs/pr_edict.c
View File

@ -1184,7 +1184,6 @@ void PRVM_ED_LoadFromFile( const char *data )
// pev = ent
PRVM_G_INT(vm.prog->pev->ofs) = PRVM_EDICT_TO_PROG(ent);
PRVM_ExecuteProgram( func - vm.prog->functions, "", __FILE__, __LINE__ );
if( vm.prog->classify_edict ) vm.prog->classify_edict( ent );
}
spawned++;
@ -1560,6 +1559,7 @@ void PRVM_LoadProgs( const char *filename )
case OP_CALL6:
case OP_CALL7:
case OP_CALL8:
case OP_CALL9:
case OP_DONE:
case OP_RETURN:
if ((dword) st->a >= vm.prog->progs->numglobals)
@ -1797,16 +1797,16 @@ void PRVM_GlobalSet_f(void)
}
// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
void VM_Warning(const char *fmt, ...)
void VM_Warning( const char *fmt, ... )
{
va_list argptr;
char msg[MAX_MSGLEN];
va_list argptr;
static char msg[MAX_MSGLEN];
va_start(argptr, fmt);
com.sprintf(msg, fmt, argptr);
va_end(argptr);
va_start( argptr, fmt );
com.vsnprintf( msg, sizeof(msg), fmt, argptr );
va_end( argptr );
Msg(msg);
Msg( msg );
// TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Msgf [9/13/2006 Black]
//PRVM_PrintState();
}

17
vprogs/pr_exec.c
View File

@ -97,6 +97,7 @@ char *prvm_opnames[] =
"^3CALL6",
"^3CALL7",
"^3CALL8",
"^3CALL9",
"^1STATE",
@ -442,7 +443,7 @@ PRVM_EnterFunction
Returns the new program statement counter
====================
*/
int PRVM_EnterFunction (mfunction_t *f)
int PRVM_EnterFunction( mfunction_t *f )
{
int i, j, c, o;
@ -452,14 +453,14 @@ int PRVM_EnterFunction (mfunction_t *f)
vm.prog->stack[vm.prog->depth].f = vm.prog->xfunction;
vm.prog->depth++;
if (vm.prog->depth >=PRVM_MAX_STACK_DEPTH)
PRVM_ERROR ("stack overflow");
PRVM_ERROR( "stack overflow\n" );
// save off any locals that the new function steps on
c = f->locals;
if (vm.prog->localstack_used + c > PRVM_LOCALSTACK_SIZE)
PRVM_ERROR ("PRVM_ExecuteProgram: locals stack overflow in %s", PRVM_NAME);
PRVM_ERROR( "PRVM_ExecuteProgram: locals stack overflow in %s", PRVM_NAME );
for (i=0 ; i < c ; i++)
for( i = 0; i < c; i++ )
vm.prog->localstack[vm.prog->localstack_used+i] = ((int *)vm.prog->globals.gp)[f->parm_start + i];
vm.prog->localstack_used += c;
@ -978,23 +979,25 @@ chooseexecprogram:
case OP_CALL6:
case OP_CALL7:
case OP_CALL8:
case OP_CALL9:
vm.prog->xfunction->profile += (st - startst);
startst = st;
vm.prog->xstatement = st - vm.prog->statements;
vm.prog->argc = st->op - OP_CALL0;
if (!OPA->function) PRVM_ERROR("NULL function in %s", PRVM_NAME);
if( !OPA->function )
PRVM_ERROR( "NULL function in %s (%s)(called at %s:%i)\n", name, PRVM_NAME, file, line );
newf = &vm.prog->functions[OPA->function];
newf->callcount++;
if (newf->first_statement < 0)
if( newf->first_statement < 0 )
{
// negative statements are built in functions
int builtinnumber = -newf->first_statement;
vm.prog->xfunction->builtinsprofile++;
if (builtinnumber < vm.prog->numbuiltins && vm.prog->builtins[builtinnumber])
vm.prog->builtins[builtinnumber]();
else PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
else PRVM_ERROR( "No such builtin #%i in %s\n", builtinnumber, PRVM_NAME );
}
else st = vm.prog->statements + PRVM_EnterFunction(newf);
startst = st;

2
vprogs/pr_utils.c
View File

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

4
vprogs/vprogs.h
View File

@ -7,7 +7,8 @@
#include <windows.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
#include "vprogs_api.h"
#include "pr_local.h"
extern stdlib_api_t com;
@ -94,6 +95,7 @@ enum op_state
OP_CALL6,
OP_CALL7,
OP_CALL8,
OP_CALL9,
OP_STATE, // 60
OP_GOTO,
OP_AND,

22
vsound/s_load.c
View File

@ -7,6 +7,7 @@
#include "s_stream.h"
#define MAX_SFX 4096
sound_t ambient_sfx[NUM_AMBIENTS];
static sfx_t s_knownSfx[MAX_SFX];
static int s_numSfx = 0;
int s_registration_sequence = 0;
@ -617,6 +618,8 @@ void S_BeginRegistration( void )
{
s_registration_sequence++;
s_registering = true;
S_InitAmbientSounds();
}
/*
@ -659,11 +662,11 @@ sound_t S_RegisterSound( const char *name )
{
sfx_t *sfx;
if(!al_state.initialized)
return 0;
if( !al_state.initialized )
return -1;
sfx = S_FindSound( name );
if( !sfx ) return 0;
if( !sfx ) return -1;
sfx->registration_sequence = s_registration_sequence;
if( !s_registering ) S_LoadSound( sfx );
@ -682,9 +685,9 @@ sfx_t *S_GetSfxByHandle( sound_t handle )
}
/*
=================
S_FreeSounds
=================
=================
S_FreeSounds
=================
*/
void S_FreeSounds( void )
{
@ -705,3 +708,10 @@ void S_FreeSounds( void )
Mem_Set( s_knownSfx, 0, sizeof(s_knownSfx));
s_numSfx = 0;
}
void S_InitAmbientSounds( void )
{
// FIXME: create external script for replace this sounds
ambient_sfx[AMBIENT_SKY] = S_RegisterSound( "ambience/wind2.wav" );
ambient_sfx[AMBIENT_WATER] = S_RegisterSound( "ambience/water1.wav" );
}

41
vsound/s_main.c
View File

@ -24,6 +24,8 @@ cvar_t *s_soundfx;
cvar_t *s_check_errors;
cvar_t *s_volume; // master volume
cvar_t *s_musicvolume; // background track volume
cvar_t *s_ambientvolume;
cvar_t *s_ambientfade;
cvar_t *s_pause;
cvar_t *s_minDistance;
cvar_t *s_maxDistance;
@ -553,6 +555,34 @@ void S_AddEnvironmentEffects( const vec3_t position )
al_config.Set3DMode(&DSPROPSETID_EAX20_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENT|DSPROPERTY_EAXLISTENER_DEFERRED, 0, &eaxEnv, sizeof(eaxEnv));
}
/*
===================
S_UpdateAmbientSounds
===================
*/
void S_UpdateAmbientSounds( int clientnum, const vec3_t position )
{
float volumes[NUM_AMBIENTS];
float volume;
sfx_t *ambient;
int i;
if( !si.AmbientLevel( position, volumes ) || !s_ambientvolume->value )
return;
for( i = 0; i < NUM_AMBIENTS; i++ )
{
// no sound
ambient = S_GetSfxByHandle( ambient_sfx[i] );
if( !ambient ) continue;
volume = s_ambientvolume->value * volumes[i];
if( volume < 0.03 ) continue; // not hearable
S_AddLoopingSound( clientnum, ambient_sfx[i], volume, ATTN_NORM );
}
}
/*
=================
S_Update
@ -600,6 +630,9 @@ void S_Update( int clientnum, const vec3_t position, const vec3_t velocity, cons
// Stream background track
S_StreamBackgroundTrack();
// Add ambient sounds (like q1)
S_UpdateAmbientSounds( clientnum, position );
// Add looping sounds
si.AddLoopingSounds();
@ -744,6 +777,8 @@ void S_Init( void *hInst )
s_rolloffFactor = Cvar_Get("s_rollofffactor", "1.0", CVAR_ARCHIVE, "3d sound rolloff factor" );
s_dopplerFactor = Cvar_Get("s_dopplerfactor", "1.0", CVAR_ARCHIVE, "cutoff doppler effect value" );
s_dopplerVelocity = Cvar_Get("s_dopplervelocity", "10976.0", CVAR_ARCHIVE, "doppler effect maxvelocity" );
s_ambientvolume = Cvar_Get( "s_ambientlevel", "0.3", CVAR_ARCHIVE, "world ambient sounds volume" );
s_ambientfade = Cvar_Get( "s_ambientfade", "100", CVAR_ARCHIVE, "speed to fading ambient sounds" );
s_pause = Cvar_Get( "paused", "0", 0, "sound engine pause" );
Cmd_AddCommand("playsound", S_PlaySound_f, "playing a specified sound file" );
@ -779,9 +814,9 @@ void S_Init( void *hInst )
}
/*
=================
S_Shutdown
=================
=================
S_Shutdown
=================
*/
void S_Shutdown( void )
{

5
vsound/sound.h
View File

@ -8,7 +8,8 @@
#include <windows.h>
#include "launch_api.h"
#include "ref_dllapi.h"
#include "qfiles_ref.h"
#include "vsound_api.h"
#include "s_openal.h"
extern stdlib_api_t com;
@ -159,6 +160,7 @@ extern cvar_t *s_alDevice;
extern cvar_t *s_soundfx;
extern cvar_t *s_musicvolume;
extern cvar_t *s_check_errors;
extern sound_t ambient_sfx[NUM_AMBIENTS];
void S_Init( void *hInst );
void S_Shutdown( void );
@ -175,6 +177,7 @@ int S_StartLocalSound( const char *name );
sfx_t *S_GetSfxByHandle( sound_t handle );
void S_StreamBackgroundTrack( void );
void S_StopBackgroundTrack( void );
void S_InitAmbientSounds( void );
void S_ClearSoundBuffer( void );
bool S_LoadSound( sfx_t *sfx );
void S_StartStreaming( void );