· Refactoring

carlosga · carlosga · commit ed9ae398ea58 · 2016-04-20T13:02:05.000+02:00
diff --git a/source/scener/content/content_manager.cpp b/source/scener/content/content_manager.cpp
@@ -18,7 +18,7 @@ using scener::io::file_stream;
 
 content_manager::content_manager(gsl::not_null<service_container*> serviceprovider
                                , const std::string&                rootdirectory) noexcept
-    : _service_provider ( serviceprovider )
+    : _service_provider { serviceprovider }
     , _root_directory   { rootdirectory }
 {
 }
diff --git a/source/scener/content/content_reader.hpp b/source/scener/content/content_reader.hpp
@@ -110,7 +110,7 @@ class content_reader final
 
 private:
     std::string               _asset_name;
-    scener::io::binary_reader _asset_reader;
+    io::binary_reader         _asset_reader;
     content::content_manager* _content_manager;
     json11::Json              _root;
 
diff --git a/source/scener/content/dds/surface.cpp b/source/scener/content/dds/surface.cpp
@@ -16,67 +16,67 @@ void surface::load(const std::string& filename) noexcept
     Expects(scener::io::file::exists(filename));
 
     file_stream stream(filename);
-    header      ddsheader;
-    std::size_t blocksize = 16;
+    header      dds_header;
+    std::size_t block_size = 16;
 
-    Ensures(stream.length() >= sizeof ddsheader);
+    Ensures(stream.length() >= sizeof dds_header);
 
-    stream.read(reinterpret_cast<char*>(&ddsheader), 0, sizeof ddsheader);
+    stream.read(reinterpret_cast<char*>(&dds_header), 0, sizeof dds_header);
 
     // ensure contents are in DDS format
-    Ensures(ddsheader.magic == 0x20534444);
+    Ensures(dds_header.magic == 0x20534444);
 
     // ensure required flags are meet
-    Ensures((ddsheader.flags & header_flags::pixelformat) == header_flags::pixelformat);
-    Ensures((ddsheader.flags & header_flags::caps)        == header_flags::caps);
-    Ensures((ddsheader.flags & header_flags::height)      == header_flags::height);
-    Ensures((ddsheader.flags & header_flags::width)       == header_flags::width);
+    Ensures((dds_header.flags & header_flags::pixelformat) == header_flags::pixelformat);
+    Ensures((dds_header.flags & header_flags::caps)        == header_flags::caps);
+    Ensures((dds_header.flags & header_flags::height)      == header_flags::height);
+    Ensures((dds_header.flags & header_flags::width)       == header_flags::width);
 
-    if (ddsheader.mipmap_count > 0)
+    if (dds_header.mipmap_count > 0)
     {
-        Ensures((ddsheader.flags & header_flags::mipmapcount) == header_flags::mipmapcount);
-        Ensures((ddsheader.flags & header_flags::linearsize)  == header_flags::linearsize);
+        Ensures((dds_header.flags & header_flags::mipmapcount) == header_flags::mipmapcount);
+        Ensures((dds_header.flags & header_flags::linearsize)  == header_flags::linearsize);
     }
 
     // ensure pixel format size is correct
-    Ensures(ddsheader.pixel_format.size == 32);
+    Ensures(dds_header.pixel_format.size == 32);
 
     // ensure the texture is in compressed format
-    Ensures((ddsheader.pixel_format.flags & pixel_format_flags::fourcc) == pixel_format_flags::fourcc);
+    Ensures((dds_header.pixel_format.flags & pixel_format_flags::fourcc) == pixel_format_flags::fourcc);
 
     // check DXTn format
-    Ensures(ddsheader.pixel_format.fourcc == fourcc::dxt1
-         || ddsheader.pixel_format.fourcc == fourcc::dxt3
-         || ddsheader.pixel_format.fourcc == fourcc::dxt5);
+    Ensures(dds_header.pixel_format.fourcc == fourcc::dxt1
+         || dds_header.pixel_format.fourcc == fourcc::dxt3
+         || dds_header.pixel_format.fourcc == fourcc::dxt5);
 
     // process dds contents
-    _height = ddsheader.height;
-    _width  = ddsheader.width;
+    _height = dds_header.height;
+    _width  = dds_header.width;
 
-    if (ddsheader.pixel_format.fourcc == fourcc::dxt1)
+    if (dds_header.pixel_format.fourcc == fourcc::dxt1)
     {
         _format   = surface_format::dxt1;
-        blocksize = 8;
+        block_size = 8;
     }
