Assert Style

src/main.c

@@ -48,7 +48,8 @@ extern volatile unsigned char animate_index;
 static inline
 #endif
 
-void main_loop(void)
+	void
+	main_loop(void)
 {
 	quat_t q;
 
@@ -60,24 +61,24 @@ void main_loop(void)
 	{
 		static float angle = 0;
 
-		if( angle > M_PI/2 )
+		if (angle > M_PI / 2)
 		{
 			animate_index = 0;
 			angle = 0;
 
-			load_float_to_shader( shader, "angle", angle);
+			load_float_to_shader(shader, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
-			set_projection_mesh( projection );
+			set_projection_mesh(projection);
 		}
 
-		if( animate_index )
+		if (animate_index)
 		{
-			load_uint_to_shader( shader, "i", animate_index-1 );
+			load_uint_to_shader(shader, "i", animate_index - 1);
-			load_uint_to_shader( shader_plain, "i", animate_index-1 );
+			load_uint_to_shader(shader_plain, "i", animate_index - 1);
 
-			angle+=0.01;
+			angle += 0.01;
-			load_float_to_shader( shader, "angle", angle);
+			load_float_to_shader(shader, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
 		}
 	}
 	clean_context();

src/surface.c

@@ -66,10 +66,10 @@ void cube(float *d_surface, int *coord, int grid)
 	int i;
 
 	for (i = 0; i < parm.m; i++)
-		d_surface[i] = (2*(float)coord[i] / grid) - 1;
+		d_surface[i] = (2 * (float)coord[i] / grid) - 1;
 
-	if( parm.m == 2 )
+	if (parm.m == 2)
-		d_surface[2]=0;
+		d_surface[2] = 0;
 }
 
 void mobius(float *d_surface, int *coord, int grid)
@@ -207,26 +207,30 @@ static void __calculate_normal(
 		Calculate a normal vector of a plain using Gram-Schmidt process
 	*/
 	{
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
+		{
 			v1[i] = p2[i] - p1[i];
 			v2[i] = p3[i] - p1[i];
 			v3[i] = p1[i];
 		}
 
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
+		{
 			u1[i] = v1[i];
 		}
 
 		{
 			float proj[n];
 			float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				dot_v2_u1 += v2[i] * u1[i];
 				dot_u1_u1 += u1[i] * u1[i];
 			}
 			alpha = dot_v2_u1 / dot_u1_u1;
 
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				proj[i] = u1[i] * alpha;
 				u2[i] = v2[i] - proj[i];
 			}
@@ -237,31 +241,37 @@ static void __calculate_normal(
 			float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
 			float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
 
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				dot_v3_u1 += v3[i] * u1[i];
 				dot_u1_u1 += u1[i] * u1[i];
 			}
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
 			}
 
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				dot_v3_u2 += v3[i] * u2[i];
 				dot_u2_u2 += u2[i] * u2[i];
 			}
-            for (i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i)
+			{
 				proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
 				u3[i] = v3[i] - proj1[i] - proj2[i];
 			}
 		}
 
 		float magnitude = 0.0f;
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
+		{
 			magnitude += u3[i] * u3[i];
 		}
 		magnitude = sqrtf(magnitude);
 
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
+		{
 			normal[i] = u3[i] / magnitude;
 		}
 
@@ -275,20 +285,18 @@ static void __calculate_normal(
 	}
 }
 
-
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
 	n = malloc((*d + 1) * sizeof(float));
 	*n = *d;
 
-	float * norm_vec;
+	float *norm_vec;
-	norm_vec=malloc(m*sizeof(float));
+	norm_vec = malloc(m * sizeof(float));
 
 	for (int i = 0; i < *d; i += 3 * m)
 	{
 
-
 		__calculate_normal(
 			(d + 1) + i, (d + 1) + i + m, (d + 1) + i + 2 * m, norm_vec, m);
 		glm_vec3_copy(norm_vec, (n + 1) + i);