Cleanup

src/core/json/json.cpp

@@ -51,10 +51,10 @@ namespace json
 
 		switch (*json)
 		{
-			case '"': json = skip_string(json); break;
-			case '[': json = skip_block(json, '[', ']'); break;
-			case '{': json = skip_block(json, '{', '}'); break;
-			default: for (; *json != ',' && *json != '}' && *json != ']'; ++json) ; break;
+		case '"': json = skip_string(json); break;
+		case '[': json = skip_block(json, '[', ']'); break;
+		case '{': json = skip_block(json, '{', '}'); break;
+		default: for (; *json != ',' && *json != '}' && *json != ']'; ++json) ; break;
 		}
 
 		return json;
@@ -66,11 +66,11 @@ namespace json
 
 		switch (*json)
 		{
-			case '"': return JsonValueType::STRING;
-			case '{': return JsonValueType::OBJECT;
-			case '[': return JsonValueType::ARRAY;
-			case '-': return JsonValueType::NUMBER;
-			default: return (isdigit(*json)) ? JsonValueType::NUMBER : (*json == 'n' ? JsonValueType::NIL : JsonValueType::BOOL);
+		case '"': return JsonValueType::STRING;
+		case '{': return JsonValueType::OBJECT;
+		case '[': return JsonValueType::ARRAY;
+		case '-': return JsonValueType::NUMBER;
+		default: return (isdigit(*json)) ? JsonValueType::NUMBER : (*json == 'n' ? JsonValueType::NIL : JsonValueType::BOOL);
 		}
 	}
 
@@ -94,21 +94,21 @@ namespace json
 
 					switch (*json)
 					{
-						case '"': string += '"'; break;
-						case '\\': string += '\\'; break;
-						case '/': string += '/'; break;
-						case 'b': string += '\b'; break;
-						case 'f': string += '\f'; break;
-						case 'n': string += '\n'; break;
-						case 'r': string += '\r'; break;
-						case 't': string += '\t'; break;
-						default:
-						{
-							CE_FATAL("Bad escape character");
-							break;
-						}
+					case '"': string += '"'; break;
+					case '\\': string += '\\'; break;
+					case '/': string += '/'; break;
+					case 'b': string += '\b'; break;
+					case 'f': string += '\f'; break;
+					case 'n': string += '\n'; break;
+					case 'r': string += '\r'; break;
+					case 't': string += '\t'; break;
+					default:
+					{
+						CE_FATAL("Bad escape character");
+						break;
 					}
 				}
+				}
 				else
 				{
 					string += *json;
@@ -178,28 +178,24 @@ namespace json
 
 		switch (*json)
 		{
-			case 't':
-			{
-				json = next(json, 't');
-				json = next(json, 'r');
-				json = next(json, 'u');
-				json = next(json, 'e');
-				return true;
-			}
-			case 'f':
-			{
-				json = next(json, 'f');
-				json = next(json, 'a');
-				json = next(json, 'l');
-				json = next(json, 's');
-				json = next(json, 'e');
-				return false;
-			}
-			default:
-			{
-				CE_FATAL("Bad boolean");
-				return false;
-			}
+		case 't':
+			json = next(json, 't');
+			json = next(json, 'r');
+			json = next(json, 'u');
+			json = next(json, 'e');
+			return true;
+
+		case 'f':
+			json = next(json, 'f');
+			json = next(json, 'a');
+			json = next(json, 'l');
+			json = next(json, 's');
+			json = next(json, 'e');
+			return false;
+
+		default:
+			CE_FATAL("Bad boolean");
+			return false;
 		}
 	}
 

src/core/json/sjson.cpp

@@ -52,10 +52,10 @@ namespace sjson
 
 		switch (*json)
 		{
-			case '"': json = skip_string(json); break;
-			case '[': json = skip_block(json, '[', ']'); break;
-			case '{': json = skip_block(json, '{', '}'); break;
-			default: for (; *json != '\0' && *json != ',' && *json != '\n' && *json != ' ' && *json != '}' && *json != ']'; ++json) ; break;
+		case '"': json = skip_string(json); break;
+		case '[': json = skip_block(json, '[', ']'); break;
+		case '{': json = skip_block(json, '{', '}'); break;
+		default: for (; *json != '\0' && *json != ',' && *json != '\n' && *json != ' ' && *json != '}' && *json != ']'; ++json) ; break;
 		}
 
 		return json;
@@ -109,11 +109,11 @@ namespace sjson
 
 		switch (*json)
 		{
-			case '"': return JsonValueType::STRING;
-			case '{': return JsonValueType::OBJECT;
-			case '[': return JsonValueType::ARRAY;
-			case '-': return JsonValueType::NUMBER;
-			default: return (isdigit(*json)) ? JsonValueType::NUMBER : (*json == 'n' ? JsonValueType::NIL : JsonValueType::BOOL);
+		case '"': return JsonValueType::STRING;
+		case '{': return JsonValueType::OBJECT;
+		case '[': return JsonValueType::ARRAY;
+		case '-': return JsonValueType::NUMBER;
+		default: return (isdigit(*json)) ? JsonValueType::NUMBER : (*json == 'n' ? JsonValueType::NIL : JsonValueType::BOOL);
 		}
 	}
 
@@ -137,19 +137,15 @@ namespace sjson
 
 					switch (*json)
 					{
-						case '"': string += '"'; break;
-						case '\\': string += '\\'; break;
-						case '/': string += '/'; break;
-						case 'b': string += '\b'; break;
-						case 'f': string += '\f'; break;
-						case 'n': string += '\n'; break;
-						case 'r': string += '\r'; break;
-						case 't': string += '\t'; break;
-						default:
-						{
-							CE_FATAL("Bad escape character");
-							break;
-						}
+					case '"': string += '"'; break;
+					case '\\': string += '\\'; break;
+					case '/': string += '/'; break;
+					case 'b': string += '\b'; break;
+					case 'f': string += '\f'; break;
+					case 'n': string += '\n'; break;
+					case 'r': string += '\r'; break;
+					case 't': string += '\t'; break;
+					default: CE_FATAL("Bad escape character"); break;
 					}
 				}
 				else
@@ -242,28 +238,24 @@ namespace sjson
 
 		switch (*json)
 		{
-			case 't':
-			{
-				json = next(json, 't');
-				json = next(json, 'r');
-				json = next(json, 'u');
-				json = next(json, 'e');
-				return true;
-			}
-			case 'f':
-			{
-				json = next(json, 'f');
-				json = next(json, 'a');
-				json = next(json, 'l');
-				json = next(json, 's');
-				json = next(json, 'e');
-				return false;
-			}
-			default:
-			{
-				CE_FATAL("Bad boolean");
-				return false;
-			}
+		case 't':
+			json = next(json, 't');
+			json = next(json, 'r');
+			json = next(json, 'u');
+			json = next(json, 'e');
+			return true;
+
+		case 'f':
+			json = next(json, 'f');
+			json = next(json, 'a');
+			json = next(json, 'l');
+			json = next(json, 's');
+			json = next(json, 'e');
+			return false;
+
+		default:
+			CE_FATAL("Bad boolean");
+			return false;
 		}
 	}
 

src/core/math/aabb.h

@@ -99,15 +99,15 @@ namespace aabb
 
 		switch (index)
 		{
-			case 0: return vector3(b.min.x, b.min.y, b.min.z);
-			case 1: return vector3(b.max.x, b.min.y, b.min.z);
-			case 2: return vector3(b.max.x, b.min.y, b.max.z);
-			case 3: return vector3(b.min.x, b.min.y, b.max.z);
-			case 4: return vector3(b.min.x, b.max.y, b.min.z);
-			case 5: return vector3(b.max.x, b.max.y, b.min.z);
-			case 6: return vector3(b.max.x, b.max.y, b.max.z);
-			case 7: return vector3(b.min.x, b.max.y, b.max.z);
-			default: return VECTOR3_ZERO;
+		case 0: return vector3(b.min.x, b.min.y, b.min.z);
+		case 1: return vector3(b.max.x, b.min.y, b.min.z);
+		case 2: return vector3(b.max.x, b.min.y, b.max.z);
+		case 3: return vector3(b.min.x, b.min.y, b.max.z);
+		case 4: return vector3(b.min.x, b.max.y, b.min.z);
+		case 5: return vector3(b.max.x, b.max.y, b.min.z);
+		case 6: return vector3(b.max.x, b.max.y, b.max.z);
+		case 7: return vector3(b.min.x, b.max.y, b.max.z);
+		default: return VECTOR3_ZERO;
 		}
 	}
 

src/core/math/frustum.h