-    else if (ddsheader.pixel_format.fourcc == fourcc::dxt3)
+    else if (dds_header.pixel_format.fourcc == fourcc::dxt3)
     {
         _format = surface_format::dxt3;
     }
-    else if (ddsheader.pixel_format.fourcc == fourcc::dxt5)
+    else if (dds_header.pixel_format.fourcc == fourcc::dxt5)
     {
         _format = surface_format::dxt5;
     }
 
-    auto mipmapwidth  = _width;
-    auto mipmapheight = _height;
-    auto position     = size_type { 0 };
-    auto length       = stream.length() - sizeof ddsheader;
+    auto mipmap_width  = _width;
+    auto mipmap_height = _height;
+    auto position      = size_type { 0 };
+    auto length        = stream.length() - sizeof dds_header;
 
     _mipmaps.clear();
     _buffer.clear();
     _view = { };
 
-    _mipmaps.reserve(ddsheader.mipmap_count);
+    _mipmaps.reserve(dds_header.mipmap_count);
     _buffer.reserve(length);
 
     auto readed = stream.read(reinterpret_cast<char*>(_buffer.data()), 0, length);
@@ -85,15 +85,15 @@ void surface::load(const std::string& filename) noexcept
 
     _view = gsl::span<std::uint8_t>(_buffer.data(), static_cast<std::ptrdiff_t>(length));
 
-    for (size_type level = 0; level < ddsheader.mipmap_count; ++level)
+    for (size_type level = 0; level < dds_header.mipmap_count; ++level)
     {
-        auto size = std::max<size_type>(4, mipmapwidth) / 4 * std::max<size_type>(4, mipmapheight) / 4 * blocksize;
+        auto size = std::max<size_type>(4, mipmap_width) / 4 * std::max<size_type>(4, mipmap_height) / 4 * block_size;
         auto view = _view.subspan(static_cast<std::ptrdiff_t>(position), static_cast<std::ptrdiff_t>(size));
 
-        _mipmaps.push_back({ level, mipmapwidth, mipmapheight, view });
+        _mipmaps.push_back({ level, mipmap_width, mipmap_height, view });
 
-        mipmapwidth  = std::max<std::size_t>(1, mipmapwidth  >>= 1);
-        mipmapheight = std::max<std::size_t>(1, mipmapheight >>= 1);
+        mipmap_width  = std::max<std::size_t>(1, mipmap_width  >>= 1);
+        mipmap_height = std::max<std::size_t>(1, mipmap_height >>= 1);
 
         position += size;
     }
diff --git a/source/scener/content/gltf/node.cpp b/source/scener/content/gltf/node.cpp
@@ -10,17 +10,17 @@ using scener::math::quaternion;
 using scener::math::vector3;
 
 node::node() noexcept
-    : name          ()
-    , camera        ()
+    : name          { }
+    , camera        { }
     , instance_skin { nullptr }
     , joint         { nullptr }
-    , light         ()
+    , light         { }
     , matrix        { matrix4::identity() }
-    , meshes        ()
+    , meshes        { }
     , rotation      { quaternion::identity() }
     , scale         { vector3::one() }
     , translation   { vector3::zero() }
-    , children      ()
+    , children      { }
 {
 }
 
