style cleanup - comment formatting

source/blender/python/mathutils/mathutils.c

@@ -257,7 +257,7 @@ int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
 }
 
 /*---------------------- EXPP_VectorsAreEqual -------------------------
-  Builds on EXPP_FloatsAreEqual to test vectors */
+ * Builds on EXPP_FloatsAreEqual to test vectors */
 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
 {
 	int x;

source/blender/python/mathutils/mathutils_Color.c

@@ -619,7 +619,7 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2)
 }
 
 /* -obj
-  returns the negative of this object */
+ * returns the negative of this object */
 static PyObject *Color_neg(ColorObject *self)
 {
 	float tcol[COLOR_SIZE];
@@ -848,10 +848,10 @@ PyTypeObject color_Type = {
 };
 //------------------------Color_CreatePyObject (internal)-------------
 //creates a new color object
-/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
- (i.e. it was allocated elsewhere by MEM_mallocN())
-  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
- (i.e. it must be created here with PyMEM_malloc())*/
+/* pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ *  (i.e. it was allocated elsewhere by MEM_mallocN())
+ *   pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ *  (i.e. it must be created here with PyMEM_malloc())*/
 PyObject *Color_CreatePyObject(float *col, int type, PyTypeObject *base_type)
 {
 	ColorObject *self;

source/blender/python/mathutils/mathutils_Color.h

@@ -42,10 +42,10 @@ typedef struct {
 	BASE_MATH_MEMBERS(col);
 } ColorObject;
 
-/*struct data contains a pointer to the actual data that the
-object uses. It can use either PyMem allocated data (which will
-be stored in py_data) or be a wrapper for data allocated through
-blender (stored in blend_data). This is an either/or struct not both*/
+/* struct data contains a pointer to the actual data that the
+ * object uses. It can use either PyMem allocated data (which will
+ * be stored in py_data) or be a wrapper for data allocated through
+ * blender (stored in blend_data). This is an either/or struct not both*/
 
 //prototypes
 PyObject *Color_CreatePyObject( float *col, int type, PyTypeObject *base_type);

source/blender/python/mathutils/mathutils_Euler.c

@@ -691,10 +691,10 @@ PyTypeObject euler_Type = {
 };
 //------------------------Euler_CreatePyObject (internal)-------------
 //creates a new euler object
-/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
- (i.e. it was allocated elsewhere by MEM_mallocN())
-  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
- (i.e. it must be created here with PyMEM_malloc())*/
+/* pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ * (i.e. it was allocated elsewhere by MEM_mallocN())
+ * pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ * (i.e. it must be created here with PyMEM_malloc())*/
 PyObject *Euler_CreatePyObject(float *eul, short order, int type, PyTypeObject *base_type)
 {
 	EulerObject *self;

source/blender/python/mathutils/mathutils_Euler.h

@@ -44,10 +44,10 @@ typedef struct {
 
 } EulerObject;
 
-/*struct data contains a pointer to the actual data that the
-object uses. It can use either PyMem allocated data (which will
-be stored in py_data) or be a wrapper for data allocated through
-blender (stored in blend_data). This is an either/or struct not both */
+/* struct data contains a pointer to the actual data that the
+ * object uses. It can use either PyMem allocated data (which will
+ * be stored in py_data) or be a wrapper for data allocated through
+ * blender (stored in blend_data). This is an either/or struct not both */
 
 //prototypes
 PyObject *Euler_CreatePyObject( float *eul, short order, int type, PyTypeObject *base_type);

source/blender/python/mathutils/mathutils_Matrix.c

@@ -1218,8 +1218,6 @@ static PyObject *Matrix_invert(MatrixObject *self)
 				z++;
 			}
 		}
-		/*transpose
-		Matrix_transpose(self);*/
 	}
 	else {
 		PyErr_SetString(PyExc_ValueError,
@@ -1631,15 +1629,15 @@ static PyObject *Matrix_richcmpr(PyObject *a, PyObject *b, int op)
 }
 
 /*---------------------SEQUENCE PROTOCOLS------------------------
-  ----------------------------len(object)------------------------
-  sequence length */
+ * ----------------------------len(object)------------------------
+ * sequence length */
 static int Matrix_len(MatrixObject *self)
 {
 	return (self->num_row);
 }
 /*----------------------------object[]---------------------------
-  sequence accessor (get)
-  the wrapped vector gives direct access to the matrix data */
+ * sequence accessor (get)
+ * the wrapped vector gives direct access to the matrix data */
 static PyObject *Matrix_item_row(MatrixObject *self, int row)
 {
 	if (BaseMath_ReadCallback(self) == -1)
@@ -1669,7 +1667,7 @@ static PyObject *Matrix_item_col(MatrixObject *self, int col)
 }
 
 /*----------------------------object[]-------------------------
-  sequence accessor (set) */
+ * sequence accessor (set) */
 
 static int Matrix_ass_item_row(MatrixObject *self, int row, PyObject *value)
 {
@@ -1724,7 +1722,7 @@ static int Matrix_ass_item_col(MatrixObject *self, int col, PyObject *value)
 
 
 /*----------------------------object[z:y]------------------------
-  sequence slice (get)*/
+ * sequence slice (get)*/
 static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
 {
 
@@ -1748,7 +1746,7 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
 	return tuple;
 }
 /*----------------------------object[z:y]------------------------
-  sequence slice (set)*/
+ * sequence slice (set)*/
 static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *value)
 {
 	PyObject *value_fast = NULL;
@@ -1807,7 +1805,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
 	}
 }
 /*------------------------NUMERIC PROTOCOLS----------------------
-  ------------------------obj + obj------------------------------*/
+ *------------------------obj + obj------------------------------*/
 static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
 {
 	float mat[16];
@@ -1839,7 +1837,7 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
 	return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_NEW, Py_TYPE(mat1));
 }
 /*------------------------obj - obj------------------------------
-  subtraction*/
+ * subtraction */
 static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
 {
 	float mat[16];
@@ -1872,7 +1870,7 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
 	return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_NEW, Py_TYPE(mat1));
 }
 /*------------------------obj * obj------------------------------
-  mulplication*/
+ * mulplication */
 static PyObject *matrix_mul_float(MatrixObject *mat, const float scalar)
 {
 	float tmat[16];

source/blender/python/mathutils/mathutils_Quaternion.c

@@ -854,7 +854,7 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
 }
 
 /* -obj
-  returns the negative of this object*/
+ * returns the negative of this object*/
 static PyObject *Quaternion_neg(QuaternionObject *self)
 {
 	float tquat[QUAT_SIZE];
@@ -1232,9 +1232,9 @@ PyTypeObject quaternion_Type = {
 //------------------------Quaternion_CreatePyObject (internal)-------------
 //creates a new quaternion object
 /*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
- (i.e. it was allocated elsewhere by MEM_mallocN())
-  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
- (i.e. it must be created here with PyMEM_malloc())*/
+ * (i.e. it was allocated elsewhere by MEM_mallocN())
+ *  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ * (i.e. it must be created here with PyMEM_malloc())*/
 PyObject *Quaternion_CreatePyObject(float *quat, int type, PyTypeObject *base_type)
 {
 	QuaternionObject *self;

source/blender/python/mathutils/mathutils_Quaternion.h

@@ -42,10 +42,10 @@ typedef struct {
 	BASE_MATH_MEMBERS(quat);
 } QuaternionObject;
 
-/*struct data contains a pointer to the actual data that the
-object uses. It can use either PyMem allocated data (which will
-be stored in py_data) or be a wrapper for data allocated through
-blender (stored in blend_data). This is an either/or struct not both*/
+/* struct data contains a pointer to the actual data that the
+ * object uses. It can use either PyMem allocated data (which will
+ * be stored in py_data) or be a wrapper for data allocated through
+ * blender (stored in blend_data). This is an either/or struct not both */
 
 //prototypes
 PyObject *Quaternion_CreatePyObject( float *quat, int type, PyTypeObject *base_type);

source/blender/python/mathutils/mathutils_Vector.c

@@ -40,8 +40,8 @@
 #define MAX_DIMENSIONS 4
 
 /* Swizzle axes get packed into a single value that is used as a closure. Each
-   axis uses SWIZZLE_BITS_PER_AXIS bits. The first bit (SWIZZLE_VALID_AXIS) is
-   used as a sentinel: if it is unset, the axis is not valid. */
+ * axis uses SWIZZLE_BITS_PER_AXIS bits. The first bit (SWIZZLE_VALID_AXIS) is
+ * used as a sentinel: if it is unset, the axis is not valid. */
 #define SWIZZLE_BITS_PER_AXIS 3
 #define SWIZZLE_VALID_AXIS 0x4
 #define SWIZZLE_AXIS       0x3
@@ -439,8 +439,6 @@ static PyObject *Vector_resized(VectorObject *self, PyObject *value)
 	int size;
 	float *vec;
 
-	/*if (!PyArg_ParseTuple(args, "i:resize", &size))
-		return NULL;*/
 	if ((size = PyLong_AsLong(value)) == -1) {
 		return NULL;
 	}
@@ -788,8 +786,8 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
 	}
 
 	/*
-		flip vector around, since vectoquat expect a vector from target to tracking object
-		and the python function expects the inverse (a vector to the target).
+	 * flip vector around, since vectoquat expect a vector from target to tracking object
+	 * and the python function expects the inverse (a vector to the target).
 	*/
 	negate_v3_v3(vec, self->vec);
 
@@ -1476,7 +1474,7 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
 }
 
 /*------------------------obj * obj------------------------------
-  mulplication*/
+ * mulplication*/
 
 
 /* COLUMN VECTOR Multiplication (Matrix X Vector)
@@ -1643,7 +1641,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
 		return NULL;
 
 	/* only support vec*=float and vec*=mat
-	   vec*=vec result is a float so that wont work */
+	 *  vec*=vec result is a float so that wont work */
 	if (MatrixObject_Check(v2)) {
 /* ------ to be removed ------*/
 #if 1
@@ -1785,7 +1783,7 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
 }
 
 /* -obj
-  returns the negative of this object*/
+ * returns the negative of this object*/
 static PyObject *Vector_neg(VectorObject *self)
 {
 	float *tvec;
@@ -1801,16 +1799,16 @@ static PyObject *Vector_neg(VectorObject *self)
 /*------------------------vec_magnitude_nosqrt (internal) - for comparing only */
 static double vec_magnitude_nosqrt(float *data, int size)
 {
-	/*return (double)sqrt(dot);*/
+	/* return (double)sqrt(dot);*/
 	/* warning, line above removed because we are not using the length,
-	   rather the comparing the sizes and for this we do not need the sqrt
-	   for the actual length, the dot must be sqrt'd */
+	 * rather the comparing the sizes and for this we do not need the sqrt
+	 * for the actual length, the dot must be sqrt'd */
 	return dot_vn_vn(data, data, size);
 }
 
 
 /*------------------------tp_richcmpr
-  returns -1 execption, 0 false, 1 true */
+ * returns -1 execption, 0 false, 1 true */
 static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
 {
 	VectorObject *vecA = NULL, *vecB = NULL;
@@ -2147,7 +2145,7 @@ static PyObject *Vector_swizzle_get(VectorObject *self, void *closure)
  * - If the value is scalar, it is copied to all axes listed in the swizzle.
  * - If an axis appears more than once in the swizzle, the final occurrence is
  *   the one that determines its value.
-
+ *
  * Returns 0 on success and -1 on failure. On failure, the vector will be
  * unchanged. */
 static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure)
@@ -2719,9 +2717,9 @@ static struct PyMethodDef Vector_methods[] = {
 
 
 /* Note
- Py_TPFLAGS_CHECKTYPES allows us to avoid casting all types to Vector when coercing
- but this means for eg that
- vec*mat and mat*vec both get sent to Vector_mul and it neesd to sort out the order
+ * Py_TPFLAGS_CHECKTYPES allows us to avoid casting all types to Vector when coercing
+ * but this means for eg that
+ * (vec * mat) and (mat * vec) both get sent to Vector_mul and it neesd to sort out the order
 */
 
 PyDoc_STRVAR(vector_doc,
@@ -2809,11 +2807,11 @@ PyTypeObject vector_Type = {
 };
 
 /*------------------------Vector_CreatePyObject (internal)-------------
-  creates a new vector object
-  pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
- (i.e. it was allocated elsewhere by MEM_mallocN())
-  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
- (i.e. it must be created here with PyMEM_malloc())*/
+ * creates a new vector object
+ * pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ * (i.e. it was allocated elsewhere by MEM_mallocN())
+ *  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ * (i.e. it must be created here with PyMEM_malloc())*/
 PyObject *Vector_CreatePyObject(float *vec, const int size, const int type, PyTypeObject *base_type)
 {
 	VectorObject *self;

source/blender/python/mathutils/mathutils_geometry.c

@@ -1120,7 +1120,7 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
 		filldisplist(&dispbase, &dispbase, 0);
 
 		/* The faces are stored in a new DisplayList
-		thats added to the head of the listbase */
+		 * thats added to the head of the listbase */
 		dl = dispbase.first;
 
 		tri_list = PyList_New(dl->parts);

source/blender/python/mathutils/mathutils_noise.c

@@ -64,50 +64,50 @@
 /*-----------------------------------------*/
 /* 'mersenne twister' random number generator */
 
-/* 
-   A C-program for MT19937, with initialization improved 2002/2/10.
-   Coded by Takuji Nishimura and Makoto Matsumoto.
-   This is a faster version by taking Shawn Cokus's optimization,
-   Matthe Bellew's simplification, Isaku Wada's real version.
-
-   Before using, initialize the state by using init_genrand(seed) 
-   or init_by_array(init_key, key_length).
-
-   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-   All rights reserved.                          
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-     1. Redistributions of source code must retain the above copyright
-        notice, this list of conditions and the following disclaimer.
-
-     2. Redistributions in binary form must reproduce the above copyright
-        notice, this list of conditions and the following disclaimer in the
-        documentation and/or other materials provided with the distribution.
-
-     3. The names of its contributors may not be used to endorse or promote 
-        products derived from this software without specific prior written 
-        permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-   Any feedback is very welcome.
-   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
-   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
-*/
+/*
+ * A C-program for MT19937, with initialization improved 2002/2/10.
+ * Coded by Takuji Nishimura and Makoto Matsumoto.
+ * This is a faster version by taking Shawn Cokus's optimization,
+ * Matthe Bellew's simplification, Isaku Wada's real version.
+ *
+ * Before using, initialize the state by using init_genrand(seed) 
+ * or init_by_array(init_key, key_length).
+ *
+ * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ * All rights reserved.                          
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *
+ *   3. The names of its contributors may not be used to endorse or promote 
+ *      products derived from this software without specific prior written 
+ *      permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Any feedback is very welcome.
+ * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ * email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+ */
 
 /* Period parameters */
 #define N 624
@@ -237,7 +237,7 @@ static float turb(float x, float y, float z, int oct, int hard, int nb,
 }
 
 /* Fills an array of length 3 with the turbulence vector for a given
-position (x, y, z) */
+ * position (x, y, z) */
 static void vTurb(float x, float y, float z, int oct, int hard, int nb,
                   float ampscale, float freqscale, float v[3])
 {
@@ -321,7 +321,7 @@ static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *ar
 	return Vector_CreatePyObject(vec, size, Py_NEW, NULL);
 }
 /* This is dumb, most people will want a unit vector anyway, since this doesn't have uniform distribution over a sphere*/
-/*
+#if 0
 PyDoc_STRVAR(M_Noise_random_vector_doc,
 ".. function:: random_vector(size=3)\n"
 "\n"
@@ -349,7 +349,7 @@ static PyObject *M_Noise_random_vector(PyObject *UNUSED(self), PyObject *args)
 
 	return Vector_CreatePyObject(vec, size, Py_NEW, NULL);
 }
-*/
+#endif
 
 PyDoc_STRVAR(M_Noise_seed_set_doc,
 ".. function:: seed_set(seed)\n"