@@ -111,15 +111,15 @@ namespace frustum
 
 		switch (index)
 		{
-			case 0: plane_3_intersection(side[4], side[0], side[2], ip); break;
-			case 1: plane_3_intersection(side[4], side[1], side[2], ip); break;
-			case 2: plane_3_intersection(side[4], side[1], side[3], ip); break;
-			case 3: plane_3_intersection(side[4], side[0], side[3], ip); break;
-			case 4: plane_3_intersection(side[5], side[0], side[2], ip); break;
-			case 5: plane_3_intersection(side[5], side[1], side[2], ip); break;
-			case 6: plane_3_intersection(side[5], side[1], side[3], ip); break;
-			case 7: plane_3_intersection(side[5], side[0], side[3], ip); break;
-			default: break;
+		case 0: plane_3_intersection(side[4], side[0], side[2], ip); break;
+		case 1: plane_3_intersection(side[4], side[1], side[2], ip); break;
+		case 2: plane_3_intersection(side[4], side[1], side[3], ip); break;
+		case 3: plane_3_intersection(side[4], side[0], side[3], ip); break;
+		case 4: plane_3_intersection(side[5], side[0], side[2], ip); break;
+		case 5: plane_3_intersection(side[5], side[1], side[2], ip); break;
+		case 6: plane_3_intersection(side[5], side[1], side[3], ip); break;
+		case 7: plane_3_intersection(side[5], side[0], side[3], ip); break;
+		default: break;
 		}
 
 		return ip;

src/core/math/quaternion.cpp

@@ -43,43 +43,37 @@ Quaternion quaternion(const Matrix3x3& m)
 	Quaternion tmp;
 	switch (index)
 	{
-		case 0:
-		{
-			tmp.w = biggest;
-			tmp.x = (m.y.z - m.z.y) * mult;
-			tmp.y = (m.z.x - m.x.z) * mult;
-			tmp.z = (m.x.y - m.y.x) * mult;
-			break;
-		}
-		case 1:
-		{
-			tmp.x = biggest;
-			tmp.w = (m.y.z - m.z.y) * mult;
-			tmp.y = (m.x.y + m.y.x) * mult;
-			tmp.z = (m.z.x + m.x.z) * mult;
-			break;
-		}
-		case 2:
-		{
-			tmp.y = biggest;
-			tmp.w = (m.z.x - m.x.z) * mult;
-			tmp.x = (m.x.y + m.y.x) * mult;
-			tmp.z = (m.y.z + m.z.y) * mult;
-			break;
-		}
-		case 3:
-		{
-			tmp.z = biggest;
-			tmp.w = (m.x.y - m.y.x) * mult;
-			tmp.x = (m.z.x + m.x.z) * mult;
-			tmp.y = (m.y.z + m.z.y) * mult;
-			break;
-		}
-		default:
-		{
-			CE_FATAL("You should not be here");
-			break;
-		}
+	case 0:
+		tmp.w = biggest;
+		tmp.x = (m.y.z - m.z.y) * mult;
+		tmp.y = (m.z.x - m.x.z) * mult;
+		tmp.z = (m.x.y - m.y.x) * mult;
+		break;
+
+	case 1:
+		tmp.x = biggest;
+		tmp.w = (m.y.z - m.z.y) * mult;
+		tmp.y = (m.x.y + m.y.x) * mult;
+		tmp.z = (m.z.x + m.x.z) * mult;
+		break;
+
+	case 2:
+		tmp.y = biggest;
+		tmp.w = (m.z.x - m.x.z) * mult;
+		tmp.x = (m.x.y + m.y.x) * mult;
+		tmp.z = (m.y.z + m.z.y) * mult;
+		break;
+
+	case 3:
+		tmp.z = biggest;
+		tmp.w = (m.x.y - m.y.x) * mult;
+		tmp.x = (m.z.x + m.x.z) * mult;
+		tmp.y = (m.y.z + m.z.y) * mult;
+		break;
+
+	default:
+		CE_FATAL("Fatal");
+		break;
 	}
 
 	normalize(tmp);

src/device/device.cpp

@@ -188,99 +188,104 @@ bool Device::process_events(s16& mouse_x, s16& mouse_y, s16& mouse_last_x, s16&
 
 		switch (event.type)
 		{
-			case OsEvent::TOUCH:
+		case OsEvent::TOUCH:
 			{
 				const OsTouchEvent& ev = event.touch;
 				switch (ev.type)
 				{
-					case OsTouchEvent::POINTER:
-						im->touch()->set_button_state(ev.pointer_id, ev.pressed);
-						break;
-					case OsTouchEvent::MOVE:
-						im->touch()->set_axis(ev.pointer_id, vector3(ev.x, ev.y, 0.0f));
-						break;
-					default:
-						CE_FATAL("Unknown touch event type");
-						break;
+				case OsTouchEvent::POINTER:
+					im->touch()->set_button_state(ev.pointer_id, ev.pressed);
+					break;
+
+				case OsTouchEvent::MOVE:
+					im->touch()->set_axis(ev.pointer_id, vector3(ev.x, ev.y, 0.0f));
+					break;
+
+				default:
+					CE_FATAL("Unknown touch event type");
+					break;
 				}
-				break;
 			}
-			case OsEvent::MOUSE:
+			break;
+
+		case OsEvent::MOUSE:
 			{
 				const OsMouseEvent& ev = event.mouse;
 				switch (ev.type)
 				{
-					case OsMouseEvent::BUTTON:
-						im->mouse()->set_button_state(ev.button, ev.pressed);
-						break;
-					case OsMouseEvent::MOVE:
-						mouse_x = ev.x;
-						mouse_y = ev.y;
-						im->mouse()->set_axis(MouseAxis::CURSOR, vector3(ev.x, ev.y, 0.0f));
-						break;
-					case OsMouseEvent::WHEEL:
-						im->mouse()->set_axis(MouseAxis::WHEEL, vector3(0.0f, ev.wheel, 0.0f));
-						break;
-					default:
-						CE_FATAL("Unknown mouse event type");
-						break;
+				case OsMouseEvent::BUTTON:
+					im->mouse()->set_button_state(ev.button, ev.pressed);
+					break;
+
+				case OsMouseEvent::MOVE:
+					mouse_x = ev.x;
+					mouse_y = ev.y;
+					im->mouse()->set_axis(MouseAxis::CURSOR, vector3(ev.x, ev.y, 0.0f));
+					break;
+
+				case OsMouseEvent::WHEEL:
+					im->mouse()->set_axis(MouseAxis::WHEEL, vector3(0.0f, ev.wheel, 0.0f));
+					break;
+
+				default:
+					CE_FATAL("Unknown mouse event type");
+					break;
 				}
-				break;
 			}
-			case OsEvent::KEYBOARD:
-			{
-				const OsKeyboardEvent& ev = event.keyboard;
-				im->keyboard()->set_button_state(ev.button, ev.pressed);
-				break;
-			}
-			case OsEvent::JOYPAD:
+			break;
+
+		case OsEvent::KEYBOARD:
+			im->keyboard()->set_button_state(event.keyboard.button, event.keyboard.pressed);
+			break;
+
+		case OsEvent::JOYPAD:
 			{
 				const OsJoypadEvent& ev = event.joypad;
 				switch (ev.type)
 				{
-					case OsJoypadEvent::CONNECTED:
-						im->joypad(ev.index)->set_connected(ev.connected);
-						break;
-					case OsJoypadEvent::BUTTON:
-						im->joypad(ev.index)->set_button_state(ev.button, ev.pressed);
-						break;
-					case OsJoypadEvent::AXIS:
-						im->joypad(ev.index)->set_axis(ev.button, vector3(ev.x, ev.y, ev.z));
-						break;
-					default:
-						CE_FATAL("Unknown joypad event");
-						break;
+				case OsJoypadEvent::CONNECTED:
+					im->joypad(ev.index)->set_connected(ev.connected);
+					break;
+
+				case OsJoypadEvent::BUTTON:
+					im->joypad(ev.index)->set_button_state(ev.button, ev.pressed);
+					break;
+
+				case OsJoypadEvent::AXIS:
+					im->joypad(ev.index)->set_axis(ev.button, vector3(ev.x, ev.y, ev.z));
+					break;
+
+				default:
+					CE_FATAL("Unknown joypad event");
+					break;
 				}
-				break;
 			}
-			case OsEvent::METRICS:
+			break;
+
+		case OsEvent::METRICS:
 			{
 				const OsMetricsEvent& ev = event.metrics;
 				_width = ev.width;
 				_height = ev.height;
 				bgfx::reset(ev.width, ev.height, (vsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE));
-				break;
-			}
-			case OsEvent::EXIT:
-			{
-				exit = true;
-				break;
-			}
-			case OsEvent::PAUSE:
-			{
-				pause();
-				break;
-			}
-			case OsEvent::RESUME:
-			{
-				unpause();
-				break;
-			}
-			default:
-			{
-				CE_FATAL("Unknown Os Event");
-				break;
 			}
+			break;
+
+		case OsEvent::EXIT:
+			exit = true;
+			break;
+
+		case OsEvent::PAUSE:
+			pause();
+			break;
+
+		case OsEvent::RESUME:
+			unpause();
+			break;
+
+		default:
+			CE_FATAL("Unknown os event");
+			break;
 		}
 	}
 

