general: Fix assorted compiler warnings

direct/src/distributed/cConnectionRepository.cxx

@@ -58,19 +58,18 @@ CConnectionRepository(bool has_owner_view, bool threaded_net) :
   _bdc(4096000,4096000,1400),
   _native(false),
 #endif
+  _has_owner_view(has_owner_view),
+  _handle_c_updates(true),
   _client_datagram(true),
   _handle_datagrams_internally(handle_datagrams_internally),
   _simulated_disconnect(false),
   _verbose(distributed_cat.is_spam()),
+  _in_quiet_zone(0),
   _time_warning(0.0),
-// _msg_channels(),
   _msg_sender(0),
   _msg_type(0),
-  _has_owner_view(has_owner_view),
-  _handle_c_updates(true),
   _want_message_bundling(true),
-  _bundling_msgs(0),
-  _in_quiet_zone(0)
+  _bundling_msgs(0)
 {
 #if defined(HAVE_NET) && defined(SIMULATE_NETWORK_DELAY)
   if (min_lag != 0.0 || max_lag != 0.0) {

dtool/metalibs/dtoolconfig/pydtool.cxx

@@ -2449,145 +2449,145 @@ _inP07ytw_15(PyObject *, PyObject *args) {
 
 
 static PyMethodDef python_simple_funcs[] = {
-  { "interrogate_add_search_directory", &_inP07yttbRf, METH_VARARGS },
-  { "interrogate_add_search_path", &_inP07ytda_g, METH_VARARGS },
-  { "interrogate_error_flag", &_inP07yt4RgX, METH_VARARGS },
-  { "interrogate_number_of_manifests", &_inP07yt3Gip, METH_VARARGS },
-  { "interrogate_get_manifest", &_inP07ytRKDz, METH_VARARGS },
-  { "interrogate_get_manifest_by_name", &_inP07ytgZ9N, METH_VARARGS },
-  { "interrogate_manifest_name", &_inP07ytFnRZ, METH_VARARGS },
-  { "interrogate_manifest_definition", &_inP07ytg0Qv, METH_VARARGS },
-  { "interrogate_manifest_has_type", &_inP07yttrqw, METH_VARARGS },
-  { "interrogate_manifest_get_type", &_inP07ytdmpW, METH_VARARGS },
-  { "interrogate_manifest_has_getter", &_inP07ytUYgQ, METH_VARARGS },
-  { "interrogate_manifest_getter", &_inP07yt0k7F, METH_VARARGS },
-  { "interrogate_manifest_has_int_value", &_inP07ytfIsr, METH_VARARGS },
-  { "interrogate_manifest_get_int_value", &_inP07ytvysR, METH_VARARGS },
-  { "interrogate_element_name", &_inP07ytYQ_2, METH_VARARGS },
-  { "interrogate_element_scoped_name", &_inP07yt3kdv, METH_VARARGS },
-  { "interrogate_element_has_comment", &_inP07ytew01, METH_VARARGS },
-  { "interrogate_element_comment", &_inP07ytQna7, METH_VARARGS },
-  { "interrogate_get_element_by_name", &_inP07ytkg95, METH_VARARGS },
-  { "interrogate_get_element_by_scoped_name", &_inP07ytluRc, METH_VARARGS },
-  { "interrogate_element_type", &_inP07yttHdM, METH_VARARGS },
-  { "interrogate_element_has_getter", &_inP07ytDId0, METH_VARARGS },
-  { "interrogate_element_getter", &_inP07ytHuAm, METH_VARARGS },
-  { "interrogate_element_has_setter", &_inP07yt_xr0, METH_VARARGS },
-  { "interrogate_element_setter", &_inP07ytH5qp, METH_VARARGS },
-  { "interrogate_element_is_sequence", &_inP07ytq45U, METH_VARARGS },
-  { "interrogate_element_is_mapping", &_inP07yt6IPa, METH_VARARGS },
-  { "interrogate_number_of_globals", &_inP07ytU2_B, METH_VARARGS },
-  { "interrogate_get_global", &_inP07ytHFO2, METH_VARARGS },
-  { "interrogate_number_of_global_functions", &_inP07ytcfjm, METH_VARARGS },
-  { "interrogate_get_global_function", &_inP07yt3Sjw, METH_VARARGS },
-  { "interrogate_number_of_functions", &_inP07ytgJcX, METH_VARARGS },
-  { "interrogate_get_function", &_inP07ytYlw6, METH_VARARGS },
-  { "interrogate_function_name", &_inP07ytsmnz, METH_VARARGS },
-  { "interrogate_function_scoped_name", &_inP07ytxQ10, METH_VARARGS },
-  { "interrogate_function_has_comment", &_inP07yt6gPB, METH_VARARGS },
-  { "interrogate_function_comment", &_inP07ytISgV, METH_VARARGS },
-  { "interrogate_function_prototype", &_inP07ytH3bx, METH_VARARGS },
-  { "interrogate_function_is_method", &_inP07ytzeUk, METH_VARARGS },
-  { "interrogate_function_class", &_inP07ytUeI5, METH_VARARGS },
-  { "interrogate_function_has_module_name", &_inP07ytuSvx, METH_VARARGS },
-  { "interrogate_function_module_name", &_inP07ytwpYd, METH_VARARGS },
-  { "interrogate_function_has_library_name", &_inP07ytOfNh, METH_VARARGS },
-  { "interrogate_function_library_name", &_inP07ytf5_U, METH_VARARGS },
-  { "interrogate_function_is_virtual", &_inP07ytL3ZB, METH_VARARGS },
-  { "interrogate_function_number_of_c_wrappers", &_inP07ytXw0I, METH_VARARGS },
-  { "interrogate_function_c_wrapper", &_inP07yt3zru, METH_VARARGS },
-  { "interrogate_function_number_of_python_wrappers", &_inP07ytRrg2, METH_VARARGS },
-  { "interrogate_function_python_wrapper", &_inP07ytEJCx, METH_VARARGS },
-  { "interrogate_wrapper_name", &_inP07ytWAZr, METH_VARARGS },
-  { "interrogate_wrapper_is_callable_by_name", &_inP07ytrD_M, METH_VARARGS },
-  { "interrogate_wrapper_has_comment", &_inP07ytjolz, METH_VARARGS },
-  { "interrogate_wrapper_comment", &_inP07ytt_JD, METH_VARARGS },
-  { "interrogate_wrapper_has_return_value", &_inP07ytwEts, METH_VARARGS },
-  { "interrogate_wrapper_return_type", &_inP07ytrJWs, METH_VARARGS },
-  { "interrogate_wrapper_caller_manages_return_value", &_inP07ytpmFD, METH_VARARGS },
-  { "interrogate_wrapper_return_value_destructor", &_inP07ytyYUX, METH_VARARGS },
-  { "interrogate_wrapper_number_of_parameters", &_inP07yt54dn, METH_VARARGS },
-  { "interrogate_wrapper_parameter_type", &_inP07ytGMpW, METH_VARARGS },
-  { "interrogate_wrapper_parameter_has_name", &_inP07ytNuBV, METH_VARARGS },
-  { "interrogate_wrapper_parameter_name", &_inP07yt9UwA, METH_VARARGS },
-  { "interrogate_wrapper_parameter_is_this", &_inP07yt3FDt, METH_VARARGS },
-  { "interrogate_wrapper_has_pointer", &_inP07ytf513, METH_VARARGS },
-  { "interrogate_wrapper_pointer", &_inP07ytsqGH, METH_VARARGS },
-  { "interrogate_wrapper_unique_name", &_inP07yt7shV, METH_VARARGS },
-  { "interrogate_get_wrapper_by_unique_name", &_inP07ytA1eF, METH_VARARGS },
-  { "interrogate_make_seq_seq_name", &_inP07yt776V, METH_VARARGS },
-  { "interrogate_make_seq_scoped_name", &_inP07ytryup, METH_VARARGS },
-  { "interrogate_make_seq_has_comment", &_inP07ytiytI, METH_VARARGS },
-  { "interrogate_make_seq_comment", &_inP07ytZc07, METH_VARARGS },
-  { "interrogate_make_seq_num_name", &_inP07ytfaH0, METH_VARARGS },
-  { "interrogate_make_seq_element_name", &_inP07ytGB9D, METH_VARARGS },
-  { "interrogate_number_of_global_types", &_inP07ytsxxs, METH_VARARGS },
-  { "interrogate_get_global_type", &_inP07ytMT0z, METH_VARARGS },
-  { "interrogate_number_of_types", &_inP07ytiW3v, METH_VARARGS },
-  { "interrogate_get_type", &_inP07yt4Px8, METH_VARARGS },
-  { "interrogate_get_type_by_name", &_inP07ytNHcs, METH_VARARGS },
-  { "interrogate_get_type_by_scoped_name", &_inP07ytqHrb, METH_VARARGS },
-  { "interrogate_get_type_by_true_name", &_inP07ytaOqq, METH_VARARGS },
-  { "interrogate_type_is_global", &_inP07ytpTBb, METH_VARARGS },
-  { "interrogate_type_name", &_inP07ytqWOw, METH_VARARGS },
-  { "interrogate_type_scoped_name", &_inP07ytHu7x, METH_VARARGS },
-  { "interrogate_type_true_name", &_inP07ytwGnA, METH_VARARGS },
-  { "interrogate_type_is_nested", &_inP07ytXGxx, METH_VARARGS },
-  { "interrogate_type_outer_class", &_inP07ytj04Z, METH_VARARGS },
-  { "interrogate_type_has_comment", &_inP07ytEOv4, METH_VARARGS },
-  { "interrogate_type_comment", &_inP07ytpCqJ, METH_VARARGS },
-  { "interrogate_type_has_module_name", &_inP07yt_Pz3, METH_VARARGS },
-  { "interrogate_type_module_name", &_inP07ytt_06, METH_VARARGS },
-  { "interrogate_type_has_library_name", &_inP07ytmuPs, METH_VARARGS },
-  { "interrogate_type_library_name", &_inP07ytvM8B, METH_VARARGS },
-  { "interrogate_type_is_atomic", &_inP07ytap97, METH_VARARGS },
-  { "interrogate_type_atomic_token", &_inP07yt0o8D, METH_VARARGS },
-  { "interrogate_type_is_unsigned", &_inP07ytOoQ2, METH_VARARGS },
-  { "interrogate_type_is_signed", &_inP07ytKuFh, METH_VARARGS },
-  { "interrogate_type_is_long", &_inP07yto5L6, METH_VARARGS },
-  { "interrogate_type_is_longlong", &_inP07ytzgKK, METH_VARARGS },
-  { "interrogate_type_is_short", &_inP07yt0FIF, METH_VARARGS },
-  { "interrogate_type_is_wrapped", &_inP07ytZqvD, METH_VARARGS },
-  { "interrogate_type_is_pointer", &_inP07ytDyRd, METH_VARARGS },
-  { "interrogate_type_is_const", &_inP07ytMnKa, METH_VARARGS },
-  { "interrogate_type_is_typedef", &_inP07ytRtji, METH_VARARGS },
-  { "interrogate_type_wrapped_type", &_inP07ytCnbQ, METH_VARARGS },
-  { "interrogate_type_is_enum", &_inP07ytdUVN, METH_VARARGS },
-  { "interrogate_type_number_of_enum_values", &_inP07ytihbt, METH_VARARGS },
-  { "interrogate_type_enum_value_name", &_inP07ytbyPY, METH_VARARGS },
-  { "interrogate_type_enum_value_scoped_name", &_inP07ytAaT6, METH_VARARGS },
-  { "interrogate_type_enum_value_comment", &_inP07ytgL9q, METH_VARARGS },
-  { "interrogate_type_enum_value", &_inP07ytWB97, METH_VARARGS },
-  { "interrogate_type_is_struct", &_inP07ytDUAl, METH_VARARGS },
-  { "interrogate_type_is_class", &_inP07yt1_Kf, METH_VARARGS },
-  { "interrogate_type_is_union", &_inP07yt98lD, METH_VARARGS },
-  { "interrogate_type_is_fully_defined", &_inP07yt9SHr, METH_VARARGS },
-  { "interrogate_type_is_unpublished", &_inP07ytdiZP, METH_VARARGS },
-  { "interrogate_type_number_of_constructors", &_inP07ytTdER, METH_VARARGS },
-  { "interrogate_type_get_constructor", &_inP07ytYO56, METH_VARARGS },
-  { "interrogate_type_has_destructor", &_inP07ytxtCG, METH_VARARGS },
-  { "interrogate_type_destructor_is_inherited", &_inP07yt_EB2, METH_VARARGS },
-  { "interrogate_type_get_destructor", &_inP07ytEG1l, METH_VARARGS },
-  { "interrogate_type_number_of_elements", &_inP07yt7tUq, METH_VARARGS },
-  { "interrogate_type_get_element", &_inP07ytyStU, METH_VARARGS },
-  { "interrogate_type_number_of_methods", &_inP07ytdM85, METH_VARARGS },
-  { "interrogate_type_get_method", &_inP07ytk_GN, METH_VARARGS },
-  { "interrogate_type_number_of_make_seqs", &_inP07yt8QjG, METH_VARARGS },
-  { "interrogate_type_get_make_seq", &_inP07ytyMtj, METH_VARARGS },
-  { "interrogate_type_number_of_casts", &_inP07ytHDtN, METH_VARARGS },
-  { "interrogate_type_get_cast", &_inP07ytHFjA, METH_VARARGS },
-  { "interrogate_type_number_of_derivations", &_inP07yt_NPR, METH_VARARGS },
-  { "interrogate_type_get_derivation", &_inP07ytcTOH, METH_VARARGS },
-  { "interrogate_type_derivation_has_upcast", &_inP07ythdU7, METH_VARARGS },
-  { "interrogate_type_get_upcast", &_inP07ytQPxU, METH_VARARGS },
-  { "interrogate_type_derivation_downcast_is_impossible", &_inP07ytO7Pz, METH_VARARGS },
-  { "interrogate_type_derivation_has_downcast", &_inP07ytvu_E, METH_VARARGS },
-  { "interrogate_type_get_downcast", &_inP07ytxGUt, METH_VARARGS },
-  { "interrogate_type_number_of_nested_types", &_inP07ytzM1P, METH_VARARGS },
-  { "interrogate_type_get_nested_type", &_inP07ytoY5L, METH_VARARGS },
-  { "interrogate_request_database", &_inP07yte_7S, METH_VARARGS },
-  { "interrogate_request_module", &_inP07ytw_15, METH_VARARGS },
-  { nullptr, nullptr }
+  { "interrogate_add_search_directory", &_inP07yttbRf, METH_VARARGS, nullptr },
+  { "interrogate_add_search_path", &_inP07ytda_g, METH_VARARGS, nullptr },
+  { "interrogate_error_flag", &_inP07yt4RgX, METH_VARARGS, nullptr },
+  { "interrogate_number_of_manifests", &_inP07yt3Gip, METH_VARARGS, nullptr },
+  { "interrogate_get_manifest", &_inP07ytRKDz, METH_VARARGS, nullptr },
+  { "interrogate_get_manifest_by_name", &_inP07ytgZ9N, METH_VARARGS, nullptr },
+  { "interrogate_manifest_name", &_inP07ytFnRZ, METH_VARARGS, nullptr },
+  { "interrogate_manifest_definition", &_inP07ytg0Qv, METH_VARARGS, nullptr },
+  { "interrogate_manifest_has_type", &_inP07yttrqw, METH_VARARGS, nullptr },
+  { "interrogate_manifest_get_type", &_inP07ytdmpW, METH_VARARGS, nullptr },
+  { "interrogate_manifest_has_getter", &_inP07ytUYgQ, METH_VARARGS, nullptr },
+  { "interrogate_manifest_getter", &_inP07yt0k7F, METH_VARARGS, nullptr },
+  { "interrogate_manifest_has_int_value", &_inP07ytfIsr, METH_VARARGS, nullptr },
+  { "interrogate_manifest_get_int_value", &_inP07ytvysR, METH_VARARGS, nullptr },
+  { "interrogate_element_name", &_inP07ytYQ_2, METH_VARARGS, nullptr },
+  { "interrogate_element_scoped_name", &_inP07yt3kdv, METH_VARARGS, nullptr },
+  { "interrogate_element_has_comment", &_inP07ytew01, METH_VARARGS, nullptr },
+  { "interrogate_element_comment", &_inP07ytQna7, METH_VARARGS, nullptr },
+  { "interrogate_get_element_by_name", &_inP07ytkg95, METH_VARARGS, nullptr },
+  { "interrogate_get_element_by_scoped_name", &_inP07ytluRc, METH_VARARGS, nullptr },
+  { "interrogate_element_type", &_inP07yttHdM, METH_VARARGS, nullptr },
+  { "interrogate_element_has_getter", &_inP07ytDId0, METH_VARARGS, nullptr },
+  { "interrogate_element_getter", &_inP07ytHuAm, METH_VARARGS, nullptr },
+  { "interrogate_element_has_setter", &_inP07yt_xr0, METH_VARARGS, nullptr },
+  { "interrogate_element_setter", &_inP07ytH5qp, METH_VARARGS, nullptr },
+  { "interrogate_element_is_sequence", &_inP07ytq45U, METH_VARARGS, nullptr },
+  { "interrogate_element_is_mapping", &_inP07yt6IPa, METH_VARARGS, nullptr },
+  { "interrogate_number_of_globals", &_inP07ytU2_B, METH_VARARGS, nullptr },
+  { "interrogate_get_global", &_inP07ytHFO2, METH_VARARGS, nullptr },
+  { "interrogate_number_of_global_functions", &_inP07ytcfjm, METH_VARARGS, nullptr },
+  { "interrogate_get_global_function", &_inP07yt3Sjw, METH_VARARGS, nullptr },
+  { "interrogate_number_of_functions", &_inP07ytgJcX, METH_VARARGS, nullptr },
+  { "interrogate_get_function", &_inP07ytYlw6, METH_VARARGS, nullptr },
+  { "interrogate_function_name", &_inP07ytsmnz, METH_VARARGS, nullptr },
+  { "interrogate_function_scoped_name", &_inP07ytxQ10, METH_VARARGS, nullptr },
+  { "interrogate_function_has_comment", &_inP07yt6gPB, METH_VARARGS, nullptr },
+  { "interrogate_function_comment", &_inP07ytISgV, METH_VARARGS, nullptr },
+  { "interrogate_function_prototype", &_inP07ytH3bx, METH_VARARGS, nullptr },
+  { "interrogate_function_is_method", &_inP07ytzeUk, METH_VARARGS, nullptr },
+  { "interrogate_function_class", &_inP07ytUeI5, METH_VARARGS, nullptr },
+  { "interrogate_function_has_module_name", &_inP07ytuSvx, METH_VARARGS, nullptr },
+  { "interrogate_function_module_name", &_inP07ytwpYd, METH_VARARGS, nullptr },
+  { "interrogate_function_has_library_name", &_inP07ytOfNh, METH_VARARGS, nullptr },
+  { "interrogate_function_library_name", &_inP07ytf5_U, METH_VARARGS, nullptr },
+  { "interrogate_function_is_virtual", &_inP07ytL3ZB, METH_VARARGS, nullptr },
+  { "interrogate_function_number_of_c_wrappers", &_inP07ytXw0I, METH_VARARGS, nullptr },
+  { "interrogate_function_c_wrapper", &_inP07yt3zru, METH_VARARGS, nullptr },
+  { "interrogate_function_number_of_python_wrappers", &_inP07ytRrg2, METH_VARARGS, nullptr },
+  { "interrogate_function_python_wrapper", &_inP07ytEJCx, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_name", &_inP07ytWAZr, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_is_callable_by_name", &_inP07ytrD_M, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_has_comment", &_inP07ytjolz, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_comment", &_inP07ytt_JD, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_has_return_value", &_inP07ytwEts, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_return_type", &_inP07ytrJWs, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_caller_manages_return_value", &_inP07ytpmFD, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_return_value_destructor", &_inP07ytyYUX, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_number_of_parameters", &_inP07yt54dn, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_parameter_type", &_inP07ytGMpW, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_parameter_has_name", &_inP07ytNuBV, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_parameter_name", &_inP07yt9UwA, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_parameter_is_this", &_inP07yt3FDt, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_has_pointer", &_inP07ytf513, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_pointer", &_inP07ytsqGH, METH_VARARGS, nullptr },
+  { "interrogate_wrapper_unique_name", &_inP07yt7shV, METH_VARARGS, nullptr },
+  { "interrogate_get_wrapper_by_unique_name", &_inP07ytA1eF, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_seq_name", &_inP07yt776V, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_scoped_name", &_inP07ytryup, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_has_comment", &_inP07ytiytI, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_comment", &_inP07ytZc07, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_num_name", &_inP07ytfaH0, METH_VARARGS, nullptr },
+  { "interrogate_make_seq_element_name", &_inP07ytGB9D, METH_VARARGS, nullptr },
+  { "interrogate_number_of_global_types", &_inP07ytsxxs, METH_VARARGS, nullptr },
+  { "interrogate_get_global_type", &_inP07ytMT0z, METH_VARARGS, nullptr },
+  { "interrogate_number_of_types", &_inP07ytiW3v, METH_VARARGS, nullptr },
+  { "interrogate_get_type", &_inP07yt4Px8, METH_VARARGS, nullptr },
+  { "interrogate_get_type_by_name", &_inP07ytNHcs, METH_VARARGS, nullptr },
+  { "interrogate_get_type_by_scoped_name", &_inP07ytqHrb, METH_VARARGS, nullptr },
+  { "interrogate_get_type_by_true_name", &_inP07ytaOqq, METH_VARARGS, nullptr },
+  { "interrogate_type_is_global", &_inP07ytpTBb, METH_VARARGS, nullptr },
+  { "interrogate_type_name", &_inP07ytqWOw, METH_VARARGS, nullptr },
+  { "interrogate_type_scoped_name", &_inP07ytHu7x, METH_VARARGS, nullptr },
+  { "interrogate_type_true_name", &_inP07ytwGnA, METH_VARARGS, nullptr },
+  { "interrogate_type_is_nested", &_inP07ytXGxx, METH_VARARGS, nullptr },
+  { "interrogate_type_outer_class", &_inP07ytj04Z, METH_VARARGS, nullptr },
+  { "interrogate_type_has_comment", &_inP07ytEOv4, METH_VARARGS, nullptr },
+  { "interrogate_type_comment", &_inP07ytpCqJ, METH_VARARGS, nullptr },
+  { "interrogate_type_has_module_name", &_inP07yt_Pz3, METH_VARARGS, nullptr },
+  { "interrogate_type_module_name", &_inP07ytt_06, METH_VARARGS, nullptr },
+  { "interrogate_type_has_library_name", &_inP07ytmuPs, METH_VARARGS, nullptr },
+  { "interrogate_type_library_name", &_inP07ytvM8B, METH_VARARGS, nullptr },
+  { "interrogate_type_is_atomic", &_inP07ytap97, METH_VARARGS, nullptr },
+  { "interrogate_type_atomic_token", &_inP07yt0o8D, METH_VARARGS, nullptr },
+  { "interrogate_type_is_unsigned", &_inP07ytOoQ2, METH_VARARGS, nullptr },
+  { "interrogate_type_is_signed", &_inP07ytKuFh, METH_VARARGS, nullptr },
+  { "interrogate_type_is_long", &_inP07yto5L6, METH_VARARGS, nullptr },
+  { "interrogate_type_is_longlong", &_inP07ytzgKK, METH_VARARGS, nullptr },
+  { "interrogate_type_is_short", &_inP07yt0FIF, METH_VARARGS, nullptr },
+  { "interrogate_type_is_wrapped", &_inP07ytZqvD, METH_VARARGS, nullptr },
+  { "interrogate_type_is_pointer", &_inP07ytDyRd, METH_VARARGS, nullptr },
+  { "interrogate_type_is_const", &_inP07ytMnKa, METH_VARARGS, nullptr },
+  { "interrogate_type_is_typedef", &_inP07ytRtji, METH_VARARGS, nullptr },
+  { "interrogate_type_wrapped_type", &_inP07ytCnbQ, METH_VARARGS, nullptr },
+  { "interrogate_type_is_enum", &_inP07ytdUVN, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_enum_values", &_inP07ytihbt, METH_VARARGS, nullptr },
+  { "interrogate_type_enum_value_name", &_inP07ytbyPY, METH_VARARGS, nullptr },
+  { "interrogate_type_enum_value_scoped_name", &_inP07ytAaT6, METH_VARARGS, nullptr },
+  { "interrogate_type_enum_value_comment", &_inP07ytgL9q, METH_VARARGS, nullptr },
+  { "interrogate_type_enum_value", &_inP07ytWB97, METH_VARARGS, nullptr },
+  { "interrogate_type_is_struct", &_inP07ytDUAl, METH_VARARGS, nullptr },
+  { "interrogate_type_is_class", &_inP07yt1_Kf, METH_VARARGS, nullptr },
+  { "interrogate_type_is_union", &_inP07yt98lD, METH_VARARGS, nullptr },
+  { "interrogate_type_is_fully_defined", &_inP07yt9SHr, METH_VARARGS, nullptr },
+  { "interrogate_type_is_unpublished", &_inP07ytdiZP, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_constructors", &_inP07ytTdER, METH_VARARGS, nullptr },
+  { "interrogate_type_get_constructor", &_inP07ytYO56, METH_VARARGS, nullptr },
+  { "interrogate_type_has_destructor", &_inP07ytxtCG, METH_VARARGS, nullptr },
+  { "interrogate_type_destructor_is_inherited", &_inP07yt_EB2, METH_VARARGS, nullptr },
+  { "interrogate_type_get_destructor", &_inP07ytEG1l, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_elements", &_inP07yt7tUq, METH_VARARGS, nullptr },
+  { "interrogate_type_get_element", &_inP07ytyStU, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_methods", &_inP07ytdM85, METH_VARARGS, nullptr },
+  { "interrogate_type_get_method", &_inP07ytk_GN, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_make_seqs", &_inP07yt8QjG, METH_VARARGS, nullptr },
+  { "interrogate_type_get_make_seq", &_inP07ytyMtj, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_casts", &_inP07ytHDtN, METH_VARARGS, nullptr },
+  { "interrogate_type_get_cast", &_inP07ytHFjA, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_derivations", &_inP07yt_NPR, METH_VARARGS, nullptr },
+  { "interrogate_type_get_derivation", &_inP07ytcTOH, METH_VARARGS, nullptr },
+  { "interrogate_type_derivation_has_upcast", &_inP07ythdU7, METH_VARARGS, nullptr },
+  { "interrogate_type_get_upcast", &_inP07ytQPxU, METH_VARARGS, nullptr },
+  { "interrogate_type_derivation_downcast_is_impossible", &_inP07ytO7Pz, METH_VARARGS, nullptr },
+  { "interrogate_type_derivation_has_downcast", &_inP07ytvu_E, METH_VARARGS, nullptr },
+  { "interrogate_type_get_downcast", &_inP07ytxGUt, METH_VARARGS, nullptr },
+  { "interrogate_type_number_of_nested_types", &_inP07ytzM1P, METH_VARARGS, nullptr },
+  { "interrogate_type_get_nested_type", &_inP07ytoY5L, METH_VARARGS, nullptr },
+  { "interrogate_request_database", &_inP07yte_7S, METH_VARARGS, nullptr },
+  { "interrogate_request_module", &_inP07ytw_15, METH_VARARGS, nullptr },
+  { nullptr, nullptr, 0, nullptr }
 };
 
 #if PY_MAJOR_VERSION >= 3

dtool/src/cppparser/cppManifest.cxx

@@ -226,8 +226,8 @@ output(std::ostream &out) const {
         out << "$1";
       }
 
-      for (int i = 1; i < _num_parameters; ++i) {
-        if (_variadic_param == i) {
+      for (size_t i = 1; i < _num_parameters; ++i) {
+        if (_variadic_param == (int)i) {
           out << ", ...";
         } else {
           out << ", $" << i + 1;

dtool/src/cppparser/cppManifest.h

@@ -43,7 +43,7 @@ public:
 
   std::string _name;
   bool _has_parameters;
-  int _num_parameters;
+  size_t _num_parameters;
   int _variadic_param;
   cppyyltype _loc;
   CPPExpression *_expr;

dtool/src/cppparser/cppNamespace.cxx

@@ -22,9 +22,9 @@
 CPPNamespace::
 CPPNamespace(CPPIdentifier *ident, CPPScope *scope, const CPPFile &file) :
   CPPDeclaration(file),
+  _is_inline(false),
   _ident(ident),
-  _scope(scope),
-  _is_inline(false)
+  _scope(scope)
 {
 }
 

dtool/src/cppparser/cppStructType.cxx

@@ -58,8 +58,8 @@ CPPStructType(const CPPStructType &copy) :
   CPPExtensionType(copy),
   _scope(copy._scope),
   _incomplete(copy._incomplete),
-  _derivation(copy._derivation),
-  _final(copy._final)
+  _final(copy._final),
+  _derivation(copy._derivation)
 {
   _subst_decl_recursive_protect = false;
 }

dtool/src/dtoolbase/patomic.I

@@ -356,7 +356,7 @@ clear(std::memory_order order) noexcept {
  */
 ALWAYS_INLINE bool patomic_flag::
 test_and_set(std::memory_order order) noexcept {
-  return (bool)_value.exchange(1u, order);
+  return _value.exchange(1u, order) != 0u;
 }
 
 /**
@@ -364,7 +364,7 @@ test_and_set(std::memory_order order) noexcept {
  */
 ALWAYS_INLINE bool patomic_flag::
 test(std::memory_order order) const noexcept {
-  return (bool)_value.load(order);
+  return _value.load(order) != 0u;
 }
 
 /**

dtool/src/dtoolbase/typeHandle_ext.cxx

@@ -38,7 +38,6 @@ make(PyTypeObject *tp) {
 PyObject *Extension<TypeHandle>::
 __reduce__() const {
   extern struct Dtool_PyTypedObject Dtool_TypeHandle;
-  extern struct Dtool_PyTypedObject Dtool_TypeRegistry;
 
   if (!*_this) {
     PyObject *func = PyObject_GetAttrString((PyObject *)&Dtool_TypeHandle, "none");

dtool/src/interrogate/interfaceMaker.cxx

@@ -77,8 +77,8 @@ InterfaceMaker::Function::
  */
 InterfaceMaker::MakeSeq::
 MakeSeq(const string &name, const InterrogateMakeSeq &imake_seq) :
-  _name(name),
   _imake_seq(imake_seq),
+  _name(name),
   _length_getter(nullptr),
   _element_getter(nullptr)
 {

dtool/src/interrogate/interfaceMakerPythonNative.cxx

@@ -2510,11 +2510,11 @@ write_module_class(ostream &out, Object *obj) {
           out << "  if (arg2 != nullptr && arg2 != Py_None) {\n";
           out << "    PyObject *args = PyTuple_Pack(2, arg, arg2);\n";
           write_function_forset(out, two_param_remaps, 2, 2, expected_params, 4,
-                                true, true, AT_varargs, RF_pyobject | RF_err_null | RF_decref_args, true);
+                                true, true, AT_varargs, return_flags | RF_decref_args, true);
           out << "    Py_DECREF(args);\n";
           out << "  } else {\n";
           write_function_forset(out, one_param_remaps, 1, 1, expected_params, 4,
-                                true, true, AT_single_arg, RF_pyobject | RF_err_null, true);
+                                true, true, AT_single_arg, return_flags, true);
           out << "  }\n\n";
 
           out << "  if (!_PyErr_OCCURRED()) {\n";

dtool/src/interrogate/interfaceMakerPythonObj.cxx

@@ -102,10 +102,10 @@ write_module(ostream &out,ostream *out_h, InterrogateModuleDef *def) {
          ++fi) {
       Function *func = (*fi);
       out << "  { \"" << func->_ifunc.get_name() << "\", &" << func->_name
-          << ", METH_VARARGS },\n";
+          << ", METH_VARARGS, nullptr },\n";
     }
   }
-  out << "  { nullptr, nullptr }\n"
+  out << "  { nullptr, nullptr, 0, nullptr }\n"
       << "};\n\n"
 
       << "#if PY_MAJOR_VERSION >= 3\n"

dtool/src/interrogate/interfaceMakerPythonSimple.cxx

@@ -89,10 +89,10 @@ write_module(ostream &out,ostream *out_h, InterrogateModuleDef *def) {
     for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri) {
       FunctionRemap *remap = (*ri);
       out << "  { \"" << remap->_reported_name << "\", &"
-          << remap->_wrapper_name << ", METH_VARARGS },\n";
+          << remap->_wrapper_name << ", METH_VARARGS, nullptr },\n";
     }
   }
-  out << "  { nullptr, nullptr }\n"
+  out << "  { nullptr, nullptr, 0, nullptr }\n"
       << "};\n\n"
 
       << "#if PY_MAJOR_VERSION >= 3\n"

panda/src/bullet/bulletConvexPointCloudShape.I

@@ -16,8 +16,8 @@
  */
 INLINE BulletConvexPointCloudShape::
 BulletConvexPointCloudShape() :
-  _scale(1),
-  _shape(nullptr) {
+  _shape(nullptr),
+  _scale(1) {
 }
 
 /**

panda/src/bullet/bulletTriangleMeshShape.cxx

@@ -29,9 +29,9 @@ TypeHandle BulletTriangleMeshShape::_type_handle;
  */
 BulletTriangleMeshShape::
 BulletTriangleMeshShape() :
-  _mesh(nullptr),
-  _gimpact_shape(nullptr),
   _bvh_shape(nullptr),
+  _gimpact_shape(nullptr),
+  _mesh(nullptr),
   _dynamic(false),
   _compress(false),
   _bvh(false) {

panda/src/chan/animControl.cxx

@@ -32,8 +32,8 @@ AnimControl(const std::string &name, PartBundle *part,
   Namable(name),
   _pending_lock(name),
   _pending_cvar(_pending_lock),
-  _bound_joints(BitArray::all_on()),
-  _part(part)
+  _part(part),
+  _bound_joints(BitArray::all_on())
 {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::update_type(this, get_class_type());

panda/src/char/character.cxx

@@ -38,16 +38,16 @@ PStatCollector Character::_animation_pcollector("*:Animation");
 Character::
 Character(const Character &copy, bool copy_bundles) :
   PartBundleNode(copy),
+  _last_auto_update(-1.0),
+  _view_frame(-1),
+  _view_distance2(0.0f),
   _lod_center(copy._lod_center),
   _lod_far_distance(copy._lod_far_distance),
   _lod_near_distance(copy._lod_near_distance),
   _lod_delay_factor(copy._lod_delay_factor),
   _do_lod_animation(copy._do_lod_animation),
   _joints_pcollector(copy._joints_pcollector),
-  _skinning_pcollector(copy._skinning_pcollector),
-  _last_auto_update(-1.0),
-  _view_frame(-1),
-  _view_distance2(0.0f)
+  _skinning_pcollector(copy._skinning_pcollector)
 {
   set_cull_callback();
 
@@ -75,11 +75,11 @@ Character(const Character &copy, bool copy_bundles) :
 Character::
 Character(const std::string &name) :
   PartBundleNode(name, new CharacterJointBundle(name)),
-  _joints_pcollector(PStatCollector(_animation_pcollector, name), "Joints"),
-  _skinning_pcollector(PStatCollector(_animation_pcollector, name), "Vertices"),
   _last_auto_update(-1.0),
   _view_frame(-1),
-  _view_distance2(0.0f)
+  _view_distance2(0.0f),
+  _joints_pcollector(PStatCollector(_animation_pcollector, name), "Joints"),
+  _skinning_pcollector(PStatCollector(_animation_pcollector, name), "Vertices")
 {
   set_cull_callback();
   clear_lod_animation();

panda/src/collide/collisionBox.cxx

@@ -506,7 +506,7 @@ test_intersection_from_parabola(const CollisionEntry &entry) const {
   LParabola local_p(parabola->get_parabola());
   local_p.xform(wrt_mat);
 
-  PN_stdfloat t = INT_MAX;
+  PN_stdfloat t = FLT_MAX;
   PN_stdfloat t1, t2;
   int intersecting_face = -1;
   for (int i = 0; i < get_num_planes(); i++) {

panda/src/collide/collisionHandlerEvent.I

@@ -25,15 +25,6 @@ operator () (const PT(CollisionEntry) &a,
   return a->get_into_node_path() < b->get_into_node_path();
 }
 
-/**
- * The assignment operator does absolutely nothing, since this is just a
- * function object class that stores no data.  We define it just to quiet up
- * g++ in -Wall mode.
- */
-INLINE void CollisionHandlerEvent::SortEntries::
-operator = (const CollisionHandlerEvent::SortEntries &) {
-}
-
 /**
  * Removes all of the previously-added in patterns.  See add_in_pattern.
  */

panda/src/collide/collisionHandlerEvent.h

@@ -90,7 +90,6 @@ protected:
     INLINE bool
     operator () (const PT(CollisionEntry) &a,
                  const PT(CollisionEntry) &b) const;
-    INLINE void operator = (const SortEntries &other);
   };
 
   typedef pset<PT(CollisionEntry), SortEntries> Colliding;

panda/src/collide/collisionHandlerPhysical_ext.cxx

@@ -21,7 +21,6 @@
  */
 PyObject *Extension<CollisionHandlerPhysical>::
 __reduce__(PyObject *self) const {
-  extern struct Dtool_PyTypedObject Dtool_Datagram;
   extern struct Dtool_PyTypedObject Dtool_NodePath;
 
   // Create a tuple with all the NodePath pointers.

panda/src/collide/collisionLevelStateBase.I

@@ -31,8 +31,8 @@ CollisionLevelStateBase(const CollisionLevelStateBase &parent, PandaNode *child)
   _node_path(parent._node_path, child),
   _colliders(parent._colliders),
   _include_mask(parent._include_mask),
-  _local_bounds(parent._local_bounds),
-  _node_gbv(child->get_bounds()->as_geometric_bounding_volume())
+  _node_gbv(child->get_bounds()->as_geometric_bounding_volume()),
+  _local_bounds(parent._local_bounds)
 {
 }
 
@@ -44,8 +44,8 @@ CollisionLevelStateBase(const CollisionLevelStateBase &parent, const PandaNode::
   _node_path(parent._node_path, child.get_child()),
   _colliders(parent._colliders),
   _include_mask(parent._include_mask),
-  _local_bounds(parent._local_bounds),
-  _node_gbv(child.get_bounds())
+  _node_gbv(child.get_bounds()),
+  _local_bounds(parent._local_bounds)
 {
 }
 
@@ -57,9 +57,9 @@ CollisionLevelStateBase(const CollisionLevelStateBase &copy) :
   _node_path(copy._node_path),
   _colliders(copy._colliders),
   _include_mask(copy._include_mask),
+  _node_gbv(copy._node_gbv),
   _local_bounds(copy._local_bounds),
-  _parent_bounds(copy._parent_bounds),
-  _node_gbv(copy._node_gbv)
+  _parent_bounds(copy._parent_bounds)
 {
 }
 
@@ -71,9 +71,9 @@ operator = (const CollisionLevelStateBase &copy) {
   _node_path = copy._node_path;
   _colliders = copy._colliders;
   _include_mask = copy._include_mask;
+  _node_gbv = copy._node_gbv;
   _local_bounds = copy._local_bounds;
   _parent_bounds = copy._parent_bounds;
-  _node_gbv = copy._node_gbv;
 }
 
 /**

panda/src/collide/collisionTraverser.cxx

@@ -647,7 +647,7 @@ r_traverse_single(CollisionLevelStateSingle &level_state, size_t pass) {
     // child.
     int index = node->get_visible_child();
     PandaNode::Children children = node->get_children();
-    if (index >= 0 && index < children.get_num_children()) {
+    if (index >= 0 && (size_t)index < children.get_num_children()) {
       const PandaNode::DownConnection &child = children.get_child_connection(index);
       CollisionLevelStateSingle::CurrentMask mask = level_state.get_child_mask(child);
       if (!mask.is_zero()) {
@@ -856,7 +856,7 @@ r_traverse_double(CollisionLevelStateDouble &level_state, size_t pass) {
     // child.
     int index = node->get_visible_child();
     PandaNode::Children children = node->get_children();
-    if (index >= 0 && index < children.get_num_children()) {
+    if (index >= 0 && (size_t)index < children.get_num_children()) {
       const PandaNode::DownConnection &child = children.get_child_connection(index);
       CollisionLevelStateDouble::CurrentMask mask = level_state.get_child_mask(child);
       if (!mask.is_zero()) {
@@ -1065,7 +1065,7 @@ r_traverse_quad(CollisionLevelStateQuad &level_state, size_t pass) {
     // child.
     int index = node->get_visible_child();
     PandaNode::Children children = node->get_children();
-    if (index >= 0 && index < children.get_num_children()) {
+    if (index >= 0 && (size_t)index < children.get_num_children()) {
       const PandaNode::DownConnection &child = children.get_child_connection(index);
       CollisionLevelStateQuad::CurrentMask mask = level_state.get_child_mask(child);
       if (!mask.is_zero()) {

panda/src/collide/collisionTraverser_ext.cxx

@@ -21,7 +21,6 @@
 PyObject *Extension<CollisionTraverser>::
 __getstate__() const {
   extern struct Dtool_PyTypedObject Dtool_CollisionHandler;
-  extern struct Dtool_PyTypedObject Dtool_CollisionTraverser;
   extern struct Dtool_PyTypedObject Dtool_NodePath;
 
   const std::string &name = _this->get_name();

panda/src/device/evdevInputDevice.cxx

@@ -126,8 +126,9 @@ TypeHandle EvdevInputDevice::_type_handle;
 EvdevInputDevice::
 EvdevInputDevice(LinuxInputDeviceManager *manager, size_t index) :
   _manager(manager),
-  _index(index),
   _fd(-1),
+  _quirks(0),
+  _index(index),
   _can_write(false),
   _ff_id(-1),
   _ff_playing(false),
@@ -138,9 +139,8 @@ EvdevInputDevice(LinuxInputDeviceManager *manager, size_t index) :
   _dpad_left_button(-1),
   _dpad_up_button(-1),
   _ltrigger_code(-1),
-  _rtrigger_code(-1),
-  _quirks(0) {
-
+  _rtrigger_code(-1)
+{
   char path[64];
   sprintf(path, "/dev/input/event%zd", index);
 

panda/src/display/displayRegion.cxx

@@ -731,6 +731,7 @@ do_cull(CullHandler *cull_handler, SceneSetup *scene_setup,
  */
 DisplayRegion::CData::
 CData() :
+  _depth_range(0, 1),
   _lens_index(0),
   _camera_node(nullptr),
   _active(true),
@@ -738,8 +739,7 @@ CData() :
   _stereo_channel(Lens::SC_mono),
   _tex_view_offset(0),
   _target_tex_page(-1),
-  _scissor_enabled(true),
-  _depth_range(0, 1)
+  _scissor_enabled(true)
 {
   _regions.push_back(Region());
 }
@@ -750,6 +750,7 @@ CData() :
 DisplayRegion::CData::
 CData(const DisplayRegion::CData &copy) :
   _regions(copy._regions),
+  _depth_range(copy._depth_range),
   _lens_index(copy._lens_index),
   _camera(copy._camera),
   _camera_node(copy._camera_node),
@@ -758,8 +759,7 @@ CData(const DisplayRegion::CData &copy) :
   _stereo_channel(copy._stereo_channel),
   _tex_view_offset(copy._tex_view_offset),
   _target_tex_page(copy._target_tex_page),
-  _scissor_enabled(copy._scissor_enabled),
-  _depth_range(copy._depth_range)
+  _scissor_enabled(copy._scissor_enabled)
 {
 }
 

panda/src/display/graphicsOutput.cxx

@@ -75,10 +75,10 @@ GraphicsOutput(GraphicsEngine *engine, GraphicsPipe *pipe,
                GraphicsOutput *host,
                bool default_stereo_flags) :
   _lock("GraphicsOutput"),
+  _size(0, 0),
   _cull_window_pcollector(_cull_pcollector, name),
   _draw_window_pcollector(_draw_pcollector, name),
-  _clear_window_pcollector(_draw_window_pcollector, "Clear"),
-  _size(0, 0)
+  _clear_window_pcollector(_draw_window_pcollector, "Clear")
 {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::update_type(this, this);

panda/src/display/graphicsStateGuardian.cxx

@@ -2035,7 +2035,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2058,7 +2058,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2087,7 +2087,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2117,7 +2117,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2140,7 +2140,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2170,7 +2170,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();
@@ -2191,7 +2191,7 @@ fetch_specified_texture(Shader::ShaderTexSpec &spec, SamplerState &sampler,
     {
       const TextureAttrib *texattrib;
       if (_target_rs->get_attrib(texattrib)) {
-        size_t si = 0;
+        int si = 0;
         for (int i = 0; i < texattrib->get_num_on_stages(); ++i) {
           TextureStage *stage = texattrib->get_on_stage(i);
           TextureStage::Mode mode = stage->get_mode();

panda/src/display/graphicsWindow.cxx

@@ -39,8 +39,8 @@ GraphicsWindow(GraphicsEngine *engine, GraphicsPipe *pipe,
                GraphicsOutput *host) :
   GraphicsOutput(engine, pipe, name, fb_prop, win_prop, flags, gsg, host, true),
   _input_lock("GraphicsWindow::_input_lock"),
-  _properties_lock("GraphicsWindow::_properties_lock"),
-  _latency_pcollector(name + " latency")
+  _latency_pcollector(name + " latency"),
+  _properties_lock("GraphicsWindow::_properties_lock")
 {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::update_type(this, this);

panda/src/display/standardMunger.cxx

@@ -37,11 +37,11 @@ StandardMunger(GraphicsStateGuardianBase *gsg, const RenderState *state,
   _num_components(num_components),
   _numeric_type(numeric_type),
   _contents(contents),
-  _munge_color(false),
-  _munge_color_scale(false),
   _auto_shader(false),
   _shader_skinning(false),
-  _remove_material(false)
+  _remove_material(false),
+  _munge_color(false),
+  _munge_color_scale(false)
 {
   const ShaderAttrib *shader_attrib;
   state->get_attrib_def(shader_attrib);

panda/src/egg/eggMesherEdge.I

@@ -20,18 +20,6 @@ EggMesherEdge(int vi_a, int vi_b) : _vi_a(vi_a), _vi_b(vi_b) {
   _opposite = nullptr;
 }
 
-/**
- *
- */
-INLINE EggMesherEdge::
-EggMesherEdge(const EggMesherEdge &copy) :
-  _vi_a(copy._vi_a),
-  _vi_b(copy._vi_b),
-  _strips(copy._strips),
-  _opposite(copy._opposite)
-{
-}
-
 /**
  * Returns true if the edge contains the indicated vertex index, false
  * otherwise.

panda/src/egg/eggMesherEdge.h

@@ -29,7 +29,6 @@ class EggMesherStrip;
 class EXPCL_PANDA_EGG EggMesherEdge {
 public:
   INLINE EggMesherEdge(int vi_a, int vi_b);
-  INLINE EggMesherEdge(const EggMesherEdge &copy);
 
   void remove(EggMesherStrip *strip);
   void change_strip(EggMesherStrip *from, EggMesherStrip *to);

panda/src/egg2pg/eggSaver.cxx

@@ -803,7 +803,7 @@ convert_primitive(const GeomVertexData *vertex_data,
     const TexMatrixAttrib *tma = nullptr;
     net_state->get_attrib(tma);
 
-    for (size_t i = 0; i < ta->get_num_on_stages(); ++i) {
+    for (size_t i = 0; i < (size_t)ta->get_num_on_stages(); ++i) {
       TextureStage *tex_stage = ta->get_on_stage(i);
 
       EggTexture *egg_tex = get_egg_texture(ta->get_on_texture(tex_stage));

panda/src/event/eventHandler.I

@@ -19,7 +19,7 @@ INLINE EventHandler *EventHandler::
 get_global_event_handler(EventQueue *queue) {
   // The event queue parameter is present for now, for backward compatibility,
   // but it is ignored.
-  if (_global_event_handler == 0) {
+  if (_global_event_handler == nullptr) {
     make_global_event_handler();
   }
   return _global_event_handler;

panda/src/event/pythonTask.cxx

@@ -40,13 +40,13 @@ PythonTask(PyObject *func_or_coro, const std::string &name) :
   _args(nullptr),
   _upon_death(nullptr),
   _owner(nullptr),
-  _registered_to_owner(false),
   _exception(nullptr),
   _exc_value(nullptr),
   _exc_traceback(nullptr),
   _generator(nullptr),
   _fut_waiter(nullptr),
   _ignore_return(false),
+  _registered_to_owner(false),
   _retrieved_exception(false) {
 
   nassertv(func_or_coro != nullptr);

panda/src/express/referenceCount.I

@@ -28,8 +28,8 @@ TypeHandle RefCountObj<Base>::_type_handle;
  */
 INLINE ReferenceCount::
 ReferenceCount() :
-  _weak_list(nullptr),
-  _ref_count(0) {
+  _ref_count(0),
+  _weak_list(nullptr) {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::record_pointer(this);
 #endif
@@ -45,8 +45,8 @@ ReferenceCount() :
  */
 INLINE ReferenceCount::
 ReferenceCount(const ReferenceCount &) :
-  _weak_list(nullptr),
-  _ref_count(0) {
+  _ref_count(0),
+  _weak_list(nullptr) {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::record_pointer(this);
 #endif

panda/src/express/zipArchive.cxx

@@ -1461,7 +1461,6 @@ read_index() {
 
   uint64_t cdir_entries = 0;
   uint64_t cdir_offset = 0;
-  uint64_t cdir_size = 0;
   uint32_t comment_length = 0;
   std::streampos eocd_offset = 0;
   bool found = false;
@@ -1482,7 +1481,7 @@ read_index() {
         eocd_offset = read->tellg() - (std::streamoff)4;
         reader.skip_bytes(6);
         cdir_entries = reader.get_uint16();
-        cdir_size = reader.get_uint32();
+        /*cdir_size = */reader.get_uint32();
         cdir_offset = reader.get_uint32();
         if (comment_length > 0) {
           _comment = reader.get_fixed_string(comment_length);
@@ -1526,7 +1525,7 @@ read_index() {
       if (reader.get_uint32() == 0x06064b50) {
         reader.skip_bytes(20);
         cdir_entries = reader.get_uint64();
-        cdir_size = reader.get_uint64();
+        /*cdir_size = */reader.get_uint64();
         cdir_offset = reader.get_uint64();
       } else {
         express_cat.info()
@@ -1702,9 +1701,9 @@ read_index(std::istream &read) {
     return false;
   }
 
-  uint16_t version = reader.get_uint8();
+  /*uint16_t version = */reader.get_uint8();
   _system = reader.get_uint8();
-  uint16_t min_version = reader.get_uint16();
+  /*uint16_t min_version = */reader.get_uint16();
   _flags = reader.get_uint16();
   _compression_method = (CompressionMethod)reader.get_uint16();
   {

panda/src/ffmpeg/ffmpegAudioCursor.cxx

@@ -50,10 +50,10 @@ FfmpegAudioCursor(FfmpegAudio *src) :
   _packet_data(nullptr),
   _format_ctx(nullptr),
   _audio_ctx(nullptr),
-  _resample_ctx(nullptr),
+  _frame(nullptr),
   _buffer(nullptr),
   _buffer_alloc(nullptr),
-  _frame(nullptr)
+  _resample_ctx(nullptr)
 {
   if (!_ffvfile.open_vfs(_filename)) {
     cleanup();

panda/src/ffmpeg/ffmpegVideoCursor.cxx

@@ -47,6 +47,7 @@ FfmpegVideoCursor::
 FfmpegVideoCursor() :
   _max_readahead_frames(0),
   _thread_priority(ffmpeg_thread_priority),
+  _pixel_format((int)AV_PIX_FMT_NONE),
   _lock("FfmpegVideoCursor::_lock"),
   _action_cvar(_lock),
   _thread_status(TS_stopped),
@@ -55,7 +56,6 @@ FfmpegVideoCursor() :
   _format_ctx(nullptr),
   _video_ctx(nullptr),
   _convert_ctx(nullptr),
-  _pixel_format((int)AV_PIX_FMT_NONE),
   _video_index(-1),
   _frame(nullptr),
   _frame_out(nullptr),

panda/src/glstuff/glGraphicsBuffer_src.cxx

@@ -30,12 +30,12 @@ CLP(GraphicsBuffer)(GraphicsEngine *engine, GraphicsPipe *pipe,
                     GraphicsStateGuardian *gsg,
                     GraphicsOutput *host) :
   GraphicsBuffer(engine, pipe, name, fb_prop, win_prop, flags, gsg, host),
-  _bind_texture_pcollector(_draw_window_pcollector, "Bind textures"),
-  _generate_mipmap_pcollector(_draw_window_pcollector, "Generate mipmaps"),
-  _resolve_multisample_pcollector(_draw_window_pcollector, "Resolve multisamples"),
   _requested_multisamples(0),
   _requested_coverage_samples(0),
-  _rb_context(nullptr)
+  _rb_context(nullptr),
+  _bind_texture_pcollector(_draw_window_pcollector, "Bind textures"),
+  _generate_mipmap_pcollector(_draw_window_pcollector, "Generate mipmaps"),
+  _resolve_multisample_pcollector(_draw_window_pcollector, "Resolve multisamples")
 {
   // A FBO doesn't have a back buffer.
   _draw_buffer_type       = RenderBuffer::T_front;

panda/src/glstuff/glShaderContext_src.cxx

@@ -2689,7 +2689,9 @@ update_shader_texture_bindings(ShaderContext *prev) {
     return;
   }
 
+#ifndef OPENGLES
   GLbitfield barriers = 0;
+#endif
 
   // First bind all the 'image units'; a bit of an esoteric OpenGL feature
   // right now.
@@ -2738,9 +2740,11 @@ update_shader_texture_bindings(ShaderContext *prev) {
           _glgsg->update_texture(gtc, true);
           gl_tex = gtc->_index;
 
+#ifndef OPENGLES
           if (gtc->needs_barrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)) {
             barriers |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT;
           }
+#endif
         }
       }
       input._writable = false;
@@ -2858,6 +2862,12 @@ update_shader_texture_bindings(ShaderContext *prev) {
           << "Sampler type of GLSL shader input p3d_LightSource[" << spec._stage
           << "].shadowMap does not match type of texture " << *tex << ".\n";
         break;
+
+      default:
+        GLCAT.error()
+          << "Sampler type of GLSL shader input does not match type of "
+             "texture " << *tex << ".\n";
+        break;
       }
       // TODO: also check whether shadow sampler textures have shadow filter
       // enabled.

panda/src/gobj/geomVertexArrayData.cxx

@@ -83,8 +83,8 @@ GeomVertexArrayData(const GeomVertexArrayFormat *array_format,
                     GeomVertexArrayData::UsageHint usage_hint) :
   SimpleLruPage(0),
   _array_format(array_format),
-  _cycler(CData(usage_hint)),
-  _contexts(nullptr)
+  _contexts(nullptr),
+  _cycler(CData(usage_hint))
 {
   set_lru_size(0);
   nassertv(_array_format->is_registered());
@@ -98,8 +98,8 @@ GeomVertexArrayData(const GeomVertexArrayData &copy) :
   CopyOnWriteObject(copy),
   SimpleLruPage(copy),
   _array_format(copy._array_format),
-  _cycler(copy._cycler),
-  _contexts(nullptr)
+  _contexts(nullptr),
+  _cycler(copy._cycler)
 {
   copy.mark_used_lru();
 

panda/src/gobj/geomVertexColumn.I

@@ -30,11 +30,11 @@ GeomVertexColumn(CPT_InternalName name, int num_components,
                  int element_stride) :
   _name(std::move(name)),
   _num_components(num_components),
+  _num_elements(num_elements),
   _numeric_type(numeric_type),
   _contents(contents),
   _start(start),
   _column_alignment(column_alignment),
-  _num_elements(num_elements),
   _element_stride(element_stride),
   _packer(nullptr)
 {
@@ -48,11 +48,11 @@ INLINE GeomVertexColumn::
 GeomVertexColumn(const GeomVertexColumn &copy) :
   _name(copy._name),
   _num_components(copy._num_components),
+  _num_elements(copy._num_elements),
   _numeric_type(copy._numeric_type),
   _contents(copy._contents),
   _start(copy._start),
   _column_alignment(copy._column_alignment),
-  _num_elements(copy._num_elements),
   _element_stride(copy._element_stride),
   _packer(nullptr)
 {

panda/src/gobj/geomVertexData.I

@@ -605,8 +605,8 @@ CacheEntry(GeomVertexData *source, CacheKey &&key) noexcept :
  */
 INLINE GeomVertexData::CData::
 CData() :
-  _format(nullptr),
-  _usage_hint(UH_unspecified)
+  _usage_hint(UH_unspecified),
+  _format(nullptr)
 {
 }
 
@@ -615,8 +615,8 @@ CData() :
  */
 INLINE GeomVertexData::CData::
 CData(const GeomVertexFormat *format, GeomVertexData::UsageHint usage_hint) :
-  _format(format),
-  _usage_hint(usage_hint)
+  _usage_hint(usage_hint),
+  _format(format)
 {
   size_t num_arrays = format->get_num_arrays();
   for (size_t i = 0; i < num_arrays; ++i) {

panda/src/gobj/geomVertexData.cxx

@@ -66,11 +66,11 @@ GeomVertexData(const std::string &name,
                const GeomVertexFormat *format,
                GeomVertexData::UsageHint usage_hint) :
   _name(name),
+  _cycler(GeomVertexData::CData(format, usage_hint)),
   _char_pcollector(PStatCollector(_animation_pcollector, name)),
   _skinning_pcollector(_char_pcollector, "Skinning"),
   _morphs_pcollector(_char_pcollector, "Morphs"),
-  _blends_pcollector(_char_pcollector, "Calc blends"),
-  _cycler(GeomVertexData::CData(format, usage_hint))
+  _blends_pcollector(_char_pcollector, "Calc blends")
 {
   nassertv(format->is_registered());
 }

panda/src/gobj/samplerState.I

@@ -17,14 +17,14 @@
 INLINE SamplerState::
 SamplerState() :
   _border_color(0, 0, 0, 1),
-  _wrap_u(WM_repeat),
-  _wrap_v(WM_repeat),
-  _wrap_w(WM_repeat),
-  _minfilter(FT_default),
-  _magfilter(FT_default),
   _min_lod(-1000),
   _max_lod(1000),
   _lod_bias(0),
+  _minfilter(FT_default),
+  _magfilter(FT_default),
+  _wrap_u(WM_repeat),
+  _wrap_v(WM_repeat),
+  _wrap_w(WM_repeat),
   _anisotropic_degree(0)
 {
 }

panda/src/gobj/texture.cxx

@@ -1116,7 +1116,7 @@ set_ram_image_as(CPTA_uchar image, const string &supplied_format) {
   if (cdata->_component_width == 1) {
     if (format == "RGBA" && cdata->_num_components == 4) {
       imgsize *= 4;
-      for (int p = 0; p < imgsize; p += 4) {
+      for (size_t p = 0; p < imgsize; p += 4) {
         newdata[p + 2] = image[p    ];
         newdata[p + 1] = image[p + 1];
         newdata[p    ] = image[p + 2];
@@ -1127,7 +1127,7 @@ set_ram_image_as(CPTA_uchar image, const string &supplied_format) {
     }
     if (format == "RGB" && cdata->_num_components == 3) {
       imgsize *= 3;
-      for (int p = 0; p < imgsize; p += 3) {
+      for (size_t p = 0; p < imgsize; p += 3) {
         newdata[p + 2] = image[p    ];
         newdata[p + 1] = image[p + 1];
         newdata[p    ] = image[p + 2];
@@ -1138,13 +1138,13 @@ set_ram_image_as(CPTA_uchar image, const string &supplied_format) {
     if (format == "A" && cdata->_num_components != 3) {
       // We can generally rely on alpha to be the last component.
       int component = cdata->_num_components - 1;
-      for (int p = 0; p < imgsize; ++p) {
+      for (size_t p = 0; p < imgsize; ++p) {
         newdata[component] = image[p];
       }
       do_set_ram_image(cdata, newdata);
       return;
     }
-    for (int p = 0; p < imgsize; ++p) {
+    for (size_t p = 0; p < imgsize; ++p) {
       for (unsigned char s = 0; s < format.size(); ++s) {
         signed char component = -1;
         if (format.at(s) == 'B' || (cdata->_num_components <= 2 && format.at(s) != 'A')) {
@@ -1176,7 +1176,7 @@ set_ram_image_as(CPTA_uchar image, const string &supplied_format) {
     do_set_ram_image(cdata, newdata);
     return;
   }
-  for (int p = 0; p < imgsize; ++p) {
+  for (size_t p = 0; p < imgsize; ++p) {
     for (unsigned char s = 0; s < format.size(); ++s) {
       signed char component = -1;
       if (format.at(s) == 'B' || (cdata->_num_components <= 2 && format.at(s) != 'A')) {

panda/src/grutil/heightfieldTesselator.cxx

@@ -161,10 +161,10 @@ generate() {
   PT(PandaNode) result = new PandaNode(get_name());
   NodePath root(result);
 
-  int total = 0;
+  //int total = 0;
   for (int y=0; y<ycells; y++) {
     for (int x=0; x<xcells; x++) {
-      total += count_triangles(scale,x*size,y*size);
+      /*total += */count_triangles(scale,x*size,y*size);
     }
   }
   for (int y=0; y<ycells; y++) {

panda/src/grutil/shaderTerrainMesh.cxx

@@ -99,13 +99,13 @@ ShaderTerrainMesh::ShaderTerrainMesh() :
   _size(0),
   _chunk_size(32),
   _generate_patches(false),
-  _data_texture(nullptr),
+  _heightfield_tex(nullptr),
   _chunk_geom(nullptr),
+  _data_texture(nullptr),
   _current_view_index(0),
   _last_frame_count(-1),
   _target_triangle_width(10.0f),
-  _update_enabled(true),
-  _heightfield_tex(nullptr)
+  _update_enabled(true)
 {
   set_renderable();
 }

panda/src/mathutil/perlinNoise2.cxx

@@ -44,12 +44,12 @@ noise(const LVecBase2d &value) const {
   double v = fade(y);
 
   // Hash coordinates of the 4 square corners (A, B, A + 1, and B + 1)
-  nassertr(X >= 0 && X + 1 < _index.size(), make_nan(0.0));
+  nassertr(X >= 0 && (size_t)X + 1 < _index.size(), make_nan(0.0));
   int A = _index[X] + Y;
   int B = _index[X + 1] + Y;
 
-  nassertr(A >= 0 && A + 1 < _index.size(), make_nan(0.0));
-  nassertr(B >= 0 && B + 1 < _index.size(), make_nan(0.0));
+  nassertr(A >= 0 && (size_t)A + 1 < _index.size(), make_nan(0.0));
+  nassertr(B >= 0 && (size_t)B + 1 < _index.size(), make_nan(0.0));
 
   // and add blended results from 4 corners of square.
   double result =

panda/src/pgraph/camera.cxx

@@ -28,8 +28,8 @@ Camera(const string &name, Lens *lens) :
   LensNode(name, lens),
   _active(true),
   _camera_mask(~PandaNode::get_overall_bit()),
-  _initial_state(RenderState::make_empty()),
-  _lod_scale(1)
+  _lod_scale(1),
+  _initial_state(RenderState::make_empty())
 {
 }
 
@@ -42,8 +42,8 @@ Camera(const Camera &copy) :
   _active(copy._active),
   _scene(copy._scene),
   _camera_mask(copy._camera_mask),
-  _initial_state(copy._initial_state),
   _lod_scale(copy._lod_scale),
+  _initial_state(copy._initial_state),
   _tag_state_key(copy._tag_state_key),
   _tag_states(copy._tag_states)
 {

panda/src/pgraph/cullableObject.cxx

@@ -360,7 +360,7 @@ munge_points_to_quads(const CullTraverser *traverser, bool force) {
       for (size_t ai = 0; ai < sformat._format->get_num_arrays(); ++ai) {
         const GeomVertexArrayFormat *aformat = sformat._format->get_array(ai);
 
-        for (size_t ci = 0; ci < aformat->get_num_columns(); ++ci) {
+        for (size_t ci = 0; ci < (size_t)aformat->get_num_columns(); ++ci) {
           const GeomVertexColumn *column = aformat->get_column(ci);
           const InternalName *name = column->get_name();
           if (name != InternalName::get_vertex() &&
@@ -436,7 +436,7 @@ munge_points_to_quads(const CullTraverser *traverser, bool force) {
   pvector<CopyOp> copies;
 
   const GeomVertexArrayFormat *aformat = new_format->get_array(0);
-  for (size_t ci = 0; ci < aformat->get_num_columns(); ++ci) {
+  for (size_t ci = 0; ci < (size_t)aformat->get_num_columns(); ++ci) {
     const GeomVertexColumn *column = aformat->get_column(ci);
     const InternalName *name = column->get_name();
     if (name != InternalName::get_vertex() &&

panda/src/pgraph/nodePath.I

@@ -16,8 +16,8 @@
  */
 INLINE NodePath::
 NodePath() :
-  _error_type(ET_ok),
-  _backup_key(0)
+  _backup_key(0),
+  _error_type(ET_ok)
 {
 }
 

panda/src/pgraph/renderState.I

@@ -386,22 +386,6 @@ consider_update_pstats(int old_referenced_bits) const {
 #endif  // DO_PSTATS
 }
 
-/**
- *
- */
-INLINE RenderState::Composition::
-Composition() {
-}
-
-/**
- *
- */
-INLINE RenderState::Composition::
-Composition(const RenderState::Composition &copy) :
-  _result(copy._result)
-{
-}
-
 /**
  *
  */

panda/src/pgraph/renderState.h

@@ -253,9 +253,6 @@ private:
   // two involved RenderState objects.
   class Composition {
   public:
-    INLINE Composition();
-    INLINE Composition(const Composition &copy);
-
     // _result is reference counted if and only if it is not the same pointer
     // as this.
     const RenderState *_result;

panda/src/pgraph/shaderInput.I

@@ -19,8 +19,8 @@
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, int priority) :
   _name(std::move(name)),
-  _type(M_invalid),
-  _priority(priority)
+  _priority(priority),
+  _type(M_invalid)
 {
 }
 
@@ -30,9 +30,9 @@ ShaderInput(CPT_InternalName name, int priority) :
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, Texture *tex, int priority) :
   _name(std::move(name)),
-  _type(M_texture),
+  _value(tex),
   _priority(priority),
-  _value(tex)
+  _type(M_texture)
 {
 }
 
@@ -42,9 +42,9 @@ ShaderInput(CPT_InternalName name, Texture *tex, int priority) :
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, ParamValueBase *param, int priority) :
   _name(std::move(name)),
-  _type(M_param),
+  _value(param),
   _priority(priority),
-  _value(param)
+  _type(M_param)
 {
 }
 
@@ -54,9 +54,9 @@ ShaderInput(CPT_InternalName name, ParamValueBase *param, int priority) :
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, ShaderBuffer *buf, int priority) :
   _name(std::move(name)),
-  _type(M_buffer),
+  _value(buf),
   _priority(priority),
-  _value(buf)
+  _type(M_buffer)
 {
 }
 
@@ -65,10 +65,10 @@ ShaderInput(CPT_InternalName name, ShaderBuffer *buf, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_float &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -77,10 +77,10 @@ ShaderInput(CPT_InternalName name, const PTA_float &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase4f &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -89,10 +89,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase4f &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase3f &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -101,10 +101,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase3f &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase2f &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -113,11 +113,11 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase2f &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase4f &vec, int priority) :
+  _stored_vector(LCAST(PN_stdfloat, vec)),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_vector),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(LCAST(PN_stdfloat, vec))
+  _type(M_vector)
 {
 }
 
@@ -126,11 +126,11 @@ ShaderInput(CPT_InternalName name, const LVecBase4f &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase3f &vec, int priority) :
+  _stored_vector(vec.get_x(), vec.get_y(), vec.get_z(), 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_vector),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(vec.get_x(), vec.get_y(), vec.get_z(), 0.0)
+  _type(M_vector)
 {
 }
 
@@ -139,11 +139,11 @@ ShaderInput(CPT_InternalName name, const LVecBase3f &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase2f &vec, int priority) :
+  _stored_vector(vec.get_x(), vec.get_y(), 0.0, 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_vector),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(vec.get_x(), vec.get_y(), 0.0, 0.0)
+  _type(M_vector)
 {
 }
 
@@ -152,10 +152,10 @@ ShaderInput(CPT_InternalName name, const LVecBase2f &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LMatrix4f &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -164,10 +164,10 @@ ShaderInput(CPT_InternalName name, const PTA_LMatrix4f &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LMatrix3f &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -176,10 +176,10 @@ ShaderInput(CPT_InternalName name, const PTA_LMatrix3f &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LMatrix4f &mat, int priority) :
+  _stored_ptr(mat),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(mat)
+  _type(M_numeric)
 {
 }
 
@@ -188,10 +188,10 @@ ShaderInput(CPT_InternalName name, const LMatrix4f &mat, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LMatrix3f &mat, int priority) :
+  _stored_ptr(mat),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(mat)
+  _type(M_numeric)
 {
 }
 
@@ -200,10 +200,10 @@ ShaderInput(CPT_InternalName name, const LMatrix3f &mat, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_double &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -212,10 +212,10 @@ ShaderInput(CPT_InternalName name, const PTA_double &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase4d &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -224,10 +224,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase4d &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase3d &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -236,10 +236,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase3d &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase2d &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -248,11 +248,11 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase2d &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase4d &vec, int priority) :
+  _stored_vector(LCAST(PN_stdfloat, vec)),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(LCAST(PN_stdfloat, vec))
+  _type(M_numeric)
 {
 }
 
@@ -261,11 +261,11 @@ ShaderInput(CPT_InternalName name, const LVecBase4d &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase3d &vec, int priority) :
+  _stored_vector(vec.get_x(), vec.get_y(), vec.get_z(), 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(vec.get_x(), vec.get_y(), vec.get_z(), 0.0)
+  _type(M_numeric)
 {
 }
 
@@ -274,11 +274,11 @@ ShaderInput(CPT_InternalName name, const LVecBase3d &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase2d &vec, int priority) :
+  _stored_vector(vec.get_x(), vec.get_y(), 0.0, 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector(vec.get_x(), vec.get_y(), 0.0, 0.0)
+  _type(M_numeric)
 {
 }
 
@@ -287,10 +287,10 @@ ShaderInput(CPT_InternalName name, const LVecBase2d &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LMatrix4d &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -299,10 +299,10 @@ ShaderInput(CPT_InternalName name, const PTA_LMatrix4d &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LMatrix3d &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -311,10 +311,10 @@ ShaderInput(CPT_InternalName name, const PTA_LMatrix3d &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LMatrix4d &mat, int priority) :
+  _stored_ptr(mat),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(mat)
+  _type(M_numeric)
 {
 }
 
@@ -323,10 +323,10 @@ ShaderInput(CPT_InternalName name, const LMatrix4d &mat, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LMatrix3d &mat, int priority) :
+  _stored_ptr(mat),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(mat)
+  _type(M_numeric)
 {
 }
 
@@ -335,10 +335,10 @@ ShaderInput(CPT_InternalName name, const LMatrix3d &mat, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_int &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -347,10 +347,10 @@ ShaderInput(CPT_InternalName name, const PTA_int &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase4i &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -359,10 +359,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase4i &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase3i &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -371,10 +371,10 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase3i &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const PTA_LVecBase2i &ptr, int priority) :
+  _stored_ptr(ptr),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(ptr)
+  _type(M_numeric)
 {
 }
 
@@ -383,11 +383,11 @@ ShaderInput(CPT_InternalName name, const PTA_LVecBase2i &ptr, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase4i &vec, int priority) :
+  _stored_vector((int)vec.get_x(), (int)vec.get_y(), (int)vec.get_z(), (int)vec.get_w()),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector((int)vec.get_x(), (int)vec.get_y(), (int)vec.get_z(), (int)vec.get_w())
+  _type(M_numeric)
 {
 }
 
@@ -396,11 +396,11 @@ ShaderInput(CPT_InternalName name, const LVecBase4i &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase3i &vec, int priority) :
+  _stored_vector((int)vec.get_x(), (int)vec.get_y(), (int)vec.get_z(), 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector((int)vec.get_x(), (int)vec.get_y(), (int)vec.get_z(), 0.0)
+  _type(M_numeric)
 {
 }
 
@@ -409,11 +409,11 @@ ShaderInput(CPT_InternalName name, const LVecBase3i &vec, int priority) :
  */
 INLINE ShaderInput::
 ShaderInput(CPT_InternalName name, const LVecBase2i &vec, int priority) :
+  _stored_vector((int)vec.get_x(), (int)vec.get_y(), 0.0, 0.0),
+  _stored_ptr(vec),
   _name(std::move(name)),
-  _type(M_numeric),
   _priority(priority),
-  _stored_ptr(vec),
-  _stored_vector((int)vec.get_x(), (int)vec.get_y(), 0.0, 0.0)
+  _type(M_numeric)
 {
 }
 

panda/src/pgraph/shaderInput.cxx

@@ -31,9 +31,9 @@ get_blank() {
 ShaderInput::
 ShaderInput(CPT_InternalName name, const NodePath &np, int priority) :
   _name(std::move(name)),
-  _type(M_nodepath),
+  _value(new ParamNodePath(np)),
   _priority(priority),
-  _value(new ParamNodePath(np))
+  _type(M_nodepath)
 {
 }
 
@@ -43,9 +43,9 @@ ShaderInput(CPT_InternalName name, const NodePath &np, int priority) :
 ShaderInput::
 ShaderInput(CPT_InternalName name, Texture *tex, bool read, bool write, int z, int n, int priority) :
   _name(std::move(name)),
-  _type(M_texture_image),
+  _value(new ParamTextureImage(tex, read, write, z, n)),
   _priority(priority),
-  _value(new ParamTextureImage(tex, read, write, z, n))
+  _type(M_texture_image)
 {
 }
 
@@ -55,9 +55,9 @@ ShaderInput(CPT_InternalName name, Texture *tex, bool read, bool write, int z, i
 ShaderInput::
 ShaderInput(CPT_InternalName name, Texture *tex, const SamplerState &sampler, int priority) :
   _name(std::move(name)),
-  _type(M_texture_sampler),
+  _value(new ParamTextureSampler(tex, sampler)),
   _priority(priority),
-  _value(new ParamTextureSampler(tex, sampler))
+  _type(M_texture_sampler)
 {
 }
 

panda/src/pgraph/textureAttrib.I

@@ -236,9 +236,9 @@ StageNode(const TextureStage *stage, unsigned int implicit_sort, int override) :
   // Yeah, we cast away the constness here.  Just too much trouble to deal
   // with it properly.
   _stage((TextureStage *)stage),
+  _has_sampler(false),
   _implicit_sort(implicit_sort),
-  _override(override),
-  _has_sampler(false)
+  _override(override)
 {
 }
 

panda/src/pgraph/transformState.I

@@ -1050,22 +1050,6 @@ consider_update_pstats(int old_referenced_bits) const {
 #endif  // DO_PSTATS
 }
 
-/**
- *
- */
-INLINE TransformState::Composition::
-Composition() {
-}
-
-/**
- *
- */
-INLINE TransformState::Composition::
-Composition(const TransformState::Composition &copy) :
-  _result(copy._result)
-{
-}
-
 /**
  *
  */

panda/src/pgraph/transformState.h

@@ -282,9 +282,6 @@ private:
   // object destructs.
   class Composition {
   public:
-    INLINE Composition();
-    INLINE Composition(const Composition &copy);
-
     // _result is reference counted if and only if it is not the same pointer
     // as this.
     const TransformState *_result;

panda/src/pgraphnodes/fadeLodNode.cxx

@@ -168,13 +168,13 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
         if (elapsed < half_fade_time) {
           // FIRST HALF OF FADE Fade the new LOD in with z writing off Keep
           // drawing the old LOD opaque with z writing on
-          if (out_child >= 0 && out_child < children.get_num_children()) {
+          if (out_child >= 0 && (size_t)out_child < children.get_num_children()) {
             const PandaNode::DownConnection &child = children.get_child_connection(out_child);
             trav->traverse_down(data, child,
               data._state->compose(get_fade_1_old_state()));
           }
 
-          if (in_child >= 0 && in_child < children.get_num_children()) {
+          if (in_child >= 0 && (size_t)in_child < children.get_num_children()) {
             const PandaNode::DownConnection &child = children.get_child_connection(in_child);
             PN_stdfloat in_alpha = elapsed / half_fade_time;
             trav->traverse_down(data, child,
@@ -184,13 +184,13 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
         } else {
           // SECOND HALF OF FADE: Fade out the old LOD with z write off and
           // draw the opaque new LOD with z write on
-          if (in_child >= 0 && in_child < children.get_num_children()) {
+          if (in_child >= 0 && (size_t)in_child < children.get_num_children()) {
             const PandaNode::DownConnection &child = children.get_child_connection(in_child);
             trav->traverse_down(data, child,
               data._state->compose(get_fade_2_new_state()));
           }
 
-          if (out_child >= 0 && out_child < children.get_num_children()) {
+          if (out_child >= 0 && (size_t)out_child < children.get_num_children()) {
             const PandaNode::DownConnection &child = children.get_child_connection(out_child);
             PN_stdfloat out_alpha = 1.0f - (elapsed - half_fade_time) / half_fade_time;
             trav->traverse_down(data, child,
@@ -206,7 +206,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
     // just drawing one child of the LOD.
     int index = ldata->_fade_in;
     Children children = get_children();
-    if (index >= 0 && index < children.get_num_children()) {
+    if (index >= 0 && (size_t)index < children.get_num_children()) {
       const PandaNode::DownConnection &child = children.get_child_connection(index);
       trav->traverse_down(data, child, data._state);
     }

panda/src/pgraphnodes/lightLensNode.cxx

@@ -30,8 +30,8 @@ LightLensNode::
 LightLensNode(const std::string &name, Lens *lens) :
   Camera(name, lens),
   _has_specular_color(false),
-  _attrib_count(0),
-  _used_by_auto_shader(false)
+  _used_by_auto_shader(false),
+  _attrib_count(0)
 {
   set_active(false);
   _shadow_caster = false;
@@ -63,12 +63,12 @@ LightLensNode::
 LightLensNode(const LightLensNode &copy) :
   Light(copy),
   Camera(copy),
-  _shadow_caster(copy._shadow_caster),
   _sb_size(copy._sb_size),
-  _sb_sort(-10),
+  _shadow_caster(copy._shadow_caster),
   _has_specular_color(copy._has_specular_color),
-  _attrib_count(0),
-  _used_by_auto_shader(false)
+  _sb_sort(-10),
+  _used_by_auto_shader(false),
+  _attrib_count(0)
 {
   if (_shadow_caster) {
     setup_shadow_map();

panda/src/pgraphnodes/lodNode.cxx

@@ -430,7 +430,7 @@ show_switches_cull_callback(CullTraverser *trav, CullTraverserData &data) {
         // This switch level is in range.  Draw its children in the funny
         // wireframe mode.
         Children children = get_children();
-        if (index < children.get_num_children()) {
+        if ((size_t)index < children.get_num_children()) {
           const PandaNode::DownConnection &child = children.get_child_connection(index);
           trav->traverse_down(data, child, data._state->compose(sw.get_viz_model_state()));
         }

panda/src/pgui/pgItem.cxx

@@ -62,9 +62,9 @@ PGItem(const string &name) :
   _notify(nullptr),
   _has_frame(false),
   _frame(0, 0, 0, 0),
-  _region(new PGMouseWatcherRegion(this)),
   _state(0),
-  _flags(0)
+  _flags(0),
+  _region(new PGMouseWatcherRegion(this))
 {
   set_cull_callback();
   set_renderable();

panda/src/pipeline/pipeline.cxx

@@ -26,9 +26,9 @@ Pipeline(const std::string &name, int num_stages) :
   Namable(name),
 #ifdef THREADED_PIPELINE
   _num_stages(num_stages),
+  _next_cycle_seq(1),
   _cycle_lock("Pipeline cycle"),
-  _lock("Pipeline"),
-  _next_cycle_seq(1)
+  _lock("Pipeline")
 #else
   _num_stages(1)
 #endif

panda/src/pstatclient/config_pstatclient.cxx

@@ -12,7 +12,7 @@
  */
 
 #include "config_pstatclient.h"
-
+#include "pStatTimer.h"
 #include "dconfig.h"
 
 #if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_PANDA_PSTATCLIENT)

panda/src/pstatclient/pStatClient.cxx

@@ -1097,7 +1097,7 @@ stop_clock_wait() {
 void PStatClient::
 add_collector(PStatClient::Collector *collector) {
   int num_collectors = get_num_collectors();
-  if (num_collectors >= _collectors_size) {
+  if (num_collectors >= (int)_collectors_size) {
     // We need to grow the array.  We have to be careful here, because there
     // might be clients accessing the array right now who are not protected by
     // the lock.
@@ -1136,7 +1136,7 @@ add_thread(PStatClient::InternalThread *thread) {
   _threads_by_name[thread->_name].push_back(num_threads);
   _threads_by_sync_name[thread->_sync_name].push_back(num_threads);
 
-  if (num_threads >= _threads_size) {
+  if (num_threads >= (int)_threads_size) {
     // We need to grow the array.  We have to be careful here, because there
     // might be clients accessing the array right now who are not protected by
     // the lock.

panda/src/pstatclient/pStatTimer.h

@@ -27,7 +27,7 @@ class Thread;
  * and when the PStatTimer variable goes out of scope (for instance, at the
  * end of the function), it will automatically stop the Collector.
  */
-class PStatTimer {
+class EXPCL_PANDA_PSTATCLIENT PStatTimer {
 public:
 #ifdef DO_PSTATS
   INLINE PStatTimer(PStatCollector &collector);

panda/src/putil/clockObject.cxx

@@ -32,7 +32,7 @@ TypeHandle ClockObject::_type_handle;
  *
  */
 ClockObject::
-ClockObject(Mode mode) : _ticks(get_class_type()), _mode(mode) {
+ClockObject(Mode mode) : _mode(mode), _ticks(get_class_type()) {
   _true_clock = TrueClock::get_global_ptr();
 
   _start_short_time = _true_clock->get_short_time();

panda/src/tinydisplay/tinyGraphicsStateGuardian.cxx

@@ -3040,6 +3040,15 @@ get_color_blend_op(ColorBlendAttrib::Operand operand) {
   case ColorBlendAttrib::O_incoming_color_saturate:
     return 1;
 
+  case ColorBlendAttrib::O_incoming1_color:
+    return 1;
+  case ColorBlendAttrib::O_one_minus_incoming1_color:
+    return 0;
+  case ColorBlendAttrib::O_incoming1_alpha:
+    return 1;
+  case ColorBlendAttrib::O_one_minus_incoming1_alpha:
+    return 0;
+
   case ColorBlendAttrib::O_color_scale:
     return 10;
   case ColorBlendAttrib::O_one_minus_color_scale:

panda/src/tinydisplay/ztriangle.h

@@ -351,7 +351,7 @@
         unsigned int z,zz;
 #endif
 #ifdef INTERP_RGB
-        unsigned int or1,og1,ob1,oa1;
+        UNUSED unsigned int or1,og1,ob1,oa1;
 #endif
 #ifdef INTERP_ST
         unsigned int s,t;

panda/src/x11display/x11GraphicsPipe.cxx

@@ -35,8 +35,8 @@ LightReMutex x11GraphicsPipe::_x_mutex;
  */
 x11GraphicsPipe::
 x11GraphicsPipe(const std::string &display) :
-  _have_xrandr(false),
   _xcursor_size(-1),
+  _have_xrandr(false),
   _XF86DGADirectVideo(nullptr) {
 
   std::string display_spec = display;

pandatool/src/egg-qtess/isoPlacer.cxx

@@ -106,8 +106,6 @@ get_scores(int subdiv, int across, double ratio,
  */
 void IsoPlacer::
 place(int count, pvector<double> &iso_points) {
-  int i;
-
   // Count up the average curvature.
   /*
   double avg_curve = 0.0;

pandatool/src/palettizer/textureProperties.cxx

@@ -292,6 +292,8 @@ fully_define() {
     case EggTexture::F_luminance:
     case EggTexture::F_luminance_alpha:
     case EggTexture::F_luminance_alphamask:
+    case EggTexture::F_srgb:
+    case EggTexture::F_srgb_alpha:
       break;
 
     case EggTexture::F_rgba12:
@@ -598,6 +600,12 @@ get_format_string(EggTexture::Format format) {
 
   case EggTexture::F_luminance:
     return "l";
+
+  case EggTexture::F_srgb:
+    return "sc";
+
+  case EggTexture::F_srgb_alpha:
+    return "sa";
   }
 
   return "x";