Exemplo n.º 1
0
//-------------------------------------------------------------------------------------
int ScriptVector3::py_nonzero(PyObject *self)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	// 点乘
	Vector3 v = sv->getVector();
	float val = v.x * v.x + v.y * v.y + v.z * v.z;
	return val > 0.f;
}
Exemplo n.º 2
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::py_inplace_divide(PyObject *self, PyObject *b)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	float f = float(PyFloat_AsDouble(b));
	v /= f;

	Py_INCREF(sv);
	return sv;
}
Exemplo n.º 3
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::seq_item(PyObject* self, Py_ssize_t index)
{
	if (index < 0 || VECTOR_SIZE <= index)
	{
		PyErr_SetString(PyExc_IndexError, "Vector3 index out of range");
		//PyErr_PrintEx(0);
		return NULL;
	}

	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	return PyFloat_FromDouble(sv->getVector()[static_cast<int>(index)]);
}
Exemplo n.º 4
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyDot(PyObject* self, PyObject* args)
{
	ScriptVector3* v = new ScriptVector3(0,0,0);

	PyObject* pyResult = v->__py_pySet((PyObject*)v, args);
	if(pyResult)
		Py_DECREF(pyResult);

	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	float result = KBEVec3Dot(const_cast<Vector3*>(&sv->getVector()), const_cast<Vector3*>(&v->getVector()));
	Py_DECREF(v);
	return PyFloat_FromDouble(result);
}
Exemplo n.º 5
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyScale(PyObject* self, PyObject* args)
{
	if(PyTuple_Size(args) == 1)
	{
		ScriptVector3* sv = static_cast<ScriptVector3*>(self);
		Vector3& v = sv->getVector();
		PyObject* pItem = PyTuple_GetItem(args, 0);
		return new ScriptVector3(v * float(PyFloat_AsDouble(pItem)));
	}

	PyErr_SetString(PyExc_TypeError, "Vector.scale expects a float argument");
	PyErr_PrintEx(0);
	return NULL;
}
Exemplo n.º 6
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyNormalise(PyObject* self, PyObject* args)
{
	if (PyTuple_Size(args) != 0)
	{
		PyErr_SetString(PyExc_TypeError, "Vector.normalise takes no arguments(nor does it brook any dissent :)");
		PyErr_PrintEx(0);
		return NULL;
	}

	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	KBEVec3Normalize(&v, &v);
	S_Return;
}
Exemplo n.º 7
0
//-------------------------------------------------------------------------------------
int ScriptVector3::seq_ass_item(PyObject* self, Py_ssize_t index, PyObject* value)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);

	if (index < 0 || VECTOR_SIZE <= index)
	{
		PyErr_SetString(PyExc_IndexError, "Vector assignment index out of range");
		PyErr_PrintEx(0);
		return -1;
	}

	Vector3& v = sv->getVector();
	v[static_cast<int>(index)] = float(PyFloat_AsDouble(value));
	return 0;
}
Exemplo n.º 8
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyCross2D(PyObject* self, PyObject* args)
{
	ScriptVector3* v = new ScriptVector3(0,0,0);
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);

	PyObject* pyResult = v->__py_pySet((PyObject*)v, args);
	if(pyResult)
		Py_DECREF(pyResult);

	const Vector3 otherV = v->getVector();
	const Vector3 thisV = sv->getVector();
	float result = thisV[0] * otherV[2] - thisV[2] * otherV[0];
	Py_DECREF(v);
	return PyFloat_FromDouble(result);
}
Exemplo n.º 9
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyFlatDistTo(PyObject* self, PyObject* args)
{
	if (PyTuple_Size(args) != 1)
	{
		PyErr_SetString(PyExc_TypeError, "args > 1 is error!\n");
		PyErr_PrintEx(0);
		S_Return;
	}
	
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	
	Vector3 v1;
	convertPyObjectToVector3(v1, PyTuple_GET_ITEM(args, 0));
	return PyFloat_FromDouble(KBEVec3CalcVec2Length(v, v1));
}
Exemplo n.º 10
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::py_inplace_subtract(PyObject *self, PyObject *b)
{
	if(!check(b))
	{
		PyErr_Clear();
		Py_INCREF(Py_NotImplemented);
		return Py_NotImplemented;
	}
	
	Vector3 bv;
	convertPyObjectToVector3(bv, b);
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	v -= bv;
	Py_INCREF(sv);
	return sv;
}
Exemplo n.º 11
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyList(PyObject* self, PyObject* args)
{
	if (PyTuple_Size(args) != 0)
	{
		PyErr_SetString(PyExc_TypeError, "Vector.tuple takes no arguments");
		PyErr_PrintEx(0);
		return NULL;
	}

	PyObject* pyList = PyList_New(VECTOR_SIZE);
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	
	for (int i=0; i < VECTOR_SIZE; ++i)
		PyList_SetItem(pyList, i, PyFloat_FromDouble(v[i]));

	return pyList;
}
Exemplo n.º 12
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyFlatDistSqrTo(PyObject* self, PyObject* args)
{
	if (PyTuple_Size(args) != 1)
	{
		PyErr_SetString(PyExc_TypeError, "args > 1 is error!\n");
		PyErr_PrintEx(0);
		S_Return;
	}
	
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	
	Vector3 v1;
	convertPyObjectToVector3(v1, PyTuple_GET_ITEM(args, 0));
	
	float x = v.x - v1.x;
	float z = v.z - v1.z;
	return PyFloat_FromDouble(x*x + z*z);
}
Exemplo n.º 13
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pySet(PyObject* self, PyObject* args)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	bool good = false;
	Vector3 v;

	// 如果参数只有1个元素
	int tupleSize = (int)PyTuple_Size(args);
	if(tupleSize == 1)
	{
		PyObject* pyItem = PyTuple_GetItem(args, 0);

		if(ScriptVector3::check(pyItem, false))
		{
			convertPyObjectToVector3(v, pyItem);
			good = true;
		}
		else
		{
			float f = float(PyFloat_AsDouble(pyItem));
			for (int i=0; i < VECTOR_SIZE; ++i)
			{
				v[i] = f;
			}
			good = true;
		}
	}
	else if(tupleSize >= VECTOR_SIZE)
	{
		convertPyObjectToVector3(v, args);
		good = true;
	}

	if(!good)
	{
		PyErr_Format(PyExc_TypeError, "Vector.set must be set to a tuple of %d floats, or one float", VECTOR_SIZE);
		PyErr_PrintEx(0);
		return NULL;
	}

	sv->setVector(v);
	S_Return;
}
Exemplo n.º 14
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__reduce_ex__(PyObject* self, PyObject* protocol)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	PyObject* args = PyTuple_New(2);
	PyObject* unpickleMethod = script::Pickler::getUnpickleFunc("Vector3");
	PyTuple_SET_ITEM(args, 0, unpickleMethod);
	PyObject* args1 = PyTuple_New(VECTOR_SIZE);
	PyTuple_SET_ITEM(args1, 0, PyFloat_FromDouble(v.x));
	PyTuple_SET_ITEM(args1, 1, PyFloat_FromDouble(v.y));
	PyTuple_SET_ITEM(args1, 2, PyFloat_FromDouble(v.z));
	PyTuple_SET_ITEM(args, 1, args1);
	
	if(unpickleMethod == NULL){
		Py_DECREF(args);
		return NULL;
	}
	return args;
}
Exemplo n.º 15
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::py_inplace_multiply(PyObject *self, PyObject *b)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	
	if (check(b, false))
	{
		Vector3 bv;
		convertPyObjectToVector3(bv, b);
	
		// 叉乘
		v.x = (v.y * bv.z) - (v.z * bv.y);
		v.y = (v.z * bv.x) - (v.x * bv.z);
		v.z = (v.x * bv.y) - (v.y * bv.x);
	}
	else
	{
		float f = float(PyFloat_AsDouble(b));
		v *= f;
	}

	Py_INCREF(sv);
	return sv;
}
Exemplo n.º 16
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::__py_pyDistSqrTo(PyObject* self, PyObject* args)
{
	if (PyTuple_Size(args) != 1)
	{
		PyErr_SetString(PyExc_TypeError, "args > 1 is error!\n");
		PyErr_PrintEx(0);
		S_Return;
	}
	
	PyObject* pyVal = PyTuple_GET_ITEM(args, 0);
	if(!check(pyVal))
	{
		S_Return;
	}

	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& v = sv->getVector();
	
	Vector3 v1;
	convertPyObjectToVector3(v1, pyVal);
	
	Vector3 rv = (v - v1);
	return PyFloat_FromDouble(KBEVec3LengthSq(&rv)); //计算点乘并返回
}
Exemplo n.º 17
0
//-------------------------------------------------------------------------------------
Py_ssize_t ScriptVector3::seq_length(PyObject* self)
{
	ScriptVector3* seq = static_cast<ScriptVector3*>(self);
	return seq->length();
}
Exemplo n.º 18
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::seq_slice(PyObject* self, Py_ssize_t startIndex, Py_ssize_t endIndex)
{
	if(startIndex < 0)
		startIndex = 0;

	if(endIndex > VECTOR_SIZE)
		endIndex = VECTOR_SIZE;

	if(endIndex < startIndex)
		endIndex = startIndex;

	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	Vector3& my_v = sv->getVector();
	PyObject* pyResult = NULL;

	int length = (int)(endIndex - startIndex);

	if (length == VECTOR_SIZE)
	{
		pyResult = sv;
		Py_INCREF(pyResult);
	}
	else
		switch(length)
		{
			case 0:
				pyResult = PyTuple_New(0);
				break;
			case 1:
				pyResult = PyTuple_New(1);
				PyTuple_SET_ITEM(pyResult, 0, PyFloat_FromDouble(sv->getVector()[static_cast<int>(startIndex)]));
				break;
			case 2:
			{
				Vector2 v;
				
				for (int i = (int)startIndex; i < (int)endIndex; ++i){
					v[i - static_cast<int>(startIndex)] = my_v[i];
				}

				pyResult = new ScriptVector2(v);
				break;
			}
			case 3:
			{
				Vector3 v;
				for (int i = (int)startIndex; i < (int)endIndex; ++i){
					v[i - static_cast<int>(startIndex)] = my_v[i];
				}

				pyResult = new ScriptVector3(v);
				break;
			}
			default:
				PyErr_Format(PyExc_IndexError, "Bad slice indexes [%d, %d] for Vector%d", startIndex, endIndex, VECTOR_SIZE);
				PyErr_PrintEx(0);
				break;
		}

	return pyResult;
}
Exemplo n.º 19
0
//-------------------------------------------------------------------------------------
PyObject* ScriptVector3::py_positive(PyObject *self)
{
	ScriptVector3* sv = static_cast<ScriptVector3*>(self);
	return new ScriptVector3(sv->getVector() * -1.f);
}