src/device/main_linux.cpp

@@ -31,106 +31,106 @@ static KeyboardButton::Enum x11_translate_key(KeySym x11_key)
 {
 	switch (x11_key)
 	{
-		case XK_BackSpace:    return KeyboardButton::BACKSPACE;
-		case XK_Tab:          return KeyboardButton::TAB;
-		case XK_space:        return KeyboardButton::SPACE;
-		case XK_Escape:       return KeyboardButton::ESCAPE;
-		case XK_Return:       return KeyboardButton::ENTER;
-		case XK_F1:           return KeyboardButton::F1;
-		case XK_F2:           return KeyboardButton::F2;
-		case XK_F3:           return KeyboardButton::F3;
-		case XK_F4:           return KeyboardButton::F4;
-		case XK_F5:           return KeyboardButton::F5;
-		case XK_F6:           return KeyboardButton::F6;
-		case XK_F7:           return KeyboardButton::F7;
-		case XK_F8:           return KeyboardButton::F8;
-		case XK_F9:           return KeyboardButton::F9;
-		case XK_F10:          return KeyboardButton::F10;
-		case XK_F11:          return KeyboardButton::F11;
-		case XK_F12:          return KeyboardButton::F12;
-		case XK_Home:         return KeyboardButton::HOME;
-		case XK_Left:         return KeyboardButton::LEFT;
-		case XK_Up:           return KeyboardButton::UP;
-		case XK_Right:        return KeyboardButton::RIGHT;
-		case XK_Down:         return KeyboardButton::DOWN;
-		case XK_Page_Up:      return KeyboardButton::PAGE_UP;
-		case XK_Page_Down:    return KeyboardButton::PAGE_DOWN;
-		case XK_Insert:       return KeyboardButton::INSERT;
-		case XK_Delete:       return KeyboardButton::DELETE;
-		case XK_End:          return KeyboardButton::END;
-		case XK_Shift_L:      return KeyboardButton::LEFT_SHIFT;
-		case XK_Shift_R:      return KeyboardButton::RIGHT_SHIFT;
-		case XK_Control_L:    return KeyboardButton::LEFT_CTRL;
-		case XK_Control_R:    return KeyboardButton::RIGHT_CTRL;
-		case XK_Caps_Lock:    return KeyboardButton::CAPS_LOCK;
-		case XK_Alt_L:        return KeyboardButton::LEFT_ALT;
-		case XK_Alt_R:        return KeyboardButton::RIGHT_ALT;
-		case XK_Super_L:      return KeyboardButton::LEFT_SUPER;
-		case XK_Super_R:      return KeyboardButton::RIGHT_SUPER;
-		case XK_Num_Lock:     return KeyboardButton::NUM_LOCK;
-		case XK_KP_Enter:     return KeyboardButton::NUMPAD_ENTER;
-		case XK_KP_Delete:    return KeyboardButton::NUMPAD_DELETE;
-		case XK_KP_Multiply:  return KeyboardButton::NUMPAD_MULTIPLY;
-		case XK_KP_Add:       return KeyboardButton::NUMPAD_ADD;
-		case XK_KP_Subtract:  return KeyboardButton::NUMPAD_SUBTRACT;
-		case XK_KP_Divide:    return KeyboardButton::NUMPAD_DIVIDE;
-		case XK_KP_Insert:
-		case XK_KP_0:         return KeyboardButton::NUMPAD_0;
-		case XK_KP_End:
-		case XK_KP_1:         return KeyboardButton::NUMPAD_1;
-		case XK_KP_Down:
-		case XK_KP_2:         return KeyboardButton::NUMPAD_2;
-		case XK_KP_Page_Down: // or XK_KP_Next
-		case XK_KP_3:         return KeyboardButton::NUMPAD_3;
-		case XK_KP_Left:
-		case XK_KP_4:         return KeyboardButton::NUMPAD_4;
-		case XK_KP_Begin:
-		case XK_KP_5:         return KeyboardButton::NUMPAD_5;
-		case XK_KP_Right:
-		case XK_KP_6:         return KeyboardButton::NUMPAD_6;
-		case XK_KP_Home:
-		case XK_KP_7:         return KeyboardButton::NUMPAD_7;
-		case XK_KP_Up:
-		case XK_KP_8:         return KeyboardButton::NUMPAD_8;
-		case XK_KP_Page_Up:   // or XK_KP_Prior
-		case XK_KP_9:         return KeyboardButton::NUMPAD_9;
-		case '0':             return KeyboardButton::NUMBER_0;
-		case '1':             return KeyboardButton::NUMBER_1;
-		case '2':             return KeyboardButton::NUMBER_2;
-		case '3':             return KeyboardButton::NUMBER_3;
-		case '4':             return KeyboardButton::NUMBER_4;
-		case '5':             return KeyboardButton::NUMBER_5;
-		case '6':             return KeyboardButton::NUMBER_6;
-		case '7':             return KeyboardButton::NUMBER_7;
-		case '8':             return KeyboardButton::NUMBER_8;
-		case '9':             return KeyboardButton::NUMBER_9;
-		case 'a':             return KeyboardButton::A;
-		case 'b':             return KeyboardButton::B;
-		case 'c':             return KeyboardButton::C;
-		case 'd':             return KeyboardButton::D;
-		case 'e':             return KeyboardButton::E;
-		case 'f':             return KeyboardButton::F;
-		case 'g':             return KeyboardButton::G;
-		case 'h':             return KeyboardButton::H;
-		case 'i':             return KeyboardButton::I;
-		case 'j':             return KeyboardButton::J;
-		case 'k':             return KeyboardButton::K;
-		case 'l':             return KeyboardButton::L;
-		case 'm':             return KeyboardButton::M;
-		case 'n':             return KeyboardButton::N;
-		case 'o':             return KeyboardButton::O;
-		case 'p':             return KeyboardButton::P;
-		case 'q':             return KeyboardButton::Q;
-		case 'r':             return KeyboardButton::R;
-		case 's':             return KeyboardButton::S;
-		case 't':             return KeyboardButton::T;
-		case 'u':             return KeyboardButton::U;
-		case 'v':             return KeyboardButton::V;
-		case 'w':             return KeyboardButton::W;
-		case 'x':             return KeyboardButton::X;
-		case 'y':             return KeyboardButton::Y;
-		case 'z':             return KeyboardButton::Z;
-		default:              return KeyboardButton::COUNT;
+	case XK_BackSpace:    return KeyboardButton::BACKSPACE;
+	case XK_Tab:          return KeyboardButton::TAB;
+	case XK_space:        return KeyboardButton::SPACE;
+	case XK_Escape:       return KeyboardButton::ESCAPE;
+	case XK_Return:       return KeyboardButton::ENTER;
+	case XK_F1:           return KeyboardButton::F1;
+	case XK_F2:           return KeyboardButton::F2;
+	case XK_F3:           return KeyboardButton::F3;
+	case XK_F4:           return KeyboardButton::F4;
+	case XK_F5:           return KeyboardButton::F5;
+	case XK_F6:           return KeyboardButton::F6;
+	case XK_F7:           return KeyboardButton::F7;
+	case XK_F8:           return KeyboardButton::F8;
+	case XK_F9:           return KeyboardButton::F9;
+	case XK_F10:          return KeyboardButton::F10;
+	case XK_F11:          return KeyboardButton::F11;
+	case XK_F12:          return KeyboardButton::F12;
+	case XK_Home:         return KeyboardButton::HOME;
+	case XK_Left:         return KeyboardButton::LEFT;
+	case XK_Up:           return KeyboardButton::UP;
+	case XK_Right:        return KeyboardButton::RIGHT;
+	case XK_Down:         return KeyboardButton::DOWN;
+	case XK_Page_Up:      return KeyboardButton::PAGE_UP;
+	case XK_Page_Down:    return KeyboardButton::PAGE_DOWN;
+	case XK_Insert:       return KeyboardButton::INSERT;
+	case XK_Delete:       return KeyboardButton::DELETE;
+	case XK_End:          return KeyboardButton::END;
+	case XK_Shift_L:      return KeyboardButton::LEFT_SHIFT;
+	case XK_Shift_R:      return KeyboardButton::RIGHT_SHIFT;
+	case XK_Control_L:    return KeyboardButton::LEFT_CTRL;
+	case XK_Control_R:    return KeyboardButton::RIGHT_CTRL;
+	case XK_Caps_Lock:    return KeyboardButton::CAPS_LOCK;
+	case XK_Alt_L:        return KeyboardButton::LEFT_ALT;
+	case XK_Alt_R:        return KeyboardButton::RIGHT_ALT;
+	case XK_Super_L:      return KeyboardButton::LEFT_SUPER;
+	case XK_Super_R:      return KeyboardButton::RIGHT_SUPER;
+	case XK_Num_Lock:     return KeyboardButton::NUM_LOCK;
+	case XK_KP_Enter:     return KeyboardButton::NUMPAD_ENTER;
+	case XK_KP_Delete:    return KeyboardButton::NUMPAD_DELETE;
+	case XK_KP_Multiply:  return KeyboardButton::NUMPAD_MULTIPLY;
+	case XK_KP_Add:       return KeyboardButton::NUMPAD_ADD;
+	case XK_KP_Subtract:  return KeyboardButton::NUMPAD_SUBTRACT;
+	case XK_KP_Divide:    return KeyboardButton::NUMPAD_DIVIDE;
+	case XK_KP_Insert:
+	case XK_KP_0:         return KeyboardButton::NUMPAD_0;
+	case XK_KP_End:
+	case XK_KP_1:         return KeyboardButton::NUMPAD_1;
+	case XK_KP_Down:
+	case XK_KP_2:         return KeyboardButton::NUMPAD_2;
+	case XK_KP_Page_Down: // or XK_KP_Next
+	case XK_KP_3:         return KeyboardButton::NUMPAD_3;
+	case XK_KP_Left:
+	case XK_KP_4:         return KeyboardButton::NUMPAD_4;
+	case XK_KP_Begin:
+	case XK_KP_5:         return KeyboardButton::NUMPAD_5;
+	case XK_KP_Right:
+	case XK_KP_6:         return KeyboardButton::NUMPAD_6;
+	case XK_KP_Home:
+	case XK_KP_7:         return KeyboardButton::NUMPAD_7;
+	case XK_KP_Up:
+	case XK_KP_8:         return KeyboardButton::NUMPAD_8;
+	case XK_KP_Page_Up:   // or XK_KP_Prior
+	case XK_KP_9:         return KeyboardButton::NUMPAD_9;
+	case '0':             return KeyboardButton::NUMBER_0;
+	case '1':             return KeyboardButton::NUMBER_1;
+	case '2':             return KeyboardButton::NUMBER_2;
+	case '3':             return KeyboardButton::NUMBER_3;
+	case '4':             return KeyboardButton::NUMBER_4;
+	case '5':             return KeyboardButton::NUMBER_5;
+	case '6':             return KeyboardButton::NUMBER_6;
+	case '7':             return KeyboardButton::NUMBER_7;
+	case '8':             return KeyboardButton::NUMBER_8;
+	case '9':             return KeyboardButton::NUMBER_9;
+	case 'a':             return KeyboardButton::A;
+	case 'b':             return KeyboardButton::B;
+	case 'c':             return KeyboardButton::C;
+	case 'd':             return KeyboardButton::D;
+	case 'e':             return KeyboardButton::E;
+	case 'f':             return KeyboardButton::F;
+	case 'g':             return KeyboardButton::G;
+	case 'h':             return KeyboardButton::H;
+	case 'i':             return KeyboardButton::I;
+	case 'j':             return KeyboardButton::J;
+	case 'k':             return KeyboardButton::K;
+	case 'l':             return KeyboardButton::L;
+	case 'm':             return KeyboardButton::M;
+	case 'n':             return KeyboardButton::N;
+	case 'o':             return KeyboardButton::O;
+	case 'p':             return KeyboardButton::P;
+	case 'q':             return KeyboardButton::Q;
+	case 'r':             return KeyboardButton::R;
+	case 's':             return KeyboardButton::S;
+	case 't':             return KeyboardButton::T;
+	case 'u':             return KeyboardButton::U;
+	case 'v':             return KeyboardButton::V;
+	case 'w':             return KeyboardButton::W;
+	case 'x':             return KeyboardButton::X;
+	case 'y':             return KeyboardButton::Y;
+	case 'z':             return KeyboardButton::Z;
+	default:              return KeyboardButton::COUNT;
 	}
 }
 