diff --git a/source/scener/graphics/component.cpp b/source/scener/graphics/component.cpp
@@ -8,7 +8,7 @@
 namespace scener { namespace graphics {
 
 component::component(gsl::not_null<graphics::renderer*> renderer) noexcept
-    : _renderer ( renderer )
+    : _renderer { renderer }
 {
 }
 
diff --git a/source/scener/graphics/effect_technique.cpp b/source/scener/graphics/effect_technique.cpp
@@ -17,7 +17,7 @@ effect_technique::effect_technique(gsl::not_null<graphics_device*> device) noexc
     : graphics_resource          { device }
     , _alpha                     { 1.0 }
     , _ambient_light_color       { vector3::zero() }
-    , _bone_transforms           ( 0 )
+    , _bone_transforms           { }
     , _diffuse_color             { vector3::one() }
     , _light_0                   { }
     , _light_1                   { }
@@ -29,12 +29,12 @@ effect_technique::effect_technique(gsl::not_null<graphics_device*> device) noexc
     , _specular_color            { vector3::one() }
     , _specular_power            { 16.0f }
     , _texture_enabled           { false }
-    , _textures                  ( 0 )
+    , _textures                  { }
     , _view                      { matrix4::identity() }
     , _world                     { matrix4::identity() }
     , _dirty_flags               { effect_dirty_flags::all }
-    , _passes                    ()
-    , _parameters                ()
+    , _passes                    { }
+    , _parameters                { }
 {
 }
 
diff --git a/source/scener/graphics/model.cpp b/source/scener/graphics/model.cpp
@@ -13,8 +13,8 @@ namespace scener { namespace graphics {
 using scener::math::matrix4;
 
 model::model() noexcept
-    : _meshes (0)
-    , _name   ()
+    : _meshes { }
+    , _name   { }
 {
 }
 
diff --git a/source/scener/graphics/opengl/display_surface.cpp b/source/scener/graphics/opengl/display_surface.cpp
@@ -15,7 +15,7 @@
 namespace scener { namespace graphics { namespace opengl {
 
 display_surface::display_surface(display_device* display)
-    : _display(display)
+    : _display { display }
 {
 }
 
diff --git a/source/scener/io/binary_reader.cpp b/source/scener/io/binary_reader.cpp
@@ -33,16 +33,16 @@ char16_t binary_reader::read() noexcept
     // Decode UTF-8.
     if (buffer & 0x80)
     {
-        std::uint32_t bytecount = 1;
+        std::uint32_t byte_count = 1;
 
-        while (buffer & (0x80 >> bytecount))
+        while (buffer & (0x80 >> byte_count))
         {
-            bytecount++;
+            byte_count++;
         }
 
-        buffer &= (1 << (8 - bytecount)) - 1;
+        buffer &= (1 << (8 - byte_count)) - 1;
 
-        while (--bytecount)
+        while (--byte_count)
         {
             buffer <<= 6;
             buffer  |= _stream.read_byte() & 0x3F;
@@ -169,34 +169,34 @@ double binary_reader::read() noexcept
 
 std::int32_t binary_reader::peek_char() noexcept
 {
-    std::int32_t nextchar = -1;
+    std::int32_t next_char = -1;
 
     if (_stream.can_seek())
     {
         auto position = _stream.position();
 
         if (position != _stream.length())
         {
-            nextchar = _stream.read_byte();
+            next_char = _stream.read_byte();
 
             _stream.seek(position, std::ios::beg);
         }
     }
 
-    return nextchar;
+    return next_char;
 }
 
 std::uint32_t binary_reader::read_7_bit_encoded_int() noexcept
 {
-    std::uint32_t result   = 0;
-    std::uint32_t bitsread = 0;
-    std::uint32_t value    = 0;
+    std::uint32_t result    = 0;
+    std::uint32_t bits_read = 0;
+    std::uint32_t value     = 0;
 
     do
     {
         value     = read<std::uint8_t>();
-        result   |= (value & 0x7f) << bitsread;
-        bitsread += 7;
+        result   |= (value & 0x7f) << bits_read;
+        bits_read += 7;
     } while (value & 0x80);
 
     return result;
diff --git a/source/scener/io/path.hpp b/source/scener/io/path.hpp
@@ -27,31 +27,31 @@ class path
     /// \returns the directory information for the specified path string.
     static std::string get_directory_name(const std::string& path) noexcept
     {
-        auto position      = path.find_last_of(path::directory_separator());
-        auto directoryName = path;
+        auto position       = path.find_last_of(path::directory_separator());
+        auto directory_name = path;
 
         if (position != std::string::npos)
         {
-            directoryName.erase(position);
+            directory_name.erase(position);
         }
 
-        return directoryName;
+        return directory_name;
     }
 
     /// Returns the file name of the specified path string without the extension.
     /// \param path The path of the file.
     /// \returns the file name of the specified path string without the extension.
     static std::string get_file_name_without_extension(const std::string& path) noexcept
     {
-        auto position             = path.find_last_of('.');
-        auto pathWithoutExtension = path;
+        auto position               = path.find_last_of('.');
+        auto path_without_extension = path;
 
         if (position != std::string::npos)
         {
-            pathWithoutExtension.erase(position);
+            path_without_extension.erase(position);
         }
 
-        return pathWithoutExtension;
+        return path_without_extension;
     }
 
     /// Combines two strings into a path.
diff --git a/source/scener/timespan.hpp b/source/scener/timespan.hpp
@@ -15,14 +15,14 @@ namespace scener {
 class timespan final
 {
 public:
-    using clock                  = std::chrono::high_resolution_clock;
-    using days_duration          = std::chrono::duration<double      , std::ratio<86400>>;
-    using hours_duration         = std::chrono::duration<double      , std::ratio<3600>>;
-    using minutes_duration       = std::chrono::duration<double      , std::ratio<60>>;
-    using seconds_duration       = std::chrono::duration<double>;
-    using milli_seconds_duration = std::chrono::duration<double      , std::ratio<1, 1000>>;
-    using micro_seconds_duration = std::chrono::duration<double      , std::ratio<1, 1000000>>;
-    using ticks_duration         = std::chrono::duration<std::int64_t, std::ratio<1, 10000000>>;
+    using clock                 = std::chrono::high_resolution_clock;
+    using days_duration         = std::chrono::duration<double      , std::ratio<86400>>;
+    using hours_duration        = std::chrono::duration<double      , std::ratio<3600>>;
+    using minutes_duration      = std::chrono::duration<double      , std::ratio<60>>;
+    using seconds_duration      = std::chrono::duration<double>;
+    using milliseconds_duration = std::chrono::duration<double      , std::ratio<1, 1000>>;
+    using microseconds_duration = std::chrono::duration<double      , std::ratio<1, 1000000>>;
+    using ticks_duration        = std::chrono::duration<std::int64_t, std::ratio<1, 10000000>>;
 
 public:
     /// Represents the number of ticks in 1 day.
@@ -88,7 +88,7 @@ class timespan final
     /// \returns a TimeSpan that represents a specified number of milliseconds.
     constexpr static timespan from_milliseconds(double value) noexcept
     {
-        return { std::chrono::duration_cast<ticks_duration>(milli_seconds_duration(value)).count() };
+        return { std::chrono::duration_cast<ticks_duration>(milliseconds_duration(value)).count() };
     }
 
     /// Returns a TimeSpan that represents a specified number of minutes.
@@ -149,15 +149,15 @@ class timespan final
     /// \param seconds number of seconds.
     /// \param milliseconds number of milliseconds.
     constexpr timespan(std::int32_t days
-                      , std::int32_t hours
-                      , std::int32_t minutes
-                      , std::int32_t seconds
-                      , std::int32_t milliseconds) noexcept
+                     , std::int32_t hours
+                     , std::int32_t minutes
+                     , std::int32_t seconds
+                     , std::int32_t milliseconds) noexcept
         : _ticks { std::chrono::duration_cast<ticks_duration>(days_duration(days))
                  + std::chrono::duration_cast<ticks_duration>(hours_duration(hours))
                  + std::chrono::duration_cast<ticks_duration>(minutes_duration(minutes))
                  + std::chrono::duration_cast<ticks_duration>(seconds_duration(seconds))
-                 + std::chrono::duration_cast<ticks_duration>(milli_seconds_duration(milliseconds)) }
+                 + std::chrono::duration_cast<ticks_duration>(milliseconds_duration(milliseconds)) }
     {
     }
 
@@ -236,7 +236,7 @@ class timespan final
     /// \returns the value of the current TimeSpan structure expressed in whole and fractional milliseconds.
     constexpr double total_milli_seconds() const noexcept
     {
-        return std::chrono::duration_cast<milli_seconds_duration>(_ticks).count();
+        return std::chrono::duration_cast<milliseconds_duration>(_ticks).count();
     }
 
     /// Gets the value of the current TimeSpan structure expressed in whole and fractional minutes.

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ using scener::io::file_stream;`
`18`	`18`
`19`	`19`	`content_manager::content_manager(gsl::not_null<service_container*> serviceprovider`
`20`	`20`	`, const std::string& rootdirectory) noexcept`
`21`		`- : _service_provider ( serviceprovider )`
	`21`	`+ : _service_provider { serviceprovider }`
`22`	`22`	`, _root_directory { rootdirectory }`
`23`	`23`	`{`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`namespace scener { namespace graphics {`
`9`	`9`
`10`	`10`	`component::component(gsl::not_null<graphics::renderer*> renderer) noexcept`
`11`		`- : _renderer ( renderer )`
	`11`	`+ : _renderer { renderer }`
`12`	`12`	`{`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ namespace scener { namespace graphics {`
`13`	`13`	`using scener::math::matrix4;`
`14`	`14`
`15`	`15`	`model::model() noexcept`
`16`		`- : _meshes (0)`
`17`		`- , _name ()`
	`16`	`+ : _meshes { }`
	`17`	`+ , _name { }`
`18`	`18`	`{`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`	`namespace scener { namespace graphics { namespace opengl {`
`16`	`16`
`17`	`17`	`display_surface::display_surface(display_device* display)`
`18`		`- : _display(display)`
	`18`	`+ : _display { display }`
`19`	`19`	`{`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -33,16 +33,16 @@ char16_t binary_reader::read() noexcept`
`33`	`33`	`// Decode UTF-8.`
`34`	`34`	`if (buffer & 0x80)`
`35`	`35`	`{`
`36`		`- std::uint32_t bytecount = 1;`
	`36`	`+ std::uint32_t byte_count = 1;`
`37`	`37`
`38`		`- while (buffer & (0x80 >> bytecount))`
	`38`	`+ while (buffer & (0x80 >> byte_count))`
`39`	`39`	`{`
`40`		`- bytecount++;`
	`40`	`+ byte_count++;`
`41`	`41`	`}`
`42`	`42`
`43`		`- buffer &= (1 << (8 - bytecount)) - 1;`
	`43`	`+ buffer &= (1 << (8 - byte_count)) - 1;`
`44`	`44`
`45`		`- while (--bytecount)`
	`45`	`+ while (--byte_count)`
`46`	`46`	`{`
`47`	`47`	`buffer <<= 6;`
`48`	`48`	`buffer \|= _stream.read_byte() & 0x3F;`
`@@ -169,34 +169,34 @@ double binary_reader::read() noexcept`
`169`	`169`
`170`	`170`	`std::int32_t binary_reader::peek_char() noexcept`
`171`	`171`	`{`
`172`		`- std::int32_t nextchar = -1;`
	`172`	`+ std::int32_t next_char = -1;`
`173`	`173`
`174`	`174`	`if (_stream.can_seek())`
`175`	`175`	`{`
`176`	`176`	`auto position = _stream.position();`
`177`	`177`
`178`	`178`	`if (position != _stream.length())`
`179`	`179`	`{`
`180`		`- nextchar = _stream.read_byte();`
	`180`	`+ next_char = _stream.read_byte();`
`181`	`181`
`182`	`182`	`_stream.seek(position, std::ios::beg);`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`
`186`		`- return nextchar;`
	`186`	`+ return next_char;`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`std::uint32_t binary_reader::read_7_bit_encoded_int() noexcept`
`190`	`190`	`{`
`191`		`- std::uint32_t result = 0;`
`192`		`- std::uint32_t bitsread = 0;`
`193`		`- std::uint32_t value = 0;`
	`191`	`+ std::uint32_t result = 0;`
	`192`	`+ std::uint32_t bits_read = 0;`
	`193`	`+ std::uint32_t value = 0;`
`194`	`194`
`195`	`195`	`do`
`196`	`196`	`{`
`197`	`197`	`value = read<std::uint8_t>();`
`198`		`- result \|= (value & 0x7f) << bitsread;`
`199`		`- bitsread += 7;`
	`198`	`+ result \|= (value & 0x7f) << bits_read;`
	`199`	`+ bits_read += 7;`
`200`	`200`	`} while (value & 0x80);`
`201`	`201`
`202`	`202`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -27,31 +27,31 @@ class path`
`27`	`27`	`/// \returns the directory information for the specified path string.`
`28`	`28`	`static std::string get_directory_name(const std::string& path) noexcept`
`29`	`29`	`{`
`30`		`- auto position = path.find_last_of(path::directory_separator());`
`31`		`- auto directoryName = path;`
	`30`	`+ auto position = path.find_last_of(path::directory_separator());`
	`31`	`+ auto directory_name = path;`
`32`	`32`
`33`	`33`	`if (position != std::string::npos)`
`34`	`34`	`{`
`35`		`- directoryName.erase(position);`
	`35`	`+ directory_name.erase(position);`
`36`	`36`	`}`
`37`	`37`
`38`		`- return directoryName;`
	`38`	`+ return directory_name;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`/// Returns the file name of the specified path string without the extension.`
`42`	`42`	`/// \param path The path of the file.`
`43`	`43`	`/// \returns the file name of the specified path string without the extension.`
`44`	`44`	`static std::string get_file_name_without_extension(const std::string& path) noexcept`
`45`	`45`	`{`
`46`		`- auto position = path.find_last_of('.');`
`47`		`- auto pathWithoutExtension = path;`
	`46`	`+ auto position = path.find_last_of('.');`
	`47`	`+ auto path_without_extension = path;`
`48`	`48`
`49`	`49`	`if (position != std::string::npos)`
`50`	`50`	`{`
`51`		`- pathWithoutExtension.erase(position);`
	`51`	`+ path_without_extension.erase(position);`
`52`	`52`	`}`
`53`	`53`
`54`		`- return pathWithoutExtension;`
	`54`	`+ return path_without_extension;`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`/// Combines two strings into a path.`