sourcemod-central: core/smn_bitbuffer.cpp@f1bfc4089ce5 (annotated)

faluco@505	1	/**
dvander@600	2	* vim: set ts=4 :
ds@1330	3	* =============================================================================
dvander@1231	4	* SourceMod
ds@1947	5	* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
ds@1330	6	* =============================================================================
dvander@600	7	*
ds@1330	8	* This program is free software; you can redistribute it and/or modify it under
ds@1330	9	* the terms of the GNU General Public License, version 3.0, as published by the
ds@1330	10	* Free Software Foundation.
dvander@1231	11	*
ds@1330	12	* This program is distributed in the hope that it will be useful, but WITHOUT
ds@1330	13	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
ds@1330	14	* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
ds@1330	15	* details.
dvander@1231	16	*
ds@1330	17	* You should have received a copy of the GNU General Public License along with
ds@1330	18	* this program. If not, see <http://www.gnu.org/licenses/>.
dvander@1231	19	*
ds@1330	20	* As a special exception, AlliedModders LLC gives you permission to link the
ds@1330	21	* code of this program (as well as its derivative works) to "Half-Life 2," the
ds@1330	22	* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
ds@1330	23	* by the Valve Corporation. You must obey the GNU General Public License in
ds@1330	24	* all respects for all other code used. Additionally, AlliedModders LLC grants
ds@1330	25	* this exception to all derivative works. AlliedModders LLC defines further
ds@1330	26	* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
ds@1330	27	* or <http://www.sourcemod.net/license.php>.
dvander@600	28	*
dvander@600	29	* Version: $Id$
dvander@600	30	*/
faluco@505	31
ds@511	32	#include "sourcemod.h"
ds@511	33	#include "HandleSys.h"
faluco@505	34	#include <bitbuf.h>
faluco@505	35	#include <vector.h>
pred@2746	36	#include <HalfLife2.h>
faluco@505	37
faluco@505	38	static cell_t smn_BfWriteBool(IPluginContext pCtx, const cell_t params)
faluco@505	39	{
faluco@505	40	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	41	HandleError herr;
faluco@505	42	HandleSecurity sec;
faluco@505	43	bf_write *pBitBuf;
faluco@505	44
faluco@505	45	sec.pOwner = NULL;
faluco@505	46	sec.pIdentity = g_pCoreIdent;
faluco@505	47
faluco@505	48	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	49	!= HandleError_None)
faluco@505	50	{
faluco@505	51	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	52	}
faluco@505	53
faluco@505	54	pBitBuf->WriteOneBit(params[2]);
faluco@505	55
faluco@505	56	return 1;
faluco@505	57	}
faluco@505	58
faluco@505	59	static cell_t smn_BfWriteByte(IPluginContext pCtx, const cell_t params)
faluco@505	60	{
faluco@505	61	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	62	HandleError herr;
faluco@505	63	HandleSecurity sec;
faluco@505	64	bf_write *pBitBuf;
faluco@505	65
faluco@505	66	sec.pOwner = NULL;
faluco@505	67	sec.pIdentity = g_pCoreIdent;
faluco@505	68
faluco@505	69	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	70	!= HandleError_None)
faluco@505	71	{
faluco@505	72	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	73	}
faluco@505	74
faluco@505	75	pBitBuf->WriteByte(params[2]);
faluco@505	76
faluco@505	77	return 1;
faluco@505	78	}
faluco@505	79
faluco@505	80	static cell_t smn_BfWriteChar(IPluginContext pCtx, const cell_t params)
faluco@505	81	{
faluco@505	82	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	83	HandleError herr;
faluco@505	84	HandleSecurity sec;
faluco@505	85	bf_write *pBitBuf;
faluco@505	86
faluco@505	87	sec.pOwner = NULL;
faluco@505	88	sec.pIdentity = g_pCoreIdent;
faluco@505	89
faluco@505	90	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	91	!= HandleError_None)
faluco@505	92	{
faluco@505	93	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	94	}
faluco@505	95
faluco@505	96	pBitBuf->WriteChar(params[2]);
faluco@505	97
faluco@505	98	return 1;
faluco@505	99	}
faluco@505	100
faluco@505	101	static cell_t smn_BfWriteShort(IPluginContext pCtx, const cell_t params)
faluco@505	102	{
faluco@505	103	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	104	HandleError herr;
faluco@505	105	HandleSecurity sec;
faluco@505	106	bf_write *pBitBuf;
faluco@505	107
faluco@505	108	sec.pOwner = NULL;
faluco@505	109	sec.pIdentity = g_pCoreIdent;
faluco@505	110
faluco@505	111	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	112	!= HandleError_None)
faluco@505	113	{
faluco@505	114	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	115	}
faluco@505	116
faluco@505	117	pBitBuf->WriteShort(params[2]);
faluco@505	118
faluco@505	119	return 1;
faluco@505	120	}
faluco@505	121
faluco@505	122	static cell_t smn_BfWriteWord(IPluginContext pCtx, const cell_t params)
faluco@505	123	{
faluco@505	124	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	125	HandleError herr;
faluco@505	126	HandleSecurity sec;
faluco@505	127	bf_write *pBitBuf;
faluco@505	128
faluco@505	129	sec.pOwner = NULL;
faluco@505	130	sec.pIdentity = g_pCoreIdent;
faluco@505	131
faluco@505	132	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	133	!= HandleError_None)
faluco@505	134	{
faluco@505	135	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	136	}
faluco@505	137
faluco@505	138	pBitBuf->WriteWord(params[2]);
faluco@505	139
faluco@505	140	return 1;
faluco@505	141	}
faluco@505	142
faluco@505	143	static cell_t smn_BfWriteNum(IPluginContext pCtx, const cell_t params)
faluco@505	144	{
faluco@505	145	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	146	HandleError herr;
faluco@505	147	HandleSecurity sec;
faluco@505	148	bf_write *pBitBuf;
faluco@505	149
faluco@505	150	sec.pOwner = NULL;
faluco@505	151	sec.pIdentity = g_pCoreIdent;
faluco@505	152
faluco@505	153	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	154	!= HandleError_None)
faluco@505	155	{
faluco@505	156	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	157	}
faluco@505	158
faluco@505	159	pBitBuf->WriteLong(static_cast<long>(params[2]));
faluco@505	160
faluco@505	161	return 1;
faluco@505	162	}
faluco@505	163
faluco@505	164	static cell_t smn_BfWriteFloat(IPluginContext pCtx, const cell_t params)
faluco@505	165	{
faluco@505	166	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	167	HandleError herr;
faluco@505	168	HandleSecurity sec;
faluco@505	169	bf_write *pBitBuf;
faluco@505	170
faluco@505	171	sec.pOwner = NULL;
faluco@505	172	sec.pIdentity = g_pCoreIdent;
faluco@505	173
faluco@505	174	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	175	!= HandleError_None)
faluco@505	176	{
faluco@505	177	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	178	}
faluco@505	179
faluco@505	180	pBitBuf->WriteFloat(sp_ctof(params[2]));
faluco@505	181
faluco@505	182	return 1;
faluco@505	183	}
faluco@505	184
faluco@505	185	static cell_t smn_BfWriteString(IPluginContext pCtx, const cell_t params)
faluco@505	186	{
faluco@505	187	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	188	HandleError herr;
faluco@505	189	HandleSecurity sec;
faluco@505	190	bf_write *pBitBuf;
faluco@505	191	int err;
faluco@505	192
faluco@505	193	sec.pOwner = NULL;
faluco@505	194	sec.pIdentity = g_pCoreIdent;
faluco@505	195
faluco@505	196	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	197	!= HandleError_None)
faluco@505	198	{
faluco@505	199	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	200	}
faluco@505	201
faluco@505	202	char *str;
faluco@505	203	if ((err=pCtx->LocalToString(params[2], &str)) != SP_ERROR_NONE)
faluco@505	204	{
faluco@505	205	pCtx->ThrowNativeErrorEx(err, NULL);
faluco@505	206	return 0;
faluco@505	207	}
faluco@505	208
faluco@505	209	pBitBuf->WriteString(str);
faluco@505	210
faluco@505	211	return 1;
faluco@505	212	}
faluco@505	213
faluco@505	214	static cell_t smn_BfWriteEntity(IPluginContext pCtx, const cell_t params)
faluco@505	215	{
faluco@505	216	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	217	HandleError herr;
faluco@505	218	HandleSecurity sec;
faluco@505	219	bf_write *pBitBuf;
faluco@505	220
faluco@505	221	sec.pOwner = NULL;
faluco@505	222	sec.pIdentity = g_pCoreIdent;
faluco@505	223
faluco@505	224	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	225	!= HandleError_None)
faluco@505	226	{
faluco@505	227	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	228	}
faluco@505	229
pred@2746	230	int index = g_HL2.ReferenceToIndex(params[2]);
pred@2746	231
pred@2746	232	if (index == -1)
pred@2746	233	{
pred@2746	234	return 0;
pred@2746	235	}
pred@2746	236
pred@2746	237	pBitBuf->WriteShort(index);
faluco@505	238
faluco@505	239	return 1;
faluco@505	240	}
faluco@505	241
faluco@505	242	static cell_t smn_BfWriteAngle(IPluginContext pCtx, const cell_t params)
faluco@505	243	{
faluco@505	244	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	245	HandleError herr;
faluco@505	246	HandleSecurity sec;
faluco@505	247	bf_write *pBitBuf;
faluco@505	248
faluco@505	249	sec.pOwner = NULL;
faluco@505	250	sec.pIdentity = g_pCoreIdent;
faluco@505	251
faluco@505	252	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	253	!= HandleError_None)
faluco@505	254	{
faluco@505	255	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	256	}
faluco@505	257
faluco@505	258	pBitBuf->WriteBitAngle(sp_ctof(params[2]), params[3]);
faluco@505	259
faluco@505	260	return 1;
faluco@505	261	}
faluco@505	262
faluco@505	263	static cell_t smn_BfWriteCoord(IPluginContext pCtx, const cell_t params)
faluco@505	264	{
faluco@505	265	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	266	HandleError herr;
faluco@505	267	HandleSecurity sec;
faluco@505	268	bf_write *pBitBuf;
faluco@505	269
faluco@505	270	sec.pOwner = NULL;
faluco@505	271	sec.pIdentity = g_pCoreIdent;
faluco@505	272
faluco@505	273	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	274	!= HandleError_None)
faluco@505	275	{
faluco@505	276	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	277	}
faluco@505	278
faluco@505	279	pBitBuf->WriteBitCoord(sp_ctof(params[2]));
faluco@505	280
faluco@505	281	return 1;
faluco@505	282	}
faluco@505	283
faluco@505	284	static cell_t smn_BfWriteVecCoord(IPluginContext pCtx, const cell_t params)
faluco@505	285	{
faluco@505	286	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	287	HandleError herr;
faluco@505	288	HandleSecurity sec;
faluco@505	289	bf_write *pBitBuf;
faluco@505	290
faluco@505	291	sec.pOwner = NULL;
faluco@505	292	sec.pIdentity = g_pCoreIdent;
faluco@505	293
faluco@505	294	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	295	!= HandleError_None)
faluco@505	296	{
faluco@505	297	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	298	}
faluco@505	299
faluco@505	300	cell_t *pVec;
faluco@505	301	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@505	302	Vector vec(sp_ctof(pVec[0]), sp_ctof(pVec[1]), sp_ctof(pVec[2]));
faluco@505	303	pBitBuf->WriteBitVec3Coord(vec);
faluco@505	304
faluco@505	305	return 1;
faluco@505	306	}
faluco@505	307
faluco@505	308	static cell_t smn_BfWriteVecNormal(IPluginContext pCtx, const cell_t params)
faluco@505	309	{
faluco@505	310	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	311	HandleError herr;
faluco@505	312	HandleSecurity sec;
faluco@505	313	bf_write *pBitBuf;
faluco@505	314
faluco@505	315	sec.pOwner = NULL;
faluco@505	316	sec.pIdentity = g_pCoreIdent;
faluco@505	317
faluco@505	318	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	319	!= HandleError_None)
faluco@505	320	{
faluco@505	321	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	322	}
faluco@505	323
faluco@505	324	cell_t *pVec;
faluco@505	325	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@505	326	Vector vec(sp_ctof(pVec[0]), sp_ctof(pVec[1]), sp_ctof(pVec[2]));
faluco@505	327	pBitBuf->WriteBitVec3Normal(vec);
faluco@505	328
faluco@505	329	return 1;
faluco@505	330	}
faluco@505	331
faluco@505	332	static cell_t smn_BfWriteAngles(IPluginContext pCtx, const cell_t params)
faluco@505	333	{
faluco@505	334	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	335	HandleError herr;
faluco@505	336	HandleSecurity sec;
faluco@505	337	bf_write *pBitBuf;
faluco@505	338
faluco@505	339	sec.pOwner = NULL;
faluco@505	340	sec.pIdentity = g_pCoreIdent;
faluco@505	341
faluco@505	342	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	343	!= HandleError_None)
faluco@505	344	{
faluco@505	345	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	346	}
faluco@505	347
faluco@505	348	cell_t *pAng;
faluco@505	349	pCtx->LocalToPhysAddr(params[2], &pAng);
faluco@505	350	QAngle ang(sp_ctof(pAng[0]), sp_ctof(pAng[1]), sp_ctof(pAng[2]));
faluco@505	351	pBitBuf->WriteBitAngles(ang);
faluco@505	352
faluco@505	353	return 1;
faluco@505	354	}
faluco@505	355
faluco@598	356	static cell_t smn_BfReadBool(IPluginContext pCtx, const cell_t params)
faluco@598	357	{
faluco@598	358	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	359	HandleError herr;
faluco@598	360	HandleSecurity sec;
faluco@598	361	bf_read *pBitBuf;
faluco@598	362
faluco@598	363	sec.pOwner = NULL;
faluco@598	364	sec.pIdentity = g_pCoreIdent;
faluco@598	365
faluco@598	366	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	367	!= HandleError_None)
faluco@598	368	{
faluco@598	369	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	370	}
faluco@598	371
faluco@598	372	return pBitBuf->ReadOneBit() ? 1 : 0;
faluco@598	373	}
faluco@598	374
faluco@598	375	static cell_t smn_BfReadByte(IPluginContext pCtx, const cell_t params)
faluco@598	376	{
faluco@598	377	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	378	HandleError herr;
faluco@598	379	HandleSecurity sec;
faluco@598	380	bf_read *pBitBuf;
faluco@598	381
faluco@598	382	sec.pOwner = NULL;
faluco@598	383	sec.pIdentity = g_pCoreIdent;
faluco@598	384
faluco@598	385	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	386	!= HandleError_None)
faluco@598	387	{
faluco@598	388	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	389	}
faluco@598	390
faluco@598	391	return pBitBuf->ReadByte();
faluco@598	392	}
faluco@598	393
faluco@598	394	static cell_t smn_BfReadChar(IPluginContext pCtx, const cell_t params)
faluco@598	395	{
faluco@598	396	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	397	HandleError herr;
faluco@598	398	HandleSecurity sec;
faluco@598	399	bf_read *pBitBuf;
faluco@598	400
faluco@598	401	sec.pOwner = NULL;
faluco@598	402	sec.pIdentity = g_pCoreIdent;
faluco@598	403
faluco@598	404	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	405	!= HandleError_None)
faluco@598	406	{
faluco@598	407	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	408	}
faluco@598	409
faluco@598	410	return pBitBuf->ReadChar();
faluco@598	411	}
faluco@598	412
faluco@598	413	static cell_t smn_BfReadShort(IPluginContext pCtx, const cell_t params)
faluco@598	414	{
faluco@598	415	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	416	HandleError herr;
faluco@598	417	HandleSecurity sec;
faluco@598	418	bf_read *pBitBuf;
faluco@598	419
faluco@598	420	sec.pOwner = NULL;
faluco@598	421	sec.pIdentity = g_pCoreIdent;
faluco@598	422
faluco@598	423	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	424	!= HandleError_None)
faluco@598	425	{
faluco@598	426	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	427	}
faluco@598	428
faluco@598	429	return pBitBuf->ReadShort();
faluco@598	430	}
faluco@598	431
faluco@598	432	static cell_t smn_BfReadWord(IPluginContext pCtx, const cell_t params)
faluco@598	433	{
faluco@598	434	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	435	HandleError herr;
faluco@598	436	HandleSecurity sec;
faluco@598	437	bf_read *pBitBuf;
faluco@598	438
faluco@598	439	sec.pOwner = NULL;
faluco@598	440	sec.pIdentity = g_pCoreIdent;
faluco@598	441
faluco@598	442	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	443	!= HandleError_None)
faluco@598	444	{
faluco@598	445	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	446	}
faluco@598	447
faluco@598	448	return pBitBuf->ReadWord();
faluco@598	449	}
faluco@598	450
faluco@598	451	static cell_t smn_BfReadNum(IPluginContext pCtx, const cell_t params)
faluco@598	452	{
faluco@598	453	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	454	HandleError herr;
faluco@598	455	HandleSecurity sec;
faluco@598	456	bf_read *pBitBuf;
faluco@598	457
faluco@598	458	sec.pOwner = NULL;
faluco@598	459	sec.pIdentity = g_pCoreIdent;
faluco@598	460
faluco@598	461	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	462	!= HandleError_None)
faluco@598	463	{
faluco@598	464	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	465	}
faluco@598	466
faluco@598	467	return static_cast<cell_t>(pBitBuf->ReadLong());
faluco@598	468	}
faluco@598	469
faluco@598	470	static cell_t smn_BfReadFloat(IPluginContext pCtx, const cell_t params)
faluco@598	471	{
faluco@598	472	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	473	HandleError herr;
faluco@598	474	HandleSecurity sec;
faluco@598	475	bf_read *pBitBuf;
faluco@598	476
faluco@598	477	sec.pOwner = NULL;
faluco@598	478	sec.pIdentity = g_pCoreIdent;
faluco@598	479
faluco@598	480	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	481	!= HandleError_None)
faluco@598	482	{
faluco@598	483	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	484	}
faluco@598	485
faluco@598	486	return sp_ftoc(pBitBuf->ReadFloat());
faluco@598	487	}
faluco@598	488
faluco@598	489	static cell_t smn_BfReadString(IPluginContext pCtx, const cell_t params)
faluco@598	490	{
faluco@598	491	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	492	HandleError herr;
faluco@598	493	HandleSecurity sec;
faluco@598	494	bf_read *pBitBuf;
dvander@1750	495	int numChars = 0;
faluco@598	496	char *buf;
faluco@598	497
faluco@598	498	sec.pOwner = NULL;
faluco@598	499	sec.pIdentity = g_pCoreIdent;
faluco@598	500
faluco@598	501	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	502	!= HandleError_None)
faluco@598	503	{
faluco@598	504	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	505	}
faluco@598	506
faluco@598	507	pCtx->LocalToPhysAddr(params[2], (cell_t **)&buf);
dvander@1764	508	pBitBuf->ReadString(buf, params[3], params[4] ? true : false, &numChars);
dvander@1750	509
dvander@1750	510	if (pBitBuf->IsOverflowed())
faluco@598	511	{
dvander@1750	512	return -numChars - 1;
faluco@598	513	}
faluco@598	514
dvander@1750	515	return numChars;
faluco@598	516	}
faluco@598	517
faluco@598	518	static cell_t smn_BfReadEntity(IPluginContext pCtx, const cell_t params)
faluco@598	519	{
faluco@598	520	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	521	HandleError herr;
faluco@598	522	HandleSecurity sec;
faluco@598	523	bf_read *pBitBuf;
faluco@598	524
faluco@598	525	sec.pOwner = NULL;
faluco@598	526	sec.pIdentity = g_pCoreIdent;
faluco@598	527
faluco@598	528	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	529	!= HandleError_None)
faluco@598	530	{
faluco@598	531	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	532	}
faluco@598	533
pred@2746	534	int ref = g_HL2.IndexToReference(pBitBuf->ReadShort());
pred@2746	535
pred@2746	536	return g_HL2.ReferenceToBCompatRef(ref);
faluco@598	537	}
faluco@598	538
faluco@598	539	static cell_t smn_BfReadAngle(IPluginContext pCtx, const cell_t params)
faluco@598	540	{
faluco@598	541	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	542	HandleError herr;
faluco@598	543	HandleSecurity sec;
faluco@598	544	bf_read *pBitBuf;
faluco@598	545
faluco@598	546	sec.pOwner = NULL;
faluco@598	547	sec.pIdentity = g_pCoreIdent;
faluco@598	548
faluco@598	549	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	550	!= HandleError_None)
faluco@598	551	{
faluco@598	552	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	553	}
faluco@598	554
faluco@598	555	return sp_ftoc(pBitBuf->ReadBitAngle(params[2]));
faluco@598	556	}
faluco@598	557
faluco@598	558	static cell_t smn_BfReadCoord(IPluginContext pCtx, const cell_t params)
faluco@598	559	{
faluco@598	560	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	561	HandleError herr;
faluco@598	562	HandleSecurity sec;
faluco@598	563	bf_read *pBitBuf;
faluco@598	564
faluco@598	565	sec.pOwner = NULL;
faluco@598	566	sec.pIdentity = g_pCoreIdent;
faluco@598	567
faluco@598	568	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	569	!= HandleError_None)
faluco@598	570	{
faluco@598	571	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	572	}
faluco@598	573
faluco@598	574	return sp_ftoc(pBitBuf->ReadBitCoord());
faluco@598	575	}
faluco@598	576
faluco@598	577	static cell_t smn_BfReadVecCoord(IPluginContext pCtx, const cell_t params)
faluco@598	578	{
faluco@598	579	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	580	HandleError herr;
faluco@598	581	HandleSecurity sec;
faluco@598	582	bf_read *pBitBuf;
faluco@598	583
faluco@598	584	sec.pOwner = NULL;
faluco@598	585	sec.pIdentity = g_pCoreIdent;
faluco@598	586
faluco@598	587	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	588	!= HandleError_None)
faluco@598	589	{
faluco@598	590	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	591	}
faluco@598	592
faluco@598	593	cell_t *pVec;
faluco@598	594	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@598	595
faluco@598	596	Vector vec;
faluco@598	597	pBitBuf->ReadBitVec3Coord(vec);
faluco@598	598
faluco@598	599	pVec[0] = sp_ftoc(vec.x);
faluco@598	600	pVec[1] = sp_ftoc(vec.y);
faluco@598	601	pVec[2] = sp_ftoc(vec.z);
faluco@598	602
faluco@598	603	return 1;
faluco@598	604	}
faluco@598	605
faluco@598	606	static cell_t smn_BfReadVecNormal(IPluginContext pCtx, const cell_t params)
faluco@598	607	{
faluco@598	608	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	609	HandleError herr;
faluco@598	610	HandleSecurity sec;
faluco@598	611	bf_read *pBitBuf;
faluco@598	612
faluco@598	613	sec.pOwner = NULL;
faluco@598	614	sec.pIdentity = g_pCoreIdent;
faluco@598	615
faluco@598	616	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	617	!= HandleError_None)
faluco@598	618	{
faluco@598	619	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	620	}
faluco@598	621
faluco@598	622	cell_t *pVec;
faluco@598	623	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@598	624
faluco@598	625	Vector vec;
faluco@598	626	pBitBuf->ReadBitVec3Normal(vec);
faluco@598	627
faluco@598	628	pVec[0] = sp_ftoc(vec.x);
faluco@598	629	pVec[1] = sp_ftoc(vec.y);
faluco@598	630	pVec[2] = sp_ftoc(vec.z);
faluco@598	631
faluco@598	632	return 1;
faluco@598	633	}
faluco@598	634
faluco@598	635	static cell_t smn_BfReadAngles(IPluginContext pCtx, const cell_t params)
faluco@598	636	{
faluco@598	637	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	638	HandleError herr;
faluco@598	639	HandleSecurity sec;
faluco@598	640	bf_read *pBitBuf;
faluco@598	641
faluco@598	642	sec.pOwner = NULL;
faluco@598	643	sec.pIdentity = g_pCoreIdent;
faluco@598	644
faluco@598	645	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	646	!= HandleError_None)
faluco@598	647	{
faluco@598	648	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	649	}
faluco@598	650
faluco@598	651	cell_t *pAng;
faluco@598	652	pCtx->LocalToPhysAddr(params[2], &pAng);
faluco@598	653
faluco@598	654	QAngle ang;
faluco@598	655	pBitBuf->ReadBitAngles(ang);
faluco@598	656
faluco@598	657	pAng[0] = sp_ftoc(ang.x);
faluco@598	658	pAng[1] = sp_ftoc(ang.y);
faluco@598	659	pAng[2] = sp_ftoc(ang.z);
faluco@598	660
faluco@598	661	return 1;
faluco@598	662	}
faluco@598	663
pred@1872	664	static cell_t smn_BfGetNumBytesLeft(IPluginContext pCtx, const cell_t params)
pred@1872	665	{
pred@1872	666	Handle_t hndl = static_cast<Handle_t>(params[1]);
pred@1872	667	HandleError herr;
pred@1872	668	HandleSecurity sec;
pred@1872	669	bf_read *pBitBuf;
pred@1872	670
pred@1872	671	sec.pOwner = NULL;
pred@1872	672	sec.pIdentity = g_pCoreIdent;
pred@1872	673
pred@1872	674	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
pred@1872	675	!= HandleError_None)
pred@1872	676	{
pred@1872	677	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
pred@1872	678	}
pred@1872	679
pred@1872	680	return pBitBuf->GetNumBitsLeft() >> 3;
pred@1872	681	}
pred@1872	682
faluco@598	683	REGISTER_NATIVES(bitbufnatives)
faluco@505	684	{
faluco@505	685	{"BfWriteBool", smn_BfWriteBool},
faluco@505	686	{"BfWriteByte", smn_BfWriteByte},
faluco@505	687	{"BfWriteChar", smn_BfWriteChar},
faluco@505	688	{"BfWriteShort", smn_BfWriteShort},
faluco@505	689	{"BfWriteWord", smn_BfWriteWord},
faluco@505	690	{"BfWriteNum", smn_BfWriteNum},
faluco@505	691	{"BfWriteFloat", smn_BfWriteFloat},
faluco@505	692	{"BfWriteString", smn_BfWriteString},
faluco@505	693	{"BfWriteEntity", smn_BfWriteEntity},
faluco@505	694	{"BfWriteAngle", smn_BfWriteAngle},
faluco@505	695	{"BfWriteCoord", smn_BfWriteCoord},
faluco@505	696	{"BfWriteVecCoord", smn_BfWriteVecCoord},
faluco@505	697	{"BfWriteVecNormal", smn_BfWriteVecNormal},
faluco@505	698	{"BfWriteAngles", smn_BfWriteAngles},
faluco@598	699	{"BfReadBool", smn_BfReadBool},
faluco@598	700	{"BfReadByte", smn_BfReadByte},
faluco@598	701	{"BfReadChar", smn_BfReadChar},
faluco@598	702	{"BfReadShort", smn_BfReadShort},
faluco@598	703	{"BfReadWord", smn_BfReadWord},
faluco@598	704	{"BfReadNum", smn_BfReadNum},
faluco@598	705	{"BfReadFloat", smn_BfReadFloat},
faluco@598	706	{"BfReadString", smn_BfReadString},
faluco@598	707	{"BfReadEntity", smn_BfReadEntity},
faluco@598	708	{"BfReadAngle", smn_BfReadAngle},
faluco@598	709	{"BfReadCoord", smn_BfReadCoord},
faluco@598	710	{"BfReadVecCoord", smn_BfReadVecCoord},
faluco@598	711	{"BfReadVecNormal", smn_BfReadVecNormal},
faluco@598	712	{"BfReadAngles", smn_BfReadAngles},
pred@1872	713	{"BfGetNumBytesLeft", smn_BfGetNumBytesLeft},
faluco@505	714	{NULL, NULL}
faluco@505	715	};

author	Nicholas Hastings <skamonkey@gmail.com>
	Mon Jun 28 19:12:37 2010 -0400 (2010-06-28)
changeset 3060	f1bfc4089ce5
parent 2746	8d68569b9648
child 3743	a98686a77974
permissions	-rw-r--r--