@@ -230,7 +230,7 @@ struct Joypad
 
 				switch (ev.type &= ~JS_EVENT_INIT)
 				{
-					case JS_EVENT_AXIS:
+				case JS_EVENT_AXIS:
 					{
 						AxisData& axis = _axis[i];
 						// Indices into axis.left/right respectively
@@ -256,19 +256,21 @@ struct Joypad
 							, -values[1]
 							, values[2]
 							);
-						break;
 					}
-					case JS_EVENT_BUTTON:
+					break;
+
+				case JS_EVENT_BUTTON:
+					if (ev.number < countof(s_button))
 					{
-						if (ev.number < countof(s_button))
-						{
-							queue.push_joypad_event(i
-								, s_button[ev.number]
-								, val == 1
-								);
-						}
-						break;
+						queue.push_joypad_event(i
+							, s_button[ev.number]
+							, val == 1
+							);
 					}
+					break;
+
+				default:
+					break;
 				}
 			}
 		}
@@ -354,30 +356,25 @@ struct LinuxDevice
 
 				switch (event.type)
 				{
-					case EnterNotify:
-					{
-						_queue.push_mouse_event(event.xcrossing.x, event.xcrossing.y);
-						break;
-					}
-					case ClientMessage:
-					{
-						if ((Atom)event.xclient.data.l[0] == _wm_delete_message)
-						{
-							_queue.push_exit_event(0);
-						}
-						break;
-					}
-					case ConfigureNotify:
-					{
-						_queue.push_metrics_event(event.xconfigure.x
-							, event.xconfigure.y
-							, event.xconfigure.width
-							, event.xconfigure.height
-							);
-						break;
-					}
-					case ButtonPress:
-					case ButtonRelease:
+				case EnterNotify:
+					_queue.push_mouse_event(event.xcrossing.x, event.xcrossing.y);
+					break;
+
+				case ClientMessage:
+					if ((Atom)event.xclient.data.l[0] == _wm_delete_message)
+						_queue.push_exit_event(0);
+					break;
+
+				case ConfigureNotify:
+					_queue.push_metrics_event(event.xconfigure.x
+						, event.xconfigure.y
+						, event.xconfigure.width
+						, event.xconfigure.height
+						);
+					break;
+
+				case ButtonPress:
+				case ButtonRelease:
 					{
 						if (event.xbutton.button == Button4 || event.xbutton.button == Button5)
 						{
@@ -405,15 +402,15 @@ struct LinuxDevice
 								, event.type == ButtonPress
 								);
 						}
-						break;
 					}
-					case MotionNotify:
-					{
-						_queue.push_mouse_event(event.xmotion.x, event.xmotion.y);
-						break;
-					}
-					case KeyPress:
-					case KeyRelease:
+					break;
+
+				case MotionNotify:
+					_queue.push_mouse_event(event.xmotion.x, event.xmotion.y);
+					break;
+
+				case KeyPress:
+				case KeyRelease:
 					{
 						KeySym keysym = XLookupKeysym(&event.xkey, 0);
 						KeyboardButton::Enum kb = x11_translate_key(keysym);
@@ -421,17 +418,14 @@ struct LinuxDevice
 						if (kb != KeyboardButton::COUNT)
 							_queue.push_keyboard_event(kb, event.type == KeyPress);
 
-						break;
-					}
-					case KeymapNotify:
-					{
-						XRefreshKeyboardMapping(&event.xmapping);
-						break;
-					}
-					default:
-					{
-						break;
 					}
+					break;
+				case KeymapNotify:
+					XRefreshKeyboardMapping(&event.xmapping);
+					break;
+
+				default:
+					break;
 				}
 			}
 

src/device/main_windows.cpp

