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

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

author	David Anderson <dvander@alliedmods.net>
	Mon Mar 12 00:07:54 2007 +0000 (2007-03-12)
changeset 600	f6d811158ad3
parent 598	991d7e247a2c
child 1231	17badaf66ce4
permissions	-rw-r--r--