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

faluco@505	1	/**
dvander@600	2	* vim: set ts=4 :
dvander@1231	3	* ================================================================
dvander@1231	4	* SourceMod
dvander@1231	5	* Copyright (C) 2004-2007 AlliedModders LLC. All rights reserved.
dvander@1231	6	* ================================================================
dvander@600	7	*
dvander@1231	8	* This program is free software; you can redistribute it and/or
dvander@1231	9	* modify it under the terms of the GNU General Public License,
dvander@1231	10	* version 3.0, as published by the Free Software Foundation.
dvander@1231	11	*
dvander@1231	12	* This program is distributed in the hope that it will be useful,
dvander@1231	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
dvander@1231	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
dvander@1231	15	* GNU General Public License for more details.
dvander@1231	16	*
dvander@1231	17	* You should have received a copy of the GNU General Public License
dvander@1231	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
dvander@1231	19	*
dvander@1231	20	* As a special exception, AlliedModders LLC gives you permission to
dvander@1231	21	* link the code of this program (as well as its derivative works) to
dvander@1231	22	* "Half-Life 2," the "Source Engine," the "SourcePawn JIT," and any
dvander@1231	23	* Game MODs that run on software by the Valve Corporation. You must
dvander@1231	24	* obey the GNU General Public License in all respects for all other
dvander@1231	25	* code used. Additionally, AlliedModders LLC grants this exception
dvander@1231	26	* to all derivative works. AlliedModders LLC defines further
dvander@1231	27	* exceptions, found in LICENSE.txt (as of this writing, version
dvander@1231	28	* JULY-31-2007), or <http://www.sourcemod.net/license.php>.
dvander@600	29	*
dvander@600	30	* Version: $Id$
dvander@600	31	*/
faluco@505	32
ds@511	33	#include "sourcemod.h"
ds@511	34	#include "HandleSys.h"
faluco@505	35	#include <bitbuf.h>
faluco@505	36	#include <vector.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
faluco@505	230	pBitBuf->WriteShort(params[2]);
faluco@505	231
faluco@505	232	return 1;
faluco@505	233	}
faluco@505	234
faluco@505	235	static cell_t smn_BfWriteAngle(IPluginContext pCtx, const cell_t params)
faluco@505	236	{
faluco@505	237	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	238	HandleError herr;
faluco@505	239	HandleSecurity sec;
faluco@505	240	bf_write *pBitBuf;
faluco@505	241
faluco@505	242	sec.pOwner = NULL;
faluco@505	243	sec.pIdentity = g_pCoreIdent;
faluco@505	244
faluco@505	245	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	246	!= HandleError_None)
faluco@505	247	{
faluco@505	248	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	249	}
faluco@505	250
faluco@505	251	pBitBuf->WriteBitAngle(sp_ctof(params[2]), params[3]);
faluco@505	252
faluco@505	253	return 1;
faluco@505	254	}
faluco@505	255
faluco@505	256	static cell_t smn_BfWriteCoord(IPluginContext pCtx, const cell_t params)
faluco@505	257	{
faluco@505	258	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	259	HandleError herr;
faluco@505	260	HandleSecurity sec;
faluco@505	261	bf_write *pBitBuf;
faluco@505	262
faluco@505	263	sec.pOwner = NULL;
faluco@505	264	sec.pIdentity = g_pCoreIdent;
faluco@505	265
faluco@505	266	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	267	!= HandleError_None)
faluco@505	268	{
faluco@505	269	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	270	}
faluco@505	271
faluco@505	272	pBitBuf->WriteBitCoord(sp_ctof(params[2]));
faluco@505	273
faluco@505	274	return 1;
faluco@505	275	}
faluco@505	276
faluco@505	277	static cell_t smn_BfWriteVecCoord(IPluginContext pCtx, const cell_t params)
faluco@505	278	{
faluco@505	279	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	280	HandleError herr;
faluco@505	281	HandleSecurity sec;
faluco@505	282	bf_write *pBitBuf;
faluco@505	283
faluco@505	284	sec.pOwner = NULL;
faluco@505	285	sec.pIdentity = g_pCoreIdent;
faluco@505	286
faluco@505	287	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	288	!= HandleError_None)
faluco@505	289	{
faluco@505	290	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	291	}
faluco@505	292
faluco@505	293	cell_t *pVec;
faluco@505	294	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@505	295	Vector vec(sp_ctof(pVec[0]), sp_ctof(pVec[1]), sp_ctof(pVec[2]));
faluco@505	296	pBitBuf->WriteBitVec3Coord(vec);
faluco@505	297
faluco@505	298	return 1;
faluco@505	299	}
faluco@505	300
faluco@505	301	static cell_t smn_BfWriteVecNormal(IPluginContext pCtx, const cell_t params)
faluco@505	302	{
faluco@505	303	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	304	HandleError herr;
faluco@505	305	HandleSecurity sec;
faluco@505	306	bf_write *pBitBuf;
faluco@505	307
faluco@505	308	sec.pOwner = NULL;
faluco@505	309	sec.pIdentity = g_pCoreIdent;
faluco@505	310
faluco@505	311	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	312	!= HandleError_None)
faluco@505	313	{
faluco@505	314	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	315	}
faluco@505	316
faluco@505	317	cell_t *pVec;
faluco@505	318	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@505	319	Vector vec(sp_ctof(pVec[0]), sp_ctof(pVec[1]), sp_ctof(pVec[2]));
faluco@505	320	pBitBuf->WriteBitVec3Normal(vec);
faluco@505	321
faluco@505	322	return 1;
faluco@505	323	}
faluco@505	324
faluco@505	325	static cell_t smn_BfWriteAngles(IPluginContext pCtx, const cell_t params)
faluco@505	326	{
faluco@505	327	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@505	328	HandleError herr;
faluco@505	329	HandleSecurity sec;
faluco@505	330	bf_write *pBitBuf;
faluco@505	331
faluco@505	332	sec.pOwner = NULL;
faluco@505	333	sec.pIdentity = g_pCoreIdent;
faluco@505	334
faluco@505	335	if ((herr=g_HandleSys.ReadHandle(hndl, g_WrBitBufType, &sec, (void **)&pBitBuf))
faluco@505	336	!= HandleError_None)
faluco@505	337	{
faluco@505	338	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@505	339	}
faluco@505	340
faluco@505	341	cell_t *pAng;
faluco@505	342	pCtx->LocalToPhysAddr(params[2], &pAng);
faluco@505	343	QAngle ang(sp_ctof(pAng[0]), sp_ctof(pAng[1]), sp_ctof(pAng[2]));
faluco@505	344	pBitBuf->WriteBitAngles(ang);
faluco@505	345
faluco@505	346	return 1;
faluco@505	347	}
faluco@505	348
faluco@598	349	static cell_t smn_BfReadBool(IPluginContext pCtx, const cell_t params)
faluco@598	350	{
faluco@598	351	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	352	HandleError herr;
faluco@598	353	HandleSecurity sec;
faluco@598	354	bf_read *pBitBuf;
faluco@598	355
faluco@598	356	sec.pOwner = NULL;
faluco@598	357	sec.pIdentity = g_pCoreIdent;
faluco@598	358
faluco@598	359	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	360	!= HandleError_None)
faluco@598	361	{
faluco@598	362	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	363	}
faluco@598	364
faluco@598	365	return pBitBuf->ReadOneBit() ? 1 : 0;
faluco@598	366	}
faluco@598	367
faluco@598	368	static cell_t smn_BfReadByte(IPluginContext pCtx, const cell_t params)
faluco@598	369	{
faluco@598	370	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	371	HandleError herr;
faluco@598	372	HandleSecurity sec;
faluco@598	373	bf_read *pBitBuf;
faluco@598	374
faluco@598	375	sec.pOwner = NULL;
faluco@598	376	sec.pIdentity = g_pCoreIdent;
faluco@598	377
faluco@598	378	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	379	!= HandleError_None)
faluco@598	380	{
faluco@598	381	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	382	}
faluco@598	383
faluco@598	384	return pBitBuf->ReadByte();
faluco@598	385	}
faluco@598	386
faluco@598	387	static cell_t smn_BfReadChar(IPluginContext pCtx, const cell_t params)
faluco@598	388	{
faluco@598	389	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	390	HandleError herr;
faluco@598	391	HandleSecurity sec;
faluco@598	392	bf_read *pBitBuf;
faluco@598	393
faluco@598	394	sec.pOwner = NULL;
faluco@598	395	sec.pIdentity = g_pCoreIdent;
faluco@598	396
faluco@598	397	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	398	!= HandleError_None)
faluco@598	399	{
faluco@598	400	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	401	}
faluco@598	402
faluco@598	403	return pBitBuf->ReadChar();
faluco@598	404	}
faluco@598	405
faluco@598	406	static cell_t smn_BfReadShort(IPluginContext pCtx, const cell_t params)
faluco@598	407	{
faluco@598	408	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	409	HandleError herr;
faluco@598	410	HandleSecurity sec;
faluco@598	411	bf_read *pBitBuf;
faluco@598	412
faluco@598	413	sec.pOwner = NULL;
faluco@598	414	sec.pIdentity = g_pCoreIdent;
faluco@598	415
faluco@598	416	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	417	!= HandleError_None)
faluco@598	418	{
faluco@598	419	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	420	}
faluco@598	421
faluco@598	422	return pBitBuf->ReadShort();
faluco@598	423	}
faluco@598	424
faluco@598	425	static cell_t smn_BfReadWord(IPluginContext pCtx, const cell_t params)
faluco@598	426	{
faluco@598	427	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	428	HandleError herr;
faluco@598	429	HandleSecurity sec;
faluco@598	430	bf_read *pBitBuf;
faluco@598	431
faluco@598	432	sec.pOwner = NULL;
faluco@598	433	sec.pIdentity = g_pCoreIdent;
faluco@598	434
faluco@598	435	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	436	!= HandleError_None)
faluco@598	437	{
faluco@598	438	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	439	}
faluco@598	440
faluco@598	441	return pBitBuf->ReadWord();
faluco@598	442	}
faluco@598	443
faluco@598	444	static cell_t smn_BfReadNum(IPluginContext pCtx, const cell_t params)
faluco@598	445	{
faluco@598	446	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	447	HandleError herr;
faluco@598	448	HandleSecurity sec;
faluco@598	449	bf_read *pBitBuf;
faluco@598	450
faluco@598	451	sec.pOwner = NULL;
faluco@598	452	sec.pIdentity = g_pCoreIdent;
faluco@598	453
faluco@598	454	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	455	!= HandleError_None)
faluco@598	456	{
faluco@598	457	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	458	}
faluco@598	459
faluco@598	460	return static_cast<cell_t>(pBitBuf->ReadLong());
faluco@598	461	}
faluco@598	462
faluco@598	463	static cell_t smn_BfReadFloat(IPluginContext pCtx, const cell_t params)
faluco@598	464	{
faluco@598	465	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	466	HandleError herr;
faluco@598	467	HandleSecurity sec;
faluco@598	468	bf_read *pBitBuf;
faluco@598	469
faluco@598	470	sec.pOwner = NULL;
faluco@598	471	sec.pIdentity = g_pCoreIdent;
faluco@598	472
faluco@598	473	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	474	!= HandleError_None)
faluco@598	475	{
faluco@598	476	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	477	}
faluco@598	478
faluco@598	479	return sp_ftoc(pBitBuf->ReadFloat());
faluco@598	480	}
faluco@598	481
faluco@598	482	static cell_t smn_BfReadString(IPluginContext pCtx, const cell_t params)
faluco@598	483	{
faluco@598	484	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	485	HandleError herr;
faluco@598	486	HandleSecurity sec;
faluco@598	487	bf_read *pBitBuf;
faluco@598	488	char *buf;
faluco@598	489
faluco@598	490	sec.pOwner = NULL;
faluco@598	491	sec.pIdentity = g_pCoreIdent;
faluco@598	492
faluco@598	493	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	494	!= HandleError_None)
faluco@598	495	{
faluco@598	496	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	497	}
faluco@598	498
faluco@598	499	pCtx->LocalToPhysAddr(params[2], (cell_t **)&buf);
faluco@598	500	if (!pBitBuf->ReadString(buf, params[3], params[4] ? true : false))
faluco@598	501	{
faluco@598	502	return pCtx->ThrowNativeError("Destination string buffer is too short, try increasing its size");
faluco@598	503	}
faluco@598	504
faluco@598	505	return 1;
faluco@598	506	}
faluco@598	507
faluco@598	508	static cell_t smn_BfReadEntity(IPluginContext pCtx, const cell_t params)
faluco@598	509	{
faluco@598	510	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	511	HandleError herr;
faluco@598	512	HandleSecurity sec;
faluco@598	513	bf_read *pBitBuf;
faluco@598	514
faluco@598	515	sec.pOwner = NULL;
faluco@598	516	sec.pIdentity = g_pCoreIdent;
faluco@598	517
faluco@598	518	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	519	!= HandleError_None)
faluco@598	520	{
faluco@598	521	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	522	}
faluco@598	523
faluco@598	524	return pBitBuf->ReadShort();
faluco@598	525	}
faluco@598	526
faluco@598	527	static cell_t smn_BfReadAngle(IPluginContext pCtx, const cell_t params)
faluco@598	528	{
faluco@598	529	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	530	HandleError herr;
faluco@598	531	HandleSecurity sec;
faluco@598	532	bf_read *pBitBuf;
faluco@598	533
faluco@598	534	sec.pOwner = NULL;
faluco@598	535	sec.pIdentity = g_pCoreIdent;
faluco@598	536
faluco@598	537	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	538	!= HandleError_None)
faluco@598	539	{
faluco@598	540	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	541	}
faluco@598	542
faluco@598	543	return sp_ftoc(pBitBuf->ReadBitAngle(params[2]));
faluco@598	544	}
faluco@598	545
faluco@598	546	static cell_t smn_BfReadCoord(IPluginContext pCtx, const cell_t params)
faluco@598	547	{
faluco@598	548	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	549	HandleError herr;
faluco@598	550	HandleSecurity sec;
faluco@598	551	bf_read *pBitBuf;
faluco@598	552
faluco@598	553	sec.pOwner = NULL;
faluco@598	554	sec.pIdentity = g_pCoreIdent;
faluco@598	555
faluco@598	556	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	557	!= HandleError_None)
faluco@598	558	{
faluco@598	559	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	560	}
faluco@598	561
faluco@598	562	return sp_ftoc(pBitBuf->ReadBitCoord());
faluco@598	563	}
faluco@598	564
faluco@598	565	static cell_t smn_BfReadVecCoord(IPluginContext pCtx, const cell_t params)
faluco@598	566	{
faluco@598	567	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	568	HandleError herr;
faluco@598	569	HandleSecurity sec;
faluco@598	570	bf_read *pBitBuf;
faluco@598	571
faluco@598	572	sec.pOwner = NULL;
faluco@598	573	sec.pIdentity = g_pCoreIdent;
faluco@598	574
faluco@598	575	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	576	!= HandleError_None)
faluco@598	577	{
faluco@598	578	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	579	}
faluco@598	580
faluco@598	581	cell_t *pVec;
faluco@598	582	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@598	583
faluco@598	584	Vector vec;
faluco@598	585	pBitBuf->ReadBitVec3Coord(vec);
faluco@598	586
faluco@598	587	pVec[0] = sp_ftoc(vec.x);
faluco@598	588	pVec[1] = sp_ftoc(vec.y);
faluco@598	589	pVec[2] = sp_ftoc(vec.z);
faluco@598	590
faluco@598	591	return 1;
faluco@598	592	}
faluco@598	593
faluco@598	594	static cell_t smn_BfReadVecNormal(IPluginContext pCtx, const cell_t params)
faluco@598	595	{
faluco@598	596	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	597	HandleError herr;
faluco@598	598	HandleSecurity sec;
faluco@598	599	bf_read *pBitBuf;
faluco@598	600
faluco@598	601	sec.pOwner = NULL;
faluco@598	602	sec.pIdentity = g_pCoreIdent;
faluco@598	603
faluco@598	604	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	605	!= HandleError_None)
faluco@598	606	{
faluco@598	607	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	608	}
faluco@598	609
faluco@598	610	cell_t *pVec;
faluco@598	611	pCtx->LocalToPhysAddr(params[2], &pVec);
faluco@598	612
faluco@598	613	Vector vec;
faluco@598	614	pBitBuf->ReadBitVec3Normal(vec);
faluco@598	615
faluco@598	616	pVec[0] = sp_ftoc(vec.x);
faluco@598	617	pVec[1] = sp_ftoc(vec.y);
faluco@598	618	pVec[2] = sp_ftoc(vec.z);
faluco@598	619
faluco@598	620	return 1;
faluco@598	621	}
faluco@598	622
faluco@598	623	static cell_t smn_BfReadAngles(IPluginContext pCtx, const cell_t params)
faluco@598	624	{
faluco@598	625	Handle_t hndl = static_cast<Handle_t>(params[1]);
faluco@598	626	HandleError herr;
faluco@598	627	HandleSecurity sec;
faluco@598	628	bf_read *pBitBuf;
faluco@598	629
faluco@598	630	sec.pOwner = NULL;
faluco@598	631	sec.pIdentity = g_pCoreIdent;
faluco@598	632
faluco@598	633	if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
faluco@598	634	!= HandleError_None)
faluco@598	635	{
faluco@598	636	return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
faluco@598	637	}
faluco@598	638
faluco@598	639	cell_t *pAng;
faluco@598	640	pCtx->LocalToPhysAddr(params[2], &pAng);
faluco@598	641
faluco@598	642	QAngle ang;
faluco@598	643	pBitBuf->ReadBitAngles(ang);
faluco@598	644
faluco@598	645	pAng[0] = sp_ftoc(ang.x);
faluco@598	646	pAng[1] = sp_ftoc(ang.y);
faluco@598	647	pAng[2] = sp_ftoc(ang.z);
faluco@598	648
faluco@598	649	return 1;
faluco@598	650	}
faluco@598	651
faluco@598	652	REGISTER_NATIVES(bitbufnatives)
faluco@505	653	{
faluco@505	654	{"BfWriteBool", smn_BfWriteBool},
faluco@505	655	{"BfWriteByte", smn_BfWriteByte},
faluco@505	656	{"BfWriteChar", smn_BfWriteChar},
faluco@505	657	{"BfWriteShort", smn_BfWriteShort},
faluco@505	658	{"BfWriteWord", smn_BfWriteWord},
faluco@505	659	{"BfWriteNum", smn_BfWriteNum},
faluco@505	660	{"BfWriteFloat", smn_BfWriteFloat},
faluco@505	661	{"BfWriteString", smn_BfWriteString},
faluco@505	662	{"BfWriteEntity", smn_BfWriteEntity},
faluco@505	663	{"BfWriteAngle", smn_BfWriteAngle},
faluco@505	664	{"BfWriteCoord", smn_BfWriteCoord},
faluco@505	665	{"BfWriteVecCoord", smn_BfWriteVecCoord},
faluco@505	666	{"BfWriteVecNormal", smn_BfWriteVecNormal},
faluco@505	667	{"BfWriteAngles", smn_BfWriteAngles},
faluco@598	668	{"BfReadBool", smn_BfReadBool},
faluco@598	669	{"BfReadByte", smn_BfReadByte},
faluco@598	670	{"BfReadChar", smn_BfReadChar},
faluco@598	671	{"BfReadShort", smn_BfReadShort},
faluco@598	672	{"BfReadWord", smn_BfReadWord},
faluco@598	673	{"BfReadNum", smn_BfReadNum},
faluco@598	674	{"BfReadFloat", smn_BfReadFloat},
faluco@598	675	{"BfReadString", smn_BfReadString},
faluco@598	676	{"BfReadEntity", smn_BfReadEntity},
faluco@598	677	{"BfReadAngle", smn_BfReadAngle},
faluco@598	678	{"BfReadCoord", smn_BfReadCoord},
faluco@598	679	{"BfReadVecCoord", smn_BfReadVecCoord},
faluco@598	680	{"BfReadVecNormal", smn_BfReadVecNormal},
faluco@598	681	{"BfReadAngles", smn_BfReadAngles},
faluco@505	682	{NULL, NULL}
faluco@505	683	};

author	Michael McKoy <ferret99gt@gmail.com>
	Wed Aug 08 23:45:24 2007 +0000 (2007-08-08)
changeset 1284	ac293d8351a3
parent 1231	17badaf66ce4
child 1330	ab94316bb52b
permissions	-rw-r--r--