@@ -26,96 +26,96 @@ static KeyboardButton::Enum win_translate_key(s32 winkey)
 {
 	switch (winkey)
 	{
-		case VK_BACK:     return KeyboardButton::BACKSPACE;
-		case VK_TAB:      return KeyboardButton::TAB;
-		case VK_SPACE:    return KeyboardButton::SPACE;
-		case VK_ESCAPE:   return KeyboardButton::ESCAPE;
-		case VK_RETURN:   return KeyboardButton::ENTER;
-		case VK_F1:       return KeyboardButton::F1;
-		case VK_F2:       return KeyboardButton::F2;
-		case VK_F3:       return KeyboardButton::F3;
-		case VK_F4:       return KeyboardButton::F4;
-		case VK_F5:       return KeyboardButton::F5;
-		case VK_F6:       return KeyboardButton::F6;
-		case VK_F7:       return KeyboardButton::F7;
-		case VK_F8:       return KeyboardButton::F8;
-		case VK_F9:       return KeyboardButton::F9;
-		case VK_F10:      return KeyboardButton::F10;
-		case VK_F11:      return KeyboardButton::F11;
-		case VK_F12:      return KeyboardButton::F12;
-		case VK_HOME:     return KeyboardButton::HOME;
-		case VK_LEFT:     return KeyboardButton::LEFT;
-		case VK_UP:       return KeyboardButton::UP;
-		case VK_RIGHT:    return KeyboardButton::RIGHT;
-		case VK_DOWN:     return KeyboardButton::DOWN;
-		case VK_PRIOR:    return KeyboardButton::PAGE_UP;
-		case VK_NEXT:     return KeyboardButton::PAGE_DOWN;
-		case VK_INSERT:   return KeyboardButton::INSERT;
-		case VK_DELETE:   return KeyboardButton::DELETE;
-		case VK_END:      return KeyboardButton::END;
-		case VK_LSHIFT:   return KeyboardButton::LEFT_SHIFT;
-		case VK_RSHIFT:   return KeyboardButton::RIGHT_SHIFT;
-		case VK_LCONTROL: return KeyboardButton::LEFT_CTRL;
-		case VK_RCONTROL: return KeyboardButton::RIGHT_CTRL;
-		case VK_CAPITAL:  return KeyboardButton::CAPS_LOCK;
-		case VK_LMENU:    return KeyboardButton::LEFT_ALT;
-		case VK_RMENU:    return KeyboardButton::RIGHT_ALT;
-		case VK_LWIN:     return KeyboardButton::LEFT_SUPER;
-		case VK_RWIN:     return KeyboardButton::RIGHT_SUPER;
-		case VK_NUMLOCK:  return KeyboardButton::NUM_LOCK;
-		// case VK_RETURN:   return KeyboardButton::NUMPAD_ENTER;
-		case VK_DECIMAL:  return KeyboardButton::NUMPAD_DELETE;
-		case VK_MULTIPLY: return KeyboardButton::NUMPAD_MULTIPLY;
-		case VK_ADD:      return KeyboardButton::NUMPAD_ADD;
-		case VK_SUBTRACT: return KeyboardButton::NUMPAD_SUBTRACT;
-		case VK_DIVIDE:   return KeyboardButton::NUMPAD_DIVIDE;
-		case VK_NUMPAD0:  return KeyboardButton::NUMPAD_0;
-		case VK_NUMPAD1:  return KeyboardButton::NUMPAD_1;
-		case VK_NUMPAD2:  return KeyboardButton::NUMPAD_2;
-		case VK_NUMPAD3:  return KeyboardButton::NUMPAD_3;
-		case VK_NUMPAD4:  return KeyboardButton::NUMPAD_4;
-		case VK_NUMPAD5:  return KeyboardButton::NUMPAD_5;
-		case VK_NUMPAD6:  return KeyboardButton::NUMPAD_6;
-		case VK_NUMPAD7:  return KeyboardButton::NUMPAD_7;
-		case VK_NUMPAD8:  return KeyboardButton::NUMPAD_8;
-		case VK_NUMPAD9:  return KeyboardButton::NUMPAD_9;
-		case '0':         return KeyboardButton::NUMBER_0;
-		case '1':         return KeyboardButton::NUMBER_1;
-		case '2':         return KeyboardButton::NUMBER_2;
-		case '3':         return KeyboardButton::NUMBER_3;
-		case '4':         return KeyboardButton::NUMBER_4;
-		case '5':         return KeyboardButton::NUMBER_5;
-		case '6':         return KeyboardButton::NUMBER_6;
-		case '7':         return KeyboardButton::NUMBER_7;
-		case '8':         return KeyboardButton::NUMBER_8;
-		case '9':         return KeyboardButton::NUMBER_9;
-		case 'A':         return KeyboardButton::A;
-		case 'B':         return KeyboardButton::B;
-		case 'C':         return KeyboardButton::C;
-		case 'D':         return KeyboardButton::D;
-		case 'E':         return KeyboardButton::E;
-		case 'F':         return KeyboardButton::F;
-		case 'G':         return KeyboardButton::G;
-		case 'H':         return KeyboardButton::H;
-		case 'I':         return KeyboardButton::I;
-		case 'J':         return KeyboardButton::J;
-		case 'K':         return KeyboardButton::K;
-		case 'L':         return KeyboardButton::L;
-		case 'M':         return KeyboardButton::M;
-		case 'N':         return KeyboardButton::N;
-		case 'O':         return KeyboardButton::O;
-		case 'P':         return KeyboardButton::P;
-		case 'Q':         return KeyboardButton::Q;
-		case 'R':         return KeyboardButton::R;
-		case 'S':         return KeyboardButton::S;
-		case 'T':         return KeyboardButton::T;
-		case 'U':         return KeyboardButton::U;
-		case 'V':         return KeyboardButton::V;
-		case 'W':         return KeyboardButton::W;
-		case 'X':         return KeyboardButton::X;
-		case 'Y':         return KeyboardButton::Y;
-		case 'Z':         return KeyboardButton::Z;
-		default:          return KeyboardButton::COUNT;
+	case VK_BACK:     return KeyboardButton::BACKSPACE;
+	case VK_TAB:      return KeyboardButton::TAB;
+	case VK_SPACE:    return KeyboardButton::SPACE;
+	case VK_ESCAPE:   return KeyboardButton::ESCAPE;
+	case VK_RETURN:   return KeyboardButton::ENTER;
+	case VK_F1:       return KeyboardButton::F1;
+	case VK_F2:       return KeyboardButton::F2;
+	case VK_F3:       return KeyboardButton::F3;
+	case VK_F4:       return KeyboardButton::F4;
+	case VK_F5:       return KeyboardButton::F5;
+	case VK_F6:       return KeyboardButton::F6;
+	case VK_F7:       return KeyboardButton::F7;
+	case VK_F8:       return KeyboardButton::F8;
+	case VK_F9:       return KeyboardButton::F9;
+	case VK_F10:      return KeyboardButton::F10;
+	case VK_F11:      return KeyboardButton::F11;
+	case VK_F12:      return KeyboardButton::F12;
+	case VK_HOME:     return KeyboardButton::HOME;
+	case VK_LEFT:     return KeyboardButton::LEFT;
+	case VK_UP:       return KeyboardButton::UP;
+	case VK_RIGHT:    return KeyboardButton::RIGHT;
+	case VK_DOWN:     return KeyboardButton::DOWN;
+	case VK_PRIOR:    return KeyboardButton::PAGE_UP;
+	case VK_NEXT:     return KeyboardButton::PAGE_DOWN;
+	case VK_INSERT:   return KeyboardButton::INSERT;
+	case VK_DELETE:   return KeyboardButton::DELETE;
+	case VK_END:      return KeyboardButton::END;
+	case VK_LSHIFT:   return KeyboardButton::LEFT_SHIFT;
+	case VK_RSHIFT:   return KeyboardButton::RIGHT_SHIFT;
+	case VK_LCONTROL: return KeyboardButton::LEFT_CTRL;
+	case VK_RCONTROL: return KeyboardButton::RIGHT_CTRL;
+	case VK_CAPITAL:  return KeyboardButton::CAPS_LOCK;
+	case VK_LMENU:    return KeyboardButton::LEFT_ALT;
+	case VK_RMENU:    return KeyboardButton::RIGHT_ALT;
+	case VK_LWIN:     return KeyboardButton::LEFT_SUPER;
+	case VK_RWIN:     return KeyboardButton::RIGHT_SUPER;
+	case VK_NUMLOCK:  return KeyboardButton::NUM_LOCK;
+	// case VK_RETURN:   return KeyboardButton::NUMPAD_ENTER;
+	case VK_DECIMAL:  return KeyboardButton::NUMPAD_DELETE;
+	case VK_MULTIPLY: return KeyboardButton::NUMPAD_MULTIPLY;
+	case VK_ADD:      return KeyboardButton::NUMPAD_ADD;
+	case VK_SUBTRACT: return KeyboardButton::NUMPAD_SUBTRACT;
+	case VK_DIVIDE:   return KeyboardButton::NUMPAD_DIVIDE;
+	case VK_NUMPAD0:  return KeyboardButton::NUMPAD_0;
+	case VK_NUMPAD1:  return KeyboardButton::NUMPAD_1;
+	case VK_NUMPAD2:  return KeyboardButton::NUMPAD_2;
+	case VK_NUMPAD3:  return KeyboardButton::NUMPAD_3;
+	case VK_NUMPAD4:  return KeyboardButton::NUMPAD_4;
+	case VK_NUMPAD5:  return KeyboardButton::NUMPAD_5;
+	case VK_NUMPAD6:  return KeyboardButton::NUMPAD_6;
+	case VK_NUMPAD7:  return KeyboardButton::NUMPAD_7;
+	case VK_NUMPAD8:  return KeyboardButton::NUMPAD_8;
+	case VK_NUMPAD9:  return KeyboardButton::NUMPAD_9;
+	case '0':         return KeyboardButton::NUMBER_0;
+	case '1':         return KeyboardButton::NUMBER_1;
+	case '2':         return KeyboardButton::NUMBER_2;
+	case '3':         return KeyboardButton::NUMBER_3;
+	case '4':         return KeyboardButton::NUMBER_4;
+	case '5':         return KeyboardButton::NUMBER_5;
+	case '6':         return KeyboardButton::NUMBER_6;
+	case '7':         return KeyboardButton::NUMBER_7;
+	case '8':         return KeyboardButton::NUMBER_8;
+	case '9':         return KeyboardButton::NUMBER_9;
+	case 'A':         return KeyboardButton::A;
+	case 'B':         return KeyboardButton::B;
+	case 'C':         return KeyboardButton::C;
+	case 'D':         return KeyboardButton::D;
+	case 'E':         return KeyboardButton::E;
+	case 'F':         return KeyboardButton::F;
+	case 'G':         return KeyboardButton::G;
+	case 'H':         return KeyboardButton::H;
+	case 'I':         return KeyboardButton::I;
+	case 'J':         return KeyboardButton::J;
+	case 'K':         return KeyboardButton::K;
+	case 'L':         return KeyboardButton::L;
+	case 'M':         return KeyboardButton::M;
+	case 'N':         return KeyboardButton::N;
+	case 'O':         return KeyboardButton::O;
+	case 'P':         return KeyboardButton::P;
+	case 'Q':         return KeyboardButton::Q;
+	case 'R':         return KeyboardButton::R;
+	case 'S':         return KeyboardButton::S;
+	case 'T':         return KeyboardButton::T;
+	case 'U':         return KeyboardButton::U;
+	case 'V':         return KeyboardButton::V;
+	case 'W':         return KeyboardButton::W;
+	case 'X':         return KeyboardButton::X;
+	case 'Y':         return KeyboardButton::Y;
+	case 'Z':         return KeyboardButton::Z;
+	default:          return KeyboardButton::COUNT;
 	}
 }
 
