summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--CMakeLists.txt44
-rw-r--r--cmake/FindSDL2_net.cmake88
-rw-r--r--cwd/shaders/gui.fs21
-rw-r--r--cwd/shaders/gui.vs27
-rw-r--r--depedencies/include/mpark/config.hpp69
-rw-r--r--depedencies/include/mpark/in_place.hpp35
-rw-r--r--depedencies/include/mpark/lib.hpp453
-rw-r--r--depedencies/include/mpark/variant.hpp1827
-rw-r--r--src/Block.hpp5
-rw-r--r--src/Render.cpp178
-rw-r--r--src/Render.hpp6
-rw-r--r--src/Renderer.hpp11
-rw-r--r--src/RendererSection.cpp120
-rw-r--r--src/RendererSection.hpp23
-rw-r--r--src/RendererWidget.cpp76
-rw-r--r--src/RendererWidget.hpp15
-rw-r--r--src/RendererWorld.cpp8
-rw-r--r--src/RendererWorld.hpp2
-rw-r--r--src/Section.cpp267
-rw-r--r--src/Section.hpp44
-rw-r--r--src/Socket.cpp43
-rw-r--r--src/Socket.hpp8
-rw-r--r--src/Stream.cpp5
-rw-r--r--src/Widget.cpp124
-rw-r--r--src/Widget.hpp74
-rw-r--r--src/World.cpp65
-rw-r--r--src/World.hpp8
-rw-r--r--src/main.cpp17
28 files changed, 803 insertions, 2860 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5655cd8..417efab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,8 @@
cmake_minimum_required(VERSION 3.8)
project(AltCraft)
set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include(externalProject)
@@ -26,7 +28,7 @@ add_definitions(${LOGGER_DEFINITIONS})
#Set compiler's flags and setup platfrom-dependent libraries
if (CMAKE_COMPILER_IS_GNUCXX)
- #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
@@ -34,6 +36,11 @@ if (CMAKE_COMPILER_IS_GNUCXX)
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -p")
set(PLATFORM_LIBRARIES "pthread" "stdc++fs")
endif ()
+
+if(MSVC)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17")
+endif(MSVC)
+
target_link_libraries(AltCraft ${PLATFORM_LIBRARIES})
############
@@ -45,29 +52,28 @@ add_subdirectory(depedencies)
target_include_directories(AltCraft PUBLIC ./depedencies/include)
target_link_libraries(AltCraft deps)
-#Setup SFML
-set (SFML_ROOT "${CMAKE_SOURCE_DIR}/external/SFML")
-find_package(SFML 2.3 COMPONENTS system window graphics network REQUIRED)
-if (SFML_FOUND)
- target_link_libraries(AltCraft ${SFML_LIBRARIES})
- target_include_directories(AltCraft PUBLIC ${SFML_INCLUDE_DIR})
-else ()
- message(FATAL_ERROR "SFML not found!")
-endif ()
+#Setup SDL2
+find_package(SDL2 REQUIRED)
+target_link_libraries(AltCraft ${SDL2_LIBRARY})
+target_include_directories(AltCraft PUBLIC ${SDL2_INCLUDE_DIR})
+
+#Setup SDL2_net
+find_package(SDL2_net REQUIRED)
+target_link_libraries(AltCraft ${SDL2_NET_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${SDL2_NET_INCLUDE_DIRS})
#Setup SFML
-#add_subdirectory(external/SFML)
-#target_include_directories(AltCraft PUBLIC external/SFML/include)
-#target_link_libraries(AltCraft sfml-main sfml-system sfml-network sfml-window sfml-graphics)
+set (SFML_ROOT "c:/dev/vcpkg/installed/x86-windows/")
+find_package(SFML 2.3 COMPONENTS system window graphics network REQUIRED)
+target_link_libraries(AltCraft ${SFML_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${SFML_INCLUDE_DIR})
#Setup OpenGL
find_package(OpenGL REQUIRED)
-if (OPENGL_FOUND)
- target_link_libraries(AltCraft ${OPENGL_LIBRARIES})
- target_include_directories(AltCraft PUBLIC ${OPENGL_INCLUDE_DIRS})
-else ()
- message(FATAL_ERROR "OpenGL not found!")
-endif ()
+target_link_libraries(AltCraft ${OPENGL_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${OPENGL_INCLUDE_DIRS})
+
+
#################
# COPY RESOURCES
diff --git a/cmake/FindSDL2_net.cmake b/cmake/FindSDL2_net.cmake
new file mode 100644
index 0000000..2ad6b9b
--- /dev/null
+++ b/cmake/FindSDL2_net.cmake
@@ -0,0 +1,88 @@
+# - Locate SDL2_net library
+# This module defines:
+# SDL2_NET_LIBRARIES, the name of the library to link against
+# SDL2_NET_INCLUDE_DIRS, where to find the headers
+# SDL2_NET_FOUND, if false, do not try to link against
+# SDL2_NET_VERSION_STRING - human-readable string containing the version of SDL2_net
+#
+# For backward compatiblity the following variables are also set:
+# SDLNET_LIBRARY (same value as SDL2_NET_LIBRARIES)
+# SDLNET_INCLUDE_DIR (same value as SDL2_NET_INCLUDE_DIRS)
+# SDLNET_FOUND (same value as SDL2_NET_FOUND)
+#
+# $SDLDIR is an environment variable that would
+# correspond to the ./configure --prefix=$SDLDIR
+# used in building SDL.
+#
+# Created by Eric Wing. This was influenced by the FindSDL.cmake
+# module, but with modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+
+#=============================================================================
+# Copyright 2005-2009 Kitware, Inc.
+# Copyright 2012 Benjamin Eikel
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+# License text for the above reference.)
+
+if(NOT SDL2_NET_INCLUDE_DIR AND SDLNET_INCLUDE_DIR)
+ set(SDL2_NET_INCLUDE_DIR ${SDLNET_INCLUDE_DIR} CACHE PATH "directory cache
+entry initialized from old variable name")
+endif()
+find_path(SDL2_NET_INCLUDE_DIR SDL_net.h
+ HINTS
+ ENV SDLNETDIR
+ ENV SDLDIR
+ PATH_SUFFIXES include/SDL2 include/SDL2.0 include
+)
+
+if(NOT SDL2_NET_LIBRARY AND SDLNET_LIBRARY)
+ set(SDL2_NET_LIBRARY ${SDLNET_LIBRARY} CACHE FILEPATH "file cache entry
+initialized from old variable name")
+endif()
+find_library(SDL2_NET_LIBRARY
+ NAMES SDL2_net
+ HINTS
+ ENV SDLNETDIR
+ ENV SDLDIR
+ PATH_SUFFIXES lib
+)
+
+if(SDL2_NET_INCLUDE_DIR AND EXISTS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h")
+ file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL2_NET_MAJOR_VERSION[ \t]+[0-9]+$")
+ file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_NET_MINOR_VERSION[ \t]+[0-9]+$")
+ file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_NET_PATCHLEVEL[ \t]+[0-9]+$")
+ string(REGEX REPLACE "^#define[ \t]+SDL2_NET_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_MAJOR "${SDL2_NET_VERSION_MAJOR_LINE}")
+ string(REGEX REPLACE "^#define[ \t]+SDL2_NET_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_MINOR "${SDL2_NET_VERSION_MINOR_LINE}")
+ string(REGEX REPLACE "^#define[ \t]+SDL2_NET_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_PATCH "${SDL2_NET_VERSION_PATCH_LINE}")
+ set(SDL2_NET_VERSION_STRING ${SDL2_NET_VERSION_MAJOR}.${SDL2_NET_VERSION_MINOR}.${SDL2_NET_VERSION_PATCH})
+ unset(SDL2_NET_VERSION_MAJOR_LINE)
+ unset(SDL2_NET_VERSION_MINOR_LINE)
+ unset(SDL2_NET_VERSION_PATCH_LINE)
+ unset(SDL2_NET_VERSION_MAJOR)
+ unset(SDL2_NET_VERSION_MINOR)
+ unset(SDL2_NET_VERSION_PATCH)
+endif()
+
+set(SDL2_NET_LIBRARIES ${SDL2_NET_LIBRARY})
+set(SDL2_NET_INCLUDE_DIRS ${SDL2_NET_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_net
+ REQUIRED_VARS SDL2_NET_LIBRARIES SDL2_NET_INCLUDE_DIRS
+ VERSION_VAR SDL2_NET_VERSION_STRING)
+
+# for backward compatiblity
+set(SDLNET_LIBRARY ${SDL2_NET_LIBRARIES})
+set(SDLNET_INCLUDE_DIR ${SDL2_NET_INCLUDE_DIRS})
+set(SDLNET_FOUND ${SDL2_NET_FOUND})
+
+mark_as_advanced(SDL2_NET_LIBRARY SDL2_NET_INCLUDE_DIR) \ No newline at end of file
diff --git a/cwd/shaders/gui.fs b/cwd/shaders/gui.fs
new file mode 100644
index 0000000..95196b9
--- /dev/null
+++ b/cwd/shaders/gui.fs
@@ -0,0 +1,21 @@
+#version 330 core
+
+in vec2 uv;
+
+uniform vec4 widgetTexture;
+uniform sampler2D textureAtlas;
+
+vec2 TransformTextureCoord(vec4 TextureAtlasCoords, vec2 UvCoords) {
+ float x = TextureAtlasCoords.x;
+ float y = TextureAtlasCoords.y;
+ float w = TextureAtlasCoords.z;
+ float h = TextureAtlasCoords.w;
+ vec2 A = vec2(x, 1 - y - h);
+ vec2 B = vec2(x + w, 1 - y);
+ return A + UvCoords * (B - A);
+}
+
+void main(){
+ vec4 color = texture(textureAtlas,TransformTextureCoord(widgetTexture,uv));
+ gl_FragColor = color;
+} \ No newline at end of file
diff --git a/cwd/shaders/gui.vs b/cwd/shaders/gui.vs
new file mode 100644
index 0000000..b6f848b
--- /dev/null
+++ b/cwd/shaders/gui.vs
@@ -0,0 +1,27 @@
+#version 330 core
+
+uniform vec4 transform;
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in vec2 UvCoordinates;
+
+out vec2 uv;
+
+vec2 TransfromWidgetCoord() {
+ vec2 origin = vec2((transform.x * 2.0f) - 1.0f, (0.5 - transform.y) * 2.0f);
+
+ float x = transform.x;
+ float y = transform.y;
+ float w = transform.z;
+ float h = transform.w;
+ vec2 A = vec2(x, 1 - y - h);
+ vec2 B = vec2(x + w, 1 - y);
+ vec2 ret = vec2(A + position.xy * (B - A));
+ return vec2(ret.x-1.0f,ret.y);
+}
+
+void main(){
+ uv = UvCoordinates;
+
+ gl_Position = vec4(TransfromWidgetCoord(),0,1);
+} \ No newline at end of file
diff --git a/depedencies/include/mpark/config.hpp b/depedencies/include/mpark/config.hpp
deleted file mode 100644
index b5706b2..0000000
--- a/depedencies/include/mpark/config.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_CONFIG_HPP
-#define MPARK_CONFIG_HPP
-
-// MSVC 2015 Update 3.
-#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024215)
-#error "MPark.Variant requires C++11 support."
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_builtin(__builtin_addressof) || \
- (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
-#define MPARK_BUILTIN_ADDRESSOF
-#endif
-
-#if __has_builtin(__type_pack_element)
-#define MPARK_TYPE_PACK_ELEMENT
-#endif
-
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
-#define MPARK_CPP14_CONSTEXPR
-#endif
-
-#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions)
-#define MPARK_EXCEPTIONS
-#endif
-
-#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
-#define MPARK_GENERIC_LAMBDAS
-#endif
-
-#if defined(__cpp_lib_integer_sequence)
-#define MPARK_INTEGER_SEQUENCE
-#endif
-
-#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
-#define MPARK_RETURN_TYPE_DEDUCTION
-#endif
-
-#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
-#define MPARK_TRANSPARENT_OPERATORS
-#endif
-
-#if defined(__cpp_variable_templates) || defined(_MSC_VER)
-#define MPARK_VARIABLE_TEMPLATES
-#endif
-
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>) // >= libstdc++-5
-#define MPARK_TRIVIALITY_TYPE_TRAITS
-#endif
-
-#endif // MPARK_CONFIG_HPP
diff --git a/depedencies/include/mpark/in_place.hpp b/depedencies/include/mpark/in_place.hpp
deleted file mode 100644
index 56cae13..0000000
--- a/depedencies/include/mpark/in_place.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_IN_PLACE_HPP
-#define MPARK_IN_PLACE_HPP
-
-#include <cstddef>
-
-#include "config.hpp"
-
-namespace mpark {
-
- struct in_place_t { explicit in_place_t() = default; };
-
- template <std::size_t I>
- struct in_place_index_t { explicit in_place_index_t() = default; };
-
- template <typename T>
- struct in_place_type_t { explicit in_place_type_t() = default; };
-
-#ifdef MPARK_VARIABLE_TEMPLATES
- constexpr in_place_t in_place{};
-
- template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
-
- template <typename T> constexpr in_place_type_t<T> in_place_type{};
-#endif
-
-} // namespace mpark
-
-#endif // MPARK_IN_PLACE_HPP
diff --git a/depedencies/include/mpark/lib.hpp b/depedencies/include/mpark/lib.hpp
deleted file mode 100644
index bba58d8..0000000
--- a/depedencies/include/mpark/lib.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_LIB_HPP
-#define MPARK_LIB_HPP
-
-#include <memory>
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#include "config.hpp"
-
-#define RETURN(...) \
- noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { \
- return __VA_ARGS__; \
- }
-
-namespace mpark {
- namespace lib {
- template <typename T>
- struct identity { using type = T; };
-
- inline namespace cpp14 {
- template <typename T, std::size_t N>
- struct array {
- constexpr const T &operator[](std::size_t index) const {
- return data[index];
- }
-
- T data[N == 0 ? 1 : N];
- };
-
- template <typename T>
- using add_pointer_t = typename std::add_pointer<T>::type;
-
- template <typename... Ts>
- using common_type_t = typename std::common_type<Ts...>::type;
-
- template <typename T>
- using decay_t = typename std::decay<T>::type;
-
- template <bool B, typename T = void>
- using enable_if_t = typename std::enable_if<B, T>::type;
-
- template <typename T>
- using remove_const_t = typename std::remove_const<T>::type;
-
- template <typename T>
- using remove_reference_t = typename std::remove_reference<T>::type;
-
- template <typename T>
- inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
- return static_cast<T &&>(t);
- }
-
- template <typename T>
- inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
- static_assert(!std::is_lvalue_reference<T>::value,
- "can not forward an rvalue as an lvalue");
- return static_cast<T &&>(t);
- }
-
- template <typename T>
- inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
- return static_cast<remove_reference_t<T> &&>(t);
- }
-
-#ifdef MPARK_INTEGER_SEQUENCE
- template <typename T, T... Is>
- using integer_sequence = std::integer_sequence<T, Is...>;
-
- template <std::size_t... Is>
- using index_sequence = std::index_sequence<Is...>;
-
- template <std::size_t N>
- using make_index_sequence = std::make_index_sequence<N>;
-
- template <typename... Ts>
- using index_sequence_for = std::index_sequence_for<Ts...>;
-#else
- template <typename T, T... Is>
- struct integer_sequence {
- using value_type = T;
- static constexpr std::size_t size() noexcept { return sizeof...(Is); }
- };
-
- template <std::size_t... Is>
- using index_sequence = integer_sequence<std::size_t, Is...>;
-
- template <typename Lhs, typename Rhs>
- struct make_index_sequence_concat;
-
- template <std::size_t... Lhs, std::size_t... Rhs>
- struct make_index_sequence_concat<index_sequence<Lhs...>,
- index_sequence<Rhs...>>
- : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
-
- template <std::size_t N>
- struct make_index_sequence_impl;
-
- template <std::size_t N>
- using make_index_sequence = typename make_index_sequence_impl<N>::type;
-
- template <std::size_t N>
- struct make_index_sequence_impl
- : make_index_sequence_concat<make_index_sequence<N / 2>,
- make_index_sequence<N - (N / 2)>> {};
-
- template <>
- struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
-
- template <>
- struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
-
- template <typename... Ts>
- using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-#endif
-
- // <functional>
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using equal_to = std::equal_to<>;
-#else
- struct equal_to {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
- };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using not_equal_to = std::not_equal_to<>;
-#else
- struct not_equal_to {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
- };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using less = std::less<>;
-#else
- struct less {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
- };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using greater = std::greater<>;
-#else
- struct greater {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
- };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using less_equal = std::less_equal<>;
-#else
- struct less_equal {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
- };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
- using greater_equal = std::greater_equal<>;
-#else
- struct greater_equal {
- template <typename Lhs, typename Rhs>
- inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
- RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
- };
-#endif
- } // namespace cpp14
-
- inline namespace cpp17 {
-
- // <type_traits>
- template <bool B>
- using bool_constant = std::integral_constant<bool, B>;
-
- template <typename...>
- struct voider : identity<void> {};
-
- template <typename... Ts>
- using void_t = typename voider<Ts...>::type;
-
- namespace detail {
- namespace swappable {
-
- using std::swap;
-
- template <typename T>
- struct is_swappable_impl {
- private:
- template <typename U,
- typename = decltype(swap(std::declval<U &>(),
- std::declval<U &>()))>
- inline static std::true_type test(int);
-
- template <typename U>
- inline static std::false_type test(...);
-
- public:
- using type = decltype(test<T>(0));
- };
-
- template <typename T>
- using is_swappable = typename is_swappable_impl<T>::type;
-
- template <typename T, bool = is_swappable<T>::value>
- struct is_nothrow_swappable {
- static constexpr bool value =
- noexcept(swap(std::declval<T &>(), std::declval<T &>()));
- };
-
- template <typename T>
- struct is_nothrow_swappable<T, false> : std::false_type {};
-
- } // namespace swappable
- } // namespace detail
-
- template <typename T>
- using is_swappable = detail::swappable::is_swappable<T>;
-
- template <typename T>
- using is_nothrow_swappable = detail::swappable::is_nothrow_swappable<T>;
-
- // <functional>
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
- template <typename F, typename... As>
- inline constexpr auto invoke(F &&f, As &&... as)
- RETURN(lib::forward<F>(f)(lib::forward<As>(as)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
- template <typename B, typename T, typename D>
- inline constexpr auto invoke(T B::*pmv, D &&d)
- RETURN(lib::forward<D>(d).*pmv)
-
- template <typename Pmv, typename Ptr>
- inline constexpr auto invoke(Pmv pmv, Ptr &&ptr)
- RETURN((*lib::forward<Ptr>(ptr)).*pmv)
-
- template <typename B, typename T, typename D, typename... As>
- inline constexpr auto invoke(T B::*pmf, D &&d, As &&... as)
- RETURN((lib::forward<D>(d).*pmf)(lib::forward<As>(as)...))
-
- template <typename Pmf, typename Ptr, typename... As>
- inline constexpr auto invoke(Pmf pmf, Ptr &&ptr, As &&... as)
- RETURN(((*lib::forward<Ptr>(ptr)).*pmf)(lib::forward<As>(as)...))
-
- namespace detail {
-
- template <typename Void, typename, typename...>
- struct invoke_result {};
-
- template <typename F, typename... Args>
- struct invoke_result<void_t<decltype(lib::invoke(
- std::declval<F>(), std::declval<Args>()...))>,
- F,
- Args...>
- : identity<decltype(
- lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
-
- } // namespace detail
-
- template <typename F, typename... Args>
- using invoke_result = detail::invoke_result<void, F, Args...>;
-
- template <typename F, typename... Args>
- using invoke_result_t = typename invoke_result<F, Args...>::type;
-
- namespace detail {
-
- template <typename Void, typename, typename...>
- struct is_invocable : std::false_type {};
-
- template <typename F, typename... Args>
- struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
- : std::true_type {};
-
- template <typename Void, typename, typename, typename...>
- struct is_invocable_r : std::false_type {};
-
- template <typename R, typename F, typename... Args>
- struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
- R,
- F,
- Args...>
- : std::is_convertible<invoke_result_t<F, Args...>, R> {};
-
- } // namespace detail
-
- template <typename F, typename... Args>
- using is_invocable = detail::is_invocable<void, F, Args...>;
-
- template <typename R, typename F, typename... Args>
- using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
-
- // <memory>
-#ifdef MPARK_BUILTIN_ADDRESSOF
- template <typename T>
- inline constexpr T *addressof(T &arg) {
- return __builtin_addressof(arg);
- }
-#else
- namespace detail {
-
- namespace has_addressof_impl {
-
- struct fail;
-
- template <typename T>
- inline fail operator&(T &&);
-
- template <typename T>
- inline static constexpr bool impl() {
- return (std::is_class<T>::value || std::is_union<T>::value) &&
- !std::is_same<decltype(&std::declval<T &>()), fail>::value;
- }
-
- } // namespace has_addressof_impl
-
- template <typename T>
- using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
-
- template <typename T>
- inline constexpr T *addressof(T &arg, std::true_type) {
- return std::addressof(arg);
- }
-
- template <typename T>
- inline constexpr T *addressof(T &arg, std::false_type) {
- return &arg;
- }
-
- } // namespace detail
-
- template <typename T>
- inline constexpr T *addressof(T &arg) {
- return detail::addressof(arg, detail::has_addressof<T>{});
- }
-#endif
-
- template <typename T>
- inline constexpr T *addressof(const T &&) = delete;
-
- } // namespace cpp17
-
- template <typename T>
- struct remove_all_extents : identity<T> {};
-
- template <typename T, std::size_t N>
- struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
-
- template <typename T>
- using remove_all_extents_t = typename remove_all_extents<T>::type;
-
- template <std::size_t N>
- using size_constant = std::integral_constant<std::size_t, N>;
-
- template <bool... Bs>
- using bool_sequence = integer_sequence<bool, Bs...>;
-
- template <std::size_t I, typename T>
- struct indexed_type : size_constant<I>, identity<T> {};
-
- template <bool... Bs>
- using all =
- std::is_same<bool_sequence<true, Bs...>, bool_sequence<Bs..., true>>;
-
-#ifdef MPARK_TYPE_PACK_ELEMENT
- template <std::size_t I, typename... Ts>
- using type_pack_element_t = __type_pack_element<I, Ts...>;
-#else
- template <std::size_t I, typename... Ts>
- struct type_pack_element_impl {
- private:
- template <typename>
- struct set;
-
- template <std::size_t... Is>
- struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
-
- template <typename T>
- inline static std::enable_if<true, T> impl(indexed_type<I, T>);
-
- inline static std::enable_if<false> impl(...);
-
- public:
- using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
- };
-
- template <std::size_t I, typename... Ts>
- using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
-
- template <std::size_t I, typename... Ts>
- using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
-#endif
-
-#ifdef MPARK_TRIVIALITY_TYPE_TRAITS
- template <typename T>
- using is_trivially_copy_constructible =
- std::is_trivially_copy_constructible<T>;
-
- template <typename T>
- using is_trivially_move_constructible =
- std::is_trivially_move_constructible<T>;
-
- template <typename T>
- using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
-
- template <typename T>
- using is_trivially_move_assignable = std::is_trivially_move_assignable<T>;
-#else
- template <typename T>
- struct is_trivially_copy_constructible
- : bool_constant<
- std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
-
- template <typename T>
- struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
-
- template <typename T>
- struct is_trivially_copy_assignable
- : bool_constant<
- std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
-
- template <typename T>
- struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
-#endif
-
- } // namespace lib
-} // namespace mpark
-
-#undef RETURN
-
-#endif // MPARK_LIB_HPP
diff --git a/depedencies/include/mpark/variant.hpp b/depedencies/include/mpark/variant.hpp
deleted file mode 100644
index 3faecba..0000000
--- a/depedencies/include/mpark/variant.hpp
+++ /dev/null
@@ -1,1827 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_VARIANT_HPP
-#define MPARK_VARIANT_HPP
-
-/*
- variant synopsis
-
-namespace std {
-
- // 20.7.2, class template variant
- template <class... Types>
- class variant {
- public:
-
- // 20.7.2.1, constructors
- constexpr variant() noexcept(see below);
- variant(const variant&);
- variant(variant&&) noexcept(see below);
-
- template <class T> constexpr variant(T&&) noexcept(see below);
-
- template <class T, class... Args>
- constexpr explicit variant(in_place_type_t<T>, Args&&...);
-
- template <class T, class U, class... Args>
- constexpr explicit variant(
- in_place_type_t<T>, initializer_list<U>, Args&&...);
-
- template <size_t I, class... Args>
- constexpr explicit variant(in_place_index_t<I>, Args&&...);
-
- template <size_t I, class U, class... Args>
- constexpr explicit variant(
- in_place_index_t<I>, initializer_list<U>, Args&&...);
-
- // 20.7.2.2, destructor
- ~variant();
-
- // 20.7.2.3, assignment
- variant& operator=(const variant&);
- variant& operator=(variant&&) noexcept(see below);
-
- template <class T> variant& operator=(T&&) noexcept(see below);
-
- // 20.7.2.4, modifiers
- template <class T, class... Args>
- T& emplace(Args&&...);
-
- template <class T, class U, class... Args>
- T& emplace(initializer_list<U>, Args&&...);
-
- template <size_t I, class... Args>
- variant_alternative<I, variant>& emplace(Args&&...);
-
- template <size_t I, class U, class... Args>
- variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...);
-
- // 20.7.2.5, value status
- constexpr bool valueless_by_exception() const noexcept;
- constexpr size_t index() const noexcept;
-
- // 20.7.2.6, swap
- void swap(variant&) noexcept(see below);
- };
-
- // 20.7.3, variant helper classes
- template <class T> struct variant_size; // undefined
-
- template <class T>
- constexpr size_t variant_size_v = variant_size<T>::value;
-
- template <class T> struct variant_size<const T>;
- template <class T> struct variant_size<volatile T>;
- template <class T> struct variant_size<const volatile T>;
-
- template <class... Types>
- struct variant_size<variant<Types...>>;
-
- template <size_t I, class T> struct variant_alternative; // undefined
-
- template <size_t I, class T>
- using variant_alternative_t = typename variant_alternative<I, T>::type;
-
- template <size_t I, class T> struct variant_alternative<I, const T>;
- template <size_t I, class T> struct variant_alternative<I, volatile T>;
- template <size_t I, class T> struct variant_alternative<I, const volatile T>;
-
- template <size_t I, class... Types>
- struct variant_alternative<I, variant<Types...>>;
-
- constexpr size_t variant_npos = -1;
-
- // 20.7.4, value access
- template <class T, class... Types>
- constexpr bool holds_alternative(const variant<Types...>&) noexcept;
-
- template <size_t I, class... Types>
- constexpr variant_alternative_t<I, variant<Types...>>&
- get(variant<Types...>&);
-
- template <size_t I, class... Types>
- constexpr variant_alternative_t<I, variant<Types...>>&&
- get(variant<Types...>&&);
-
- template <size_t I, class... Types>
- constexpr variant_alternative_t<I, variant<Types...>> const&
- get(const variant<Types...>&);
-
- template <size_t I, class... Types>
- constexpr variant_alternative_t<I, variant<Types...>> const&&
- get(const variant<Types...>&&);
-
- template <class T, class... Types>
- constexpr T& get(variant<Types...>&);
-
- template <class T, class... Types>
- constexpr T&& get(variant<Types...>&&);
-
- template <class T, class... Types>
- constexpr const T& get(const variant<Types...>&);
-
- template <class T, class... Types>
- constexpr const T&& get(const variant<Types...>&&);
-
- template <size_t I, class... Types>
- constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
- get_if(variant<Types...>*) noexcept;
-
- template <size_t I, class... Types>
- constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
- get_if(const variant<Types...>*) noexcept;
-
- template <class T, class... Types>
- constexpr add_pointer_t<T>
- get_if(variant<Types...>*) noexcept;
-
- template <class T, class... Types>
- constexpr add_pointer_t<const T>
- get_if(const variant<Types...>*) noexcept;
-
- // 20.7.5, relational operators
- template <class... Types>
- constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
-
- template <class... Types>
- constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
-
- template <class... Types>
- constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
-
- template <class... Types>
- constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
-
- template <class... Types>
- constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
-
- template <class... Types>
- constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
-
- // 20.7.6, visitation
- template <class Visitor, class... Variants>
- constexpr see below visit(Visitor&&, Variants&&...);
-
- // 20.7.7, class monostate
- struct monostate;
-
- // 20.7.8, monostate relational operators
- constexpr bool operator<(monostate, monostate) noexcept;
- constexpr bool operator>(monostate, monostate) noexcept;
- constexpr bool operator<=(monostate, monostate) noexcept;
- constexpr bool operator>=(monostate, monostate) noexcept;
- constexpr bool operator==(monostate, monostate) noexcept;
- constexpr bool operator!=(monostate, monostate) noexcept;
-
- // 20.7.9, specialized algorithms
- template <class... Types>
- void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
-
- // 20.7.10, class bad_variant_access
- class bad_variant_access;
-
- // 20.7.11, hash support
- template <class T> struct hash;
- template <class... Types> struct hash<variant<Types...>>;
- template <> struct hash<monostate>;
-
-} // namespace std
-
-*/
-
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "config.hpp"
-#include "in_place.hpp"
-#include "lib.hpp"
-
-namespace mpark {
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-
-#define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
-
-#define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#else
-
-#define AUTO auto
-#define AUTO_RETURN(...) \
- -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...) \
- -> decltype((__VA_ARGS__)) { \
- static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
- return __VA_ARGS__; \
- }
-
-#define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...) \
- -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-#endif
-
- class bad_variant_access : public std::exception {
- public:
- virtual const char *what() const noexcept { return "bad_variant_access"; }
- };
-
- [[noreturn]] inline void throw_bad_variant_access() {
-#ifdef MPARK_EXCEPTIONS
- throw bad_variant_access{};
-#else
- std::terminate();
-#endif
- }
-
- template <typename... Ts>
- class variant;
-
- template <typename T>
- struct variant_size;
-
-#ifdef MPARK_VARIABLE_TEMPLATES
- template <typename T>
- constexpr std::size_t variant_size_v = variant_size<T>::value;
-#endif
-
- template <typename T>
- struct variant_size<const T> : variant_size<T> {};
-
- template <typename T>
- struct variant_size<volatile T> : variant_size<T> {};
-
- template <typename T>
- struct variant_size<const volatile T> : variant_size<T> {};
-
- template <typename... Ts>
- struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
-
- template <std::size_t I, typename T>
- struct variant_alternative;
-
- template <std::size_t I, typename T>
- using variant_alternative_t = typename variant_alternative<I, T>::type;
-
- template <std::size_t I, typename T>
- struct variant_alternative<I, const T>
- : std::add_const<variant_alternative_t<I, T>> {};
-
- template <std::size_t I, typename T>
- struct variant_alternative<I, volatile T>
- : std::add_volatile<variant_alternative_t<I, T>> {};
-
- template <std::size_t I, typename T>
- struct variant_alternative<I, const volatile T>
- : std::add_cv<variant_alternative_t<I, T>> {};
-
- template <std::size_t I, typename... Ts>
- struct variant_alternative<I, variant<Ts...>> {
- static_assert(I < sizeof...(Ts),
- "Index out of bounds in std::variant_alternative<>");
- using type = lib::type_pack_element_t<I, Ts...>;
- };
-
- constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
-
- namespace detail {
-
- inline constexpr bool all() { return true; }
-
- template <typename... Bs>
- inline constexpr bool all(bool b, Bs... bs) {
- return b && all(bs...);
- }
-
- constexpr std::size_t not_found = static_cast<std::size_t>(-1);
- constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
-
-#ifdef MPARK_CPP14_CONSTEXPR
- template <typename T, typename... Ts>
- inline constexpr std::size_t find_index() {
- constexpr lib::array<bool, sizeof...(Ts)> matches = {
- {std::is_same<T, Ts>::value...}
- };
- std::size_t result = not_found;
- for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
- if (matches[i]) {
- if (result != not_found) {
- return ambiguous;
- }
- result = i;
- }
- }
- return result;
- }
-#else
- inline constexpr std::size_t find_index_impl(std::size_t result,
- std::size_t) {
- return result;
- }
-
- template <typename... Bs>
- inline constexpr std::size_t find_index_impl(std::size_t result,
- std::size_t idx,
- bool b,
- Bs... bs) {
- return b ? (result != not_found ? ambiguous
- : find_index_impl(idx, idx + 1, bs...))
- : find_index_impl(result, idx + 1, bs...);
- }
-
- template <typename T, typename... Ts>
- inline constexpr std::size_t find_index() {
- return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
- }
-#endif
-
- template <std::size_t I>
- using find_index_sfinae_impl =
- lib::enable_if_t<I != not_found && I != ambiguous,
- lib::size_constant<I>>;
-
- template <typename T, typename... Ts>
- using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
-
- template <std::size_t I>
- struct find_index_checked_impl : lib::size_constant<I> {
- static_assert(I != not_found, "the specified type is not found.");
- static_assert(I != ambiguous, "the specified type is ambiguous.");
- };
-
- template <typename T, typename... Ts>
- using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
-
- struct valueless_t {};
-
- enum class Trait { TriviallyAvailable, Available, Unavailable };
-
- template <typename T,
- template <typename> class IsTriviallyAvailable,
- template <typename> class IsAvailable>
- inline constexpr Trait trait() {
- return IsTriviallyAvailable<T>::value
- ? Trait::TriviallyAvailable
- : IsAvailable<T>::value ? Trait::Available
- : Trait::Unavailable;
- }
-
-#ifdef MPARK_CPP14_CONSTEXPR
- template <typename... Traits>
- inline constexpr Trait common_trait(Traits... traits) {
- Trait result = Trait::TriviallyAvailable;
- for (Trait t : {traits...}) {
- if (static_cast<int>(t) > static_cast<int>(result)) {
- result = t;
- }
- }
- return result;
- }
-#else
- inline constexpr Trait common_trait_impl(Trait result) { return result; }
-
- template <typename... Traits>
- inline constexpr Trait common_trait_impl(Trait result,
- Trait t,
- Traits... ts) {
- return static_cast<int>(t) > static_cast<int>(result)
- ? common_trait_impl(t, ts...)
- : common_trait_impl(result, ts...);
- }
-
- template <typename... Traits>
- inline constexpr Trait common_trait(Traits... ts) {
- return common_trait_impl(Trait::TriviallyAvailable, ts...);
- }
-#endif
-
- template <typename... Ts>
- struct traits {
- static constexpr Trait copy_constructible_trait =
- common_trait(trait<Ts,
- lib::is_trivially_copy_constructible,
- std::is_copy_constructible>()...);
-
- static constexpr Trait move_constructible_trait =
- common_trait(trait<Ts,
- lib::is_trivially_move_constructible,
- std::is_move_constructible>()...);
-
- static constexpr Trait copy_assignable_trait =
- common_trait(copy_constructible_trait,
- trait<Ts,
- lib::is_trivially_copy_assignable,
- std::is_copy_assignable>()...);
-
- static constexpr Trait move_assignable_trait =
- common_trait(move_constructible_trait,
- trait<Ts,
- lib::is_trivially_move_assignable,
- std::is_move_assignable>()...);
-
- static constexpr Trait destructible_trait =
- common_trait(trait<Ts,
- std::is_trivially_destructible,
- std::is_destructible>()...);
- };
-
- namespace access {
-
- struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
- template <typename V>
- inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
- return lib::forward<V>(v).head_;
- }
-
- template <typename V, std::size_t I>
- inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
- return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
- }
-#else
- template <std::size_t I, bool Dummy = true>
- struct get_alt_impl {
- template <typename V>
- inline constexpr AUTO_REFREF operator()(V &&v) const
- AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
- };
-
- template <bool Dummy>
- struct get_alt_impl<0, Dummy> {
- template <typename V>
- inline constexpr AUTO_REFREF operator()(V &&v) const
- AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
- };
-
- template <typename V, std::size_t I>
- inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
- AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
-#endif
- };
-
- struct base {
- template <std::size_t I, typename V>
- inline static constexpr AUTO_REFREF get_alt(V &&v)
- AUTO_REFREF_RETURN(recursive_union::get_alt(
- data(lib::forward<V>(v)), in_place_index_t<I>{}))
- };
-
- struct variant {
- template <std::size_t I, typename V>
- inline static constexpr AUTO_REFREF get_alt(V &&v)
- AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
- };
-
- } // namespace access
-
- namespace visitation {
-
- struct base {
- private:
- template <typename T>
- inline static constexpr const T &at(const T &elem) {
- return elem;
- }
-
- template <typename T, std::size_t N, typename... Is>
- inline static constexpr const lib::remove_all_extents_t<T> &at(
- const lib::array<T, N> &elems, std::size_t i, Is... is) {
- return at(elems[i], is...);
- }
-
- template <typename F, typename... Fs>
- inline static constexpr int visit_visitor_return_type_check() {
- static_assert(all(std::is_same<F, Fs>::value...),
- "`mpark::visit` requires the visitor to have a single "
- "return type.");
- return 0;
- }
-
- template <typename... Fs>
- inline static constexpr lib::array<
- lib::common_type_t<lib::decay_t<Fs>...>,
- sizeof...(Fs)>
- make_farray(Fs &&... fs) {
- using result = lib::array<lib::common_type_t<lib::decay_t<Fs>...>,
- sizeof...(Fs)>;
- return visit_visitor_return_type_check<lib::decay_t<Fs>...>(),
- result{{lib::forward<Fs>(fs)...}};
- }
-
- template <std::size_t... Is>
- struct dispatcher {
- template <typename F, typename... Vs>
- struct impl {
- inline static constexpr DECLTYPE_AUTO dispatch(F f, Vs... vs)
- DECLTYPE_AUTO_RETURN(lib::invoke(
- static_cast<F>(f),
- access::base::get_alt<Is>(static_cast<Vs>(vs))...))
- };
- };
-
- template <typename F, typename... Vs, std::size_t... Is>
- inline static constexpr AUTO make_dispatch(lib::index_sequence<Is...>)
- AUTO_RETURN(&dispatcher<Is...>::template impl<F, Vs...>::dispatch)
-
- template <std::size_t I, typename F, typename... Vs>
- inline static constexpr AUTO make_fdiagonal_impl()
- AUTO_RETURN(make_dispatch<F, Vs...>(
- lib::index_sequence<lib::indexed_type<I, Vs>::value...>{}))
-
- template <typename F, typename... Vs, std::size_t... Is>
- inline static constexpr AUTO make_fdiagonal_impl(
- lib::index_sequence<Is...>)
- AUTO_RETURN(make_farray(make_fdiagonal_impl<Is, F, Vs...>()...))
-
- template <typename F, typename V, typename... Vs>
- inline static constexpr /* auto * */ auto make_fdiagonal()
- -> decltype(make_fdiagonal_impl<F, V, Vs...>(
- lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
- static_assert(
- all((lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...),
- "all of the variants must be the same size.");
- return make_fdiagonal_impl<F, V, Vs...>(
- lib::make_index_sequence<lib::decay_t<V>::size()>{});
- }
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
- template <typename F, typename... Vs, std::size_t... Is>
- inline static constexpr auto make_fmatrix_impl(
- lib::index_sequence<Is...> is) {
- return make_dispatch<F, Vs...>(is);
- }
-
- template <typename F,
- typename... Vs,
- std::size_t... Is,
- std::size_t... Js,
- typename... Ls>
- inline static constexpr auto make_fmatrix_impl(
- lib::index_sequence<Is...>, lib::index_sequence<Js...>, Ls... ls) {
- return make_farray(make_fmatrix_impl<F, Vs...>(
- lib::index_sequence<Is..., Js>{}, ls...)...);
- }
-
- template <typename F, typename... Vs>
- inline static constexpr auto make_fmatrix() {
- return make_fmatrix_impl<F, Vs...>(
- lib::index_sequence<>{},
- lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
- }
-#else
- template <typename F, typename... Vs>
- struct make_fmatrix_impl {
- template <typename...>
- struct impl;
-
- template <std::size_t... Is>
- struct impl<lib::index_sequence<Is...>> {
- inline constexpr AUTO operator()() const
- AUTO_RETURN(
- make_dispatch<F, Vs...>(lib::index_sequence<Is...>{}))
- };
-
- template <std::size_t... Is, std::size_t... Js, typename... Ls>
- struct impl<lib::index_sequence<Is...>,
- lib::index_sequence<Js...>,
- Ls...> {
- inline constexpr AUTO operator()() const
- AUTO_RETURN(make_farray(
- impl<lib::index_sequence<Is..., Js>, Ls...>{}()...))
- };
- };
-
- template <typename F, typename... Vs>
- inline static constexpr AUTO make_fmatrix()
- AUTO_RETURN(
- typename make_fmatrix_impl<F, Vs...>::template impl<
- lib::index_sequence<>,
- lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
-#endif
-
- public:
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
- Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- at(make_fdiagonal<Visitor &&,
- decltype(as_base(lib::forward<Vs>(vs)))...>(),
- index)(lib::forward<Visitor>(visitor),
- as_base(lib::forward<Vs>(vs))...))
-
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- at(make_fmatrix<Visitor &&,
- decltype(as_base(lib::forward<Vs>(vs)))...>(),
- vs.index()...)(lib::forward<Visitor>(visitor),
- as_base(lib::forward<Vs>(vs))...))
- };
-
- struct variant {
- private:
- template <typename Visitor, typename... Values>
- struct visit_exhaustive_visitor_check {
- static_assert(
- lib::is_invocable<Visitor, Values...>::value,
- "`mpark::visit` requires the visitor to be exhaustive.");
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
- inline constexpr DECLTYPE_AUTO operator()(Visitor &&visitor,
- Values &&... values) const
- DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
- lib::forward<Values>(values)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
- };
-
- template <typename Visitor>
- struct value_visitor {
- Visitor &&visitor_;
-
- template <typename... Alts>
- inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
- DECLTYPE_AUTO_RETURN(
- visit_exhaustive_visitor_check<
- Visitor,
- decltype((lib::forward<Alts>(alts).value))...>{}(
- lib::forward<Visitor>(visitor_),
- lib::forward<Alts>(alts).value...))
- };
-
- template <typename Visitor>
- inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
- AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
-
- public:
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
- Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- base::visit_alt_at(index,
- lib::forward<Visitor>(visitor),
- lib::forward<Vs>(vs).impl_...))
-
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(base::visit_alt(lib::forward<Visitor>(visitor),
- lib::forward<Vs>(vs).impl_...))
-
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
- Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- visit_alt_at(index,
- make_value_visitor(lib::forward<Visitor>(visitor)),
- lib::forward<Vs>(vs)...))
-
- template <typename Visitor, typename... Vs>
- inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
- Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
- lib::forward<Vs>(vs)...))
- };
-
- } // namespace visitation
-
- template <std::size_t Index, typename T>
- struct alt {
- using value_type = T;
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
- template <typename... Args>
- inline explicit constexpr alt(in_place_t, Args &&... args)
- : value(lib::forward<Args>(args)...) {}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
- T value;
- };
-
- template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
- union recursive_union;
-
- template <Trait DestructibleTrait, std::size_t Index>
- union recursive_union<DestructibleTrait, Index> {};
-
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor) \
- template <std::size_t Index, typename T, typename... Ts> \
- union recursive_union<destructible_trait, Index, T, Ts...> { \
- public: \
- inline explicit constexpr recursive_union(valueless_t) noexcept \
- : dummy_{} {} \
- \
- template <typename... Args> \
- inline explicit constexpr recursive_union(in_place_index_t<0>, \
- Args &&... args) \
- : head_(in_place_t{}, lib::forward<Args>(args)...) {} \
- \
- template <std::size_t I, typename... Args> \
- inline explicit constexpr recursive_union(in_place_index_t<I>, \
- Args &&... args) \
- : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
- \
- recursive_union(const recursive_union &) = default; \
- recursive_union(recursive_union &&) = default; \
- \
- destructor \
- \
- recursive_union &operator=(const recursive_union &) = default; \
- recursive_union &operator=(recursive_union &&) = default; \
- \
- private: \
- char dummy_; \
- alt<Index, T> head_; \
- recursive_union<destructible_trait, Index + 1, Ts...> tail_; \
- \
- friend struct access::recursive_union; \
- }
-
- MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
- ~recursive_union() = default;);
- MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
- ~recursive_union() {});
- MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
- ~recursive_union() = delete;);
-
-#undef MPARK_VARIANT_RECURSIVE_UNION
-
- using index_t = unsigned int;
-
- template <Trait DestructibleTrait, typename... Ts>
- class base {
- public:
- inline explicit constexpr base(valueless_t tag) noexcept
- : data_(tag), index_(static_cast<index_t>(-1)) {}
-
- template <std::size_t I, typename... Args>
- inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
- : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
- index_(I) {}
-
- inline constexpr bool valueless_by_exception() const noexcept {
- return index_ == static_cast<index_t>(-1);
- }
-
- inline constexpr std::size_t index() const noexcept {
- return valueless_by_exception() ? variant_npos : index_;
- }
-
- protected:
- using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
-
- friend inline constexpr base &as_base(base &b) { return b; }
- friend inline constexpr const base &as_base(const base &b) { return b; }
- friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
- friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
-
- friend inline constexpr data_t &data(base &b) { return b.data_; }
- friend inline constexpr const data_t &data(const base &b) { return b.data_; }
- friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
- friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
-
- inline static constexpr std::size_t size() { return sizeof...(Ts); }
-
- data_t data_;
- index_t index_;
-
- friend struct access::base;
- friend struct visitation::base;
- };
-
- struct dtor {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
- template <typename Alt>
- inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
- };
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#define INHERITING_CTOR(type, base) \
- template <typename... Args> \
- inline explicit constexpr type(Args &&... args) \
- : base(lib::forward<Args>(args)...) {}
-#else
-#define INHERITING_CTOR(type, base) using base::base;
-#endif
-
- template <typename Traits, Trait = Traits::destructible_trait>
- class destructor;
-
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
- template <typename... Ts> \
- class destructor<traits<Ts...>, destructible_trait> \
- : public base<destructible_trait, Ts...> { \
- using super = base<destructible_trait, Ts...>; \
- \
- public: \
- INHERITING_CTOR(destructor, super) \
- using super::operator=; \
- \
- destructor(const destructor &) = default; \
- destructor(destructor &&) = default; \
- definition \
- destructor &operator=(const destructor &) = default; \
- destructor &operator=(destructor &&) = default; \
- \
- protected: \
- destroy \
- }
-
- MPARK_VARIANT_DESTRUCTOR(
- Trait::TriviallyAvailable,
- ~destructor() = default;,
- inline void destroy() noexcept {
- this->index_ = static_cast<index_t>(-1);
- });
-
- MPARK_VARIANT_DESTRUCTOR(
- Trait::Available,
- ~destructor() { destroy(); },
- inline void destroy() noexcept {
- if (!this->valueless_by_exception()) {
- visitation::base::visit_alt(dtor{}, *this);
- }
- this->index_ = static_cast<index_t>(-1);
- });
-
- MPARK_VARIANT_DESTRUCTOR(
- Trait::Unavailable,
- ~destructor() = delete;,
- inline void destroy() noexcept = delete;);
-
-#undef MPARK_VARIANT_DESTRUCTOR
-
- template <typename Traits>
- class constructor : public destructor<Traits> {
- using super = destructor<Traits>;
-
- public:
- INHERITING_CTOR(constructor, super)
- using super::operator=;
-
- protected:
-#ifndef MPARK_GENERIC_LAMBDAS
- struct ctor {
- template <typename LhsAlt, typename RhsAlt>
- inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
- constructor::construct_alt(lhs_alt,
- lib::forward<RhsAlt>(rhs_alt).value);
- }
- };
-#endif
-
- template <std::size_t I, typename T, typename... Args>
- inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
- ::new (static_cast<void *>(lib::addressof(a)))
- alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
- return a.value;
- }
-
- template <typename Rhs>
- inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
- lhs.destroy();
- if (!rhs.valueless_by_exception()) {
- visitation::base::visit_alt_at(
- rhs.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
- [](auto &lhs_alt, auto &&rhs_alt) {
- constructor::construct_alt(
- lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
- }
-#else
- ctor{}
-#endif
- ,
- lhs,
- lib::forward<Rhs>(rhs));
- lhs.index_ = rhs.index_;
- }
- }
- };
-
- template <typename Traits, Trait = Traits::move_constructible_trait>
- class move_constructor;
-
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
- template <typename... Ts> \
- class move_constructor<traits<Ts...>, move_constructible_trait> \
- : public constructor<traits<Ts...>> { \
- using super = constructor<traits<Ts...>>; \
- \
- public: \
- INHERITING_CTOR(move_constructor, super) \
- using super::operator=; \
- \
- move_constructor(const move_constructor &) = default; \
- definition \
- ~move_constructor() = default; \
- move_constructor &operator=(const move_constructor &) = default; \
- move_constructor &operator=(move_constructor &&) = default; \
- }
-
- MPARK_VARIANT_MOVE_CONSTRUCTOR(
- Trait::TriviallyAvailable,
- move_constructor(move_constructor &&that) = default;);
-
- MPARK_VARIANT_MOVE_CONSTRUCTOR(
- Trait::Available,
- move_constructor(move_constructor &&that) noexcept(
- all(std::is_nothrow_move_constructible<Ts>::value...))
- : move_constructor(valueless_t{}) {
- this->generic_construct(*this, lib::move(that));
- });
-
- MPARK_VARIANT_MOVE_CONSTRUCTOR(
- Trait::Unavailable,
- move_constructor(move_constructor &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_CONSTRUCTOR
-
- template <typename Traits, Trait = Traits::copy_constructible_trait>
- class copy_constructor;
-
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
- template <typename... Ts> \
- class copy_constructor<traits<Ts...>, copy_constructible_trait> \
- : public move_constructor<traits<Ts...>> { \
- using super = move_constructor<traits<Ts...>>; \
- \
- public: \
- INHERITING_CTOR(copy_constructor, super) \
- using super::operator=; \
- \
- definition \
- copy_constructor(copy_constructor &&) = default; \
- ~copy_constructor() = default; \
- copy_constructor &operator=(const copy_constructor &) = default; \
- copy_constructor &operator=(copy_constructor &&) = default; \
- }
-
- MPARK_VARIANT_COPY_CONSTRUCTOR(
- Trait::TriviallyAvailable,
- copy_constructor(const copy_constructor &that) = default;);
-
- MPARK_VARIANT_COPY_CONSTRUCTOR(
- Trait::Available,
- copy_constructor(const copy_constructor &that)
- : copy_constructor(valueless_t{}) {
- this->generic_construct(*this, that);
- });
-
- MPARK_VARIANT_COPY_CONSTRUCTOR(
- Trait::Unavailable,
- copy_constructor(const copy_constructor &) = delete;);
-
-#undef MPARK_VARIANT_COPY_CONSTRUCTOR
-
- template <typename Traits>
- class assignment : public copy_constructor<Traits> {
- using super = copy_constructor<Traits>;
-
- public:
- INHERITING_CTOR(assignment, super)
- using super::operator=;
-
- template <std::size_t I, typename... Args>
- inline /* auto & */ auto emplace(Args &&... args)
- -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
- lib::forward<Args>(args)...)) {
- this->destroy();
- auto &result = this->construct_alt(access::base::get_alt<I>(*this),
- lib::forward<Args>(args)...);
- this->index_ = I;
- return result;
- }
-
- protected:
-#ifndef MPARK_GENERIC_LAMBDAS
- template <typename That>
- struct assigner {
- template <typename ThisAlt, typename ThatAlt>
- inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
- self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
- }
- assignment *self;
- };
-#endif
-
- template <std::size_t I, typename T, typename Arg>
- inline void assign_alt(alt<I, T> &a, Arg &&arg) {
- if (this->index() == I) {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
- a.value = lib::forward<Arg>(arg);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
- } else {
- struct {
- void operator()(std::true_type) const {
- this_->emplace<I>(lib::forward<Arg>(arg_));
- }
- void operator()(std::false_type) const {
- this_->emplace<I>(T(lib::forward<Arg>(arg_)));
- }
- assignment *this_;
- Arg &&arg_;
- } impl{this, lib::forward<Arg>(arg)};
- impl(lib::bool_constant<
- std::is_nothrow_constructible<T, Arg>::value ||
- !std::is_nothrow_move_constructible<T>::value>{});
- }
- }
-
- template <typename That>
- inline void generic_assign(That &&that) {
- if (this->valueless_by_exception() && that.valueless_by_exception()) {
- // do nothing.
- } else if (that.valueless_by_exception()) {
- this->destroy();
- } else {
- visitation::base::visit_alt_at(
- that.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
- [this](auto &this_alt, auto &&that_alt) {
- this->assign_alt(
- this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
- }
-#else
- assigner<That>{this}
-#endif
- ,
- *this,
- lib::forward<That>(that));
- }
- }
- };
-
- template <typename Traits, Trait = Traits::move_assignable_trait>
- class move_assignment;
-
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
- template <typename... Ts> \
- class move_assignment<traits<Ts...>, move_assignable_trait> \
- : public assignment<traits<Ts...>> { \
- using super = assignment<traits<Ts...>>; \
- \
- public: \
- INHERITING_CTOR(move_assignment, super) \
- using super::operator=; \
- \
- move_assignment(const move_assignment &) = default; \
- move_assignment(move_assignment &&) = default; \
- ~move_assignment() = default; \
- move_assignment &operator=(const move_assignment &) = default; \
- definition \
- }
-
- MPARK_VARIANT_MOVE_ASSIGNMENT(
- Trait::TriviallyAvailable,
- move_assignment &operator=(move_assignment &&that) = default;);
-
- MPARK_VARIANT_MOVE_ASSIGNMENT(
- Trait::Available,
- move_assignment &
- operator=(move_assignment &&that) noexcept(
- all((std::is_nothrow_move_constructible<Ts>::value &&
- std::is_nothrow_move_assignable<Ts>::value)...)) {
- this->generic_assign(lib::move(that));
- return *this;
- });
-
- MPARK_VARIANT_MOVE_ASSIGNMENT(
- Trait::Unavailable,
- move_assignment &operator=(move_assignment &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_ASSIGNMENT
-
- template <typename Traits, Trait = Traits::copy_assignable_trait>
- class copy_assignment;
-
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
- template <typename... Ts> \
- class copy_assignment<traits<Ts...>, copy_assignable_trait> \
- : public move_assignment<traits<Ts...>> { \
- using super = move_assignment<traits<Ts...>>; \
- \
- public: \
- INHERITING_CTOR(copy_assignment, super) \
- using super::operator=; \
- \
- copy_assignment(const copy_assignment &) = default; \
- copy_assignment(copy_assignment &&) = default; \
- ~copy_assignment() = default; \
- definition \
- copy_assignment &operator=(copy_assignment &&) = default; \
- }
-
- MPARK_VARIANT_COPY_ASSIGNMENT(
- Trait::TriviallyAvailable,
- copy_assignment &operator=(const copy_assignment &that) = default;);
-
- MPARK_VARIANT_COPY_ASSIGNMENT(
- Trait::Available,
- copy_assignment &operator=(const copy_assignment &that) {
- this->generic_assign(that);
- return *this;
- });
-
- MPARK_VARIANT_COPY_ASSIGNMENT(
- Trait::Unavailable,
- copy_assignment &operator=(const copy_assignment &) = delete;);
-
-#undef MPARK_VARIANT_COPY_ASSIGNMENT
-
- template <typename... Ts>
- class impl : public copy_assignment<traits<Ts...>> {
- using super = copy_assignment<traits<Ts...>>;
-
- public:
- INHERITING_CTOR(impl, super)
- using super::operator=;
-
- template <std::size_t I, typename Arg>
- inline void assign(Arg &&arg) {
- this->assign_alt(access::base::get_alt<I>(*this),
- lib::forward<Arg>(arg));
- }
-
- inline void swap(impl &that) {
- if (this->valueless_by_exception() && that.valueless_by_exception()) {
- // do nothing.
- } else if (this->index() == that.index()) {
- visitation::base::visit_alt_at(this->index(),
-#ifdef MPARK_GENERIC_LAMBDAS
- [](auto &this_alt, auto &that_alt) {
- using std::swap;
- swap(this_alt.value,
- that_alt.value);
- }
-#else
- swapper{}
-#endif
- ,
- *this,
- that);
- } else {
- impl *lhs = this;
- impl *rhs = lib::addressof(that);
- if (lhs->move_nothrow() && !rhs->move_nothrow()) {
- std::swap(lhs, rhs);
- }
- impl tmp(lib::move(*rhs));
-#ifdef MPARK_EXCEPTIONS
- // EXTENSION: When the move construction of `lhs` into `rhs` throws
- // and `tmp` is nothrow move constructible then we move `tmp` back
- // into `rhs` and provide the strong exception safety guarantee.
- try {
- this->generic_construct(*rhs, lib::move(*lhs));
- } catch (...) {
- if (tmp.move_nothrow()) {
- this->generic_construct(*rhs, lib::move(tmp));
- }
- throw;
- }
-#else
- this->generic_construct(*rhs, lib::move(*lhs));
-#endif
- this->generic_construct(*lhs, lib::move(tmp));
- }
- }
-
- private:
-#ifndef MPARK_GENERIC_LAMBDAS
- struct swapper {
- template <typename ThisAlt, typename ThatAlt>
- inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
- using std::swap;
- swap(this_alt.value, that_alt.value);
- }
- };
-#endif
-
- inline constexpr bool move_nothrow() const {
- return this->valueless_by_exception() ||
- lib::array<bool, sizeof...(Ts)>{
- {std::is_nothrow_move_constructible<Ts>::value...}
- }[this->index()];
- }
- };
-
- template <typename... Ts>
- struct overload;
-
- template <>
- struct overload<> { void operator()() const {} };
-
- template <typename T, typename... Ts>
- struct overload<T, Ts...> : overload<Ts...> {
- using overload<Ts...>::operator();
- lib::identity<T> operator()(T) const { return {}; }
- };
-
- template <typename T, typename... Ts>
- using best_match_t =
- typename lib::invoke_result_t<overload<Ts...>, T &&>::type;
-
- template <typename T>
- struct is_in_place_index : std::false_type {};
-
- template <std::size_t I>
- struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
-
- template <typename T>
- struct is_in_place_type : std::false_type {};
-
- template <typename T>
- struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
-
- } // detail
-
- template <typename... Ts>
- class variant {
- static_assert(0 < sizeof...(Ts),
- "variant must consist of at least one alternative.");
-
- static_assert(lib::all<!std::is_array<Ts>::value...>::value,
- "variant can not have an array type as an alternative.");
-
- static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
- "variant can not have a reference type as an alternative.");
-
- static_assert(lib::all<!std::is_void<Ts>::value...>::value,
- "variant can not have a void type as an alternative.");
-
- public:
- template <
- typename Front = lib::type_pack_element_t<0, Ts...>,
- lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
- inline constexpr variant() noexcept(
- std::is_nothrow_default_constructible<Front>::value)
- : impl_(in_place_index_t<0>{}) {}
-
- variant(const variant &) = default;
- variant(variant &&) = default;
-
- template <
- typename Arg,
- typename Decayed = lib::decay_t<Arg>,
- lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
- lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
- lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0,
- typename T = detail::best_match_t<Arg, Ts...>,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
- inline constexpr variant(Arg &&arg) noexcept(
- std::is_nothrow_constructible<T, Arg>::value)
- : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
-
- template <
- std::size_t I,
- typename... Args,
- typename T = lib::type_pack_element_t<I, Ts...>,
- lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
- inline explicit constexpr variant(
- in_place_index_t<I>,
- Args &&... args) noexcept(std::is_nothrow_constructible<T,
- Args...>::value)
- : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
- template <
- std::size_t I,
- typename Up,
- typename... Args,
- typename T = lib::type_pack_element_t<I, Ts...>,
- lib::enable_if_t<std::is_constructible<T,
- std::initializer_list<Up> &,
- Args...>::value,
- int> = 0>
- inline explicit constexpr variant(
- in_place_index_t<I>,
- std::initializer_list<Up> il,
- Args &&... args) noexcept(std::
- is_nothrow_constructible<
- T,
- std::initializer_list<Up> &,
- Args...>::value)
- : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
- template <
- typename T,
- typename... Args,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
- inline explicit constexpr variant(
- in_place_type_t<T>,
- Args &&... args) noexcept(std::is_nothrow_constructible<T,
- Args...>::value)
- : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
- template <
- typename T,
- typename Up,
- typename... Args,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<std::is_constructible<T,
- std::initializer_list<Up> &,
- Args...>::value,
- int> = 0>
- inline explicit constexpr variant(
- in_place_type_t<T>,
- std::initializer_list<Up> il,
- Args &&... args) noexcept(std::
- is_nothrow_constructible<
- T,
- std::initializer_list<Up> &,
- Args...>::value)
- : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
- ~variant() = default;
-
- variant &operator=(const variant &) = default;
- variant &operator=(variant &&) = default;
-
- template <typename Arg,
- lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
- int> = 0,
- typename T = detail::best_match_t<Arg, Ts...>,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
- std::is_constructible<T, Arg>::value),
- int> = 0>
- inline variant &operator=(Arg &&arg) noexcept(
- (std::is_nothrow_assignable<T &, Arg>::value &&
- std::is_nothrow_constructible<T, Arg>::value)) {
- impl_.template assign<I>(lib::forward<Arg>(arg));
- return *this;
- }
-
- template <
- std::size_t I,
- typename... Args,
- typename T = lib::type_pack_element_t<I, Ts...>,
- lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
- inline T &emplace(Args &&... args) {
- return impl_.template emplace<I>(lib::forward<Args>(args)...);
- }
-
- template <
- std::size_t I,
- typename Up,
- typename... Args,
- typename T = lib::type_pack_element_t<I, Ts...>,
- lib::enable_if_t<std::is_constructible<T,
- std::initializer_list<Up> &,
- Args...>::value,
- int> = 0>
- inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
- return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
- }
-
- template <
- typename T,
- typename... Args,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
- inline T &emplace(Args &&... args) {
- return impl_.template emplace<I>(lib::forward<Args>(args)...);
- }
-
- template <
- typename T,
- typename Up,
- typename... Args,
- std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
- lib::enable_if_t<std::is_constructible<T,
- std::initializer_list<Up> &,
- Args...>::value,
- int> = 0>
- inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
- return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
- }
-
- inline constexpr bool valueless_by_exception() const noexcept {
- return impl_.valueless_by_exception();
- }
-
- inline constexpr std::size_t index() const noexcept {
- return impl_.index();
- }
-
- template <
- bool Dummy = true,
- lib::enable_if_t<lib::all<Dummy,
- (std::is_move_constructible<Ts>::value &&
- lib::is_swappable<Ts>::value)...>::value,
- int> = 0>
- inline void swap(variant &that) noexcept(
- lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
- lib::is_nothrow_swappable<Ts>::value)...>::value) {
- impl_.swap(that.impl_);
- }
-
- private:
- detail::impl<Ts...> impl_;
-
- friend struct detail::access::variant;
- friend struct detail::visitation::variant;
- };
-
- template <std::size_t I, typename... Ts>
- inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
- return v.index() == I;
- }
-
- template <typename T, typename... Ts>
- inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
- return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
- }
-
- namespace detail {
- template <std::size_t I, typename V>
- struct generic_get_impl {
- constexpr generic_get_impl(int) {}
-
- constexpr AUTO_REFREF operator()(V &&v) const
- AUTO_REFREF_RETURN(
- access::variant::get_alt<I>(lib::forward<V>(v)).value)
- };
-
- template <std::size_t I, typename V>
- inline constexpr AUTO_REFREF generic_get(V &&v)
- AUTO_REFREF_RETURN(generic_get_impl<I, V>(
- holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
- lib::forward<V>(v)))
- } // namespace detail
-
- template <std::size_t I, typename... Ts>
- inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
- variant<Ts...> &v) {
- return detail::generic_get<I>(v);
- }
-
- template <std::size_t I, typename... Ts>
- inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
- variant<Ts...> &&v) {
- return detail::generic_get<I>(lib::move(v));
- }
-
- template <std::size_t I, typename... Ts>
- inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
- const variant<Ts...> &v) {
- return detail::generic_get<I>(v);
- }
-
- template <std::size_t I, typename... Ts>
- inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
- const variant<Ts...> &&v) {
- return detail::generic_get<I>(lib::move(v));
- }
-
- template <typename T, typename... Ts>
- inline constexpr T &get(variant<Ts...> &v) {
- return get<detail::find_index_checked<T, Ts...>::value>(v);
- }
-
- template <typename T, typename... Ts>
- inline constexpr T &&get(variant<Ts...> &&v) {
- return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
- }
-
- template <typename T, typename... Ts>
- inline constexpr const T &get(const variant<Ts...> &v) {
- return get<detail::find_index_checked<T, Ts...>::value>(v);
- }
-
- template <typename T, typename... Ts>
- inline constexpr const T &&get(const variant<Ts...> &&v) {
- return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
- }
-
- namespace detail {
-
- template <std::size_t I, typename V>
- inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
- AUTO_RETURN(v && holds_alternative<I>(*v)
- ? lib::addressof(access::variant::get_alt<I>(*v).value)
- : nullptr)
-
- } // namespace detail
-
- template <std::size_t I, typename... Ts>
- inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
- get_if(variant<Ts...> *v) noexcept {
- return detail::generic_get_if<I>(v);
- }
-
- template <std::size_t I, typename... Ts>
- inline constexpr lib::add_pointer_t<
- const variant_alternative_t<I, variant<Ts...>>>
- get_if(const variant<Ts...> *v) noexcept {
- return detail::generic_get_if<I>(v);
- }
-
- template <typename T, typename... Ts>
- inline constexpr lib::add_pointer_t<T>
- get_if(variant<Ts...> *v) noexcept {
- return get_if<detail::find_index_checked<T, Ts...>::value>(v);
- }
-
- template <typename T, typename... Ts>
- inline constexpr lib::add_pointer_t<const T>
- get_if(const variant<Ts...> *v) noexcept {
- return get_if<detail::find_index_checked<T, Ts...>::value>(v);
- }
-
- template <typename... Ts>
- inline constexpr bool operator==(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (lhs.index() != rhs.index()) return false;
- if (lhs.valueless_by_exception()) return true;
- return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
-#else
- return lhs.index() == rhs.index() &&
- (lhs.valueless_by_exception() ||
- variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
-#endif
- }
-
- template <typename... Ts>
- inline constexpr bool operator!=(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::not_equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (lhs.index() != rhs.index()) return true;
- if (lhs.valueless_by_exception()) return false;
- return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
-#else
- return lhs.index() != rhs.index() ||
- (!lhs.valueless_by_exception() &&
- variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
-#endif
- }
-
- template <typename... Ts>
- inline constexpr bool operator<(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::less;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (rhs.valueless_by_exception()) return false;
- if (lhs.valueless_by_exception()) return true;
- if (lhs.index() < rhs.index()) return true;
- if (lhs.index() > rhs.index()) return false;
- return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
-#else
- return !rhs.valueless_by_exception() &&
- (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
- (lhs.index() == rhs.index() &&
- variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
-#endif
- }
-
- template <typename... Ts>
- inline constexpr bool operator>(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::greater;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (lhs.valueless_by_exception()) return false;
- if (rhs.valueless_by_exception()) return true;
- if (lhs.index() > rhs.index()) return true;
- if (lhs.index() < rhs.index()) return false;
- return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
-#else
- return !lhs.valueless_by_exception() &&
- (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
- (lhs.index() == rhs.index() &&
- variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
-#endif
- }
-
- template <typename... Ts>
- inline constexpr bool operator<=(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::less_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (lhs.valueless_by_exception()) return true;
- if (rhs.valueless_by_exception()) return false;
- if (lhs.index() < rhs.index()) return true;
- if (lhs.index() > rhs.index()) return false;
- return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
-#else
- return lhs.valueless_by_exception() ||
- (!rhs.valueless_by_exception() &&
- (lhs.index() < rhs.index() ||
- (lhs.index() == rhs.index() &&
- variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
-#endif
- }
-
- template <typename... Ts>
- inline constexpr bool operator>=(const variant<Ts...> &lhs,
- const variant<Ts...> &rhs) {
- using detail::visitation::variant;
- using lib::greater_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
- if (rhs.valueless_by_exception()) return true;
- if (lhs.valueless_by_exception()) return false;
- if (lhs.index() > rhs.index()) return true;
- if (lhs.index() < rhs.index()) return false;
- return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
-#else
- return rhs.valueless_by_exception() ||
- (!lhs.valueless_by_exception() &&
- (lhs.index() > rhs.index() ||
- (lhs.index() == rhs.index() &&
- variant::visit_value_at(
- lhs.index(), greater_equal{}, lhs, rhs))));
-#endif
- }
-
- template <typename Visitor, typename... Vs>
- inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
- DECLTYPE_AUTO_RETURN(
- (detail::all(!vs.valueless_by_exception()...)
- ? (void)0
- : throw_bad_variant_access()),
- detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
- lib::forward<Vs>(vs)...))
-
- struct monostate {};
-
- inline constexpr bool operator<(monostate, monostate) noexcept {
- return false;
- }
-
- inline constexpr bool operator>(monostate, monostate) noexcept {
- return false;
- }
-
- inline constexpr bool operator<=(monostate, monostate) noexcept {
- return true;
- }
-
- inline constexpr bool operator>=(monostate, monostate) noexcept {
- return true;
- }
-
- inline constexpr bool operator==(monostate, monostate) noexcept {
- return true;
- }
-
- inline constexpr bool operator!=(monostate, monostate) noexcept {
- return false;
- }
-
- template <typename... Ts>
- inline auto swap(variant<Ts...> &lhs,
- variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
- -> decltype(lhs.swap(rhs)) {
- lhs.swap(rhs);
- }
-
- namespace detail {
-
- template <typename T, typename...>
- using enabled_type = T;
-
- namespace hash {
-
- template <typename H, typename K>
- constexpr bool meets_requirements() {
- return std::is_copy_constructible<H>::value &&
- std::is_move_constructible<H>::value &&
- lib::is_invocable_r<std::size_t, H, const K &>::value;
- }
-
- template <typename K>
- constexpr bool is_enabled() {
- using H = std::hash<K>;
- return meets_requirements<H, K>() &&
- std::is_default_constructible<H>::value &&
- std::is_copy_assignable<H>::value &&
- std::is_move_assignable<H>::value;
- }
-
- } // namespace hash
-
- } // namespace detail
-
-#undef AUTO
-#undef AUTO_RETURN
-
-#undef AUTO_REFREF
-#undef AUTO_REFREF_RETURN
-
-#undef DECLTYPE_AUTO
-#undef DECLTYPE_AUTO_RETURN
-
-} // namespace mpark
-
-namespace std {
-
- template <typename... Ts>
- struct hash<mpark::detail::enabled_type<
- mpark::variant<Ts...>,
- mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
- mpark::lib::remove_const_t<Ts>>()...>::value>>> {
- using argument_type = mpark::variant<Ts...>;
- using result_type = std::size_t;
-
- inline result_type operator()(const argument_type &v) const {
- using mpark::detail::visitation::variant;
- std::size_t result =
- v.valueless_by_exception()
- ? 299792458 // Random value chosen by the universe upon creation
- : variant::visit_alt(
-#ifdef MPARK_GENERIC_LAMBDAS
- [](const auto &alt) {
- using alt_type = mpark::lib::decay_t<decltype(alt)>;
- using value_type = mpark::lib::remove_const_t<
- typename alt_type::value_type>;
- return hash<value_type>{}(alt.value);
- }
-#else
- hasher{}
-#endif
- ,
- v);
- return hash_combine(result, hash<std::size_t>{}(v.index()));
- }
-
- private:
-#ifndef MPARK_GENERIC_LAMBDAS
- struct hasher {
- template <typename Alt>
- inline std::size_t operator()(const Alt &alt) const {
- using alt_type = mpark::lib::decay_t<Alt>;
- using value_type =
- mpark::lib::remove_const_t<typename alt_type::value_type>;
- return hash<value_type>{}(alt.value);
- }
- };
-#endif
-
- static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
- return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
- }
- };
-
- template <>
- struct hash<mpark::monostate> {
- using argument_type = mpark::monostate;
- using result_type = std::size_t;
-
- inline result_type operator()(const argument_type &) const noexcept {
- return 66740831; // return a fundamentally attractive random value.
- }
- };
-
-} // namespace std
-
-#endif // MPARK_VARIANT_HPP
diff --git a/src/Block.hpp b/src/Block.hpp
index 367e559..6bd4e93 100644
--- a/src/Block.hpp
+++ b/src/Block.hpp
@@ -11,4 +11,9 @@ struct Block {
unsigned char state : 4;
unsigned char light : 4;
unsigned char sky : 4;
+};
+
+struct BlockId {
+ unsigned short id : 13;
+ unsigned char state : 4;
}; \ No newline at end of file
diff --git a/src/Render.cpp b/src/Render.cpp
index 7e88068..c739b77 100644
--- a/src/Render.cpp
+++ b/src/Render.cpp
@@ -6,12 +6,12 @@
#include "Event.hpp"
Render::Render(unsigned int windowWidth, unsigned int windowHeight, std::string windowTitle) : timer(std::chrono::milliseconds(0)) {
- InitSfml(windowWidth, windowHeight, windowTitle);
- glCheckError();
- InitGlew();
- glCheckError();
- PrepareToRendering();
- glCheckError();
+ InitSfml(windowWidth, windowHeight, windowTitle);
+ glCheckError();
+ InitGlew();
+ glCheckError();
+ PrepareToRendering();
+ glCheckError();
}
Render::~Render() {
@@ -29,7 +29,8 @@ void Render::InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string
glCheckError();
window->setPosition(sf::Vector2i(sf::VideoMode::getDesktopMode().width / 2 - window->getSize().x / 2,
sf::VideoMode::getDesktopMode().height / 2 - window->getSize().y / 2));
- SetMouseCapture(false);
+ window->setKeyRepeatEnabled(false);
+ SetMouseCapture(false);
renderState.WindowWidth = WinWidth;
renderState.WindowHeight = WinHeight;
}
@@ -59,6 +60,23 @@ void Render::PrepareToRendering() {
AssetManager::Instance().GetTextureAtlasIndexes();
}
+void Render::UpdateKeyboard() {
+ sf::Keyboard::Key toUpdate[] = { sf::Keyboard::A,sf::Keyboard::W,sf::Keyboard::S,sf::Keyboard::D,sf::Keyboard::Space };
+ for (auto key : toUpdate) {
+ bool isPressed = sf::Keyboard::isKeyPressed(key);
+ if (!isKeyPressed[key] && isPressed) {
+ EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ key });
+ }
+ if (isKeyPressed[key] && isPressed) {
+ //KeyHeld
+ }
+ if (isKeyPressed[key] && !isPressed) {
+ EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ key });
+ }
+ isKeyPressed[key] = isPressed;
+ }
+}
+
void Render::RenderFrame() {
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -75,92 +93,62 @@ void Render::RenderFrame() {
void Render::HandleEvents() {
sf::Event event;
- while (window->pollEvent(event)) {
- switch (event.type) {
- case sf::Event::Closed:
- LOG(INFO) << "Received close event by window closing";
- isRunning = false;
- break;
- case sf::Event::Resized:
- glViewport(0, 0, window->getSize().x, window->getSize().y);
- renderState.WindowWidth = window->getSize().x;
- renderState.WindowHeight = window->getSize().y;
- break;
- case sf::Event::KeyPressed:
- if (!window->hasFocus()) break;
- switch (event.key.code) {
- case sf::Keyboard::Escape:
- LOG(INFO) << "Received close event by esc";
- isRunning = false;
- break;
- case sf::Keyboard::T:
- SetMouseCapture(!isMouseCaptured);
- break;
- case sf::Keyboard::U:
- EventAgregator::PushEvent(EventType::ConnectToServer, ConnectToServerData{ "10.1.1.2", 25565 });
- break;
- case sf::Keyboard::I:
- EventAgregator::PushEvent(EventType::Disconnect, DisconnectData{ "Manual disconnect" });
- break;
- case sf::Keyboard::K:
- if (renderWorld) {
- world->MaxRenderingDistance--;
- if (world->MaxRenderingDistance <= 0)
- world->MaxRenderingDistance = 1;
- LOG(INFO) << "Decreased rendering distance: " << world->MaxRenderingDistance;
- EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
- }
- break;
- case sf::Keyboard::L:
- if (renderWorld) {
- world->MaxRenderingDistance++;
- LOG(INFO) << "Increased rendering distance: " << world->MaxRenderingDistance;
- EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
- }
- break;
- case sf::Keyboard::W:
- EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::W });
- break;
- case sf::Keyboard::A:
- EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::A });
- break;
- case sf::Keyboard::S:
- EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::S });
- break;
- case sf::Keyboard::D:
- EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::D });
- break;
- case sf::Keyboard::Space:
- EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::Space });
- break;
- default:
- break;
- }
- case sf::Event::KeyReleased:
- if (!window->hasFocus()) break;
- switch (event.key.code) {
- case sf::Keyboard::W:
- EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::W });
- break;
- case sf::Keyboard::A:
- EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::A });
- break;
- case sf::Keyboard::S:
- EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::S });
- break;
- case sf::Keyboard::D:
- EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::D });
- break;
- case sf::Keyboard::Space:
- EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::Space });
- break;
- default:
- break;
+ while (window->pollEvent(event)) {
+ switch (event.type) {
+ case sf::Event::Closed:
+ LOG(INFO) << "Received close event by window closing";
+ isRunning = false;
+ break;
+ case sf::Event::Resized:
+ glViewport(0, 0, window->getSize().x, window->getSize().y);
+ renderState.WindowWidth = window->getSize().x;
+ renderState.WindowHeight = window->getSize().y;
+ break;
+ case sf::Event::KeyPressed:
+ if (!window->hasFocus()) break;
+ switch (event.key.code) {
+ case sf::Keyboard::Escape:
+ LOG(INFO) << "Received close event by esc";
+ isRunning = false;
+ break;
+ case sf::Keyboard::T:
+ SetMouseCapture(!isMouseCaptured);
+ break;
+ case sf::Keyboard::U:
+ EventAgregator::PushEvent(EventType::ConnectToServer, ConnectToServerData{ "10.1.1.2", 25565 });
+ break;
+ case sf::Keyboard::I:
+ EventAgregator::PushEvent(EventType::Disconnect, DisconnectData{ "Manual disconnect" });
+ break;
+ case sf::Keyboard::K:
+ if (renderWorld) {
+ world->MaxRenderingDistance--;
+ if (world->MaxRenderingDistance <= 0)
+ world->MaxRenderingDistance = 1;
+ LOG(INFO) << "Decreased rendering distance: " << world->MaxRenderingDistance;
+ EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
}
- default:
- break;
- }
- }
+ break;
+ case sf::Keyboard::L:
+ if (renderWorld) {
+ world->MaxRenderingDistance++;
+ LOG(INFO) << "Increased rendering distance: " << world->MaxRenderingDistance;
+ EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
+ }
+ break;
+ default:
+ break;
+ }
+ case sf::Event::KeyReleased:
+ if (!window->hasFocus()) break;
+ switch (event.key.code) {
+ default:
+ break;
+ }
+ default:
+ break;
+ }
+ }
}
void Render::HandleMouseCapture() {
@@ -216,6 +204,7 @@ void Render::ExecuteRenderLoop() {
while (isRunning) {
HandleEvents();
+ if (window->hasFocus()) UpdateKeyboard();
if (isMouseCaptured) HandleMouseCapture();
glCheckError();
@@ -223,10 +212,7 @@ void Render::ExecuteRenderLoop() {
while (listener.IsEventsQueueIsNotEmpty())
listener.HandleEvent();
if (renderWorld) {
- world->renderDataMutex.lock();
- size_t size = world->renderData.size();
- world->renderDataMutex.unlock();
- window->setTitle("Size: " + std::to_string(size) + " FPS: " + std::to_string(1.0 / timer.GetRealDeltaS()));
+ window->setTitle("FPS: " + std::to_string(1.0 / timer.GetRealDeltaS()));
}
timer.Update();
}
diff --git a/src/Render.hpp b/src/Render.hpp
index 6b4b5a4..b7d12d0 100644
--- a/src/Render.hpp
+++ b/src/Render.hpp
@@ -4,16 +4,18 @@
#include "Shader.hpp"
#include "RendererWorld.hpp"
+#include "RendererWidget.hpp"
class Render {
sf::Window *window;
- bool isRunning=true;
+ bool isRunning = true;
bool isMouseCaptured = false;
float mouseXDelta, mouseYDelta;
std::unique_ptr<RendererWorld> world;
bool renderWorld = false;
RenderState renderState;
LoopExecutionTimeController timer;
+ std::map<sf::Keyboard::Key, bool> isKeyPressed;
void SetMouseCapture(bool IsCaptured);
@@ -28,6 +30,8 @@ class Render {
void RenderFrame();
void PrepareToRendering();
+
+ void UpdateKeyboard();
public:
Render(unsigned int windowWidth, unsigned int windowHeight, std::string windowTitle);
~Render();
diff --git a/src/Renderer.hpp b/src/Renderer.hpp
index 53f6cc8..306a310 100644
--- a/src/Renderer.hpp
+++ b/src/Renderer.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <GL/glew.h>
+#include "Utility.hpp"
class RenderState {
GLuint ActiveVao = -1;
@@ -10,12 +11,4 @@ public:
void SetActiveShader(GLuint Shader);
unsigned int WindowWidth, WindowHeight;
long long TimeOfDay;
-};
-
-/*struct Renderer {
- virtual ~Renderer() = default;
- virtual void Render(RenderState& renderState) = 0;
- virtual void PrepareResources() = 0;
- virtual void PrepareRender() = 0;
- virtual bool IsNeedResourcesPrepare() = 0;
-};*/ \ No newline at end of file
+}; \ No newline at end of file
diff --git a/src/RendererSection.cpp b/src/RendererSection.cpp
index 0965453..bb1a888 100644
--- a/src/RendererSection.cpp
+++ b/src/RendererSection.cpp
@@ -25,30 +25,18 @@ const GLfloat uv_coords[] = {
const GLuint magicUniqueConstant = 88375;
GLuint RendererSection::VboVertices = magicUniqueConstant;
GLuint RendererSection::VboUvs = magicUniqueConstant;
-std::map<GLuint, int> RendererSection::refCounterVbo;
-std::map<GLuint, int> RendererSection::refCounterVao;
RendererSection::~RendererSection() {
- refCounterVbo[VboTextures]--;
- refCounterVbo[VboModels]--;
- refCounterVbo[VboColors]--;
- refCounterVbo[VboLights]--;
- refCounterVao[Vao]--;
-
- if (refCounterVbo[VboTextures] <= 0)
- glDeleteBuffers(1, &VboTextures);
-
- if (refCounterVbo[VboModels] <= 0)
- glDeleteBuffers(1, &VboTextures);
-
- if (refCounterVbo[VboColors] <= 0)
- glDeleteBuffers(1, &VboColors);
-
- if (refCounterVbo[VboLights] <= 0)
- glDeleteBuffers(1, &VboLights);
+ if (Vao != 0)
+ glDeleteVertexArrays(1, &Vao);
+
+ for (int i = 0; i < VBOCOUNT; i++)
+ if (Vbo[i] != 0) {
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[i]);
+ glBufferData(GL_ARRAY_BUFFER, 0, 0, GL_STATIC_DRAW);
+ }
- if (refCounterVao[Vao] <= 0)
- glDeleteVertexArrays(1, &Vao);
+ glDeleteBuffers(VBOCOUNT, Vbo);
}
void RendererSection::Render(RenderState &renderState) {
@@ -84,30 +72,9 @@ RendererSection::RendererSection(RendererSectionData data) {
<< ") for faces";
}
- glGenBuffers(1, &VboTextures);
- if (refCounterVbo.find(VboTextures) == refCounterVbo.end())
- refCounterVbo[VboTextures] = 0;
- refCounterVbo[VboTextures]++;
-
- glGenBuffers(1, &VboModels);
- if (refCounterVbo.find(VboModels) == refCounterVbo.end())
- refCounterVbo[VboModels] = 0;
- refCounterVbo[VboModels]++;
-
- glGenBuffers(1, &VboColors);
- if (refCounterVbo.find(VboColors) == refCounterVbo.end())
- refCounterVbo[VboColors] = 0;
- refCounterVbo[VboColors]++;
-
- glGenBuffers(1, &VboLights);
- if (refCounterVbo.find(VboLights) == refCounterVbo.end())
- refCounterVbo[VboLights] = 0;
- refCounterVbo[VboLights]++;
-
glGenVertexArrays(1, &Vao);
- if (refCounterVao.find(Vao) == refCounterVao.end())
- refCounterVao[Vao] = 0;
- refCounterVao[Vao]++;
+
+ glGenBuffers(VBOCOUNT, Vbo);
glBindVertexArray(Vao);
{
@@ -125,7 +92,7 @@ RendererSection::RendererSection(RendererSectionData data) {
//Textures
GLuint textureAttribPos = 7;
- glBindBuffer(GL_ARRAY_BUFFER, VboTextures);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[TEXTURES]);
glVertexAttribPointer(textureAttribPos, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), nullptr);
glEnableVertexAttribArray(textureAttribPos);
glVertexAttribDivisor(textureAttribPos, 1);
@@ -134,7 +101,7 @@ RendererSection::RendererSection(RendererSectionData data) {
//Blocks models
GLuint matAttribPos = 8;
size_t sizeOfMat4 = 4 * 4 * sizeof(GLfloat);
- glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[MODELS]);
glVertexAttribPointer(matAttribPos + 0, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, nullptr);
glVertexAttribPointer(matAttribPos + 1, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *)(1 * 4 * sizeof(GLfloat)));
glVertexAttribPointer(matAttribPos + 2, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *)(2 * 4 * sizeof(GLfloat)));
@@ -150,14 +117,14 @@ RendererSection::RendererSection(RendererSectionData data) {
//Color
GLuint colorAttribPos = 12;
- glBindBuffer(GL_ARRAY_BUFFER, VboColors);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[COLORS]);
glVertexAttribPointer(colorAttribPos, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), nullptr);
glEnableVertexAttribArray(colorAttribPos);
glVertexAttribDivisor(colorAttribPos, 1);
//Light
GLuint lightAttribPos = 13;
- glBindBuffer(GL_ARRAY_BUFFER, VboLights);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[LIGHTS]);
glVertexAttribPointer(lightAttribPos, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), nullptr);
glEnableVertexAttribArray(lightAttribPos);
glVertexAttribDivisor(lightAttribPos, 1);
@@ -169,16 +136,16 @@ RendererSection::RendererSection(RendererSectionData data) {
//Upload data to VRAM
- glBindBuffer(GL_ARRAY_BUFFER, VboTextures);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[TEXTURES]);
glBufferData(GL_ARRAY_BUFFER, data.textures.size() * sizeof(glm::vec4), data.textures.data(), GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[MODELS]);
glBufferData(GL_ARRAY_BUFFER, data.models.size() * sizeof(glm::mat4), data.models.data(), GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, VboColors);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[COLORS]);
glBufferData(GL_ARRAY_BUFFER, data.colors.size() * sizeof(glm::vec3), data.colors.data(), GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, VboLights);
+ glBindBuffer(GL_ARRAY_BUFFER, Vbo[LIGHTS]);
glBufferData(GL_ARRAY_BUFFER, data.lights.size() * sizeof(glm::vec2), data.lights.data(), GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -188,21 +155,9 @@ RendererSection::RendererSection(RendererSectionData data) {
hash = data.hash;
}
-RendererSection::RendererSection(const RendererSection &other) {
- this->VboModels = other.VboModels;
- this->VboTextures = other.VboTextures;
- this->VboColors = other.VboColors;
- this->VboLights = other.VboLights;
- this->sectionPos = other.sectionPos;
- this->Vao = other.Vao;
- this->numOfFaces = other.numOfFaces;
- this->hash = other.hash;
-
- refCounterVbo[VboTextures]++;
- refCounterVbo[VboModels]++;
- refCounterVbo[VboColors]++;
- refCounterVbo[VboLights]++;
- refCounterVao[Vao]++;
+RendererSection::RendererSection(RendererSection && other) {
+ using std::swap;
+ swap(*this, other);
}
RendererSectionData::RendererSectionData(World * world, Vector sectionPosition) {
@@ -214,7 +169,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
for (int y = 0; y < 16; y++) {
for (int z = 0; z < 16; z++) {
for (int x = 0; x < 16; x++) {
- Block block = section.GetBlock(Vector(x, y, z));
+ BlockId block = section.GetBlockId(Vector(x, y, z));
if (block.id == 0)
continue;
@@ -243,9 +198,9 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
if (std::find(sectionsList.begin(), sectionsList.end(), sectionPosition + offset) == sectionsList.end())
return true;
const Section& blockSection = world->GetSection(sectionPosition + offset);
- return blockSection.GetBlock(block).id == 0 || blockSection.GetBlock(block).id == 31 || blockSection.GetBlock(block).id == 18;
+ return blockSection.GetBlockId(block).id == 0 || blockSection.GetBlockId(block).id == 31 || blockSection.GetBlockId(block).id == 18;
}
- return section.GetBlock(block).id == 0 || section.GetBlock(block).id == 31 || section.GetBlock(block).id == 18;
+ return section.GetBlockId(block).id == 0 || section.GetBlockId(block).id == 31 || section.GetBlockId(block).id == 18;
};
unsigned char isVisible = 0;
@@ -272,7 +227,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
for (int i = 0; i < 4; i++) {
textures.push_back(texture->second);
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0.15f, 0, 0.15f));
faceTransform = glm::scale(faceTransform, glm::vec3(1.0f, 0.9f, 1.0f));
@@ -298,7 +253,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
0.0078125, 0.00442477876106194690)); //Fallback TNT texture
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
if (isVisible >> 1 & 0x1) { //west side X-
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(1, 0, 0));
@@ -313,7 +268,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
0.0078125, 0.00442477876106194690)); //Fallback TNT texture
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
if (isVisible >> 2 & 0x1) { //Top side Y+
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 1, 0));
@@ -328,7 +283,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
colors.push_back(color);
else
colors.push_back(biomeColor);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
if (isVisible >> 3 & 0x1) { //Bottom side Y-
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 0, 0));
@@ -342,7 +297,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
0.0078125, 0.00442477876106194690)); //Fallback TNT texture
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
if (isVisible >> 4 & 0x1) { //south side Z+
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(1, 0, 0));
@@ -356,7 +311,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
0.0078125, 0.00442477876106194690)); //Fallback TNT texture
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
if (isVisible >> 5 & 0x1) { //north side Z-
glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 0, 1));
@@ -373,7 +328,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
0.0078125, 0.00442477876106194690)); //Fallback TNT texture
colors.push_back(color);
- lights.push_back(glm::vec2(block.light, block.sky));
+ lights.push_back(glm::vec2(0, 0));
}
}
}
@@ -383,9 +338,12 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
textures.shrink_to_fit();
models.shrink_to_fit();
colors.shrink_to_fit();
+}
- /*for (auto& it : lights) {
- it.x = 8;
- it.y = 16;
- }*/
+void swap(RendererSection & lhs, RendererSection & rhs) {
+ std::swap(lhs.Vbo, rhs.Vbo);
+ std::swap(lhs.Vao, rhs.Vao);
+ std::swap(lhs.hash, rhs.hash);
+ std::swap(lhs.numOfFaces, rhs.numOfFaces);
+ std::swap(lhs.sectionPos, rhs.sectionPos);
}
diff --git a/src/RendererSection.hpp b/src/RendererSection.hpp
index 9e5fd99..12a169e 100644
--- a/src/RendererSection.hpp
+++ b/src/RendererSection.hpp
@@ -23,19 +23,28 @@ struct RendererSectionData {
RendererSectionData(World *world, Vector sectionPosition);
};
-
class RendererSection {
- GLuint Vao, VboTextures, VboModels, VboColors, VboLights;
+ enum Vbos {
+ MODELS = 0,
+ TEXTURES,
+ COLORS,
+ LIGHTS,
+ VBOCOUNT,
+ };
+ GLuint Vao = { 0 };
+ GLuint Vbo[VBOCOUNT] = { 0 };
static GLuint VboVertices, VboUvs;
- static std::map<GLuint, int> refCounterVbo;
- static std::map<GLuint, int> refCounterVao;
size_t hash;
Vector sectionPos;
+
+ RendererSection(const RendererSection &other) = delete;
public:
RendererSection(RendererSectionData data);
- RendererSection(const RendererSection &other);
+
+ RendererSection(RendererSection &&other);
+
~RendererSection();
void Render(RenderState &renderState);
@@ -44,5 +53,7 @@ public:
size_t GetHash();
- size_t numOfFaces = 0;
+ size_t numOfFaces;
+
+ friend void swap(RendererSection &lhs, RendererSection &rhs);
}; \ No newline at end of file
diff --git a/src/RendererWidget.cpp b/src/RendererWidget.cpp
new file mode 100644
index 0000000..6b732e3
--- /dev/null
+++ b/src/RendererWidget.cpp
@@ -0,0 +1,76 @@
+#include "RendererWidget.hpp"
+
+const GLfloat vertices[] = {
+ 0.0f,0.0f,0.0f,
+ 1.0f,1.0f,0.0f,
+ 0.0f,1.0f,0.0f,
+
+ 0.0f,0.0f,0.0f,
+ 1.0f,0.0f,0.0f,
+ 1.0f,1.0f,0.0f,
+};
+
+const GLfloat uvs[] = {
+ 0.0f,0.0f,
+ 1.0f,1.0f,
+ 0.0f,1.0f,
+
+ 0.0f,0.0f,
+ 1.0f,0.0f,
+ 1.0f,1.0f,
+};
+
+static GLuint VboVertices, VboUvs, Vao;
+static Shader* guiShader = nullptr;
+
+RendererWidget::RendererWidget(RootWidget *widget) {
+ this->tree = widget;
+
+ if (guiShader == nullptr) {
+ guiShader = new Shader("./shaders/gui.vs", "./shaders/gui.fs");
+ guiShader->Use();
+ glUniform1i(glGetUniformLocation(guiShader->Program, "textureAtlas"), 0);
+
+ glGenBuffers(1, &VboVertices);
+ glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+ glGenBuffers(1, &VboUvs);
+ glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(uvs), uvs, GL_STATIC_DRAW);
+
+ glGenVertexArrays(1, &Vao);
+ glBindVertexArray(Vao);
+ {
+ glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+ glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
+ glEnableVertexAttribArray(0);
+
+ glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+ glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
+ glEnableVertexAttribArray(1);
+ }
+ glBindVertexArray(0);
+ }
+}
+
+RendererWidget::~RendererWidget() {
+
+}
+
+void RendererWidget::Render(RenderState &state) {
+ state.SetActiveVao(Vao);
+ state.SetActiveShader(guiShader->Program);
+
+ auto toRender = tree->GetRenderList();
+ for (auto& it : toRender) {
+ auto[x, y, w, h] = it->GetTexture();
+ glUniform4f(glGetUniformLocation(guiShader->Program, "widgetTexture"), x, y, w, h);
+
+ glUniform4f(glGetUniformLocation(guiShader->Program, "transform"), it->x, it->y, it->w, it->h);
+
+ glDrawArrays(GL_TRIANGLES, 0, 36);
+ }
+
+ glCheckError();
+} \ No newline at end of file
diff --git a/src/RendererWidget.hpp b/src/RendererWidget.hpp
new file mode 100644
index 0000000..a979c88
--- /dev/null
+++ b/src/RendererWidget.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Renderer.hpp"
+#include "Widget.hpp"
+#include "Shader.hpp"
+
+class RendererWidget {
+ RootWidget *tree;
+
+public:
+ RendererWidget(RootWidget *widget);
+ ~RendererWidget();
+
+ void Render(RenderState &state);
+}; \ No newline at end of file
diff --git a/src/RendererWorld.cpp b/src/RendererWorld.cpp
index dd5fdb4..7262583 100644
--- a/src/RendererWorld.cpp
+++ b/src/RendererWorld.cpp
@@ -94,7 +94,6 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
sectionsMutex.lock();
auto it = sections.find(vec);
if (it == sections.end()) {
- //LOG(ERROR) << "Deleting wrong sectionRenderer";
sectionsMutex.unlock();
return;
}
@@ -124,7 +123,7 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
sections.erase(sections.find(data.sectionPos));
}
RendererSection renderer(data);
- sections.insert(std::make_pair(data.sectionPos, renderer));
+ sections.insert(std::make_pair(data.sectionPos, std::move(renderer)));
sectionsMutex.unlock();
renderData.pop();
}
@@ -155,7 +154,6 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
if (isParsing.find(vec) == isParsing.end())
isParsing[vec] = false;
if (isParsing[vec] == true) {
- //LOG(WARNING) << "Changed parsing block";
isParsingMutex.unlock();
return;
}
@@ -188,6 +186,8 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
for (int i = 0; i < numOfWorkers; i++)
workers.push_back(std::thread(&RendererWorld::WorkerFunction, this, i));
+ EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
+
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
@@ -349,7 +349,7 @@ void RendererWorld::PrepareRender() {
}
void RendererWorld::Update(double timeToUpdate) {
- auto timeSincePreviousUpdate = std::chrono::steady_clock::now();
+ static auto timeSincePreviousUpdate = std::chrono::steady_clock::now();
int i = 0;
while (listener.IsEventsQueueIsNotEmpty() && i++ < 50)
listener.HandleEvent();
diff --git a/src/RendererWorld.hpp b/src/RendererWorld.hpp
index 5bc575c..4e098e5 100644
--- a/src/RendererWorld.hpp
+++ b/src/RendererWorld.hpp
@@ -37,9 +37,7 @@ public:
~RendererWorld();
void Render(RenderState& renderState);
- void PrepareResources();
void PrepareRender();
- bool IsNeedResourcesPrepare();
double MaxRenderingDistance;
diff --git a/src/Section.cpp b/src/Section.cpp
index c9af5c6..9b4292b 100644
--- a/src/Section.cpp
+++ b/src/Section.cpp
@@ -2,164 +2,134 @@
#include <bitset>
+void Section::CalculateHash() {
+ std::vector<unsigned char> rawData;
+ rawData.reserve(block.size() * sizeof(long long) + light.size() + sky.size());
+ std::copy(block.begin(), block.end(), std::back_inserter(rawData));
+ std::copy(light.begin(), light.end(), std::back_inserter(rawData));
+ if (!sky.empty())
+ std::copy(sky.begin(), sky.end(), std::back_inserter(rawData));
+
+ const unsigned char *from = reinterpret_cast<const unsigned char *>(rawData.data());
+ size_t length = rawData.size();
+
+ std::string str(from, from + length);
+ hash = std::hash<std::string>{}(str);
+}
+
+Section::Section(Vector pos, unsigned char bitsPerBlock, std::vector<unsigned short> palette, std::vector<long long> blockData, std::vector<unsigned char> lightData, std::vector<unsigned char> skyData) {
+ if (bitsPerBlock < 4)
+ bitsPerBlock = 4;
+ if (bitsPerBlock > 8)
+ bitsPerBlock = 13;
+ this->bitsPerBlock = bitsPerBlock;
+
+ this->worldPosition = pos;
+ this->block = std::move(blockData);
+ this->palette = std::move(palette);
+ this->light = std::move(lightData);
+ this->sky = std::move(skyData);
+
+ CalculateHash();
+}
+
+Section::Section() {
+
+ CalculateHash();
+}
+
Section::~Section() {
+
}
Section::Section(Section && other) noexcept {
using std::swap;
swap(*this, other);
+ CalculateHash();
}
-Block &Section::GetBlock(Vector pos) {
- return blocks[pos.y * 256 + pos.z * 16 + pos.x];
+Section &Section::operator=(Section other) noexcept {
+ using std::swap;
+ swap(*this, other);
+ CalculateHash();
+ return *this;
}
-Block Section::GetBlock(Vector pos) const
-{
- if (blocks.empty()) {
- static Block fallback;
- return fallback;
+BlockId Section::GetBlockId(Vector pos) const {
+ if (block.empty())
+ return BlockId{ 0,0 };
+ int value;
+
+ unsigned char individualValueMask = ((1 << bitsPerBlock) - 1);
+
+ int blockNumber = (((pos.y * 16) + pos.z) * 16) + pos.x;
+ int startLong = (blockNumber * bitsPerBlock) / 64;
+ int startOffset = (blockNumber * bitsPerBlock) % 64;
+ int endLong = ((blockNumber + 1) * bitsPerBlock - 1) / 64;
+
+ unsigned short t;
+
+ if (startLong == endLong) {
+ t = (block[startLong] >> startOffset);
+ }
+ else {
+ int endOffset = 64 - startOffset;
+ t = (block[startLong] >> startOffset |block[endLong] << endOffset);
}
- return blocks[pos.y * 256 + pos.z * 16 + pos.x];
+
+ t &= individualValueMask;
+
+
+ if (t >= palette.size()) {
+ //LOG(ERROR) << "Out of palette: " << t;
+ value = 0;
+ }
+ else
+ value = palette[t];
+
+ BlockId blockId;
+ blockId.id = value >> 4;
+ blockId.state = value & 0xF;
+ return blockId;
}
-double totalParsingTime = 0;
+unsigned char Section::GetBlockLight(Vector pos)
+{
+ int blockNumber = pos.y * 256 + pos.z * 16 + pos.x;
+ unsigned char lightValue = this->light[blockNumber];
+ return (blockNumber % 2 == 0) ? (lightValue & 0xF) : (lightValue >> 4);
+}
-Section::Section(PackedSection data)
+unsigned char Section::GetBlockSkyLight(Vector pos)
{
- if (data.blocks.empty())
- return;
- worldPosition = data.position;
-
- bool useFirst = false;
-
- if (useFirst) {
- unsigned char *blocksData = reinterpret_cast<unsigned char*>(data.blocks.data());
- std::vector<unsigned short> blocks;
- blocks.reserve(4096);
- {
- auto begin = std::chrono::steady_clock::now();
- int bitPos = 0;
- unsigned short t = 0;
- for (size_t i = 0; i < data.blocks.size() * 8; i++) {
- for (int j = 0; j < 8; j++) {
- t |= (blocksData[i] & 0x01) ? 0x80 : 0x00;
- t >>= 1;
- blocksData[i] >>= 1;
- bitPos++;
- if (bitPos >= data.bitsPerBlock) {
- bitPos = 0;
- t >>= data.bitsPerBlock - 1;
- blocks.push_back(t);
- t = 0;
- }
- }
- }
- auto end = std::chrono::steady_clock::now();
- std::chrono::duration<double, std::milli> time = end - begin;
- totalParsingTime += time.count();
- }
- std::vector<byte> light;
- light.reserve(4096);
- for (int i = 0; i < 2048; i++) {
- byte t = data.light[i];
- byte first = t & 0x0F;
- byte second = t >> 4;
- light.push_back(0);
- light.push_back(0);
- }
-
- std::vector<byte> sky;
- if (!data.sky.empty()) {
- sky.reserve(4096);
- for (int i = 0; i < 2048; i++) {
- byte t = data.sky[i];
- byte first = t & 0x0F;
- byte second = t >> 4;
- sky.push_back(first);
- sky.push_back(second);
- }
- }
-
- for (int i = 0; i < 4096; i++) {
- unsigned short blockId = !data.palette.empty() ? data.palette[blocks[i]] : blocks[i];
- Block block(blockId >> 4, blockId & 0xF, light[i], sky.empty() ? 0 : sky[i]);
- this->blocks.push_back(block);
- }
- } else {
-
- std::vector<unsigned short> blocks;
- blocks.reserve(4096);
-
- unsigned char individualValueMask = ((1 << data.bitsPerBlock) - 1);
-
- for (int blockNumber = 0; blockNumber < 4096; blockNumber++) {
- int startLong = (blockNumber * data.bitsPerBlock) / 64;
- int startOffset = (blockNumber * data.bitsPerBlock) % 64;
- int endLong = ((blockNumber + 1) * data.bitsPerBlock - 1) / 64;
-
- unsigned short t;
-
- if (startLong == endLong) {
- t = (data.blocks[startLong] >> startOffset);
- }
- else {
- int endOffset = 64 - startOffset;
- t = (data.blocks[startLong] >> startOffset | data.blocks[endLong] << endOffset);
- }
-
- t &= individualValueMask;
-
-
- if (t >= data.palette.size()) {
- //LOG(ERROR) << "Out of palette: "<<t;
- blocks.push_back(0);
- }
- else
- blocks.push_back(data.palette.empty() ? t : data.palette[t]);
- }
-
-
- std::vector<unsigned char> light;
- light.reserve(4096);
- for (int i = 0; i < 2048; i++) {
- unsigned char t = data.light[i];
- light.push_back(t & 0xF);
- light.push_back(t >> 4 & 0xF);
- }
-
- std::vector<unsigned char> sky;
- if (!data.sky.empty()) {
- sky.reserve(4096);
- for (int i = 0; i < 2048; i++) {
- unsigned char t = data.sky[i];
- sky.push_back(t & 0xF);
- sky.push_back(t >> 4 & 0xF);
- }
- }
-
- for (int i = 0; i < 4096; i++) {
- unsigned short blockId = blocks[i];
- Block block(blockId >> 4, blockId & 0xF, light[i], sky.empty() ? 0 : sky[i]);
- this->blocks.push_back(block);
- }
- }
+ int blockNumber = pos.y * 256 + pos.z * 16 + pos.x;
+ unsigned char skyValue = this->sky[blockNumber];
+ return (blockNumber % 2 == 0) ? (skyValue & 0xF) : (skyValue >> 4);
}
-Section &Section::operator=(Section other) noexcept {
- using std::swap;
- swap(*this, other);
- return *this;
+void Section::SetBlockId(Vector pos, BlockId value) {
+ LOG(WARNING) << "Block changing not implemented!";
}
void swap(Section& lhs, Section& rhs) noexcept {
- std::swap(lhs.blocks, rhs.blocks);
+ std::swap(lhs.block, rhs.block);
+ std::swap(lhs.light, rhs.light);
+ std::swap(lhs.sky, rhs.sky);
+ std::swap(lhs.bitsPerBlock, rhs.bitsPerBlock);
+ std::swap(lhs.palette, rhs.palette);
+ std::swap(lhs.hash, rhs.hash);
std::swap(lhs.worldPosition, rhs.worldPosition);
}
Section::Section(const Section &other) {
worldPosition = other.worldPosition;
- this->blocks = other.blocks;
+ this->block = other.block;
+ this->light = other.light;
+ this->sky = other.sky;
+ this->bitsPerBlock = other.bitsPerBlock;
+ this->palette = other.palette;
+ this->hash = other.hash;
+ this->worldPosition = other.worldPosition;
}
Vector Section::GetPosition() const {
@@ -167,32 +137,5 @@ Vector Section::GetPosition() const {
}
size_t Section::GetHash() const {
- if (blocks.empty()) return 0;
-
- const unsigned char *from = reinterpret_cast<const unsigned char *>(blocks.data());
- size_t length = blocks.size() * sizeof(Block);
-
- std::string str(from, from + length);
- return std::hash<std::string>{}(str);
-}
-
-PackedSection::PackedSection(Vector position, byte * dataBlocks, size_t dataBlocksLength, byte * dataLight, byte * dataSky, byte bitsPerBlock, std::vector<unsigned short> palette)
-{
- this->position = position;
-
- this->palette = palette;
-
- this->bitsPerBlock = bitsPerBlock;
-
- for (long long *t = reinterpret_cast<long long *>(dataBlocks); (byte*)t < dataBlocks + dataBlocksLength; t++) {
- long long l = *t;
- endswap(l);
- this->blocks.push_back(l);
- }
-
- light.assign(dataLight, dataLight + 2048);
-
- if (dataSky != nullptr) {
- sky.assign(dataSky, dataSky + 2048);
- }
-}
+ return hash;
+} \ No newline at end of file
diff --git a/src/Section.hpp b/src/Section.hpp
index dfa738a..bda3584 100644
--- a/src/Section.hpp
+++ b/src/Section.hpp
@@ -11,47 +11,45 @@
#include "Vector.hpp"
#include "Utility.hpp"
-struct PackedSection {
- Vector position;
-
- int bitsPerBlock;
-
- std::vector<unsigned short> palette;
-
- std::vector<long long> blocks;
+class Section {
+ std::vector<long long> block;
std::vector<unsigned char> light;
std::vector<unsigned char> sky;
-
- PackedSection(Vector position, byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky, byte bitsPerBlock,
- std::vector<unsigned short> palette);
-
- PackedSection() = default;
-};
-
-class Section {
- std::vector<Block> blocks;
+ unsigned char bitsPerBlock;
+ std::vector<unsigned short> palette;
Vector worldPosition;
+ size_t hash;
+ void CalculateHash();
public:
+ Section(Vector pos, unsigned char bitsPerBlock, std::vector<unsigned short> palette, std::vector<long long> blockData, std::vector<unsigned char> lightData, std::vector<unsigned char> skyData);
- Section(PackedSection data);
+ Section();
~Section();
+ Section(const Section &other);
+
Section(Section &&other) noexcept;
- Block &GetBlock(Vector pos);
+ Section &operator=(Section other) noexcept;
- Block GetBlock(Vector pos) const;
+ BlockId GetBlockId(Vector pos) const;
- Section &operator=(Section other) noexcept;
+ unsigned char GetBlockLight(Vector pos);
- friend void swap(Section& lhs, Section& rhs) noexcept;
+ unsigned char GetBlockSkyLight(Vector pos);
- Section(const Section &other);
+ void SetBlockId(Vector pos, BlockId value);
+
+ void SetBlockLight(Vector pos, unsigned char value);
+
+ void SetBlockSkyLight(Vector pos, unsigned char value);
Vector GetPosition() const;
size_t GetHash() const;
+
+ friend void swap(Section& lhs, Section& rhs) noexcept;
}; \ No newline at end of file
diff --git a/src/Socket.cpp b/src/Socket.cpp
index 519da2f..aea0c73 100644
--- a/src/Socket.cpp
+++ b/src/Socket.cpp
@@ -1,30 +1,37 @@
#include <iostream>
#include "Socket.hpp"
-Socket::Socket(std::string address, unsigned short port) {
- sf::Socket::Status connectionStatus = socket.connect(sf::IpAddress(address), port);
- if (connectionStatus == sf::Socket::Status::Error)
- throw std::runtime_error("Can't connect to remote server");
- else if (connectionStatus != sf::Socket::Status::Done)
- throw std::runtime_error("Connection failed with unknown reason");
+#include <thread>
+
+Socket::Socket(std::string address, unsigned short port) {
+ if (SDLNet_Init() == -1)
+ throw std::runtime_error("SDL_Net initalization failed: " + std::string(SDLNet_GetError()));
+
+ if (SDLNet_ResolveHost(&server, address.c_str(), port) == -1)
+ throw std::runtime_error("Hostname not resolved: " + std::string(SDLNet_GetError()));
+
+ socket = SDLNet_TCP_Open(&server);
+ if (!socket)
+ throw std::runtime_error(std::string(SDLNet_GetError()));
}
Socket::~Socket() {
- socket.disconnect();
+ SDLNet_TCP_Close(socket);
+
+ SDLNet_Quit();
}
-void Socket::Read(unsigned char *buffPtr, size_t buffLen) {
- size_t received = 0;
- socket.receive(buffPtr, buffLen, received);
- size_t totalReceived = received;
- while (totalReceived < buffLen) {
- if (socket.receive(buffPtr + totalReceived, buffLen - totalReceived, received) != sf::Socket::Done)
- throw std::runtime_error("Raw socket data receiving is failed");
- totalReceived += received;
- }
+void Socket::Read(unsigned char *buffPtr, size_t buffLen) {
+ size_t totalReceived = 0;
+ while (buffLen > totalReceived) {
+ size_t received = SDLNet_TCP_Recv(socket, buffPtr + totalReceived, buffLen - totalReceived);
+ if ( received <= 0)
+ throw std::runtime_error("Data receiving failed: " + std::string(SDLNet_GetError()));
+ totalReceived += received;
+ }
}
void Socket::Write(unsigned char *buffPtr, size_t buffLen) {
- if (socket.send(buffPtr, buffLen) != sf::Socket::Done)
- throw std::runtime_error("Raw socket data sending is failed");
+ if (SDLNet_TCP_Send(socket, buffPtr, buffLen) < buffLen)
+ throw std::runtime_error("Data sending failed: " + std::string(SDLNet_GetError()));
}
diff --git a/src/Socket.hpp b/src/Socket.hpp
index 48bcad9..16825f0 100644
--- a/src/Socket.hpp
+++ b/src/Socket.hpp
@@ -4,14 +4,16 @@
#include <SFML/Network.hpp>
+#include <SDL_net.h>
+
/**
* Platform independent class for working with platform dependent hardware socket
* @brief Wrapper around raw sockets
* @warning Connection state is based on lifetime of Socket object instance, ie connected at ctor and disconnect at dtor
- * @todo Replace SFML's socket with WinSock and POSIX's socket implementation
*/
class Socket {
- sf::TcpSocket socket;
+ IPaddress server;
+ TCPsocket socket;
public:
/**
* Constructs Socket class instance from IP's string and Port number and connects to remote server
@@ -23,7 +25,7 @@ public:
/**
* Destruct Socket instance and disconnect from server
- * @warning There is no way to force disconnect, except use delete for manually allocated objects and scope of visibility for variables on stack
+ * @warning There is no way to force disconnect, except use delete for manually allocated objects and scope of visibility for auto variables
*/
~Socket();
diff --git a/src/Stream.cpp b/src/Stream.cpp
index a44b91c..28680c6 100644
--- a/src/Stream.cpp
+++ b/src/Stream.cpp
@@ -281,8 +281,9 @@ void StreamOutput::WriteByteArray(std::vector<unsigned char> value) {
void StreamBuffer::ReadData(unsigned char *buffPtr, size_t buffLen) {
size_t bufferLengthLeft = buffer + bufferLength - bufferPtr;
+
if (bufferLengthLeft < buffLen)
- throw std::runtime_error("Required data is more, than in buffer available");
+ throw std::runtime_error("Internal error: StreamBuffer reader out of data");
std::memcpy(buffPtr, bufferPtr, buffLen);
bufferPtr += buffLen;
}
@@ -290,7 +291,7 @@ void StreamBuffer::ReadData(unsigned char *buffPtr, size_t buffLen) {
void StreamBuffer::WriteData(unsigned char *buffPtr, size_t buffLen) {
size_t bufferLengthLeft = buffer + bufferLength - bufferPtr;
if (bufferLengthLeft < buffLen)
- throw std::runtime_error("Required data is more, than in buffer available");
+ throw std::runtime_error("Internal error: StreamBuffer writer out of data");
std::memcpy(bufferPtr, buffPtr, buffLen);
bufferPtr += buffLen;
}
diff --git a/src/Widget.cpp b/src/Widget.cpp
new file mode 100644
index 0000000..1a522ca
--- /dev/null
+++ b/src/Widget.cpp
@@ -0,0 +1,124 @@
+#include "Widget.hpp"
+
+void RootWidget::AttachWidget(std::unique_ptr<Widget> widget, Widget * parent)
+{
+ parent->childs.push_back(widget.get());
+ this->allWidgets.push_back(std::move(widget));
+}
+
+void RootWidget::AttachWidget(std::unique_ptr<Widget> widget) {
+ widget->parent = nullptr;
+ this->childs.push_back(widget.get());
+ this->allWidgets.push_back(std::move(widget));
+}
+
+std::vector<Widget*> RootWidget::GetRenderList()
+{
+ std::vector<Widget*> renderList;
+
+ std::function<void(Widget*)> treeWalker = [&](Widget* node) {
+ for (auto it : node->childs)
+ treeWalker(it);
+ renderList.push_back(node);
+ };
+
+ for (auto& it : this->childs)
+ treeWalker(it);
+
+ return renderList;
+}
+
+void RootWidget::UpdateEvents(double mouseX, double mouseY, bool mouseButton) {
+
+ LOG(INFO) << mouseX << "x" << mouseY;
+
+ auto testIsHover = [&](double x, double y, Widget* widget) {
+ bool isOnX = widget->x > x && widget->x + widget->w < x;
+ bool isOnY = widget->y > y && widget->y + widget->h < y;
+ if (mouseButton)
+ LOG(INFO) << "X: " << isOnX << " Y: " << isOnY;
+ return isOnX && isOnY;
+ };
+
+ std::function<void(Widget*)> treeWalker = [&](Widget* node) {
+ for (auto it : node->childs)
+ treeWalker(it);
+
+ if (testIsHover(mouseX,mouseY,node)) {
+ if (node->onHover)
+ node->onHover(node);
+ if (mouseButton && !prevBut)
+ if (node->onPress)
+ node->onPress(node);
+ else if (!mouseButton && prevBut)
+ if (node->onRelease)
+ node->onRelease(node);
+ }
+ else {
+ if (testIsHover(prevX, prevY, node))
+ if (node->onUnhover)
+ node->onUnhover(node);
+ }
+
+ if (node->onUpdate)
+ node->onUpdate(node);
+ };
+
+ for (auto it : childs)
+ treeWalker(it);
+
+ prevX = mouseX;
+ prevY = mouseY;
+ prevBut = mouseButton;
+}
+
+WidgetButton::WidgetButton()
+{
+ this->state = WidgetState::Idle;
+
+ onHover = [](Widget* widget) {
+ WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+ if (w->state != WidgetState::Pressed)
+ w->state = WidgetState::Hovering;
+ LOG(INFO) << "Hover";
+ };
+
+ onPress = [](Widget* widget) {
+ WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+ w->state = WidgetState::Pressed;
+ LOG(INFO) << "Press";
+ };
+
+ onRelease = [](Widget* widget) {
+ WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+ w->state = WidgetState::Idle;
+ w->onClick(w);
+ LOG(INFO) << "Release";
+ };
+
+ onUnhover = [](Widget *widget) {
+ WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+ if (w->state!=WidgetState::Pressed)
+ w->state = WidgetState::Idle;
+ LOG(INFO) << "Unhover";
+ };
+
+}
+
+std::tuple<double, double, double, double> WidgetButton::GetTexture()
+{
+ double yOffset;
+ switch (this->state) {
+ case WidgetState::Idle:
+ yOffset = 0.2578;
+ break;
+ case WidgetState::Hovering:
+ yOffset = 0.3359;
+ break;
+ case WidgetState::Pressed:
+ yOffset = 0.1796;
+ }
+
+ TextureCoordinates texture = AssetManager::Instance().GetTextureByAssetName("minecraft/textures/gui/widgets");
+ return { texture.x,texture.y + texture.h * yOffset,texture.w * 0.7812,texture.h * 0.07812 };
+}
diff --git a/src/Widget.hpp b/src/Widget.hpp
new file mode 100644
index 0000000..6d78ebe
--- /dev/null
+++ b/src/Widget.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <functional>
+
+#include "AssetManager.hpp"
+
+class Widget;
+class RootWidget {
+ std::vector<std::unique_ptr<Widget>> allWidgets;
+
+ std::vector<Widget*> childs;
+
+ double prevX, prevY;
+ bool prevBut;
+public:
+ RootWidget() = default;
+
+ ~RootWidget() = default;
+
+ void AttachWidget(std::unique_ptr<Widget> widget, Widget* parent);
+
+ void AttachWidget(std::unique_ptr<Widget> widget);
+
+ std::vector<Widget*> GetRenderList();
+
+ void UpdateEvents(double mouseX, double mouseY, bool mouseButton);
+};
+
+struct Widget {
+ Widget() = default;
+
+ virtual ~Widget() = default;
+
+ Widget *parent;
+
+ std::vector<Widget*> childs;
+
+ double x, y, w, h; //In OGL screen-coordinates
+
+ virtual std::tuple<double, double, double, double> GetTexture() = 0;
+
+
+ using Handler = std::function<void(Widget*)>;
+
+ Handler onPress;
+
+ Handler onRelease;
+
+ Handler onHover;
+
+ Handler onUnhover;
+
+ Handler onUpdate;
+};
+
+struct WidgetButton : Widget {
+ WidgetButton();
+
+ ~WidgetButton() override = default;
+
+ std::string Text;
+
+ Handler onClick;
+
+ std::tuple<double, double, double, double> GetTexture() override;
+
+ enum class WidgetState {
+ Idle,
+ Hovering,
+ Pressed,
+ } state;
+}; \ No newline at end of file
diff --git a/src/World.cpp b/src/World.cpp
index f9edbe1..1a0e0fa 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -7,29 +7,23 @@ void World::ParseChunkData(std::shared_ptr<PacketChunkData> packet) {
for (int i = 0; i < 16; i++) {
if (bitmask[i]) {
Vector chunkPosition = Vector(packet->ChunkX, i, packet->ChunkZ);
- PackedSection packedSection = ParseSection(&chunkData, chunkPosition);
- Section section(packedSection);
+ Section section = ParseSection(&chunkData, chunkPosition);
if (packet->GroundUpContinuous) {
- if (!cachedSections.insert(std::make_pair(chunkPosition, section)).second) {
+ if (!sections.insert(std::make_pair(chunkPosition, section)).second) {
LOG(ERROR) << "New chunk not created " << chunkPosition << " potential memory leak";
}
} else {
using std::swap;
- swap(cachedSections.at(chunkPosition), section);
+ swap(sections.at(chunkPosition), section);
}
EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ chunkPosition });
}
}
}
-PackedSection World::ParseSection(StreamInput *data, Vector position) {
- unsigned char bitsPerBlock = data->ReadUByte();
- if (bitsPerBlock < 4)
- bitsPerBlock = 4;
-
- if (bitsPerBlock > 8)
- bitsPerBlock = 13;
+Section World::ParseSection(StreamInput *data, Vector position) {
+ unsigned char bitsPerBlock = data->ReadUByte();
int paletteLength = data->ReadVarInt();
std::vector<unsigned short> palette;
@@ -42,24 +36,17 @@ PackedSection World::ParseSection(StreamInput *data, Vector position) {
std::vector<unsigned char> skyLight;
if (dimension == 0)
skyLight = data->ReadByteArray(2048);
- return PackedSection(position, dataArray.data(), dataArray.size(), blockLight.data(),
- (skyLight.size() > 0 ? skyLight.data() : nullptr), bitsPerBlock, palette);
-}
-World::~World() {
+ long long *blockData = reinterpret_cast<long long*>(dataArray.data());
+ for (int i = 0; i < dataArray.size() / sizeof(long long); i++)
+ endswap(blockData[i]);
+ std::vector<long long> blockArray (blockData, blockData + dataArray.size() / sizeof (long long));
+
+
+ return Section(position, bitsPerBlock, std::move(palette), std::move(blockArray), std::move(blockLight), std::move(skyLight));
}
-Block & World::GetBlock(Vector worldPosition)
-{
- Vector sectionPos(std::floor(worldPosition.x / 16.0), std::floor(worldPosition.y / 16.0), std::floor(worldPosition.z / 16.0));
- auto it = cachedSections.find(sectionPos);
- if (it == cachedSections.end()) {
- static Block fallbackBlock;
- return fallbackBlock;
- }
- Section& section = it->second;
- Block& block = section.GetBlock(worldPosition - sectionPos * 16);
- return block;
+World::~World() {
}
World::World() {
@@ -67,7 +54,7 @@ World::World() {
bool World::isPlayerCollides(double X, double Y, double Z) {
Vector PlayerChunk(floor(X / 16.0), floor(Y / 16.0), floor(Z / 16.0));
- if (cachedSections.find(PlayerChunk) == cachedSections.end() || cachedSections.find(PlayerChunk - Vector(0,1,0)) == cachedSections.end())
+ if (sections.find(PlayerChunk) == sections.end() || sections.find(PlayerChunk - Vector(0,1,0)) == sections.end())
return true;
std::vector<Vector> closestSectionsCoordinates = {
Vector(PlayerChunk.x, PlayerChunk.y, PlayerChunk.z),
@@ -80,7 +67,7 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
};
std::vector<Vector> closestSections;
for (auto &coord:closestSectionsCoordinates) {
- if (cachedSections.find(coord) != cachedSections.end())
+ if (sections.find(coord) != sections.end())
closestSections.push_back(coord);
}
@@ -102,7 +89,7 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
for (int z = 0; z < 16; z++) {
- Block block = section.GetBlock(Vector(x, y, z));
+ BlockId block = section.GetBlockId(Vector(x, y, z));
if (block.id == 0 || block.id == 31)
continue;
AABB blockColl{(x + it.x * 16.0),
@@ -119,18 +106,18 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
std::vector<Vector> World::GetSectionsList() {
std::vector<Vector> sectionsList;
- for (auto& it : cachedSections) {
+ for (auto& it : sections) {
if (std::find(sectionsList.begin(), sectionsList.end(), it.first) == sectionsList.end())
sectionsList.push_back(it.first);
}
return sectionsList;
}
-static Section fallbackSection = Section(PackedSection());
+static Section fallbackSection;
const Section &World::GetSection(Vector sectionPos) {
- auto result = cachedSections.find(sectionPos);
- if (result == cachedSections.end()) {
+ auto result = sections.find(sectionPos);
+ if (result == sections.end()) {
LOG(ERROR) << "Accessed not loaded section " << sectionPos;
return fallbackSection;
} else {
@@ -205,14 +192,14 @@ void World::DeleteEntity(unsigned int EntityId)
}
void World::ParseChunkData(std::shared_ptr<PacketBlockChange> packet) {
- Block& block = this->GetBlock(packet->Position);
+ /*Block& block = this->GetBlock(packet->Position);
block = Block(packet->BlockId >> 4, packet->BlockId & 15, block.light, block.sky);
Vector sectionPos(std::floor(packet->Position.x / 16.0), std::floor(packet->Position.y / 16.0), std::floor(packet->Position.z / 16.0));
- EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });
+ EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });*/
}
void World::ParseChunkData(std::shared_ptr<PacketMultiBlockChange> packet) {
- std::vector<Vector> changedSections;
+ /*std::vector<Vector> changedSections;
for (auto& it : packet->Records) {
int x = (it.HorizontalPosition >> 4 & 15) + (packet->ChunkX * 16);
int y = it.YCoordinate;
@@ -226,17 +213,17 @@ void World::ParseChunkData(std::shared_ptr<PacketMultiBlockChange> packet) {
changedSections.push_back(sectionPos);
}
for (auto& sectionPos: changedSections)
- EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });
+ EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });*/
}
void World::ParseChunkData(std::shared_ptr<PacketUnloadChunk> packet) {
std::vector<std::map<Vector,Section>::iterator> toRemove;
- for (auto it = cachedSections.begin(); it != cachedSections.end(); ++it) {
+ for (auto it = sections.begin(); it != sections.end(); ++it) {
if (it->first.x == packet->ChunkX && it->first.z == packet->ChunkZ)
toRemove.push_back(it);
}
for (auto& it : toRemove) {
EventAgregator::PushEvent(EventType::ChunkDeleted, ChunkDeletedData{ it->first });
- cachedSections.erase(it);
+ sections.erase(it);
}
} \ No newline at end of file
diff --git a/src/World.hpp b/src/World.hpp
index 6ff0619..a5cf60c 100644
--- a/src/World.hpp
+++ b/src/World.hpp
@@ -16,17 +16,15 @@
class World {
int dimension = 0;
- //std::map<Vector, PackedSection> sections;
- std::map<Vector, Section> cachedSections;
- PackedSection ParseSection(StreamInput *data, Vector position);
+ std::map<Vector, Section> sections;
+
+ Section ParseSection(StreamInput *data, Vector position);
std::vector<Entity> entities;
std::mutex entitiesMutex;
- Block& GetBlock(Vector worldPosition);
-
public:
World();
diff --git a/src/main.cpp b/src/main.cpp
index 0a6ad17..9c38814 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -16,12 +16,9 @@ const char *getTimeSinceProgramStart(void) {
INITIALIZE_EASYLOGGINGPP
-#ifdef WIN32
-int CALLBACK WinMain(_In_ HINSTANCE hInstance, _In_ HINSTANCE hPrevInstance,
- _In_ LPSTR lpCmdLine, _In_ int nCmdShow) {
-#else
-int main() {
-#endif
+#undef main
+
+int main(int argc, char** argv) {
el::Configurations loggerConfiguration;
el::Helpers::installCustomFormatSpecifier(
el::CustomFormatSpecifier("%startTime", std::bind(getTimeSinceProgramStart)));
@@ -37,6 +34,14 @@ int main() {
LOG(WARNING) << "Sizeof EventData is " << sizeof(EventData);
+ try {
+ if (SDL_Init(0) == -1)
+ throw std::runtime_error("SDL initialization failed: " + std::string(SDL_GetError()));
+ } catch (std::exception& e) {
+ LOG(ERROR) << e.what();
+ return -1;
+ }
+
ThreadGame game;
std::thread threadGame(&ThreadGame::Execute, game);