@@ -362,93 +362,98 @@ struct WindowsDevice
 	{
 		switch (id)
 		{
-			case WM_DESTROY:
-			{
-				break;
-			}
-			case WM_QUIT:
-			case WM_CLOSE:
-			{
-				s_exit = true;
-				_queue.push_exit_event(0);
-				return 0;
-			}
-			case WM_SIZE:
+		case WM_DESTROY:
+			break;
+
+		case WM_QUIT:
+		case WM_CLOSE:
+			s_exit = true;
+			_queue.push_exit_event(0);
+			return 0;
+
+		case WM_SIZE:
 			{
 				u32 width = GET_X_LPARAM(lparam);
 				u32 height = GET_Y_LPARAM(lparam);
 				_queue.push_metrics_event(0, 0, width, height);
-				break;
 			}
-			case WM_SYSCOMMAND:
+			break;
+
+		case WM_SYSCOMMAND:
+			switch (wparam)
 			{
-				switch (wparam)
+			case SC_MINIMIZE:
+			case SC_RESTORE:
 				{
-					case SC_MINIMIZE:
-					case SC_RESTORE:
+					HWND parent = GetWindow(hwnd, GW_OWNER);
+					if (NULL != parent)
 					{
-						HWND parent = GetWindow(hwnd, GW_OWNER);
-						if (NULL != parent)
-						{
-							PostMessage(parent, id, wparam, lparam);
-						}
+						PostMessage(parent, id, wparam, lparam);
 					}
 				}
 				break;
 			}
-			case WM_MOUSEWHEEL:
+			break;
+
+		case WM_MOUSEWHEEL:
 			{
 				s32 mx = GET_X_LPARAM(lparam);
 				s32 my = GET_Y_LPARAM(lparam);
 				short delta = GET_WHEEL_DELTA_WPARAM(wparam);
 				_queue.push_mouse_event(mx, my, (f32)(delta/WHEEL_DELTA));
-				break;
 			}
-			case WM_MOUSEMOVE:
+			break;
+
+		case WM_MOUSEMOVE:
 			{
 				s32 mx = GET_X_LPARAM(lparam);
 				s32 my = GET_Y_LPARAM(lparam);
 				_queue.push_mouse_event(mx, my);
-				break;
 			}
-			case WM_LBUTTONDOWN:
-			case WM_LBUTTONUP:
+			break;
+
+		case WM_LBUTTONDOWN:
+		case WM_LBUTTONUP:
 			{
 				s32 mx = GET_X_LPARAM(lparam);
 				s32 my = GET_Y_LPARAM(lparam);
 				_queue.push_mouse_event(mx, my, MouseButton::LEFT, id == WM_LBUTTONDOWN);
-				break;
 			}
-			case WM_RBUTTONUP:
-			case WM_RBUTTONDOWN:
+			break;
+
+		case WM_RBUTTONUP:
+		case WM_RBUTTONDOWN:
 			{
 				s32 mx = GET_X_LPARAM(lparam);
 				s32 my = GET_Y_LPARAM(lparam);
 				_queue.push_mouse_event(mx, my, MouseButton::RIGHT, id == WM_RBUTTONDOWN);
-				break;
 			}
-			case WM_MBUTTONDOWN:
-			case WM_MBUTTONUP:
+			break;
+
+		case WM_MBUTTONDOWN:
+		case WM_MBUTTONUP:
 			{
 				s32 mx = GET_X_LPARAM(lparam);
 				s32 my = GET_Y_LPARAM(lparam);
 				_queue.push_mouse_event(mx, my, MouseButton::MIDDLE, id == WM_MBUTTONDOWN);
-				break;
 			}
-			case WM_KEYDOWN:
-			case WM_SYSKEYDOWN:
-			case WM_KEYUP:
-			case WM_SYSKEYUP:
+			break;
+
+		case WM_KEYDOWN:
+		case WM_SYSKEYDOWN:
+		case WM_KEYUP:
+		case WM_SYSKEYUP:
 			{
 				KeyboardButton::Enum kb = win_translate_key(wparam & 0xff);
 
 				if (kb != KeyboardButton::COUNT)
 					_queue.push_keyboard_event(kb, (id == WM_KEYDOWN || id == WM_SYSKEYDOWN));
 
-				break;
 			}
-			default:
-				break;
+			break;
+
+		default:
+			break;
 		}
 
 		return DefWindowProc(hwnd, id, wparam, lparam);

src/lua/lua_api.cpp

@@ -1029,10 +1029,10 @@ static int lightuserdata_index(lua_State* L)
 
 	switch (s[0])
 	{
-		case 'x': stack.push_float(v.x); return 1;
-		case 'y': stack.push_float(v.y); return 1;
-		case 'z': stack.push_float(v.z); return 1;
-		default: LUA_ASSERT(false, stack, "Bad index: '%c'", s[0]); break;
+	case 'x': stack.push_float(v.x); return 1;
+	case 'y': stack.push_float(v.y); return 1;
+	case 'z': stack.push_float(v.z); return 1;
+	default: LUA_ASSERT(false, stack, "Bad index: '%c'", s[0]); break;
 	}
 
 	return 0;
@@ -1047,10 +1047,10 @@ static int lightuserdata_newindex(lua_State* L)
 
 	switch (s[0])
 	{
-		case 'x': v.x = value; break;
-		case 'y': v.y = value; break;
-		case 'z': v.z = value; break;
-		default: LUA_ASSERT(false, stack, "Bad index: '%c'", s[0]); break;
+	case 'x': v.x = value; break;
+	case 'y': v.y = value; break;
+	case 'z': v.z = value; break;
+	default: LUA_ASSERT(false, stack, "Bad index: '%c'", s[0]); break;
 	}
 
 	return 0;

src/lua/lua_environment.cpp

@@ -180,16 +180,13 @@ void LuaEnvironment::call_global(const char* func, u8 argc, ...)
 		const int type = va_arg(vl, int);
 		switch (type)
 		{
-			case ARGUMENT_FLOAT:
-			{
-				stack.push_float(va_arg(vl, f64));
-				break;
-			}
-			default:
-			{
-				CE_ASSERT(false, "Oops, lua argument unknown");
-				break;
-			}
+		case ARGUMENT_FLOAT:
+			stack.push_float(va_arg(vl, f64));
+			break;
+
+		default:
+			CE_FATAL("Unknown argument type");
+			break;
 		}
 	}
 

src/resource/material_resource.cpp

@@ -147,31 +147,25 @@ namespace material_resource
 
 			switch (ud.type)
 			{
-				case UniformType::FLOAT:
-				{
-					f32 data = sjson::parse_float(uniform["value"]);
-					reserve_dynamic_data(data, dynamic);
-					break;
-				}
-				case UniformType::VECTOR2:
-				{
-					Vector2 data = sjson::parse_vector2(uniform["value"]);
-					reserve_dynamic_data(data, dynamic);
-					break;
-				}
-				case UniformType::VECTOR3:
-				{
-					Vector3 data = sjson::parse_vector3(uniform["value"]);
-					reserve_dynamic_data(data, dynamic);
-					break;
-				}
-				case UniformType::VECTOR4:
-				{
-					Vector4 data = sjson::parse_vector4(uniform["value"]);
-					reserve_dynamic_data(data, dynamic);
-					break;
-				}
-				default: CE_FATAL("Oops"); break;
+			case UniformType::FLOAT:
+				reserve_dynamic_data(sjson::parse_float(uniform["value"]), dynamic);
+				break;
+
+			case UniformType::VECTOR2:
+				reserve_dynamic_data(sjson::parse_vector2(uniform["value"]), dynamic);
+				break;
+
+			case UniformType::VECTOR3:
+				reserve_dynamic_data(sjson::parse_vector3(uniform["value"]), dynamic);
+				break;
+
+			case UniformType::VECTOR4:
+				reserve_dynamic_data(sjson::parse_vector4(uniform["value"]), dynamic);
+				break;
+
+			default:
+				CE_FATAL("Unknown uniform type");
+				break;
 			}
 
 			array::push_back(uniforms, ud);

src/resource/physics_resource.cpp

@@ -205,16 +205,14 @@ namespace physics_resource
 
 		switch (cd.type)
 		{
-			case ColliderType::SPHERE:      compile_sphere(points, cd); break;
-			case ColliderType::CAPSULE:     compile_capsule(points, cd); break;
-			case ColliderType::BOX:         compile_box(points, cd); break;
-			case ColliderType::CONVEX_HULL: break;
-			case ColliderType::MESH:        break;
-			case ColliderType::HEIGHTFIELD:
-			{
-				RESOURCE_COMPILER_ASSERT(false, opts, "Not implemented yet");
-				break;
-			}
+		case ColliderType::SPHERE:      compile_sphere(points, cd); break;
+		case ColliderType::CAPSULE:     compile_capsule(points, cd); break;
+		case ColliderType::BOX:         compile_box(points, cd); break;
+		case ColliderType::CONVEX_HULL: break;
+		case ColliderType::MESH:        break;
+		case ColliderType::HEIGHTFIELD:
+			RESOURCE_COMPILER_ASSERT(false, opts, "Not implemented yet");
+			break;
 		}
 
 		const u32 num_points  = array::size(points);
@@ -290,16 +288,14 @@ namespace physics_resource
 
 		switch (jd.type)
 		{
-			case JointType::HINGE:
-			{
-				jd.hinge.use_motor         = sjson::parse_bool (obj["use_motor"]);
-				jd.hinge.target_velocity   = sjson::parse_float(obj["target_velocity"]);
-				jd.hinge.max_motor_impulse = sjson::parse_float(obj["max_motor_impulse"]);
-				jd.hinge.lower_limit       = sjson::parse_float(obj["lower_limit"]);
-				jd.hinge.upper_limit       = sjson::parse_float(obj["upper_limit"]);
-				jd.hinge.bounciness        = sjson::parse_float(obj["bounciness"]);
-				break;
-			}
+		case JointType::HINGE:
+			jd.hinge.use_motor         = sjson::parse_bool (obj["use_motor"]);
+			jd.hinge.target_velocity   = sjson::parse_float(obj["target_velocity"]);
+			jd.hinge.max_motor_impulse = sjson::parse_float(obj["max_motor_impulse"]);
+			jd.hinge.lower_limit       = sjson::parse_float(obj["lower_limit"]);
+			jd.hinge.upper_limit       = sjson::parse_float(obj["upper_limit"]);
+			jd.hinge.bounciness        = sjson::parse_float(obj["bounciness"]);
+			break;
 		}
 
 		Buffer buf(default_allocator());

src/world/debug_gui.cpp

@@ -236,17 +236,14 @@ void DebugGui::text3d(const Vector3& pos, u32 font_size, const char* str, String
 	{
 		switch (str[i])
 		{
-			case '\n':
-			{
-				x_pen_advance = 0.0f;
-				y_pen_advance -= fr->font_size;
-				continue;
-			}
-			case '\t':
-			{
-				x_pen_advance += font_size * 4;
-				continue;
-			}
+		case '\n':
+			x_pen_advance = 0.0f;
+			y_pen_advance -= fr->font_size;
+			continue;
+
+		case '\t':
+			x_pen_advance += font_size * 4;
+			continue;
 		}
 
 		if (utf8::decode(&state, &code_point, str[i]) == UTF8_ACCEPT)

src/world/physics_world_bullet.cpp

@@ -226,25 +226,29 @@ public:
 
 		switch(sd->type)
 		{
-			case ColliderType::SPHERE:
-				child_shape = CE_NEW(*_allocator, btSphereShape)(sd->sphere.radius);
-				break;
-			case ColliderType::CAPSULE:
-				child_shape = CE_NEW(*_allocator, btCapsuleShape)(sd->capsule.radius, sd->capsule.height);
-				break;
-			case ColliderType::BOX:
-				child_shape = CE_NEW(*_allocator, btBoxShape)(to_btVector3(sd->box.half_size));
-				break;
-			case ColliderType::CONVEX_HULL:
+		case ColliderType::SPHERE:
+			child_shape = CE_NEW(*_allocator, btSphereShape)(sd->sphere.radius);
+			break;
+
+		case ColliderType::CAPSULE:
+			child_shape = CE_NEW(*_allocator, btCapsuleShape)(sd->capsule.radius, sd->capsule.height);
+			break;
+
+		case ColliderType::BOX:
+			child_shape = CE_NEW(*_allocator, btBoxShape)(to_btVector3(sd->box.half_size));
+			break;
+
+		case ColliderType::CONVEX_HULL:
 			{
 				const char* data       = (char*)&sd[1];
 				const u32 num          = *(u32*)data;
 				const btScalar* points = (btScalar*)(data + sizeof(u32));
 
 				child_shape = CE_NEW(*_allocator, btConvexHullShape)(points, (int)num, sizeof(Vector3));
-				break;
 			}
-			case ColliderType::MESH:
+			break;
+
+		case ColliderType::MESH:
 			{
 				const char* data      = (char*)&sd[1];
 				const u32 num_points  = *(u32*)data;
@@ -267,18 +271,16 @@ public:
 				const btVector3 aabb_min(-1000.0f,-1000.0f,-1000.0f);
 				const btVector3 aabb_max(1000.0f,1000.0f,1000.0f);
 				child_shape = CE_NEW(*_allocator, btBvhTriangleMeshShape)(vertex_array, false, aabb_min, aabb_max);
-				break;
-			}
-			case ColliderType::HEIGHTFIELD:
-			{
-				CE_FATAL("Not implemented yet");
-				break;
-			}
-			default:
-			{
-				CE_FATAL("Bad shape");
-				break;
 			}
+			break;
+
+		case ColliderType::HEIGHTFIELD:
+			CE_FATAL("Not implemented");
+			break;
+
+		default:
+			CE_FATAL("Unknown shape type");
+			break;
 		}
 
 		const u32 last = array::size(_collider);
@@ -754,7 +756,7 @@ public:
 		btTypedConstraint* joint = NULL;
 		switch(jd.type)
 		{
-			case JointType::FIXED:
+		case JointType::FIXED:
 			{
 				const btTransform frame_0 = btTransform(btQuaternion::getIdentity(), anchor_0);
 				const btTransform frame_1 = btTransform(btQuaternion::getIdentity(), anchor_1);
@@ -763,18 +765,18 @@ public:
 	 				, frame_0
 	 				, frame_1
 	 				);
-				break;
 			}
-			case JointType::SPRING:
-			{
-				joint = CE_NEW(*_allocator, btPoint2PointConstraint)(*actor_0
-					, *actor_1
-					, anchor_0
-					, anchor_1
-					);
-				break;
-			}
-			case JointType::HINGE:
+			break;
+
+		case JointType::SPRING:
+			joint = CE_NEW(*_allocator, btPoint2PointConstraint)(*actor_0
+				, *actor_1
+				, anchor_0
+				, anchor_1
+				);
+			break;
+
+		case JointType::HINGE:
 			{
 				btHingeConstraint* hinge = CE_NEW(*_allocator, btHingeConstraint)(*actor_0
 					, *actor_1
@@ -795,13 +797,12 @@ public:
 					);
 
 				joint = hinge;
-				break;
-			}
-			default:
-			{
-				CE_FATAL("Bad joint type");
-				break;
 			}
+			break;
+
+		default:
+			CE_FATAL("Unknown joint type");
+			break;
 		}
 
 		joint->setBreakingImpulseThreshold(jd.break_force);
@@ -822,23 +823,22 @@ public:
 
 		switch (mode)
 		{
-			case RaycastMode::CLOSEST:
+		case RaycastMode::CLOSEST:
 			{
 				btCollisionWorld::ClosestRayResultCallback cb(start, end);
 				_scene->rayTest(start, end, cb);
 
+				array::resize(hits, 1);
 				if (cb.hasHit())
 				{
-					RaycastHit hit;
-					hit.position = to_vector3(cb.m_hitPointWorld);
-					hit.normal = to_vector3(cb.m_hitNormalWorld);
-					hit.actor.i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObject)->getUserPointer();
-					array::push_back(hits, hit);
+					hits[0].position = to_vector3(cb.m_hitPointWorld);
+					hits[0].normal   = to_vector3(cb.m_hitNormalWorld);
+					hits[0].actor.i  = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObject)->getUserPointer();
 				}
-
-				break;
 			}
-			case RaycastMode::ALL:
+			break;
+
+		case RaycastMode::ALL:
 			{
 				btCollisionWorld::AllHitsRayResultCallback cb(start, end);
 				_scene->rayTest(start, end, cb);
@@ -846,25 +846,21 @@ public:
 				if (cb.hasHit())
 				{
 					const int num = cb.m_hitPointWorld.size();
-					array::resize(hits, num);
 
+					array::resize(hits, num);
 					for (int i = 0; i < num; ++i)
 					{
-						RaycastHit hit;
-						hit.position = to_vector3(cb.m_hitPointWorld[i]);
-						hit.normal = to_vector3(cb.m_hitNormalWorld[i]);
-						hit.actor.i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObjects[i])->getUserPointer();
-						hits[i] = hit;
+						hits[i].position = to_vector3(cb.m_hitPointWorld[i]);
+						hits[i].normal   = to_vector3(cb.m_hitNormalWorld[i]);
+						hits[i].actor.i  = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObjects[i])->getUserPointer();
 					}
 				}
-
-				break;
-			}
-			default:
-			{
-				CE_FATAL("Bad raycast mode");
-				break;
 			}
+			break;
+
+		default:
+			CE_FATAL("Unknown raycast mode");
+			break;
 		}
 	}
 

src/world/render_world.cpp

@@ -310,31 +310,30 @@ void RenderWorld::light_debug_draw(LightInstance i, DebugLine& dl)
 
 	switch (lid.type[i.i])
 	{
-		case LightType::DIRECTIONAL:
+	case LightType::DIRECTIONAL:
 		{
 			const Vector3 end = pos + dir*3.0f;
 			dl.add_line(pos, end, COLOR4_YELLOW);
 			dl.add_cone(pos + dir*2.8f, end, 0.1f, COLOR4_YELLOW);
-			break;
 		}
-		case LightType::OMNI:
-		{
-			dl.add_sphere(pos, lid.range[i.i], COLOR4_YELLOW);
-			break;
-		}
-		case LightType::SPOT:
+		break;
+
+	case LightType::OMNI:
+		dl.add_sphere(pos, lid.range[i.i], COLOR4_YELLOW);
+		break;
+
+	case LightType::SPOT:
 		{
 			const f32 angle  = lid.spot_angle[i.i];
 			const f32 range  = lid.range[i.i];
 			const f32 radius = tan(angle)*range;
 			dl.add_cone(pos + range*dir, pos, radius, COLOR4_YELLOW);
-			break;
-		}
-		default:
-		{
-			CE_ASSERT(false, "Bad light type");
-			break;
 		}
+		break;
+
+	default:
+		CE_FATAL("Unknown light type");
+		break;
 	}
 }
 

src/world/sound_world_al.cpp

@@ -25,11 +25,11 @@ namespace crown
 	{
 		switch (error)
 		{
-			case AL_INVALID_ENUM: return "AL_INVALID_ENUM";
-			case AL_INVALID_VALUE: return "AL_INVALID_VALUE";
-			case AL_INVALID_OPERATION: return "AL_INVALID_OPERATION";
-			case AL_OUT_OF_MEMORY: return "AL_OUT_OF_MEMORY";
-			default: return "UNKNOWN_AL_ERROR";
+		case AL_INVALID_ENUM: return "AL_INVALID_ENUM";
+		case AL_INVALID_VALUE: return "AL_INVALID_VALUE";
+		case AL_INVALID_OPERATION: return "AL_INVALID_OPERATION";
+		case AL_OUT_OF_MEMORY: return "AL_OUT_OF_MEMORY";
+		default: return "UNKNOWN_AL_ERROR";
 		}
 	}
 
@@ -93,9 +93,9 @@ struct SoundInstance
 		ALenum fmt = AL_INVALID_ENUM;
 		switch (sr.bits_ps)
 		{
-			case  8: fmt = sr.channels > 1 ? AL_FORMAT_STEREO8 : AL_FORMAT_MONO8; break;
-			case 16: fmt = sr.channels > 1 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; break;
-			default: CE_FATAL("Number of bits per sample not supported."); break;
+		case  8: fmt = sr.channels > 1 ? AL_FORMAT_STEREO8  : AL_FORMAT_MONO8; break;
+		case 16: fmt = sr.channels > 1 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; break;
+		default: CE_FATAL("Number of bits per sample not supported."); break;
 		}
 		AL_CHECK(alBufferData(_buffer, fmt, data(&sr), sr.size, sr.sample_rate));
 

src/world/world.cpp

@@ -145,22 +145,24 @@ void World::update_scene(f32 dt)
 
 		switch (h.type)
 		{
-			case EventType::PHYSICS_TRANSFORM:
+		case EventType::PHYSICS_TRANSFORM:
 			{
 				const PhysicsTransformEvent& ptev = *(PhysicsTransformEvent*)ev;
 				const TransformInstance ti = _scene_graph->get(ptev.unit_id);
 				const Matrix4x4 pose = matrix4x4(ptev.rotation, ptev.position);
 				_scene_graph->set_world_pose(ti, pose);
-				break;
-			}
-			case EventType::PHYSICS_COLLISION:
-			{
-				break;
-			}
-			case EventType::PHYSICS_TRIGGER:
-			{
-				break;
 			}
+			break;
+
+		case EventType::PHYSICS_COLLISION:
+			break;
+
+		case EventType::PHYSICS_TRIGGER:
+			break;
+
+		default:
+			CE_FATAL("Unknown event type");
+			break;
 		}
 
 		read += sizeof(h);
@@ -493,33 +495,28 @@ void World::Camera::update_projection_matrix()
 {
 	switch (projection_type)
 	{
-		case ProjectionType::ORTHOGRAPHIC:
-		{
-			orthographic(projection
-				, left
-				, right
-				, bottom
-				, top
-				, near
-				, far
-				);
-			break;
-		}
-		case ProjectionType::PERSPECTIVE:
-		{
-			perspective(projection
-				, fov
-				, aspect
-				, near
-				, far
-				);
-			break;
-		}
-		default:
-		{
-			CE_FATAL("Oops, unknown projection type");
-			break;
-		}
+	case ProjectionType::ORTHOGRAPHIC:
+		orthographic(projection
+			, left
+			, right
+			, bottom
+			, top
+			, near
+			, far
+			);
+		break;
+
+	case ProjectionType::PERSPECTIVE:
+		perspective(projection
+			, fov
+			, aspect
+			, near
+			, far
+			);
+		break;
+	default:
+		CE_FATAL("Oops, unknown projection type");
+		break;
 	}
 }